CommFactory.cpp

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
/*! \file CommFactory.cpp
*  \brief Defines 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 $
*///////////////////////////////////////////////////////////////////////////////
#include "CommFactory.h"

#include "ace/INET_Addr.h"
#include "ace/Reactor.h"
#include "ace/TP_Reactor.h"
#include "Utils/SystemProperties.h"

#include "Comm/AddressServer.h"
#include "Comm/MessageServer.h"

#include <string>


PropertyBasedCommFactory::PropertyBasedCommFactory()
        : m_pReactor(NULL),
          m_pReactorThread(NULL),
          m_pAddressClient(NULL),
          m_pAddressServer(NULL),
          m_pMessageServer(NULL)
{
}



PropertyBasedCommFactory::PropertyBasedCommFactory(SystemProperties &props,
                                                                        const char *mySection)
        : m_pReactor(NULL),
          m_pReactorThread(NULL),
          m_pAddressClient(NULL),
          m_pAddressServer(NULL),
          m_pMessageServer(NULL)
{
                Open(props, mySection);
}



PropertyBasedCommFactory::~PropertyBasedCommFactory()
{
        Close();
}



int PropertyBasedCommFactory::Open(SystemProperties &props,
                                                                        const char *mySection)
{
        //
        // If we already have a message server then return -1
        // -- we're already open.
        if (m_pMessageServer != NULL)
        {
                return -1;
        }

        //
        // The defaults before properties are applied.
        u_int                   numReactorThreads               = 2;
        std::string             addrServerHost                  = ACE_DEFAULT_MULTICAST_ADDR;
        u_int                   addrServerPort                  = ACE_DEFAULT_MULTICAST_PORT;
        u_int                   addrServerTimeout               = 0;
        bool                    addrServerAutoDetect    = true;
        bool                    spawnAddrServer                 = false;
        std::string             addrServerIface                 = "";
        bool                    addrServerLoopback              = false;
        u_int                   addrServerTTL                   = 1;

        SystemProperties::SectionKey_t                  csSection;

        //
        // Find the section.
        int status = props.GetSectionKey(mySection, csSection);
        if (status == -1)
        {
                ACE_ERROR((LM_WARNING, "(%N:%l) Section '%s' of system properties is missing. Using defaults.\n",
                        mySection));
        }
        else
        {
                std::string tmpString;
                SystemProperties::Valuetype_t vt;
                
                //
                // Try to get the number of reactor threads from the properties.
                if (props.find_value(csSection, "NumReactorThreads",vt) == 0)
                {
                        props.GetIntegerEntry(csSection, "NumReactorThreads",
                                                                        numReactorThreads);
                }
                
                //
                // Try to retrieve the IP address of the address server from properties.
                if (props.find_value(csSection, "AddrServerHost",vt) == 0)
                {
                        if (props.GetStringEntry(csSection, "AddrServerHost", tmpString) == 0
                                        && tmpString != "DEFAULT")
                        {
                                addrServerHost = tmpString;
                        }
                }
                
                //
                // Try to retrieve the port number of the address server from
                // properties.
                if (props.find_value(csSection, "AddrServerPort",vt) == 0)
                {
                        if (
                                vt != SystemProperties::STRING
                                || (props.GetStringEntry(csSection, "AddrServerPort", tmpString) == 0
                                        && tmpString != "DEFAULT")
                                )
                        {
                                props.GetIntegerEntry(csSection, "AddrServerPort", addrServerPort);
                        }
                }
                
                //
                // See if the address server auto detect option is specified.
                if (props.find_value(csSection, "AddrServerTimeout",vt) == 0)
                {
                        props.GetIntegerEntry(csSection, "AddrServerTimeout",
                                                                         addrServerTimeout);
                }

                //
                // See if the address server auto detect option is specified.
                if (props.find_value(csSection, "AddrServerAutoDetect",vt) == 0)
                {
                        props.GetBooleanEntry(csSection, "AddrServerAutoDetect", 
                                                                        addrServerAutoDetect);
                }

                //
                // See if the user specified what to do for an address server.
                if (props.find_value(csSection, "SpawnAddrServer",vt) == 0)
                {
                        //
                        // See if we should spawn an address server.
                        props.GetBooleanEntry(csSection, "SpawnAddrServer", 
                                                                        spawnAddrServer);
                }
                        
                //
                // If we might spawn an address server, try to get the properties
                // to do so.
                if (spawnAddrServer || addrServerAutoDetect)
                {
                        //
                        // Check to see if a multicast interface was specified.
                        if (props.find_value(csSection, "AddrServerInterface",vt) == 0)
                        {
                                props.GetStringEntry(csSection, "AddrServerInterface",
                                                                         addrServerIface);
                        }
                        
                        //
                        // Check to see if loopback is to be enabled.
                        if (props.find_value(csSection, "AddrServerLoopback",vt) == 0)
                        {
                                props.GetBooleanEntry(csSection, "AddrServerLoopback",
                                                                                 addrServerLoopback);
                        }
                        
                        //
                        // Check to see if TTL is to be enabled.
                        if (props.find_value(csSection, "AddrServerTTL",vt) == 0)
                        {
                                props.GetIntegerEntry(csSection, "AddrServerTTL",
                                                                                 addrServerTTL);
                        }
                }
        }

        //
        // Instantiate the thread pool reactor.
        m_pReactor = new ACE_Reactor(new ACE_TP_Reactor(), 1);


        //
        // Spawn the reactor's threads.
        m_pReactorThread = new ReactorThread(m_pReactor, numReactorThreads);


        //
        // Construct the address server's IP address.
        ACE_INET_Addr   aservAddr(addrServerPort, addrServerHost.c_str());

        //
        // Instantiate the AddressClient.
        m_pAddressClient = new AddressClient(aservAddr);

        //
        // If the timeout was specified, then set it.
        if (addrServerTimeout != 0)
        {
                m_pAddressClient->SetTimeout(ACE_Time_Value(addrServerTimeout));
        }

        //
        // Register the address client with the reactor.
        m_pAddressClient->RegisterWithReactor(*m_pReactor);


        //
        // If auto-detect, then use the address client to ping the address
        // server. If not found after 5 pings, then plan to construct an address
        // server locally.
        if (addrServerAutoDetect)
        {
                int status = -1;
                int i;
                for (i = 1; status == -1 && i <= 5; ++i)
                {
                        ACE_DEBUG((LM_INFO,
                                "(%N:%l) Addr Server auto detect try %d...\n", i));

                        status = m_pAddressClient->PingServer();

                        if (status == -1)
                                ACE_DEBUG((LM_INFO, "(%N:%l) Addr Server not found.\n", i));
                        else
                                ACE_DEBUG((LM_INFO, "(%N:%l) Addr Server found.\n", i));
                }

                spawnAddrServer = (status == -1);
                
                if (spawnAddrServer)
                        ACE_DEBUG((LM_INFO,
                                "(%N:%l) Auto detect didn't find an address server."
                                " Spawning a local one.\n"));           
        }

        //
        // If the Address Server is to be spawned, do it.
        if (spawnAddrServer)
        {
                //
                // Construct the address server with or without a specified
                // multicast interface.
                if (addrServerIface == "")
                {
                        m_pAddressServer = new AddressServer(aservAddr);
                }
                else
                {
                        m_pAddressServer = new AddressServer(aservAddr,
                                addrServerIface.c_str());
                }

                //
                // Set the multicast loopback state.
                m_pAddressServer->SetLoopbackEnable(addrServerLoopback);

                //
                // Set the multicast TTL
                m_pAddressServer->SetTimeToLive(addrServerTTL);

                //
                // Attach the address server to the reactor.
                m_pAddressServer->RegisterWithReactor(*m_pReactor);
        }

        //
        // Instantiate the message server and give it a pointer
        // to the address client.  The factory keeps ownership of
        // the address client, however.
        m_pMessageServer = new MessageServer(m_pAddressClient, false);

        //
        // Attach the message server to the reactor.
        m_pMessageServer->RegisterWithReactor(*m_pReactor);

        
        //
        // Set up the address server callback mechanism. Note that this
        // must be done after the reactor's threads are started.
        m_pMessageServer->GetAddressClient()->RegisterServerCallback();

        return 0;
}



