ORB.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef ORB_H_
#define ORB_H_

#ifndef _MSC_VER
#include "config.h" // generated as part of autotools
#endif

#ifndef ZEROC_ICE_EMBEDDED
#include <Ice/Ice.h>
#include <IceUtil/Mutex.h>
#else
#include <IceE/IceE.h>
#include <IceE/Mutex.h>
#endif

#include <list>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;

#include "ORBICE.H"

/*#ifdef _MSC_VER
#ifdef CREATING_DLL
#define SHARED __declspec( dllexport )
#else
#define SHARED __declspec( dllimport )
#endif
#else
#define SHARED
#endif
*/

namespace ORB {

#define ORB_DEFAULT_BASEPORT 10000 


template <class ZEROCICETYPE>
class ORBObject : public ZEROCICETYPE {
public:
    const static string name;
};

class ORBBase {
    int basePort; 
    IceUtil::Mutex countMutex; 
    list<int> offsetList; 

    void init(int basePortDifferent) {
        basePort=basePortDifferent;
    }
public:
    ORBBase(void) {
        init(ORB_DEFAULT_BASEPORT);
    }
    ORBBase(int basePortDifferent) {
        init(basePortDifferent);
    }
    int getPortOffset(void) {
        countMutex.lock();

        int i=-1;
        if (offsetList.size()>0) {
            // insert the first missing number
            offsetList.sort();
            std::list<int>::iterator offset=offsetList.begin();
            while (*(offset++)==++i) ; // find the first missing number
        } else // the list is empty
            i=0;
        offsetList.push_back(i); // add the missing number to the list

        countMutex.unlock();
        return i;
    }

    void removePortOffset(int whichOffset) {
        countMutex.lock();
        offsetList.remove(whichOffset);
        countMutex.unlock();
    }

    int getTCPUDPPort(int portOffset) {
        return basePort+2*portOffset;
    }

    int getSSLPort(int portOffset) {
        return getTCPUDPPort(portOffset)+1;
    }

    int getBasePort(void) {
        return basePort;
    }

    string generateEndPoint(const string& transportName, std::string& ipAddress, int& portOffset) {
        string tn=transportName, ia=ipAddress;
        int po=portOffset;
        return generateEndPoint(tn, ia, po);
    }

    string generateEndPoint(string &transportName, string ipAddress, int portOffset) {
        stringstream endPoint;
        if (ipAddress.size()>0) { // if we are setting up a proxy string
            ipAddress=string(" -h ")+ipAddress+' ';
            endPoint<<transportName<<":";
        }
        endPoint<<"tcp " <<ipAddress<< "-p "<<getTCPUDPPort(portOffset);
#ifndef ZEROC_ICE_EMBEDDED
        endPoint<<" : udp "<<ipAddress<<"-p "<<getTCPUDPPort(portOffset);
#endif
        cout<<"endpoint :"<<endl;
        cout<<endPoint.str()<<endl;
        // currently ssl is not activated ... this can be activated but would require certs
        //endPoint<<"tcp " <<ipAddress<< "-p "<<getTCPUDPPort(portOffset)<<":udp "<<ipAddress<<"-p "<<getTCPUDPPort(portOffset)<<":ssl "<<ipAddress<<"-p "<<getSSLPort(portOffset); // get the TCP, USP and SSL ports
        return endPoint.str();
    }
};

class ORBOriginator : public ORB::ORBICE, virtual public ORBBase {
protected:
    int portOffset; 
    string hostAddress; 

    string transportName; 
    Ice::CommunicatorPtr communicator; 
    Ice::ObjectAdapterPtr adapterPtr; 

    ORBOriginator(int argc, char *argv[], string transportNameIn, string ipAddress) {
        initialise(argc, argv, transportNameIn, ipAddress, vector<pair<string,string> >()); // initialise the communicator and adapter
    }

    ORBOriginator(int argc, char *argv[], string transportNameIn, string ipAddress, const vector<pair<string,string> > extraProperties) {
        initialise(argc, argv, transportNameIn, ipAddress, extraProperties); // initialise the communicator and adapter
    }

