Exemplo n.º 1
0
//=============================================================================
// 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;
}
Exemplo n.º 2
0
//=============================================================================
// 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;
}
Exemplo n.º 3
0
//=============================================================================
// 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;
}