RCF - Interprocess Communication for C++

#include <boost/test/minimal.hpp>

#include <RCF/ClientTransport.hpp>
#include <RCF/Idl.hpp>
#include <RCF/RcfServer.hpp>
#include <RCF/EndpointBrokerService.hpp>
#include <RCF/EndpointServerService.hpp>
#include <RCF/ServerInterfaces.hpp>

#include <RCF/test/TransportFactories.hpp>
#include <RCF/test/ThreadGroup.hpp>

#include <RCF/util/CommandLine.hpp>
#include <RCF/util/PortNumbers.hpp>
#include <RCF/util/Platform/OS/Sleep.hpp>

#include "Test_Endpoint.hpp"

void endpointClient(const RCF::I_ClientTransport &clientTransport, const std::string &mEndpointName, int mReps)
{
    try
    {
        for (int i=0; i<mReps; ++i)
        {
            int tries = 0;
            RCF::RcfClient<RCF::I_EndpointBroker> broker(clientTransport.clone());
            while (tries < 2 && RCF::RCF_ERROR_ENDPOINT_RETRY == broker.bindToEndpoint(RCF::Twoway, mEndpointName, ""))
            {
                ++tries;
                Platform::OS::Sleep(1);
            }
            MyRcfClient client( broker.getClientStub().releaseTransport() );
            std::string name = client.getEndpointName(RCF::Twoway);
            BOOST_CHECK(name == mEndpointName);
        }
    }
    catch(const RCF::Exception &e)
    {
        BOOST_CHECK(1==0);
        RCF_TRACE("")(e);
    }            
    catch(...)
    {
        BOOST_CHECK(1==0);
        RCF_TRACE("oops");
    }
}

int test_main(int argc, char **argv)
{

    util::CommandLine::getSingleton().parse(argc, argv);

    for (int i=0; i<RCF::getTransportFactories().size(); ++i)
    {
        RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[i];
        std::pair<RCF::ServerTransportPtr, RCF::ClientTransportAutoPtrPtr> transports;
        
        transports = transportFactoryPtr->createTransports();
        RCF::ServerTransportPtr brokerServerTransportPtr( transports.first );
        RCF::ClientTransportAutoPtr brokerClientTransportAutoPtr( *transports.second );
        
        if (NULL == dynamic_cast<RCF::I_ServerTransportEx *>(brokerServerTransportPtr.get()))
        {
            continue; 
        }

        RCF::writeTransportTypes(std::cout, *brokerServerTransportPtr, *brokerClientTransportAutoPtr);

        transports = transportFactoryPtr->createTransports();
        RCF::ServerTransportPtr serverTransportPtrA( transports.first );
        RCF::ClientTransportAutoPtr clientTransportAutoPtrA( *transports.second );

        transports = transportFactoryPtr->createTransports();
        RCF::ServerTransportPtr serverTransportPtrB( transports.first );
        RCF::ClientTransportAutoPtr clientTransportAutoPtrB( *transports.second );

        transports = transportFactoryPtr->createTransports();
        RCF::ServerTransportPtr serverTransportPtrC( transports.first );
        RCF::ClientTransportAutoPtr clientTransportAutoPtrC( *transports.second );

        std::string endpointNameA = "EndpointA";
        std::string endpointNameB = "EndpointB";
        std::string endpointNameC = "EndpointC";

        RCF::RcfServer broker(brokerServerTransportPtr);
        broker.addService( RCF::EndpointBrokerServicePtr( new RCF::EndpointBrokerService ) );
        broker.start();

        for (int i=0; i<3; ++i)
        {
            typedef RCF::EndpointServerService::EndpointId EndpointId;
            EndpointId endpointId;

            // TODO: run a server transport w/o acceptor fd
            // TODO: ok to call openEndpoint(...) w/o explicitly starting the server

            // server A
            RCF::RcfServer serverA(serverTransportPtrA);
            serverA.bind<MyInterface>( boost::shared_ptr<GetEndpointName>(new GetEndpointName(endpointNameA)));
            serverA.start();

            RCF::EndpointPtr brokerClientEndpointPtr( brokerClientTransportAutoPtr->getEndpointPtr() );

            RCF::EndpointServerServicePtr endpointServerServiceAPtr( new RCF::EndpointServerService );
            serverA.addService(endpointServerServiceAPtr);
            endpointId = endpointServerServiceAPtr->openEndpoint(*brokerClientEndpointPtr, endpointNameA);
            BOOST_CHECK(endpointId != EndpointId());

            // server B
            RCF::RcfServer serverB(serverTransportPtrB);
            serverB.bind<MyInterface>( boost::shared_ptr<GetEndpointName>(new GetEndpointName(endpointNameB)));
            serverB.start();
            
            RCF::EndpointServerServicePtr endpointServerServiceBPtr( new RCF::EndpointServerService );
            serverB.addService(endpointServerServiceBPtr);
            endpointId = endpointServerServiceBPtr->openEndpoint(*brokerClientEndpointPtr, endpointNameB);
            BOOST_CHECK(endpointId != EndpointId());
            
            // server C
            RCF::RcfServer serverC(serverTransportPtrC);
            serverC.bind<MyInterface>( boost::shared_ptr<GetEndpointName>(new GetEndpointName(endpointNameC)));
            serverC.start();
            
            RCF::EndpointServerServicePtr endpointServerServiceCPtr( new RCF::EndpointServerService );
            serverC.addService(endpointServerServiceCPtr);
            endpointId = endpointServerServiceCPtr->openEndpoint(*brokerClientEndpointPtr, endpointNameC);
            BOOST_CHECK(endpointId != EndpointId());

            Platform::OS::Sleep(1);
            
            // off we go
            ThreadGroup endpointClients;
            
            endpointClients.push_back( ThreadPtr( new Thread( 
                boost::bind( &endpointClient, boost::ref(*brokerClientTransportAutoPtr), endpointNameA, 10) ) ) );

            endpointClients.push_back( ThreadPtr( new Thread( 
                boost::bind( &endpointClient, boost::ref(*brokerClientTransportAutoPtr), endpointNameB, 10) ) ) );

            endpointClients.push_back( ThreadPtr( new Thread( 
                boost::bind( &endpointClient, boost::ref(*brokerClientTransportAutoPtr), endpointNameC, 10) ) ) );
            
            joinThreadGroup(endpointClients);
        }
    }

    return boost::exit_success;
}