int PropertyBasedCommFactory::Close()
{
        //
        // If the message server is already NULL, then
        // return -1 -- we're already closed or closing.
        if (m_pMessageServer == NULL)
        {
                return -1;
        }

        //
        // If the address server is local, then make reactor deregistrations
        // immediate.  This means no attempt will be made to deregister
        // notifications or bindings from the address server.  The address
        // server is getting destroyed now anyway.
        bool immediateShutdown = (m_pAddressServer != NULL);

        //
        // Shut down the message server first.
        m_pMessageServer->RemoveFromReactor(*m_pReactor, immediateShutdown);
        delete m_pMessageServer;
        m_pMessageServer = NULL;

        //
        // Next, shut down the address client.
        m_pAddressClient->RemoveFromReactor(*m_pReactor, immediateShutdown);
        delete m_pAddressClient;
        m_pAddressClient = NULL;

        //
        // Shut down the address server (if any).
        if (m_pAddressServer != NULL)
        {
                m_pAddressServer->RemoveFromReactor(*m_pReactor);

                delete m_pAddressServer;
                m_pAddressServer = NULL;
        }

        //
        // Delete the reactor thread object. This will cause the reactor
        // reactor to stop handling events. The destructor won't return until 
        // all the threads finish.
        delete m_pReactorThread;
        m_pReactorThread = NULL;

        //
        // Finally, delete the reactor.
        delete m_pReactor;
        m_pReactor = NULL;

        return 0;
}

---