phClientHandler.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission : 
        Realtime Vision Processing System

    Copyright (C) 2003 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics

    This file is part of Phission.

 ---------------------------------------------------------------------------*/
/* -------------------------------------------------------------------------- *
 * phClientHandler.cpp: Header for the client handler that the server spawns  *
 * to  handle multiple client requests.                                       *
 * -------------------------------------------------------------------------- */
#include <phClientHandler.h>
#include <sys/types.h>
#include <unistd.h>

/* -------------------------------------------------------------------------- *
 * phClientHandler constructor:
 * -------------------------------------------------------------------------- */
phClientHandler::phClientHandler(uint32_t controller_id,
                                 phSocket *sock,
                                 phLamportSystem *system )
{
    phFUNCTION("phClientHandler::phClientHandler")
    int locked = 0;

    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. */
    phTHIS_LOOSE_LOCK(locked);

    /* Initialize all the member variables to default values so they
     * can be more appropriately initialized later */
    this->m_sock            = NULL;
    this->m_controller_id   = phID_INVALID;
    this->m_client_id       = phID_INVALID;

    this->m_system          = NULL;
    
    rc = this->setSocket(sock);
    rc = this->setControllerId(controller_id);
    rc = this->setSystem(system); 
    
    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_LOOSE_UNLOCK(locked);
}

/* -------------------------------------------------------------------------- *
 * phClientHandler destructor:
 * -------------------------------------------------------------------------- */
phClientHandler::~phClientHandler()
{
    phFUNCTION("phClientHandler::~phClientHandler")
    int locked = 0;

    /* Lock the object and don't unlock because the object is being destroyed.
     * We don't unlock because we want the object locked all the way to the
     * destructor of the phMutex at which point anyone waiting for a mutex
     * will fail on the lock and won't try to access this information */
    phTHIS_LOOSE_LOCK(locked);
    
    /* Reset all the variables, free all the memory */
    phDelete(this->m_sock);
    this->m_controller_id   = phID_INVALID;
    this->m_client_id       = phID_INVALID;
}

