AddressServer.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
/*! \file AddressServer.h
*  \brief Declares the class that keeps track of all the networked processes.
*  \author $Author: rsharo $
*  \version $Revision: 1.1 $
*  \date    $Date: 2004/04/07 13:45:04 $
*///////////////////////////////////////////////////////////////////////////////
#ifndef ADDRESS_SERVER_H
#define ADDRESS_SERVER_H

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

#include <map>

//
// A reactor-based class that stores and reports message ID bindings via UDP.
//
// This class is a fundamental part of the MessageClient/MessageServer scheme.
// Message clients are user-derived classes that send and receive messages
// on the network. Message clients carry an integer identifier that
// determines which messages they are to receive.  Since clients can be
// distributed over a network, a means is needed to keep track of which
// message clients are at which IP addresses -- or more specifically which
// IP addresses are interested in which messages.
//
// An address server is an object that holds the mappings from message ID
// to IP address (called bindings). The address server will typically
// be located at a multicast address so it can be relocated anywhere on
// the network without changing its IP address.
//
// The AddressServer class is a subclass of ACE_Event_Handler, and must
// be registered with an ACE_Reactor to function properly.
class AddressServer : public ACE_Event_Handler
{
public:
        //
        // Constructor. 
        // Constructs an AddressServer and binds it to the specified
        // multicast address and port.
        // If an interface is specified, then the server will listen
        // on that ethernet interface only.
        // The server must be registered with a reactor before it will be
        // useful, however.
        explicit AddressServer (u_short port = ACE_DEFAULT_MULTICAST_PORT,
                const char *mcast_addr = ACE_DEFAULT_MULTICAST_ADDR,
                const char *mcast_iface=NULL);

        //
        // Constructor. 
        // Constructs an AddressServer and binds it to the specified
        // multicast IP address.
        // If an interface is specified, then the server will listen
        // on that ethernet interface only.
        // The server must be registered with a reactor before it will be
        // useful, however.
        explicit AddressServer (const ACE_INET_Addr &mcast_addr,
                const char *mcast_iface=NULL);

        //
        // Destroys the AddressServer.  The server should have been
        // deregistered from its reactor (if any) before this method
        // is called.
        ~AddressServer (void);
        
        //
        // Enables/disables loopback of multicast messages.
        // AddressClients on the same host will not be able to communicate
        // with the AddressServer unless loopback is enabled.
        // Returns 0 on success and -1 on failure.
        int SetLoopbackEnable(bool enabled);

        //
        // Sets the multicast message time to live (TTL).
        // If TTL is set to 1, then messages will only be sent on the local
        // subnet. Setting this number higher determines how many routers through
        // which multicast messages may travel.  Set this higher than one only 
        // if you have clients on different subnets than the server.
        // Returns 0 on success or -1 on failure.
        int SetTimeToLive(u_char ttl);

        //
        // Connect this object to a reactor.
        // The server will not receive network communication until this is called.
        // Returns zero on success and -1 on failure.
        int RegisterWithReactor(ACE_Reactor &theReactor);

        //
        // Disconnect this object from a reactor.
        // The server will no longer receive network communication after
        // this is called. This method should be called prior to destroying the
        // AddressServer.
        // Returns zero on success and -1 on failure.
        int RemoveFromReactor(ACE_Reactor &theReactor);

        //
        // Implementation of the handle_input() method derived from
        // ACE_Event_Handler.  This method processes messages sent to the address
        // server's multicast UDP socket.
        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 AddressServer's
        // multicast UDP socket.
        virtual ACE_HANDLE      get_handle (void) const;

protected:
        //
        // This method sends an ASCII string to the specified destination
        // address via UDP.
        // Returns the number of bytes sent on success and -1 on failure.
        int SendString(const char *str, const ACE_INET_Addr &dest);

        //
        // Notifies all registered AddressClients that a global change
        // to the bindings has occured (such as a "CLEAR_BINDINGS" command).
        // Returns 0 if all clients were successfully notified, or -1
        // if any failures occurred.
        int NotifyChange();

        //
        // Notifies all registered AddressClients that the bindings for a given
        // message ID have changed (such as a "ADD" or "REMOVE" command).
        // Returns 0 if all clients were successfully notified, or -1
        // if any failures occurred.
        int NotifyChange(u_int id);
                
private:
        //
        // The data structure type used to hold ID/address bindings.
        typedef std::multimap<u_int, std::string>       BindMap_t;

        //
        // The internal data type of a single binding.
        typedef BindMap_t::value_type                           BindValue_t;

        //
        // The data structure type used to record the AddressClient
        // notification list.
        typedef std::map<u_int,ACE_INET_Addr>           NotificationMap_t;

        //
        // The internal data type of a single notification entry.
        typedef NotificationMap_t::value_type           NotificationValue_t;

        ACE_INET_Addr                                                           m_remoteAddr;
        char                                                                            m_buf[BUFSIZ];
        
        ACE_SOCK_Dgram                                                          m_replySocket;
        ACE_SOCK_Dgram_Mcast                                            m_mcastDgram;
        ACE_INET_Addr                                                           m_mcastAddr;

        BindMap_t                                                                       m_bindings;

        NotificationMap_t                                                       m_observers;
        u_int                                                                           m_nextObserverID;
};



#endif // ADDRESS_SERVER_H

---