MessageServer.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
/*! \file MessageServer.h
*  \brief Declares the class that routes messages around the system.
*  \author $Author: rsharo $
*  \version $Revision: 1.1 $
*  \date    $Date: 2004/04/07 13:45:04 $
*///////////////////////////////////////////////////////////////////////////////
#ifndef MESSAGE_SERVER_H
#define MESSAGE_SERVER_H

#include "ace/INET_Addr.h"
#include "ace/SOCK_Dgram.h"
#include "ace/Reactor.h"

#include <map>

#include "Comm/AddressClient.h"

class MessageClient;


//
// This class manages incoming and outgoing network messages.  Message clients
// send outgoing messages through this class, and incoming messages
// are read in this class and dispatched to the respective message clients.
class MessageServer : public ACE_Event_Handler
{
public:
        //
        // MessageClients may call RegisterClient() and RemoveClient()
        // even though those methods are not public.
        friend class MessageClient;

        //
        // Constructs a Message server.  Given the IP address of the 
        // AddressServer, this constructor instantiates
        // an AddressClient as a child of this MessageServer as well.
        // The address client will be registered with the reactor
        // when RegisterWithReactor() is called for this object.
        // The message server's UDP port will be opened with the
        // specified local IP address.
        // Note that the message server will not be useful until
        // RegisterWithReactor() is called.
        explicit MessageServer (const ACE_INET_Addr &addrServer,
                const ACE_INET_Addr &localAddr=ACE_INET_Addr());

        //
        // Constructs a Message server.  This constructor instantiates
        // a MessageServer and connects it to the supplied AddressClient.
        // If the "takeOwnership" flag is set, it is assumed that
        // the supplied client is to be registered and deregistered
        // to/from the reactor, and deleted from the MessageServer's
        // destructor as if it were allocated by the MessageServer itself.
        // If the "take ownership" flag is false, then the AddressClient
        // will simply be used by the MessageServer and never registered,
        // deregistered, or destroyed.
        // The message server's UDP port will be opened with the
        // specified local IP address.
        // Note that the message server will not be useful until
        // RegisterWithReactor() is called for the MessageServer and,
        // if the AddressClient is not owned, for the AddressClient as well.
        explicit MessageServer (AddressClient *addrClient,
                bool takeOwnership = false,
                const ACE_INET_Addr &localAddr=ACE_INET_Addr());

        //
        // Destroys the message server. RemoveFromReactor() should have
        // been called before destruction. If the MessageServer owns
        // its AddressClient, then the AddressClient will be destroyed
        // as well.
        ~MessageServer (void);
        
        //
        // Registers the MessageServer with a reactor.  If the MessageServer
        // owns its AddressClient, the address client will be registered with
        // the reactor as well. Once registered, the message server can be used
        // to route messages among MessageClients.
        // Returns 0 on success or -1 on failure.
        int RegisterWithReactor(ACE_Reactor &theReactor);

        //
        // Removes the MessageServer from a reactor.  If the MessageServer
        // owns its AddressClient, the address client will be removed from
        // the reactor as well. Once removed, the message server can no longer be
        // used to route messages among MessageClients.
        // Returns 0 on success or -1 on failure.
        int RemoveFromReactor(ACE_Reactor &theReactor, bool immediate = false);

        //
        // Provides access to the MessageServer's AddressClient.
        // Returns a pointer to the AddressClient.
        AddressClient *         GetAddressClient() { return m_pAddrClient; }

        
        //
        // Implementation of the handle_input() method derived from
        // ACE_Event_Handler.  This method routes incoming messages to the
        // MessageServer's clients.
        virtual int                     handle_input (ACE_HANDLE fd);   

        //
        // Implementation of the get_handle() method derived from
        // ACE_Event_Handler.  This method returns a handle to the MessageServer's
        // UDP socket.
        virtual ACE_HANDLE      get_handle (void) const;

        //
        // Routes a message to other MessageServers.  MessageClients call this
        // method when they want to transmit a message.  The IP addresses
        // bound to the destination ID are retrieved from the AddressServer and
        // the message is sent to each of those IP addresses with a header.
        // Returns 0 if all message transmissions succeed, -1 otherwise.
        int SendMessage(u_int originator, const void *msg, size_t len, u_int dest);

protected:
        //
        // This is the header that is pre-pended to all outgoing messages.
        // It contains a magic number that allows determination of endianness
        // and fields to route and verify the integrity of the message.
        typedef struct MsgHdr
        {
                //
                // This is the big-endian interpretation of the characters
                // "MESG"  If the sender and receiver don't have the same endianness,
                // this magic number will be reversed on the receiver side.
                enum { MAGIC_NUMBER = 0x4D455347 };

                //
                // Constructs a message header and initializes the magic number.
                MsgHdr() : m_magicNumber(MAGIC_NUMBER) {}

                //
                // The magic number that identifies this block as a message and
                // shows its endianness.
                u_int m_magicNumber;
                //
                // The client ID to which this message is destined.
                u_int m_destination;
                //
                // The length of the data following this header.
                u_int m_msgLength;
        } MsgHdr_t;

        //
        // The data structure used to keep track of the clients and
        // their IDs.
        typedef std::multimap<u_int, MessageClient *>   ClientMap_t;
        //
        // The internal structure that holds a single client/ID pair.
        typedef ClientMap_t::value_type                                 ClientValue_t;

protected:
        //
        // Maps a client to receive messages with a given ID.
        // Note that this method will fail if the client is already
        // registered for the given ID.
        // This method is normally only called from MessageClient::Register().
        // Returns 0 on success and -1 on failure.
        int RegisterClient(u_int id, MessageClient *client);

        //
        // Removes a client mapping for a given ID.
        // The client will no longer receive messages with this ID.
        // Note that this method will fail if the client is not registered
        // for the given ID.
        // This method is normally only called from MessageClient::Deregister().
        // Returns 0 on success and -1 on failure.
        int RemoveClient(u_int id, MessageClient *client);

        //
        // Implementation method that removes a MessageClient from 
        // the client map.  It is called as part of RemoveClient()
        // or any time a MessageClient returns -1 from
        // MessageClient::ReceiveMessage().
        // Note that this method is not synchronized (it acquires no mutexes).
        // It depends on the calling method to ensure synchronicity.
        // Returns an iterator pointing to the element immediately following
        // the removed one in the client map.
        ClientMap_t::iterator RemoveClient_i(ClientMap_t::iterator it);

protected:
        typedef AddressClient::AddrList_t                               AddrList_t;

        ACE_Thread_Mutex                                                                m_clientMutex;
        ClientMap_t                                                                             m_clients;

        AddressClient                                                                   *m_pAddrClient;
        bool                                                                                    m_addrClientOwned;

        ACE_INET_Addr                                                                   m_localAddr;
                
private:
        ACE_SOCK_Dgram                                                                  m_socket;
        char                                                                                    m_buf[BUFSIZ];
};



#endif // MESSAGE_SERVER_H

---