//=============================================================================
// METHOD: SPELLclientIPC::
//=============================================================================
SPELLipcMessage SPELLclientIPC::processRequest( const SPELLipcMessage& msg )
{
int clientKey = msg.getKey();
DEBUG("[CLTRCV] Received request from client: " + msg.getId());
SPELLipcMessage resp = VOID_MESSAGE;
SPELLclientInterestList* list = getClientInterestList(clientKey);
// If the message is a login message, redirect it to the client manager
if (msg.getId() == ContextMessages::REQ_GUI_LOGIN)
{
SPELLclientManager::instance().clientLogin(clientKey, msg.get( MessageField::FIELD_HOST ));
resp = SPELLipcHelper::createResponse(ContextMessages::RSP_GUI_LOGIN, msg);
}
// If the message is a logout message, redirect it to the client manager
else if (msg.getId() == ContextMessages::REQ_GUI_LOGOUT )
{
// No need to close IPC here. When the GUI receives the response,
// it will close the channel by sending EOC. There, IPC layer will
// automatically close the corresponding channel.
SPELLclientManager::instance().clientLogout(clientKey);
resp = SPELLipcHelper::createResponse(ContextMessages::RSP_GUI_LOGOUT, msg);
}
else if (list != NULL)
{
//DEBUG("[CLTRCV] Distribute client request: " + msg.getId());
resp = list->distributeRequest(msg);
//DEBUG("[CLTRCV] Got response for client request: " + msg.getId());
// Executor request additional processing (request attended by executor that need to be processed in context also)
// But only if the response is not an error
if (resp.getType() != MSG_TYPE_ERROR)
{
if (msg.getId() == ExecutorMessages::REQ_SET_CONFIG)
{
SPELLipcMessage cfgChange( msg );
cfgChange.setId( ContextMessages::MSG_EXEC_CONFIG );
cfgChange.setType( MSG_TYPE_ONEWAY );
SPELLclientManager::instance().notifyMonitoringClients(&cfgChange);
}
}
if (resp.isVoid())
{
LOG_ERROR("Unable to get response for client request " + msg.getId());
}
}
else
{
LOG_ERROR("No listeners for client " + ISTR(clientKey) + " to distribute request: " + msg.getId());
}
return resp;
}
//=============================================================================
// METHOD: SPELLexecutorIPC::processConnectionError
//=============================================================================
bool SPELLexecutorIPC::shouldForwardToMonitoring( const SPELLipcMessage& msg )
{
std::string requestId = msg.getId();
if (msg.getType() == MSG_TYPE_PROMPT)
{
return false;
}
if ( requestId == ContextMessages::REQ_OPEN_EXEC )
{
return false;
}
else if ( requestId == ContextMessages::REQ_INSTANCE_ID )
{
return false;
}
else if ( requestId == ContextMessages::REQ_EXEC_INFO )
{
return false;
}
else if ( requestId == ContextMessages::REQ_DEL_SHARED_DATA )
{
return false;
}
else if ( requestId == ContextMessages::REQ_SET_SHARED_DATA )
{
return false;
}
else if ( requestId == ContextMessages::REQ_GET_SHARED_DATA )
{
return false;
}
else if ( requestId == ContextMessages::REQ_GET_SHARED_DATA_KEYS )
{
return false;
}
return true;
}
//=============================================================================
// 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;
}