root/vtcross/trunk/src/cognitive_engines/CognitiveEngine.cpp @ 218

/* Virginia Tech Cognitive Radio Open Source Systems
 * Virginia Tech, 2009
 *
 * LICENSE INFORMATION GOES HERE
 */

/* DESCRIPTION OF FILE.
 */


#include <cstdlib>
#include <cstring>
#include <stdint.h>

#include "vtcross/common.h"
#include "vtcross/components.h"
#include "vtcross/containers.h"
#include "vtcross/debug.h"
#include "vtcross/error.h"
#include "vtcross/socketcomm.h"


CognitiveEngine::CognitiveEngine()
{
    LOG("Creating Cognitive Engine.\n");
    SML_present = false;
    commandSocketFD = -1;
}


CognitiveEngine::~CognitiveEngine()
{
    delete [] pList;
    delete [] oList;
    delete [] uList;
    delete [] radioInfo;
}


CognitiveEngine::CognitiveEngine(const char* serverName, const char* serverPort, \
        const bool SML)
{
    LOG("Creating Cognitive Engine.\n");

    pList = new Parameter[10];
    oList = new Observable[10];
    uList = new Utility[10];
    radioInfo = new Radio_Info;

    ConnectToRemoteComponent(serverName, serverPort, SML);
}


void
CognitiveEngine::SendComponentType()
{
    SendMessage(commandSocketFD, "response_engine_cognitive");
    LOG("Cognitive Engine responded to GetRemoteComponentType query.\n");
}


void
CognitiveEngine::ConnectToRemoteComponent(const char* serverName, \
        const char* serverPort, const bool SML)
{
    commandSocketFD = ClientSocket(serverName, serverPort);

    SML_present = SML;

    if(SML) {
        RegisterComponent();
        RegisterServices();
        LOG("Cognitive Engine connected to SML at %s.\n", serverName);
        ReceiveRadioConfiguration();
        ReceiveExperience();
    }
    else {
        RegisterComponent();
        LOG("Cognitive Engine connected to shell at %s.\n", serverName);
        ReceiveRadioConfiguration();
        ReceiveExperience();
    }
}


void 
CognitiveEngine::WaitForSignal()
{
    char buffer[256];

    while(true) {
        memset(buffer, 0, 256);
       
        ReadMessage(commandSocketFD, buffer);

        // TODO this is ugly... is there a better way? Doesn't strcmp compare the
        // whole string?  We only need to compare until we find a single different
        // byte...
        //
        // If we send integer op codes rather than strings, this process will be
        // MUCH faster since instead of donig string compares we can simply
        // switch on the integer value...
        if(strcmp(buffer, "get_solution") == 0) {
        

        }
        else if(strcmp(buffer, "query_component_type") == 0) {
            SendComponentType();
        }
        else if(strcmp(buffer, "connect_sml") == 0) {
            /* This command implies that we are disconnecting from the shell and
             * connecting to a SML component. */
            char serverName[256];
            char serverPort[256];
            // TODO is this going to end up being too slow?
            memset(serverName, 0, 256);
            memset(serverPort, 0, 256);

            ReadMessage(commandSocketFD, serverName);
            ReadMessage(commandSocketFD, serverPort);

            /* Only continue if we are currently connected to a shell. */
            if(!SML_present) {
                DeregisterComponent();

                shutdown(commandSocketFD, 2);
                close(commandSocketFD);

                ConnectToRemoteComponent(serverName, serverPort, true);
            }
        }
        else if(strcmp(buffer, "disconnect_sml") == 0) {
            /* This command implies that we are disconnecting from the SML and
             * connecting to a shell component. */
            char serverName[256];
            char serverPort[256];
            // TODO is this going to end up being too slow?
            memset(serverName, 0, 256);
            memset(serverPort, 0, 256);

            ReadMessage(commandSocketFD, serverName);
            ReadMessage(commandSocketFD, serverPort);

            /* We only want to do this if we are actually connected to an SML
             * currently. */
            if(SML_present) {
                DeregisterServices();

                shutdown(commandSocketFD, 2);
                close(commandSocketFD);

                ConnectToRemoteComponent(serverName, serverPort, false);
            }
        }
        else if(strcmp(buffer, "reset_engine_cognitive") == 0) {
            Reset();
        }
        else if(strcmp(buffer, "shutdown_engine_cognitive") == 0) {
            Shutdown();
        }
    }
}


void 
CognitiveEngine::Shutdown()
{
    if(SML_present) {
        DeregisterServices();
        DeregisterComponent();
    } 
    else {
        DeregisterComponent();
    }
    // TODO should something else be happening here?
}


void
CognitiveEngine::Reset()
{
    LOG("Resetting Cognitive Engine.\n");

    if(SML_present) {
        DeregisterServices();
        DeregisterComponent();
    } 
    else {
        DeregisterComponent();
    }
}


void
CognitiveEngine::RegisterComponent()
{
    SendMessage(commandSocketFD, "register_engine_cognitive");
    LOG("Cognitive Engine:: Registration message sent to shell.\n");
}

void 
CognitiveEngine::DeregisterComponent()
{
    SendMessage(commandSocketFD, "deregister_engine_cognitive");
    LOG("Cognitive Engine:: Deregistration message sent.\n");

    shutdown(commandSocketFD, 2);
    close(commandSocketFD);
    commandSocketFD = -1;
    LOG("Cognitive Engine:: Shell socket closed.\n");
}


void 
CognitiveEngine::RegisterServices()
{
    LOG("Cognitive Engine:: Registering services.\n");

    SendMessage(commandSocketFD, "register_service");
    SendMessage(commandSocketFD, "jam_wifi");

    SendMessage(commandSocketFD, "register_service");
    SendMessage(commandSocketFD, "signal_detection");

    SendMessage(commandSocketFD, "register_service");
    SendMessage(commandSocketFD, "max_throughput");

    SendMessage(commandSocketFD, "register_service");
    SendMessage(commandSocketFD, "jam_bluetooth");
}


