8. Plugins (pack/unpack)

In this test we create a plugin that aggregates packets and send one collected packet when purged. This is a good example of the usage of plugins, since it makes sense to sometimes want to aggregate all data to a client into bulks, to minimize overhead.

Test Plugin

The plugin has both a packing and unpacking side to it. The packing side gets packets in the member method:

Plugin::pack(PacketType * packet);

Here it appends the packet to a packet for the given client. If no packet for this client exists it creates one. When the server calls the "purge()" method the plugin wraps up it's packets and sends them along.

On the receiving side the plugin will read the size of the packets, one by one, untill it reads a 0 size packet, this means that there are no more packets, and the readin stops. All this happens in the unpack(...) method.

/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/
#ifndef H_TEST_PLUGIN_H
#define H_TEST_PLUGIN_H

#include <map>

#include "../Ganef/common/plugin.h"

template<class PacketType>
class MyTestPlugin : public Plugin<PacketType>
{
   private:
      std::map<unsigned int, PacketType *> aggr_packs;
      typedef typename std::map<unsigned int, PacketType *>::iterator MapIterator;

   public:
      /// This method must return a unique number identifying the plugin.
      virtual const unsigned int getUniqueId() const
      {
         return 0x12345;
      }
      /// Will be called when ever a packet must be packed.
      virtual void pack(PacketType * packet)
      {
         std::cout << "MyTestPlugin::pack(" << packet << ")\n";
         if(aggr_packs.find(packet->getUserID()) == aggr_packs.end())
         {
            std::cout << "Creating new Aggregation packet for client: " << packet->getUserID() << std::endl;
            aggr_packs[packet->getUserID()] = PacketType::createPluginPacket(this, packet);
         }

         // Add a new packet
         aggr_packs[packet->getUserID()]->writeUInt32(packet->getSize());
         aggr_packs[packet->getUserID()]->writePacket(packet);
         delete packet;
      }
      /// Will be called when ever a packet must be unpacked.
      virtual void unpack(PacketType * packet)
      {
         std::cout << "MyTestPlugin::unpack(" << packet << ")\n";
         unsigned int psize;
         while((psize = packet->readUInt32()) != 0)
         {
            std::cout << "There is a packet of size:" << psize << std::endl;
            PacketType * p = packet->readPacket(psize);
            forwardUnpack(p);
         }

         // This is of no more use
         delete packet;
      }

      /// Will be called when ever we must purge our packets
      virtual void onPurge()
      {
         MapIterator it;
         for(it = aggr_packs.begin(); it != aggr_packs.end(); ++it)
         {
            PacketType * pack = it->second;
            pack->writeUInt32(0); // This ends the packet
            std::cout << "Purging a packet of size: " << pack->getSize() << std::endl;
            forwardPack(pack);
         }
         // Clean up our map
         aggr_packs.clear();
      }
};

#endif

Client Application

The client application in this example uses the member method:

ClientFramework::registerPlugin(Plugin<ClientPacket> * plugin);

to register the plugin. It should be noted that opposed to the server the client does not specify chains of plugins, since every unpacking should result in new packets forwarded back to the inqueue. That way recursively unpacking nested packets.

/// @cond EXCLUDEDTESTSOURCES
/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/

#include <iostream>
#include <cstdlib>

#include "../Ganef/client/clientframework.h"
#include "../Ganef/client/clientdata.h"

#include "test_plugin.h"

class MyClientData : public ClientData
{
   private:
      int x,y;

   public:
      MyClientData(ClientFramework * f, ClientPacket * p) : ClientData(f,p),x(0),y(0)
      {
         x = p->readInt32();
         y = p->readInt32();
         std::cout << "Constructed a new object of class: MyClientData" << std::endl;
         std::cout << " - The new object has ID: " << getFrameworkId() << std::endl;
         std::cout << " - And (x:"<<x<<",y:"<<y<<")" << std::endl;
      }
      virtual void updatePacket(ClientFramework * f, unsigned char updatetype, ClientPacket * packet)
      {
         // Here we receive updates (but no updates are comming in this test)
      }

      static ClientData * constructMyClientData(ClientFramework * f, ClientPacket * p)
      {
         return new MyClientData(f,p);
      }
};


/**
 * This is just a test-client-framework.
 * @author Lars Langer and Emanuel Greisen
 */
class TestClientFramework : public ClientFramework
{
   private:
      bool is_running;
      std::string server_hostname;

   public:
      TestClientFramework(const std::string & server_hostname) : ClientFramework(int(0)),server_hostname(server_hostname)
      {
         // Notice how the constructor is registered, now all we need is the
         // server sending a packet telling us to construct an object of
         // class with id: 0x424242
         registerConstructor(0x424242, MyClientData::constructMyClientData);
      }
      ~TestClientFramework()
      {
      };

   protected: // These must be implemented in a derived class
      virtual void writeHandshakeInitMessage( ClientPacket * fp ){}
      virtual void onHandshakingDiscontinue( ClientPacket * fp ){}
      virtual bool onHandshakeDescription( ClientPacket * fp, ClientPacket * reply )
      {
         return true;
      }
      virtual void onDisconnect( ) { std::cout << "Disconnected\n"; }
      virtual void onConnect( ){ std::cout << "Connected\n"; }