/* -------------------------------------------------------------------------- */
int phClientHandler::setSocket(phSocket *sock)
{
    phFUNCTION("phClientHandler::setSocket")
    int locked = 0;

    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. If we succeed, set 'locked' so
     * the method knows to unlock should something go wrong. */
    phTHIS_LOCK(locked);

    this->m_sock = sock;
    
    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:
    /* We're using 'locked' to tell whether we want to unlock
     * within this method. This thread could own it several times and
     * we don't want to unlock one this method doesn't own */
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* -------------------------------------------------------------------------- */
phSocket *phClientHandler::getSocket()
{
    return this->m_sock;
}

/* -------------------------------------------------------------------------- *
 * setControllerId:
 * -------------------------------------------------------------------------- */
int phClientHandler::setControllerId(uint32_t controller_id)
{
    phFUNCTION("phClientHandler::setControllerId")
    int locked = 0;
    
    phTHIS_LOCK(locked);

    this->m_controller_id = controller_id;
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* -------------------------------------------------------------------------- *
 * getControllerId:
 * -------------------------------------------------------------------------- */
uint32_t phClientHandler::getControllerId()
{
    phFUNCTION("phClientHandler::getControllerId")
    int ret_id = 0;
    int locked = 0;
    
    phTHIS_LOCK(locked);

    ret_id = this->m_controller_id;
    
error:
    phTHIS_ERROR_UNLOCK(locked);

    return ret_id;
}

/* -------------------------------------------------------------------------- *
 * setClientId:
 * -------------------------------------------------------------------------- */
int phClientHandler::setClientId(uint32_t client_id)
{
    phFUNCTION("phClientHandler::setClientId")
    int locked = 0;
    
    phTHIS_LOCK(locked);

    this->m_client_id = client_id;
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* -------------------------------------------------------------------------- *
 * getClientId:
 * -------------------------------------------------------------------------- */
uint32_t phClientHandler::getClientId()
{
    phFUNCTION("phClientHandler::getClientId")
    uint32_t ret_id = 0;
    int locked = 0;
    
    phTHIS_LOCK(locked);

    ret_id = this->m_client_id;
    
error:
    phTHIS_ERROR_UNLOCK(locked);

    return ret_id;
}

/* -------------------------------------------------------------------------- *
 * setSystem:
 * -------------------------------------------------------------------------- */
int phClientHandler::setSystem(phLamportSystem *system)
{
    phFUNCTION("phClientHandler::setSystem")
    int locked = 0;
    
    phTHIS_LOCK(locked);

    this->m_system = system;

    if (this->m_system != NULL)
    {
        rc = this->m_system->registerResource(this);
        phPRINT_RC(rc,NULL,"m_system.registerResource(this:%p) failed.",
             this);
    }
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* -------------------------------------------------------------------------- *
 * getSystem:
 * -------------------------------------------------------------------------- */
phLamportSystem *phClientHandler::getSystem()
{
    phFUNCTION("phClientHandler::")
    phLamportSystem *system = 0;
    int locked = 0;
    
    phTHIS_LOCK(locked);

    system = this->m_system;
    
error:
    phTHIS_ERROR_UNLOCK(locked);

    return system;
}


/* -------------------------------------------------------------------------- *
 * run:
 * -------------------------------------------------------------------------- */
int phClientHandler::run()
{
    phFUNCTION("phClientHandler::run")

    /* Do any setup here */
  
    /* make sure there is a mutual exclusion system to negotiate with */
    phCHECK_NULLPTR(this->m_system,NULL,
        "Bad parameter: this->m_system == NULL" );
    
    /* Make sure the socket isn't NULL */
    phCHECK_NULLPTR(this->getSocket(), NULL,
            "The client thread's socket is NULL.");
   
    /* run has the lock until here */
    rc = this->signal_running();
    phCHECK_RC(rc, NULL, "this->signal_running()");

    phPROGRESS("[C:%d<->NC:%d] Client connected and Running...\n\n", 
             this->m_client_id,this->m_controller_id );

    while (this->isRunning() && this->m_sock->isConnected())
    {
        rc = this->receive_message();
        phPRINT_RC(rc,NULL,"this->receive_message failed.");

        if (rc == phSUCCESS)
        {
            rc = this->dispatch();
            phPRINT_RC(rc,NULL,"this->dispatch() failed.");
        }
        
        phYield();
    }
    
    phPROGRESS("[C:%d<->NC:%d] client done.\n\n", 
             this->m_client_id,
             this->m_controller_id );

    return phSUCCESS;
error:
    /* Signal the spawner thread that this thread hit an error condition
     * and it should be cleaned up immediately. */
    rc = this->signal_error();
    phCHECK_RC(rc, NULL, "this->signal_error()");
   
    return phFAIL;
}
 
/* ------------------------------------------------------------------------- *
 * receive_message: 
 * ------------------------------------------------------------------------- */
int phClientHandler::receive_message()
{
    phFUNCTION("phClientHandler::receive_message")
    int locked = 0;
    int received_length = 0;
    int offset = 0;
    int retrc = phSUCCESS;
    
    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. If we succeed, set 'locked' so
     * the method knows to unlock should something go wrong. */
    phTHIS_LOCK(locked);

#if 0
    /* Turn on NON-BLOCKING socket receiving */
    rc = this->m_sock->setBlocking(phNONBLOCK);
    phPRINT_RC(rc,NULL,"m_sock->setBlocking(phNONBLOCK");
#endif
    
    /* If there isn't a receive buffer allocated, allocate one and store the
     * size of it in a member variable for safe keeping */
    DEBUG_PRINT("call:m_message.receive\n");
    rc = this->m_message.receive(this->m_sock);
    phCHECK_RC(rc,NULL,"client_message.receive(%p) failed.",
             this->m_sock);

    /* 
    if (this->m_sock->isConnected())
    {
        this->m_message.print(stderr);
        DEBUG_PRINT("done:m_message.receive\n");
    }
    */

    /* propagate a non-blocking return code; just in case */
    if (rc == 1)
    {
        retrc = 1;
    }
    
    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_UNLOCK(locked);
    
    return retrc;
error:
    /* We're using 'locked' to tell whether we want to unlock
     * within this method. This thread could own it several times and
     * we don't want to unlock one this method doesn't own */
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* ------------------------------------------------------------------------- *
 * dispatch: 
 * ------------------------------------------------------------------------- */
int phClientHandler::dispatch()
{
    phFUNCTION("phClientHandler::dispatch")
    int locked = 0;
    uint32_t message_id = phCLIENT_SUCCESS;
    
    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. If we succeed, set 'locked' so
     * the method knows to unlock should something go wrong. */
    phTHIS_LOCK(locked);
    
    if (this->m_message.getMessageId() == phCLIENT_HELLO)
    {
        DEBUG_PRINT("phCLIENT_HELLO\n");
        rc = this->handle_client_hello();
        phCHECK_RC(rc,NULL,"handle_client_hello() failed.");
    }
    else if (this->m_message.getMessageId() == phCLIENT_GOODBYE)
    {
        DEBUG_PRINT("phCLIENT_GOODBYE\n");
        rc = this->handle_client_goodbye();
        phCHECK_RC(rc,NULL,"handle_client_goodbye() failed.");
    }
    else if ((this->m_message.getMessageId() == phCLIENT_REQUEST) ||
             (this->m_message.getMessageId() == phCLIENT_RELEASE))
    {
        /* Only send the reply when it has been confirmed we got 
         * the mutex or failed to */
        rc = this->m_system->handle_message(this->m_message);
        phPRINT_RC(rc,NULL,"m_system->handle_message");
        
        if (rc != phSUCCESS)
        {
            message_id = phCLIENT_FAIL;
        }

        rc = this->send_client_message(message_id);
        phPRINT_RC(rc,NULL,
            "send_client_message(%d) failed.",
            message_id);
    }
    else
    {
        phPRINT_RC(-1,NULL,"Unrecognized message: %d",
                 this->m_message.getMessageId());
    }

    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;
error:
    /* We're using 'locked' to tell whether we want to unlock
     * within this method. This thread could own it several times and
     * we don't want to unlock one this method doesn't own */
    phTHIS_ERROR_UNLOCK(locked);

    return phFAIL;
}

/* ------------------------------------------------------------------------- *
 * handle_client_hello: 
 * ------------------------------------------------------------------------- */
int phClientHandler::handle_client_hello()
{
    phFUNCTION("phClientHandler::handle_client_hello")
    int locked = 0;
    
    phTHIS_LOCK(locked);

    /*
     * phPROGRESS("Received HELLO from client...\n");
     * this->m_message.print(stderr);    
     */

    /* This is an initialization step...
     * The sending of the phCLIENT_HELLO back to the client will send
     * this node's ID and the client's ID to be used from then on */

    rc = this->send_client_message();
    phPRINT_RC(rc,NULL,"this->send_client_message(phCLIENT_HELLO) failed.");
    
    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;
error:
   
    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------- *
 * handle_client_goodbye: 
 * ------------------------------------------------------------------------- */
int phClientHandler::handle_client_goodbye()
{
    phFUNCTION("phClientHandler::handle_client_goodbye")
    int locked = 0;
    
    phTHIS_LOCK(locked);

    /*
     * phPROGRESS("Received HELLO from client...\n");
     * this->m_message.print(stderr);    
     */

    /* This is an initialization step...
     * The sending of the phCLIENT_HELLO back to the client will send
     * this node's ID and the client's ID to be used from then on */

    rc = this->send_client_message();
    phPRINT_RC(rc,NULL,"this->send_client_message(phCLIENT_GOODBYE) failed.");
    
    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;
error:
   
    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------- *
 * : 
 * ------------------------------------------------------------------------- */
int phClientHandler::send_client_message(uint32_t message, uint32_t mutex_id)
{
    phFUNCTION("phClientHandler::send_client_message")
    int locked = 0;
    
    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. If we succeed, set 'locked' so
     * the method knows to unlock should something go wrong. */
    phTHIS_LOCK(locked);

    /* Set the source and destination ID and CLASSes */
    /* SOURCE INFO */
    rc = this->m_message.setSrcId(this->m_controller_id);
    phCHECK_RC(rc,NULL,"this->m_message.setSrcId() failed.");
    
    rc = this->m_message.setSrcClass(phCLASS_NODE);
    phCHECK_RC(rc,NULL,"this->m_message.setSrcClass() failed.");
   
    /* DESTINATION INFO */
    rc = this->m_message.setDstId(this->m_client_id);
    phCHECK_RC(rc,NULL,"this->m_message.setDstId() failed.");
    
    rc = this->m_message.setDstClass(phCLASS_CLIENT);
    phCHECK_RC(rc,NULL,"this->m_message.setDstClass() failed.");
    
    /* Set the id of the message */
    if (message != phCLIENT_INVALID_MSG)
    {
        /* Set the message */
        rc = this->m_message.setMessageId(message);
        phCHECK_RC(rc,NULL,"m_message.setMessage failed.");
    }

    /* set the Mutex id: The mutex is is already set because the handler
     * will only handle one mutex at a time */
    /* 
    rc = this->m_message.setMutexId(mutex_id);
    phCHECK_RC(rc,NULL,"m_message.setMutexId failed.");
    */

    /* send it to the client */
    DEBUG_PRINT("Sending message...\n");
     
    /* this->m_message.print(stderr); */

    rc = this->m_message.send(this->m_sock);
    phCHECK_RC(rc,NULL,"this->m_message.send(%p) failed.",
             this->m_sock );
    
    DEBUG_PRINT("Sent message.\n");

    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;

error:
    /* We're using 'locked' to tell whether we want to unlock
     * within this method. This thread could own it several times and
     * we don't want to unlock one this method doesn't own */
    phTHIS_ERROR_UNLOCK(locked);
  
    return phFAIL;
}

/* ------------------------------------------------------------------------- *
 * wakeup: 
 * ------------------------------------------------------------------------- */
int phClientHandler::wakeup()
{
    phFUNCTION("phClientHandler::wakeup")
    int locked = 0;

    /* Don't lock, we won't get through it if the handler is waiting
     * for messages */
    /* phTHIS_LOCK(locked); */
    
    phPROGRESS("client:%u\tcontroller:%u\n",
            this->m_client_id,
            this->m_controller_id );
    if (this->m_sock != NULL)
    {
        this->m_sock->wakeup();
    }
    
    /* phTHIS_UNLOCK(locked); */
    
    return phSUCCESS;
}
  
/* ------------------------------------------------------------------------- *
 * cleanup:
 * ------------------------------------------------------------------------- */
int phClientHandler::cleanup()
{
    phFUNCTION("phClientHandler::cleanup")
    int locked = 0;

    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. If we succeed, set 'locked' so
     * the method knows to unlock should something go wrong. */
    phTHIS_LOCK(locked);
    
    /* phPROGRESS("\n"); */
    if (this->m_sock != NULL)
    {
        if (this->m_sock->isConnected())
        {
            this->m_sock->disconnect();
        }
    }
    
    /* Free the phSocket class, it's the ClientHandler's responsibility */
    phDelete(this->m_sock);
    
    /* phPROGRESS("\n"); */
    
    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;
error:
    /* We're using 'locked' to tell whether we want to unlock
     * within this method. This thread could own it several times and
     * we don't want to unlock one this method doesn't own */
    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}
    

/* ------------------------------------------------------------------------- * 
 * error:
 * ------------------------------------------------------------------------- */
int phClientHandler::error()
{
    phFUNCTION("phClientHandler::error")
    int locked = 0;

    /* lock the object so we can alter things without worrying about another
     * thread getting to it at the same time. If we succeed, set 'locked' so
     * the method knows to unlock should something go wrong. */
    phTHIS_LOCK(locked);

    /* phPROGRESS("\n"); */
    
    /* Unlock the phClientHandler in case someone wants to do 
     * something with it or has been waiting to */
    phTHIS_UNLOCK(locked);
    
    return phSUCCESS;
error:
    /* We're using 'locked' to tell whether we want to unlock
     * within this method. This thread could own it several times and
     * we don't want to unlock one this method doesn't own */
    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---