srv-msg-router.cpp

Go to the documentation of this file.

/*
 * srv-msg-router.cpp
 *
 * Copyright (C) 2008  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of basic message routing.  Given a message from a client,
 * determine what to do next.  See srv-msg-router.h
 */

// includes --------------------------------------------------------------------
#include "srv-msg-router.h"             // always include our own header first!

#include "perf/perf.h"
#include "datahash/datahash_util.h"
#include "aesop-proto/protocol.h"


namespace aesop {


// interface destructor implementation
MessageRouter::~MessageRouter(void) throw() { }
StateUpdates::~StateUpdates(void) throw() { }


// protocol version
static const int s_major                        = 0;
static const int s_minor                        = 1;


//
//      handlers (pull these out?)
//

static void
handlerConverseReply
(
IN handler_state_t& state
)
{
        const Datahash * params = state.payload.arguments;
        ASSERT(params, "null");

        const char * conGuid = getString(params, "conversationGuid");
        int dialogId = getInt(params, "dialogId");
        if (dialogId < 1) {
                DPRINTF("Bad dialog ID: %d", dialogId);
                DPRINTF("Rejecting converse-reply message");
                return;
        }

        int playerId = getInt(params, "playerId");
        if (playerId < 1) {
                DPRINTF("Bad player ID: %d", playerId);
                DPRINTF("Rejecting converse-reply message");
                return;
        }
        smart_ptr<Datahash> reply = getSubhash(params, "reply");
        ASSERT(reply, "null");

        state.updates->notifyDialogReplyTS(state.src_env.fromConnId,
                                        conGuid,
                                        dialogId,
                                        playerId,
                                        reply);
}



static void
handlerTcpConnect
(
IN handler_state_t& state
)
{
        const Datahash * params = state.payload.arguments;
        ASSERT(params, "null");

        long token = getLong(params, "token");
        if (!token) {
                DPRINTF("Bad connection token");
                return;
        }

        state.updates->newTcpConnectionTS(state.src_env.fromConnId, token);
}



static void
handlerNewGame
(
IN handler_state_t& state
)
{
        DPRINTF("In handlerNewGame()...");

        const Datahash * params = state.payload.arguments;
        ASSERT(params, "null");

        int playerId = getInt(params, "playerId");
        if (playerId < 1) {
                DPRINTF("Bad player ID: %d", playerId);
                return;
        }

        state.updates->newGameTS(state.src_env.fromConnId, playerId);
}



static void
handlerShutdown
(
IN handler_state_t& state
)
{
        DPRINTF("In handlerShutdown()...");

        ASSERT(state.updates, "null updates");
        state.updates->requestShutdownTS();
}



// struct to define a mapping from incoming message --> handler
struct handler_entry_t {
        const char *            command;
        msg_handler_fn          handler;
};

#define HANDLER_ENTRY(cmd, hndl) { cmd , hndl },


// message map - this is the routing table!
// slightly more efficient to list common messages first
static const handler_entry_t s_handlers[] = {

        // assumed to be namespace "server"!
        //              command                 handler
        HANDLER_ENTRY("converse-reply",         handlerConverseReply)
        HANDLER_ENTRY("tcp",                    handlerTcpConnect)
        HANDLER_ENTRY("new-game",               handlerNewGame)
        HANDLER_ENTRY("shutdown",               handlerShutdown)

        // must be last!
        { NULL, NULL }
};



static msg_handler_fn
lookupHandler
(
IN const char * namespace_,
IN const char * cmd
)
{
        if (strcmp(namespace_, "server")) {
                DPRINTF("Unrecognized namespace: '%s'", namespace_);
                return NULL;
        }

        for (const handler_entry_t * p = s_handlers; p->command; ++p) {
                if (!strcmp(cmd, p->command)) {
                        // this is it!
                        return p->handler;
                }
        }

        // not found!
        DPRINTF("Unrecognized command: '%s'", cmd);
        return NULL;
}



//
//      Router object
//

class Router : public MessageRouter {
public:
        ~Router(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void);

        // aesop::MessageRouter class interface methods -----------------------
        msg_handler_fn getHandler(IN const tcp_payload_t& payload);

private:
        // private helper methods ----------------------------------------------

        // private member data -------------------------------------------------
};



void
Router::initialize
(
void
)
{
}



msg_handler_fn
Router::getHandler
(
IN const tcp_payload_t& payload
)
{
        ASSERT(!payload.is_empty(), "empty?");
//      DPRINTF("Received a message from connection 0x%04lx", msg.conn_id);

        return lookupHandler(payload.namespace_.c_str(),
            payload.command.c_str());
}



//
//      public API
//

smart_ptr<MessageRouter>
MessageRouter::create
(
void
)
{
        smart_ptr<Router> local = new Router;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // aesop namespace