serverframework.h

/***************************************************************************
 * 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 SERVERFRAMEWORK_H
#define SERVERFRAMEWORK_H

#include <ptypes.h>

#include <vector>
#include <map>

#include "../common/framework.h"
#include "serverdata.h"
#include "client.h"
#include "serverpacket.h"
#include "../common/presendingchain.h"
#include "../common/plugin.h"


/**
 * @ingroup Server
 * @brief This struct is used to delete all messages for a certain client (when that client disconnects).
 */
struct QueueDeletor
{
   Client * client;
   QueueDeletor(Client * client) : client(client){};
   bool operator() (const ServerPacket * packet) const
   {
      return packet->peer.host == client->getAddress() && packet->peer.port == client->getPort();
   }
   bool operator() (const unsigned int user_id) const
   {
      return client->getId() == user_id;
   }
};

/// @example testserver/testserverframework.h
/**
 * @ingroup Server
 * @brief This class is the framework on the server.
 * it contains a list of connected clients,  a sender, a reciever, pending-ack-list and all the data used to represent the gameworld.
 *
 * @author Lars Langer and Emanuel Greisen
 */
class ServerFramework : public Framework<ServerPacket,ipmsgserver>
{
friend class ServerData;

private:
   unsigned int connection_timeout_length;
   /// All the clients currently talking to the server.
   std::map<unsigned int, Client *> clients;
   /// All clients really connected to the server.
   std::map<unsigned int, Client *> connected_clients;
   typedef std::map<unsigned int, Client *>::const_iterator ConstClientIterator;
   /// The socket used to send packets.
   //ost::UDPSocket socket_send;
   /// Contains all the data on the server.
   std::map<unsigned int, ServerData *> server_data;
   /// Contains a list of pre-sending plugin-chains
   std::map<std::string, PreSendingChain<ServerPacket> *> pre_sending_chains;
   PreSendingChain<ServerPacket> * current_pre_send_chain;
   PreSendingChain<ServerPacket> * default_pre_send_chain;


public:
   ServerFramework(int port);
   ~ServerFramework();

private: // Should be private
   void registerClient(Client * client);
   /// Will be called when a new client initiates a connection with the server.
   void unregisterClient(Client * client);
   /// This method will look up the client based on sender infomation in the packet.
   Client * getClientFromPacket(ServerPacket * packet);
   /// Insert an object of type ServerData to the framework.
   void registerData(ServerData * data);
   /// Will unregister an object of type ServerData from the framework.
   void unregisterData(FrameworkData * data);

public:
   /// Return the object with the given id, or NULL if none exists.
   ServerData * getDataObject(unsigned int objid);
   /// Register a chain of plugins used to process packets before they are added in the outqueue.
   void registerPreSendingChain(const std::string & chainname, const std::vector<Plugin<ServerPacket> *> & stations);
   /// Set the current chain of plugins.
   void setPreSendingChain(const std::string &chainname);
   /// Set the current chain of plugins to the default (no plugins used, strait to the outqueue).
   void setDefaultPreSendingChain( );
   /// This method will "purge" the active presending chain.
   void purgeCurrentPreSendingChain();
   /// Change the number of milliseconds that the server/clients will use to determine if a silent disconnect has occured.
   inline void setConnectionTimeout(unsigned int ct) { connection_timeout_length = ct; };

private:
   /// This method should handle system packets.
   void handleSystemPacket(ServerPacket * p);
public:
   /// This will handle any incomming packets, along with other keep-alive-stuff.
   virtual void keepAlive(unsigned int sleepmillis = 0);
   /// This method will test if a packet is in order,
   /// and if not buffer the packet for later delivery.
   virtual bool isPacketReadyForDelivery(ServerPacket * packet);
   /// This method delivers all packets, and returns any
   /// buffered packets waiting for the packet.
   virtual ServerPacket * deliverPacket(ServerPacket * packet);
   /// Called when we want to insert a pending ack into the pendingacklist.
   virtual void addPendingAck(ServerPacket * packet, bool haslock);
   /// Returns total count of packets buffered on all clients, due to deliver-in-order.
   virtual unsigned int bufferedPackets() const;
   /// This method will be called by the sender when ever it successfully sends a
   /// reliable packet to the socket, we will look up the client and register this
   /// on him/her.
   virtual void sentReliablePacket(ServerPacket * packet);

public:
   /// Get all the well registered clients
   inline std::map<unsigned int, Client *> & getAllClients() { return connected_clients; };
   /// Get all server data objects.
   inline const std::map<unsigned int, ServerData *> & getServerDataObjects() const { return server_data; };

public:
   /// This method will copy the packet and enqueue a copy for each client.
   void enqueuePacket(ServerPacket * packet, const std::map< unsigned int, Client * > & clientlist );
   /// This method will just enqueue the packet for this single client.
   void enqueuePacket(ServerPacket * packet, Client * client );

public:
   void start();

protected: // These method should be implemented on the GameServer
   /// This method should write it's reply in the reply-packet, and return true
   /// or false depending on wether it want's us to continue the handshaking.
   virtual bool onInitialHandshake(ServerPacket * handshake, ServerPacket * reply) = 0;
   /// This method will be invoked when a new client has passed the handshaking-phase.
   virtual void onClientConnected(Client * client) = 0;
   /// This method will be invoked when a client has timed out.
   virtual void onClientDisconnected(Client * client) = 0;
   /// This method should return some dirivative of the Client-class.
   virtual Client * createClient(const ipaddress &addr, int port) = 0;
   /// This method should add a sequence number to the pluginpacket if it does not already have one.
   virtual void addPluginSequenceNumber( ServerPacket * packet);

};

#endif

---