void 
CognitiveEngine::DeregisterServices()
{
    LOG("Cognitive Engine:: Deregistering services.\n");

    SendMessage(commandSocketFD, "deregister_service");
    SendMessage(commandSocketFD, "jam_wifi");

    SendMessage(commandSocketFD, "deregister_service");
    SendMessage(commandSocketFD, "signal_detection");

    SendMessage(commandSocketFD, "deregister_service");
    SendMessage(commandSocketFD, "max_throughput");

    SendMessage(commandSocketFD, "deregister_service");
    SendMessage(commandSocketFD, "jam_bluetooth");

}

void 
CognitiveEngine::ReceiveRadioConfiguration()
{
    LOG("Cognitive Engine:: Receiving Radio Configuration.\n");
    
    char buffer[256];
    uint32_t i,j,k;   
 
    /* Receive Set of Utilities */
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD,buffer);
    radioInfo->numUtilities = atoi(buffer);
    
    for (i = 0; i < radioInfo->numUtilities; i++){
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        LOG("socket_comm::Get Utility - Name: %s\n", buffer);
        uList[i].name = std::string(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        uList[i].units = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        uList[i].goal = std::string(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        uList[i].target = atof(buffer);
    }

    /* Receive Set of Parameters */
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD, buffer);
    radioInfo->numParameters = atoi(buffer);
    LOG("socket_comm::GetParameter - Number of parameters: %d\n", \
            radioInfo->numParameters);
    
    for(size_t i = 0; i < radioInfo->numParameters; i++) {
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        LOG("socket_comm::GetParameter - Name: %s\n", buffer);
        pList[i].name = std::string(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        LOG("socket_comm::GetParameter - Units: %s\n", buffer);
        pList[i].units = std::string(buffer);

        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        LOG("socket_comm::GetParameter - Min: %s\n", buffer);
        pList[i].min = atof(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        LOG("socket_comm::GetParameter - Max: %s\n", buffer);
        pList[i].max = atof(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD, buffer);
        LOG("socket_comm::GetParameter - Step: %s\n", buffer);
        pList[i].step = atof(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        LOG("socket_comm::GetParameter - Number of Affects: %s\n", buffer);
        pList[i].numAffects = atoi(buffer);
    
        for (j = 0; j < pList[i].numAffects; j++){
            memset(buffer, 0, 256);
            ReadMessage(commandSocketFD,buffer);
            LOG("socket_comm::GetParameter - Affect Name: %s\n", buffer);
            for (k = 0; k < radioInfo->numUtilities; k++){
                if(uList[k].name == std::string(buffer)){    
                    pList[i].affection_list[j].u = &uList[k];   
                    break;
                }
            }

            memset(buffer, 0, 256);
            ReadMessage(commandSocketFD,buffer);
            LOG("socket_comm::GetParameter - Affect Relation: %s\n", buffer);
            pList[i].affection_list[j].relation = std::string(buffer);   
        }
    }   

    /* Receive Set of Observables */
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD,buffer);
    radioInfo->numObservables = atoi(buffer);
    
    for (i = 0; i < radioInfo->numObservables; i++){
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        LOG("socket_comm::Get Observable - Name: %s\n", buffer);
        oList[i].name = std::string(buffer);
    
        memset(buffer, 0, 256);
        ReadMessage(commandSocketFD,buffer);
        LOG("socket_comm::Get Observable - Number Affects: %s\n", buffer);
        oList[i].numAffects = atoi(buffer);
    
        for (j = 0; j < oList[i].numAffects; j++){
            memset(buffer, 0, 256);
            ReadMessage(commandSocketFD,buffer);
            LOG("socket_comm::Get Observable - Affect Name: %s\n", buffer);
            for (k = 0; k < radioInfo->numUtilities; k++){
                if(uList[k].name == std::string(buffer)){    
                    oList[i].affection_list[j].u = &uList[k];   
                    break;
                }
            }
 
            memset(buffer, 0, 256);
            ReadMessage(commandSocketFD,buffer);
            LOG("socket_comm::Get Observable - Affect Relation: %s\n", buffer);
            oList[i].affection_list[j].relation = std::string(buffer);   
        }
    }

    SendMessage(commandSocketFD, "receive_config_ack");
}

void 
CognitiveEngine::ReceiveExperience()
{
    LOG("Cognitive Engine:: Receiving Experience Report.\n");
    char buffer[256];
    uint32_t numberExp;
    
    /* Receive number of experience entries */
    memset(buffer, 0, 256);
    ReadMessage(commandSocketFD,buffer);
    numberExp = atoi(buffer);

    LOG("Cognitive Engine:: Waiting for %i number of entries.\n",numberExp);
 
    SendMessage(commandSocketFD, "receive_exp_ack");
}

void 
CognitiveEngine::GetSolution(Observable *observables)
{
    LOG("Cognitive Engine:: Generating solution.\n");
}

void 
CognitiveEngine::GetSolution(Observable *observables, std::string service)
{
    LOG("Cognitive Engine:: Generating solution for %s service.\n",service.c_str());
}

void 
CognitiveEngine::ReceiveFeedback(Observable *observables, Parameter *parameters, \
    Utility *utilities)
{
    LOG("Cognitive Engine:: Receiving feedback.\n");
}

void 
CognitiveEngine::ReceiveFeedback(Observable *observables, Parameter *parameters, \
    Utility *utilities, std::string service)
{
    LOG("Cognitive Engine:: Receiving feedback.\n");
}