    ORBOriginator(int argc, char *argv[], string transportNameIn, string ipAddress, int basePortDifferent): ORBBase(basePortDifferent) {
        initialise(argc, argv, transportNameIn, ipAddress, vector<pair<string,string> >()); // initialise the communicator and adapter
    }

    ORBOriginator(int argc, char *argv[], string transportNameIn, string ipAddress, const vector<pair<string,string> > extraProperties, int basePortDifferent): ORBBase(basePortDifferent) {
        initialise(argc, argv, transportNameIn, ipAddress, extraProperties); // initialise the communicator and adapter
    }

    void initialise(int argc, char *argv[], string transportNameIn, string ipAddress, const vector<pair<string,string> > extraProperties) {
        communicator=NULL;
        hostAddress=ipAddress;
        portOffset=getPortOffset(); // get a unique port offset
        transportName=transportNameIn; // set the ZeroC ICE application layer name
        Ice::InitializationData initData; // generate required initialisation data
        initData.properties = Ice::createProperties();
        initData.properties->setProperty("Ice.Warn.Connections", "2");
        initData.properties->setProperty("Ice.Warn.UnusedProperties", "1");
        // parse the extra properties
        for (vector<pair<string,string> >::const_iterator pss=extraProperties.begin(); pss!=extraProperties.end(); ++pss)
            initData.properties->setProperty(pss->first, pss->second);

        communicator = Ice::initialize(argc, argv, initData); // create the communicator
    }

    void initialiseAdapter(void) {
        //cout<<"enpoint string "<<generateEndPoint(transportName, string(), portOffset).c_str()<<endl;
        adapterPtr=communicator->createObjectAdapterWithEndpoints(transportName+".Control",generateEndPoint(transportName, hostAddress, portOffset).c_str());
        adapterPtr->add((ORB::ORBICE*)this, communicator->stringToIdentity(transportName)); // add this class to the adapter
        adapterPtr->activate();
    }

    void getObjectPointer(const string &name, Ice::ObjectPtr &objectPointer, const Ice::Current& cur) {
        Ice::Identity identity;
        identity.name=name;
        objectPointer=adapterPtr->find(identity);
        //cout<<"objectPointer = "<<objectPointer<<endl;
    }

public:
    ORBOriginator(int argc, char *argv[], string transportNameIn) {
        initialise(argc, argv, transportNameIn, string(), vector<pair<string,string> >()); // initialise the communicator and adapter
        initialiseAdapter();
    }

    ORBOriginator(int argc, char *argv[], string transportNameIn, int basePortDifferent): ORBBase(basePortDifferent) {
        initialise(argc, argv, transportNameIn, string(), vector<pair<string,string> >()); // initialise the communicator and adapter
        initialiseAdapter();
    }

    ORBOriginator(int argc, char *argv[], string transportNameIn, const vector<pair<string,string> > extraProperties) {
        initialise(argc, argv, transportNameIn, string(), extraProperties); // initialise the communicator and adapter
        initialiseAdapter();
    }

    ORBOriginator(int argc, char *argv[], string transportNameIn, const vector<pair<string,string> > extraProperties, int basePortDifferent): ORBBase(basePortDifferent) {
        initialise(argc, argv, transportNameIn, string(), extraProperties); // initialise the communicator and adapter
        initialiseAdapter();
    }

    virtual ~ORBOriginator(void) {
        removePortOffset(portOffset);
        if (communicator)
            communicator->shutdown();
    }

    void shutdown(const Ice::Current& cur) {
        cur.adapter->getCommunicator()->shutdown();
    }

    bool isShutdown(){
        if (communicator)
            return communicator->isShutdown();
        return true;
    }

    void addClass(Ice::ObjectPtr objectToORB, const string &name) {
        Ice::Identity identity;
        identity.name=name;
        if (adapterPtr->find(identity)) // check whether it already exists
            cerr<<"ORBOriginator::addClass : WARNING : that class is already serlialised on the adapter"<<endl;
        adapterPtr->add(objectToORB, identity);
    }

