//=============================================================================
// METHOD: SPELLserverCif::notifyError
//=============================================================================
void SPELLserverCif::notifyError( const std::string& error, const std::string& reason, bool fatal )
{
DEBUG("[CIF] Error notification: " + error + " (" + reason + ")");
SPELLipcMessage errorMsg( MessageId::MSG_ID_ERROR);
errorMsg.setType(MSG_TYPE_ERROR);
errorMsg.set( MessageField::FIELD_PROC_ID, getProcId() );
errorMsg.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_STATUS );
errorMsg.set( MessageField::FIELD_EXEC_STATUS, StatusToString(STATUS_ERROR) );
errorMsg.set( MessageField::FIELD_ERROR, error );
errorMsg.set( MessageField::FIELD_REASON, reason );
if (fatal)
{
errorMsg.set( MessageField::FIELD_FATAL, PythonConstants::True );
}
else
{
errorMsg.set( MessageField::FIELD_FATAL, PythonConstants::False );
}
completeMessage( &errorMsg );
m_asRun->writeErrorInfo( error, reason );
sendGUIMessage(&errorMsg);
}
//=============================================================================
// METHOD: SPELLserverCif::error
//=============================================================================
void SPELLserverCif::error( const std::string& msg, unsigned int scope )
{
if ( getVerbosity() > getVerbosityFilter() ) return;
DEBUG("[CIF] Error message: " + msg);
// We shall not bufferize in manual mode
if (isManual())
{
completeMessage( &m_wrMessage );
std::string timeStr = getTimestampUsec();
m_wrMessage.set(MessageField::FIELD_TEXT,msg);
m_wrMessage.set(MessageField::FIELD_LEVEL,MessageValue::DATA_SEVERITY_ERROR);
m_wrMessage.set(MessageField::FIELD_MSGTYPE,LanguageConstants::DISPLAY);
m_wrMessage.set(MessageField::FIELD_TIME, timeStr);
m_wrMessage.set(MessageField::FIELD_SCOPE, ISTR(scope));
sendGUIMessage(&m_wrMessage);
}
else
{
m_buffer->error( msg, scope );
}
m_asRun->writeError( getStack(), msg, scope );
}
//=============================================================================
// METHOD: SPELLserverCif::notifyStatus
//=============================================================================
void SPELLserverCif::notifyStatus( const SPELLstatusInfo& st )
{
DEBUG("[CIF] Status notification: " + StatusToString(st.status) + " (" + st.condition + ")");
m_stMessage.set(MessageField::FIELD_EXEC_STATUS, StatusToString(st.status));
completeMessage( &m_stMessage );
// Condition information
if (st.condition.size()>0)
{
m_stMessage.set( MessageField::FIELD_CONDITION, st.condition );
}
// Action information
if (st.actionLabel != "")
{
m_stMessage.set( MessageField::FIELD_ACTION_LABEL, st.actionLabel );
m_stMessage.set( MessageField::FIELD_ACTION_ENABLED, st.actionEnabled ? MessageValue::DATA_TRUE : MessageValue::DATA_FALSE );
}
m_asRun->writeStatus( st.status );
SPELLipcMessage* response = sendGUIRequest(&m_stMessage, SPELL_CIF_NOTIFICATION_TIMEOUT_SEC);
if (response) delete response;
}
/**
* ブラウザとの間に新しいソケットを開く
*/
void YASWebProxy::openNewSocket()
{
QTcpSocket* socket = server->nextPendingConnection();
connect(socket, SIGNAL(readyRead()), this, SLOT(openTunnel()));
connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));
HttpParser* parser = new HttpParser(HttpParser::REQUEST, socket);
parser->setObjectName("requestParser");
connect(parser, SIGNAL(completeMessage(QByteArray)), this, SLOT(onRequest(QByteArray)));
}
//=============================================================================
// METHOD: SPELLserverCif::notifyReturn
//=============================================================================
void SPELLserverCif::notifyReturn()
{
DEBUG("[CIF] Procedure return");
m_lnMessage.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_RETURN );
m_lnMessage.setType(MSG_TYPE_NOTIFY);
completeMessage( &m_lnMessage );
m_lnMessage.set(MessageField::FIELD_MSG_SEQUENCE, ISTR(m_sequenceStack));
m_sequenceStack++;
m_lnMessage.set(MessageField::FIELD_CODE_NAME, getCodeName() );
m_asRun->writeReturn( (m_sequence-1) );
SPELLipcMessage* response = sendGUIRequest(&m_lnMessage, SPELL_CIF_NOTIFICATION_TIMEOUT_SEC);
if (response) delete response;
}
//=============================================================================
// METHOD: SPELLserverCif::notifyCall
//=============================================================================
void SPELLserverCif::notifyCall()
{
std::string stack = getStack();
DEBUG("[CIF] Procedure call: " + stack );
m_lnMessage.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_CALL );
m_lnMessage.setType(MSG_TYPE_NOTIFY);
completeMessage( &m_lnMessage );
m_lnMessage.set(MessageField::FIELD_MSG_SEQUENCE, ISTR(m_sequenceStack));
m_sequenceStack++;
m_lnMessage.set(MessageField::FIELD_CODE_NAME, getCodeName() );
m_asRun->writeCall( stack, (m_sequence-1) );
SPELLipcMessage* response = sendGUIRequest(&m_lnMessage, SPELL_CIF_NOTIFICATION_TIMEOUT_SEC);
if (response) delete response;
}
//=============================================================================
// METHOD: SPELLserverCif::notifyLine
//=============================================================================
void SPELLserverCif::notifyLine()
{
std::string stack = getStack();
if (m_lastStack == stack) return;
m_lastStack = stack;
std::string stage = getStage();
DEBUG("[CIF] Procedure line: " + stack + "(" + stage + ")");
m_lnMessage.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_LINE );
m_lnMessage.setType(MSG_TYPE_NOTIFY_ASYNC);
completeMessage( &m_lnMessage );
m_lnMessage.set(MessageField::FIELD_MSG_SEQUENCE, ISTR(m_sequenceStack));
m_sequenceStack++;
m_lnMessage.set(MessageField::FIELD_CODE_NAME, getCodeName() );
if (stage.find(":") != std::string::npos)
{
std::vector<std::string> stage_title = tokenize(stage,":");
if (stage_title.size()==2)
{
m_lnMessage.set(MessageField::FIELD_STAGE_ID,stage_title[0]);
m_lnMessage.set(MessageField::FIELD_STAGE_TL,stage_title[1]);
}
else
{
m_lnMessage.set(MessageField::FIELD_STAGE_ID,"(none)");
m_lnMessage.set(MessageField::FIELD_STAGE_TL,"(none)");
}
}
else
{
m_lnMessage.set(MessageField::FIELD_STAGE_ID,stage);
m_lnMessage.set(MessageField::FIELD_STAGE_TL,stage);
}
m_asRun->writeLine( stack, (m_sequence-1) );
sendGUIMessage(&m_lnMessage);
}
/**
* ブラウザとのソケットと本来のホストとのソケットを接続するトンネルを作成
*/
void YASWebProxy::openTunnel()
{
QTcpSocket* socket = qobject_cast<QTcpSocket*>(sender());
QByteArray data = socket->readAll();
HttpParser* parser = socket->findChild<HttpParser*>("requestParser");
parser->input(data);
QTcpSocket* proxySocket = socket->findChild<QTcpSocket*>("tunnel");
if (!proxySocket) {
// 本来のホストへのソケットを作成
proxySocket = new QTcpSocket(socket);
proxySocket->setObjectName("tunnel");
proxySocket->connectToHost(parser->url.host(), parser->url.port(80));
connect(proxySocket, SIGNAL(disconnected()), this, SLOT(closeProxySocket()));
connect(proxySocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(closeProxySocket()));
connect(proxySocket, SIGNAL(readyRead()), this, SLOT(forwardResponse()));
if (parser->method == "CONNECT") {
disconnect(socket, SIGNAL(readyRead()), this, SLOT(openTunnel()));
connect(socket, SIGNAL(readyRead()), this, SLOT(forwardRequest()));
} else {
HttpParser* resParser = new HttpParser(HttpParser::RESPONSE, proxySocket);
resParser->setObjectName("responseParser");
resParser->setProperty("url", parser->url.toString());
connect(resParser, SIGNAL(completeMessage(QByteArray)), this, SLOT(onResponse(QByteArray)));
}
}
if (proxySocket->waitForConnected()) {
if (parser->method == "CONNECT") {
socket->write("HTTP/1.0 200 Connection established\r\n\r\n");
} else {
proxySocket->write(parser->dequeueData());
}
} else {
proxySocket->disconnect();
}
}
//=============================================================================
// METHOD: SPELLserverCif::prompt
//=============================================================================
std::string SPELLserverCif::prompt( const std::string& message, PromptOptions options, unsigned int ptype, unsigned int scope )
{
DEBUG("[CIF] Prompt message");
std::string timeStr = getTimestampUsec();
SPELLipcMessage promptMessage(MessageId::MSG_ID_PROMPT);
completeMessage( &promptMessage );
promptMessage.setType(MSG_TYPE_PROMPT);
promptMessage.set(MessageField::FIELD_PROC_ID, getProcId() );
promptMessage.set(MessageField::FIELD_TEXT, message);
promptMessage.set(MessageField::FIELD_DATA_TYPE, ISTR(ptype));
promptMessage.set(MessageField::FIELD_TIME, timeStr);
promptMessage.set(MessageField::FIELD_SCOPE, ISTR(scope));
// Used for the prompt display message
PromptOptions optionsToShow;
DEBUG("[CIF] Prompt typecode " + ISTR(ptype));
if (ptype == LanguageConstants::PROMPT_NUM ||
ptype == LanguageConstants::PROMPT_ALPHA ||
ptype == LanguageConstants::PROMPT_DATE )
{
DEBUG("[CIF] Prompt is simple");
promptMessage.set(MessageField::FIELD_EXPECTED, "");
}
else if ( ptype & LanguageConstants::PROMPT_LIST )
{
DEBUG("[CIF] Prompt is list");
PromptOptions::iterator it;
int keyCount = 1;
std::string optionStr = "";
std::string expectedStr = "";
// Iterate over the option list and build the option and expected values strings
for( it = options.begin(); it != options.end(); it++)
{
std::string key;
std::string value;
std::string opt = (*it);
DEBUG("[CIF] Option: " + opt);
if (optionStr.size()>0) optionStr += IPCinternals::OPT_SEPARATOR;
if (expectedStr.size()>0) expectedStr += IPCinternals::OPT_SEPARATOR;
if ( opt.find(IPCinternals::KEY_SEPARATOR) == std::string::npos )
{
// Put an internal key in this case
key = ISTR(keyCount);
value = opt;
// Trim the value
trim(value);
}
else
{
int idx = opt.find(IPCinternals::KEY_SEPARATOR);
key = opt.substr(0, idx);
// Trim the key
trim(key);
value = opt.substr(idx+1, opt.size()-idx);
// Trim the value
trim(value);
}
DEBUG("[CIF] Option key: '" + key + "'");
DEBUG("[CIF] Option value: '" + value + "'");
optionStr += key + IPCinternals::KEY_SEPARATOR + value;
optionsToShow.push_back(key + ": " + value);
if (ptype & LanguageConstants::PROMPT_ALPHA)
{
expectedStr += value;
DEBUG("[CIF] Expected: " + value);
}
else
{
expectedStr += key;
DEBUG("[CIF] Expected: " + key);
}
keyCount++;
}
promptMessage.set(MessageField::FIELD_EXPECTED, expectedStr);
promptMessage.set(MessageField::FIELD_OPTIONS, optionStr);
}
else if (ptype == LanguageConstants::PROMPT_OK)
{
promptMessage.set(MessageField::FIELD_EXPECTED, "O");
promptMessage.set(MessageField::FIELD_OPTIONS, "O" + IPCinternals::KEY_SEPARATOR + " Ok");
optionsToShow.push_back("O: Ok");
}
else if (ptype == LanguageConstants::PROMPT_CANCEL)
{
promptMessage.set(MessageField::FIELD_EXPECTED, "C");
promptMessage.set(MessageField::FIELD_OPTIONS, "C" + IPCinternals::KEY_SEPARATOR + " Cancel");
optionsToShow.push_back("C: Cancel");
}
else if (ptype == LanguageConstants::PROMPT_YES)
{
promptMessage.set(MessageField::FIELD_EXPECTED, "Y");
promptMessage.set(MessageField::FIELD_OPTIONS, "Y" + IPCinternals::KEY_SEPARATOR + " Yes");
optionsToShow.push_back("Y: Yes");
}
else if (ptype == LanguageConstants::PROMPT_NO)
{
promptMessage.set(MessageField::FIELD_EXPECTED, "N");
promptMessage.set(MessageField::FIELD_OPTIONS, "N" + IPCinternals::KEY_SEPARATOR + " No");
optionsToShow.push_back("N: No");
}
else if (ptype == LanguageConstants::PROMPT_YES_NO)
{
promptMessage.set(MessageField::FIELD_EXPECTED, "Y|N");
promptMessage.set(MessageField::FIELD_OPTIONS, "Y" + IPCinternals::KEY_SEPARATOR + " Yes|N" + IPCinternals::KEY_SEPARATOR + " No");
optionsToShow.push_back("Y: Yes");
optionsToShow.push_back("N: No");
}
else if (ptype == LanguageConstants::PROMPT_OK_CANCEL)
{
promptMessage.set(MessageField::FIELD_EXPECTED, "O|C");
promptMessage.set(MessageField::FIELD_OPTIONS, "O" + IPCinternals::KEY_SEPARATOR + " Ok|C" + IPCinternals::KEY_SEPARATOR + " Cancel");
optionsToShow.push_back("O: Ok");
optionsToShow.push_back("C: Cancel");
}
DEBUG("[CIF] Option string: " + promptMessage.get(MessageField::FIELD_OPTIONS));
DEBUG("[CIF] Expected string: " + promptMessage.get(MessageField::FIELD_EXPECTED));
// Write the prompt display
std::string msgToShow = message;
if (optionsToShow.size()>0)
{
msgToShow += "\nAvailable options:\n";
for(PromptOptions::iterator pit = optionsToShow.begin(); pit != optionsToShow.end(); pit++)
{
msgToShow += " - " + (*pit) + "\n";
}
}
// Send the display message via the buffer to ensure synchronization
m_buffer->prompt(msgToShow, LanguageConstants::SCOPE_PROMPT);
// Ensure buffer is flushed
m_buffer->flush();
// Write the prompt in the asrun
m_asRun->writePrompt( getStack(), message, scope );
DEBUG("[CIF] Messsage prepared");
// Send request to client
SPELLipcMessage* response = sendGUIRequest(&promptMessage, SPELL_CIF_PROMPT_TIMEOUT_SEC);
DEBUG("[CIF] Prompt response received");
std::string toProcess = "";
if (response->getId() == MessageId::MSG_ID_CANCEL)
{
LOG_WARN("Prompt cancelled");
DEBUG("[CIF] Prompt cancelled");
toProcess = PROMPT_CANCELLED;
// Abort execution in this case
SPELLexecutor::instance().abort("Prompt cancelled",true);
}
else if (response->getId() == MessageId::MSG_ID_TIMEOUT)
{
LOG_ERROR("Prompt timed out");
DEBUG("[CIF] Prompt timed out");
toProcess = PROMPT_TIMEOUT;
// Abort execution in this case
SPELLexecutor::instance().abort("Prompt timed out", true);
}
else if (response->getType() == MSG_TYPE_ERROR)
{
std::string errorMsg = response->get( MessageField::FIELD_ERROR );
DEBUG("[CIF] Prompt error: " + errorMsg );
LOG_ERROR("Prompt error: " + errorMsg);
toProcess = PROMPT_ERROR;
// \todo Should fix this and use an error code
if (errorMsg == "No controlling client")
{
warning("No controlling client to issue prompt!", LanguageConstants::SCOPE_SYS );
SPELLexecutor::instance().pause();
}
else
{
error( "Prompt error: " + errorMsg, LanguageConstants::SCOPE_SYS );
// Abort execution in this case
SPELLexecutor::instance().abort("Prompt error",true);
}
}
else
{
toProcess = response->get(MessageField::FIELD_RVALUE);
DEBUG("[CIF] Prompt response: " + toProcess);
}
// \todo When there is no controlling client we should keep the child procedure in prompt waiting state
// Send the display message via the buffer to ensure synchronization
m_buffer->write("Answer: '" + toProcess + "'", LanguageConstants::SCOPE_PROMPT);
m_buffer->flush();
m_asRun->writeAnswer( getStack(), toProcess, scope );
return toProcess;
}
//=============================================================================
// METHOD: SPELLserverCif::notify
//=============================================================================
void SPELLserverCif::notify( ItemNotification notification )
{
DEBUG("[CIF] Item notification");
completeMessage( &m_ntMessage );
DEBUG("[CIF] Processing status");
int sCount = 0;
if (notification.status.find(IPCinternals::ARG_SEPARATOR) != std::string::npos )
{
std::vector<std::string> statusList = tokenize(notification.status,IPCinternals::ARG_SEPARATOR);
std::vector<std::string>::iterator it;
for( it = statusList.begin(); it != statusList.end(); it++)
{
if (*it == MessageValue::DATA_NOTIF_STATUS_OK) sCount++;
}
std::vector<std::string> commentList = tokenize(notification.comment,IPCinternals::ARG_SEPARATOR);
if (commentList.size() == 1)
{
notification.comment = "";
for( unsigned int count=0; count<statusList.size(); count++)
{
if (notification.comment.size()>0) notification.comment += IPCinternals::ARG_SEPARATOR;
notification.comment += " ";
}
}
std::vector<std::string> timeList = tokenize(notification.time, IPCinternals::ARG_SEPARATOR);
if (timeList.size() == 1)
{
notification.time = "";
std::string tstamp = timestamp();
for( unsigned int count=0; count<statusList.size(); count++)
{
if (notification.time.size()>0) notification.time += IPCinternals::ARG_SEPARATOR;
notification.time += tstamp;
}
}
}
else
{
sCount = (notification.status == MessageValue::DATA_NOTIF_STATUS_OK) ? 1 : 0;
}
std::stringstream buffer;
buffer << sCount;
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_TYPE, NOTIF_TYPE_STR[notification.type]);
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_NAME, notification.name);
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_VALUE, notification.value);
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_STATUS, notification.status);
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_REASON, notification.comment);
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_TIME, notification.time);
m_ntMessage.set(MessageField::FIELD_NOTIF_ITEM_SCOUNT, buffer.str());
DEBUG("[CIF] Message prepared, sending");
m_asRun->writeItem( getStack(),
NOTIF_TYPE_STR[notification.type],
notification.name,
notification.value,
notification.status,
notification.comment,
notification.time );
SPELLipcMessage* response = sendGUIRequest(&m_ntMessage, SPELL_CIF_NOTIFICATION_TIMEOUT_SEC);
if (response) delete response;
DEBUG("[CIF] Notification sent");
}