   public:
      void mainLoop( )
      {
         // First we register the plugin for use when decoding packets.
         //  You might note that the plugin is a template class and that
         //  we use different packet-types on the server and client
         //  This is no big issue, because they are almost the same (they
         //  both implement the same methods used in the plugin).
         registerPlugin(new MyTestPlugin<ClientPacket>());

         // Then we connect to the server
         std::cout << "Connecting to: " << server_hostname <<":"<< 8000<< std::endl;
         initServerConnection(server_hostname, 8000);
         is_running = true;
         while(is_running)
         {
            // Get/handle Packets from the framework
            keepAlive();

            // Then we sleep to let the CPU live
            psleep(50);
         }
      }
};




int main(int argc, char *argv[])
{
   std::string server_host("localhost");
   if(argc > 1)
      server_host = argv[1];
   TestClientFramework app(server_host);

   // Start the Application
   app.mainLoop();
}

/// @endcond

Server Application

The server in this test creates some objects first. Then when a client connects, it switches the presending chain to use the plugin we have created for the test. Then it sends the client constructor packets for all the data. Finally it purges the presending chain, to let the plugin know that it should send along its aggregated packets. After this it changes back to the default presending chain (the chain where packets are inserted directly into the outqueue).

/// @cond EXCLUDEDTESTSOURCES
/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/

#include <iostream>
#include <cstdlib>
#include <vector>

#include "test_plugin.h"

#include "../Ganef/server/serverframework.h"


class MyServerData : public ServerData
{
   private:
      int x,y;

   public:
      // The two last parameters for ServerData is the priority of its updatepackets
      //  and wether they should be sent reliable.
      MyServerData(ServerFramework * fw) : ServerData(fw, 10, false)
      {
         x = 200;
         y = 150;
      };
   public:
      /// This must produce a unique id for this class, it will be used on the client side to construct new objects.
      virtual const unsigned int getClassId() const { return 0x424242; };
      /// Here the data-class should fill in data according to update type `type`.
      virtual void fillUpdatePacket(ServerPacket * packet, unsigned char type) const
      {
         // We do not use updates in this test.
      }
      /// Here the data-class should fill in all data required by the constructor on the client side.
      virtual void fillCreateObjectPacket(ServerPacket * packet) const
      {
         // Here we supply enough data to create the client-version of this object
         // Remember to make absolutely sure that what you write here is exactly the
         //   same as the client version reads in its constructor.
         packet->writeInt32(x);
         packet->writeInt32(y);
      }
      /// Called when ever we receive a packet for this object from a client.
      virtual void clientPacket(Client * client, unsigned char type, ServerPacket * packet)
      {
         // We do not receive any actions from the client in this test.
      }

};

/**
 * This is just a test server-framework;
 * @author Lars Langer and Emanuel Greisen
 */
class TestServerFramework : public ServerFramework
{
   public:
      TestServerFramework() : ServerFramework(8000)
      {
      }

      ~TestServerFramework()
      {
      }

   protected: // These method should be implemented on the GameServer
      virtual bool onInitialHandshake(ServerPacket * handshake, ServerPacket * reply)
      {
         return true; // Accept all clients.
      }
      virtual void onClientConnected(Client * client)
      {
         std::cout << "Client: " << client->getId() << " connected\n";

         // Here we send the construction packages for all Framework Data
         // But first we change the "chain" of plugins to use our registered one.
         setPreSendingChain("MyPluginChain");
         std::map<unsigned int, ServerData *>::const_iterator it;
         for(it = getServerDataObjects().begin(); it != getServerDataObjects().end(); ++it)
         {
            ServerData * s_data = it->second;
            s_data->sendCreateObject(client);
         }
         // Since our plugin aggregates the packets we need to purge it to make
         // sure everything is sent.
         purgeCurrentPreSendingChain();

         // Once we have sent all our constructor packets to the client we revert to
         // the default send-chain (the empty send chain)
         setDefaultPreSendingChain();
      }
      virtual void onClientDisconnected(Client * client)
      {
         std::cout << "Client: " << client->getId() << " disconnected\n";
      }
      virtual Client * createClient(const ipaddress &addr, int port)
      {
         return new Client(this, addr, port);
      }

   public:
      void mainLoop()
      {
         // First we create a vector of plugins (this one only containing one)
         std::vector< Plugin<ServerPacket> * > chainlist;
         chainlist.push_back(new MyTestPlugin<ServerPacket>());
         // Then we register this "chain" under a name
         registerPreSendingChain("MyPluginChain", chainlist);

         std::cout << "TestServerFramework: Running\n";

         // Construct a lot of data
         std::vector<MyServerData *> mydata;
         for(int i = 0; i < 10; i++)
            mydata.push_back(new MyServerData(this));

         while(true)
         {
            // Get all incomming messages
            keepAlive();

            // Send an update to all connected clients without using our plugin
            for(std::vector<MyServerData *>::iterator it = mydata.begin(); it != mydata.end(); ++it)
            {
               //FIXME: (*it)->sendUpdateToAll(42, false);
            }

            // Sleep a little
            psleep(100);
         }
      }
};




int main(int argc, char *argv[])
{
   try
   {
      // Create a framework
      TestServerFramework framework;

      // Start the framework
      framework.start();

      // GameLoop
      framework.mainLoop();
   }
   catch(FrameworkError *err)
   {
      std::cout << "FrameworkError:" << err->msg << std::endl;
   }
   catch(PacketError *err)
   {
      std::cout << "PacketError:" << err->msg << std::endl;
   }

   return EXIT_SUCCESS;
}

/// @endcond

---