CommFactory.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
/*! \file CommFactory.h
*  \brief Declares the classes that know how to set up the comm network.
*  \author $Author: rsharo $
*  \version $Revision: 1.1 $
*  \date    $Date: 2004/04/07 13:45:04 $
*///////////////////////////////////////////////////////////////////////////////
#ifndef COMM_FACTORY_H
#define COMM_FACTORY_H

class SystemProperties;
class ACE_Reactor;
class AddressServer;
class AddressClient;
class MessageServer;

#include "Comm/ReactorThread.h"

//
// This interface class defines the methods of a communication factory.
// A communication factory knows how to construct and configure
// the components necessary to communicate using the
// MessageClient/MessageServer scheme.
class CommFactory
{
protected:
        //
        // Constructs a CommFactory.  Since this is an abstract
        // base class, this method is protected.
        CommFactory() {}

public:
        //
        // Destroys a CommFactory. This is a virtual
        // destructor that does nothing by itself.
        virtual ~CommFactory() {}

        //
        // Provides access to a functional AddressServer.
        // The server should already be initialized and ready for use.
        // Returns a pointer to an AddressServer, or NULL
        // if none is available.
        virtual AddressServer *GetAddressServer() = 0;

        //
        // Provides access to a functional AddressClient.
        // The client should already be initialized and ready for use.
        // Returns a pointer to an AddressClient, or NULL
        // if none is available.
        virtual AddressClient *GetAddressClient() = 0;

        //
        // Provides access to a functional MessageServer.
        // The server should already be initialized and ready for use.
        // Returns a pointer to an MessageServer, or NULL
        // if none is available.
        virtual MessageServer *GetMessageServer() = 0;

        //
        // Provides access to a functional reactor.
        // The reactor should already be initialized and ready for use.
        // Returns a pointer to a reactor, or NULL
        // if none is available.
        virtual ACE_Reactor * GetReactor() = 0;
};


//
// A CommFactory that can be configured from a SystemProperties object.
// A SystemProperties object can either be read from a configuration file
// or populated programmatically.
// This class reads all the information needed to configure a Comm
// setup from a SystemProperties object. Default values are substituted
// for anything not specified in the properties.
//
// The following is a sample INI-style property file that sets all
// configuration fields to their default values. To use this file, Open
// would be called with the section name "MyServer\\Comm".
//
// ##############################################################################
// # Comm configuration file for MyServer
// ##############################################################################
// [MyServer\Comm]
//
// #-----------------------------------------------------------------------------
// # The following fields specify where to find the address server.
// #    The host field is either a multicast IP address or "DEFAULT"
// #    The port field is either an IP port number or "DEFAULT"
// #    The timeout field says how many seconds we're willing to wait
// #    to talk with the address server before giving up and calling it an error.
// #    A timeout of zero mean "wait forever"
// #-----------------------------------------------------------------------------
// AddrServerHost                                                               = DEFAULT
// AddrServerPort                                                               = DEFAULT
// AddrServerTimeout                                                    = 0
// 
// #-----------------------------------------------------------------------------
// # Fields to create/configure an address server in this process.
// #
// #    You should have exactly one address server running on the network at any
// #    time.
// #
// #    AddrServerAutoDetect tells the factory to look on the network for a
// #    server if it doesn't find one in 5 attempts (takes 5 seconds), it will
// #    spawn its own.
// #
// #    SpawnAddrServer tells the factory to spawn an address server. Use this
// #    if you always start the applications in a specific order. If
// #    AddrServerAutoDetect is enabled, it supercedes any setting to
// #    SpawnAddrServer.  Note that only one process on the network should have
// #    this field set to true.
// #
// #    Normally loopback will be enabled for this application. If its disabled
// #    then the process will only be able to function as a standalone address
// #    server -- message clients won't work.
// #
// #    The time to live (AddrServerTTL) field decides whether the address
// #    server can talk through network routers. A value of one means it can't.
// #    For each value higher, the address server can talk through one router.
// #    Unless your project spans several subnets, leave this value at one.
// #
// #    The AddrServerInterface field determines which ethernet adapter the
// #    address server will listen on. If your computer has multiple network
// #    ports, this should be set to the one you share with other processes in
// #    this application. If you want to bridge multiple adapters, leave this
// #    field as "". On Windoze machines, an interface is specified by its
// #    network address, for example, "192.168.0.1".
// #    On linux/unix flavors, its specified as the device name,
// #    for example, "eth1".
// #-----------------------------------------------------------------------------
// AddrServerAutoDetect                                                 = TRUE
// SpawnAddrServer                                                              = FALSE
// AddrServerLoopback                                                   = TRUE
// AddrServerTTL                                                                = 1
// AddrServerInterface                                                  = ""

// #-----------------------------------------------------------------------------
// # Fields to determine how Comm handles messages.
// #
// #   NumReactorThreads determines how many threads to allocate to Comm. You
// #   need at least 1 thread if you don't create a local address server, and
// #   you at least 2 if you do. If you're auto-detecting, you should be sure
// #   to budget that extra thread...
// #-----------------------------------------------------------------------------
// NumReactorThreads                                                    = 2
//
// ##############################################################################
// # End MyServer\Comm
// ##############################################################################
class PropertyBasedCommFactory : public CommFactory
{
public:
        //
        // Default constructor for a PropertyBasedCommFactory.
        // The factory will not be useful until Open() is called.
        PropertyBasedCommFactory();

        //
        // Constructor for a PropertyBasedCommFactory.
        // Constructs the factory and configures its components.
        // Note that this constructor can't return an error code on
        // failure. If there's any chance that configuration will fail,
        // the default constructor should instead be used with an explicit
        // call to Open().
        PropertyBasedCommFactory(SystemProperties &props, const char *mySection);

        //
        // Destroys the CommFactory and all its components.
        // If Close() has not already been called, it will be called
        // from the destructor.
        virtual ~PropertyBasedCommFactory();

        //
        // Configures the factory's components for comm.  The specified
        // section of the system properties will be read to determine
        // how comm should be configured.  If the specified section is not found,
        // a default configuration will be used (with a logged warning).
        // Returns 0 on success or -1 on failure.
        virtual int Open(SystemProperties &props, const char *mySection);

        //
        // Closes down the factory's comm components.  Message clients
        // will no longer be able to send/receive messages.
        // Returns 0 on success or -1 on failure.
        int Close();

        //
        // Returns the factory's address server.
        // Returns a pointer to the factory's address server, or NULL
        // if no local address server was constructed.
        virtual AddressServer *GetAddressServer() { return m_pAddressServer; }

        //
        // Returns the factory's address client.
        // Returns a pointer to the factory's address client, or NULL
        // if no address client is available.
        virtual AddressClient *GetAddressClient() { return m_pAddressClient; }

        //
        // Returns the factory's message server.  Message clients will typically
        // get the message server using this method and register themselves
        // with the returned object. Returns a pointer to the factory's message
        // server, or NULL if no message server is available.
        virtual MessageServer *GetMessageServer() { return m_pMessageServer; }

        //
        // Provides access to a the factory's reactor.
        // Returns a pointer to the reactor, or NULL if no reactor is available.
        virtual ACE_Reactor * GetReactor() { return m_pReactor; }

protected:
        ACE_Reactor   * m_pReactor;
        ReactorThread * m_pReactorThread;
        AddressClient * m_pAddressClient;
        AddressServer * m_pAddressServer;
        MessageServer * m_pMessageServer;
};


#endif // COMM_FACTORY_H

---