    void waitForShutdown(void) {
        communicator->waitForShutdown();
    }

//    void remove(const string &name){
//        Ice::Identity ident;
//        ident.name=name;
//        if (adapterPtr->find(ident)){
//            cout<<name<<" found, removing"<<endl;
//            adapterPtr->remove(ident);
//        }
//    }
};

class ORBReplicator : public Ice::ObjectFactory, public ORBOriginator {
    ORB::ORBICEPrx oRBOriginatorPrx; 

    void destroy() {
    }

    void initialise(void) {
        try {
            oRBOriginatorPrx = ORB::ORBICEPrx::checkedCast(communicator->stringToProxy(generateEndPoint(transportName, hostAddress, portOffset).c_str())->ice_twoway()->ice_timeout(-1)->ice_secure(false));
        } catch (const Ice::Exception& e) {
            cerr << e << endl;
        } catch (...) { cout << "unknown exception"; }
        if (!oRBOriginatorPrx) {
            cerr<<"ORBReplicator::initialise : couldn't get the ORBOriginator proxy, can't continue \n\n\tPlease check that the intended application on the other side of the netowrk is up and running!"<<endl;
            //assert(false);
        }
    }

public:
    ORBReplicator(int argc, char *argv[], string transportNameIn, string ipAddress) : ORBOriginator(argc, argv, transportNameIn, ipAddress) {
        initialise();
    }

    ORBReplicator(int argc, char *argv[], string transportNameIn, string ipAddress, int basePortDifferent) : ORBOriginator(argc, argv, transportNameIn, ipAddress, basePortDifferent) {
        initialise();
    }

    ORBReplicator(int argc, char *argv[], string transportNameIn, string ipAddress, const vector<pair<string,string> > extraProperties) : ORBOriginator(argc, argv, transportNameIn, ipAddress, extraProperties) {
        initialise();
    }

    ORBReplicator(int argc, char *argv[], string transportNameIn, string ipAddress, const vector<pair<string,string> > extraProperties, int basePortDifferent) : ORBOriginator(argc, argv, transportNameIn, ipAddress, extraProperties, basePortDifferent) {
        initialise();
    }

    virtual Ice::ObjectPtr create(const std::string&)=0;

//    /* Register a class with the object factory.
//    When required ORBOriginator::create will make the required class.
//    \param The unique id which identifies the class to create
//    \tparam ICEIDTYPE The class to get the static id from
//    */
//    template<typename ICEIDTYPE>
//    void addObjectFactory(void) {
//        communicator->addObjectFactory(static_cast<Ice::ObjectFactory*>(this), ICEIDTYPE::ice_staticId()); // register that the factory can now generate the specified class
//    }

    void addClass(Ice::ObjectPtr objectToORB, const string &name) {
        cerr<<"ORBReplicator::addClass : Only ORBOriginators can add classes to the ORB application layer\n\t You need an originator on this side to add your classes to the ORB application layer"<<endl;
    }

    void shutdown(void) {
        oRBOriginatorPrx->shutdown(); // call the Originator's shutdown method
    }

    template<typename PRXTYPE>
    PRXTYPE getObjectProxy(const string &nameIn) {
        return PRXTYPE::checkedCast(communicator->stringToProxy(generateEndPoint(nameIn, hostAddress, portOffset).c_str()));
    }

    template<typename CLASSTYPE>
    CLASSTYPE *getObjectPointer(const string &nameIn) {
        if (!communicator->findObjectFactory(CLASSTYPE::ice_staticId())) // add the object to the factory if it is missing
            communicator->addObjectFactory(static_cast<Ice::ObjectFactory*>(this), CLASSTYPE::ice_staticId()); // register that the factory can now generate the specified class

        // request the object from the ORBOriginator, and create it using the factory.
        Ice::ObjectPtr objectPtr;
        oRBOriginatorPrx->getObjectPointer(nameIn, objectPtr);
        objectPtr->__setNoDelete(true); // we have to memory manage ourselves
        //return PTRTYPE::dynamicCast(objectPtr); // this was used previously to return the pointer
        return dynamic_cast<CLASSTYPE *>(objectPtr.get());
    }

    bool connectedOK(){
        return (bool)oRBOriginatorPrx!=NULL;
    }
};

};
#endif // ORB_H_