protocol.cpp

Go to the documentation of this file.

/*
 * protocol.cpp
 *
 * Copyright (C) 2007,2009  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.
 *
 *
 * Base protocol objects.
 */

// includes --------------------------------------------------------------------
#include "protocol.h"           // always include our own header first!

#include <sstream>

#include "common/wave_ex.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "netlib/netlib.h"
#include "perf/perf.h"


namespace aesop {



//
//      static helper methods
//

static void
addHeader
(
IO netlib::MessageBuffer * buffer,
IN const char * namespace_,
IN const char * command
)
{
        ASSERT(buffer, "null");
        ASSERT(namespace_, "null");
        ASSERT(command, "null");

        buffer->appendToken("header {\nnamespace ");
        buffer->appendToken(namespace_);
        buffer->appendToken("\ncommand ");
        buffer->appendToken(command);
        buffer->appendToken("\n}\n");
}



static smart_ptr<netlib::MessageBuffer>
createMessageFromString
(
IN const char * namespace_,
IN const char * command,
IN const char * data
)
{
        perf::Timer timer("aesop::createMessageFromString");
        ASSERT(namespace_, "null");
        ASSERT(command, "null");
        ASSERT(data, "null");

        // even an empty message must at least contain a line return!
        static const long warnBytes = 1024;     // bigger than 1K is bad...
        long nBytes = strlen(data);
        ASSERT(nBytes > 0, "empty data string for message?");
        ASSERT('\n' == data[nBytes - 1],
            "data string must end in line return!\n%sEND", data);
        if (nBytes > warnBytes) {
                DPRINTF("WARNING!  large message (%ld bytes)", nBytes);
                DPRINTF("  namespace='%s'   command='%s'", namespace_, command);
        }

        // create buffer
        smart_ptr<netlib::MessageBuffer> buffer =
            netlib::MessageBuffer::create();
        ASSERT(buffer, "failed to create message buffer");

        // add payload (header + data)
        addHeader(buffer, namespace_, command);
        buffer->appendToken("data {\n");
        buffer->appendData(data, nBytes);
        buffer->appendToken("}\n");
        buffer->close();

        // DPRINTF("Message:\n%s", buffer->getData());
        return buffer;
}



static smart_ptr<netlib::MessageBuffer>
createMessageFromSStream
(
IN const char * namespace_,
IN const char * command,
IN const std::ostringstream& oss
)
{
        ASSERT(namespace_, "null");
        ASSERT(command, "null");

        return createMessageFromString(namespace_, command, oss.str().c_str());
}



/*
static smart_ptr<netlib::MessageBuffer>
createMessageFromDatahash
(
IN const char * namespace_,
IN const char * command,
IN const Datahash * data
)
{
        ASSERT(namespace_, "null");
        ASSERT(command, "null");

        std::ostringstream oss;
        writeHashToStream(data, oss);
        oss << "\n";    // force termination in newline

        return createMessageFromString(namespace_, command, oss.str().c_str());
}
*/



//
//      public API
//



//
//      Message Constructors
//






















































smart_ptr<netlib::MessageBuffer>
createTcpConnectMessage
(
IN long token
)
{
        ASSERT(token, "null");

        std::ostringstream oss;
        oss << "token " << token << "\n";

        return createMessageFromSStream("server", "tcp", oss);
}



smart_ptr<netlib::MessageBuffer>
createNotifyErrorMessage
(
IN eErrorCode errorCode,
IN const char * message
)
{
        // ASSERT(errorCode) -- don't care
        ASSERT(message, "null");

        std::ostringstream oss;
        oss << "errorCode " << errorCode << "\n";
        oss << "message " << message << "\n";

        return createMessageFromSStream("client", "error", oss);
}



smart_ptr<netlib::MessageBuffer>
createConversationDialogMessage
(
IN int localPlayerId,
IN const char * conversationGuid,
IN int dialogId,
IN const char * dialogData
)
{
        ASSERT(localPlayerId > 0, "Bad player ID: %d", localPlayerId);
        ASSERT(conversationGuid, "null");
        ASSERT(dialogId > 0, "Bad dialog id: %d", dialogId);
        ASSERT(dialogData, "null");

        std::ostringstream oss;
        oss << "playerId " << localPlayerId << "\n";
        oss << "conversationGuid " << conversationGuid << "\n";
        oss << "dialogId " << dialogId << "\n";
        oss << "dialog {\n";
        oss << dialogData;
        oss << "}\n";

        return createMessageFromSStream("client", "converse-dialog", oss);
}



smart_ptr<netlib::MessageBuffer>
createConversationReplyMessage
(
IN int playerId,
IN const char * conversationGuid,
IN int dialogId,
IN const char * reply
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(conversationGuid, "null");
        ASSERT(dialogId > 0, "Bad dialog id: %d", dialogId);
        ASSERT(reply, "null");

        std::ostringstream oss;
        oss << "playerId " << playerId << "\n";
        oss << "conversationGuid " << conversationGuid << "\n";
        oss << "dialogId " << dialogId << "\n";
        oss << "reply {\n";
        oss << reply << "\n";
        oss << "}\n";

        return createMessageFromSStream("server", "converse-reply", oss);
}



smart_ptr<netlib::MessageBuffer>
createRefreshConversationMessage
(
IN int playerId,
IN const char * conversationGuid
)
{
        ASSERT(conversationGuid, "null");

        std::ostringstream oss;
        oss << "playerId " << playerId << "\n";
        oss << "conversationGuid " << conversationGuid << "\n";

        return createMessageFromSStream("server", "converse-resend", oss);
}



smart_ptr<netlib::MessageBuffer>
createTerminateConversationMessage
(
IN int playerId,
IN const char * conversationGuid
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(conversationGuid, "null");

        std::ostringstream oss;
        oss << "playerId " << playerId << "\n";
        oss << "conversationGuid " << conversationGuid << "\n";

        return createMessageFromSStream("client", "converse-end", oss);
}



smart_ptr<netlib::MessageBuffer>
createNewGameMessage
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        std::ostringstream oss;
        oss << "playerId " << playerId << "\n";

        return createMessageFromSStream("server", "new-game", oss);
}


};      // aesop namespace