exec.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: exec.h,v $ $Revision: 1.27 $ $State: Exp $
*******************************************************************************/


#ifndef VXWORKS

#ifndef DtRtiExec_H_
#define DtRtiExec_H_

#include "rtiMsConfig.h"
#include <map>
#include <string>
#include <list>
#include <vlThreadedObject.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlList.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlInetAddr.h>

#include <creRespMsg.h>
#include <desRespMsg.h>
#include <joinRespMsg.h>
#include <execHandshakeMsg.h>
#include <reportFederationMembersMsg.h>
#include <rtiUtil.h>
#include <assistantConnectionInfo.h>


class DtForwarderFaultManager;
class DtLogicalTimeFactory;
class DtMulitcastDiscoveryMgr;
class DtCreateMsg;
class DtDestroyMsg;
class DtListFederationsMsg;
class DtListFederationMembersMsg;
class DtJoinMsg;
class DtDisconnectMsg;
class DtReconnectMsg;
class DtRidTestRequestMsg;
class DtFedExec;
class DtRIDParameters;
class DtExtendedRtiMsgForwarder;
class DtQueueFullMsg;

typedef std::shared_ptr<DtExtendedRtiMsgForwarder> DtRtiMsgForwarderSP;



namespace RTI_API
{
   class Authorizer;
}

class DtRtiExec;

typedef DtRtiExec* (*DtRtiExecCreator)(DtRIDParameters* p,
   std::shared_ptr<DtFilePrinter> logPrinter,
   bool autoExit, const DtRtiConnectionInfoDataPair& connInfo );

typedef void (*DtFedExCbFn)(DtFedExec* exec, void* usr);

typedef void (*DtTickCbFn)(void* usr);
typedef void (*DtTickWithExecCbFn)(const DtRtiExec& exec, void* usr);

typedef void (*DtLogFileNameCbFn)(const DtFilename& file, void* usr);

class DtFedExCallbackInfo
{
public:
   DtFedExCallbackInfo(DtFedExCbFn fn, void* data) :
      myData(data), myFn(fn) {}

   void* myData;
   DtFedExCbFn myFn;
};

class DtTickCallbackInfo
{
public:
   DtTickCallbackInfo(DtTickCbFn fn, void* data, DtTime interval) :
      myData(data), myFn(fn), myInterval(interval), myNextExecutionTime(0) {}

   bool operator<(const DtTickCallbackInfo& other) const
   {
      return ( myData < other.myData ||
         myData == other.myData && myFn < other.myFn );
   }

   void* myData;
   DtTickCbFn myFn;
   DtTime myInterval;
   DtTime myNextExecutionTime;
};

class DtTickWithExecCallbackInfo
{
public:
   DtTickWithExecCallbackInfo(DtTickWithExecCbFn fn, void* data, DtTime interval) :
      myData(data), myFn(fn), myInterval(interval), myNextExecutionTime(0) {}

   bool operator<(const DtTickWithExecCallbackInfo& other) const
   {
      return ( myData < other.myData ||
         myData == other.myData && myFn < other.myFn );
   }

   void* myData;
   DtTickWithExecCbFn myFn;
   DtTime myInterval;
   DtTime myNextExecutionTime;
};

class DtLogFileNameCallbackInfo
{
public:
   DtLogFileNameCallbackInfo(DtLogFileNameCbFn fn, void* data) :
      myData(data), myFn(fn) {}

   bool operator<(const DtLogFileNameCallbackInfo& other) const
   {
      return ( myData < other.myData ||
         myData == other.myData && myFn < other.myFn );
   }

   void* myData;
   DtLogFileNameCbFn myFn;
};

class DT_DLL_EXEC DtRtiExec
{
protected:

   DtRtiExec(DtRIDParameters* p,
      std::shared_ptr<DtFilePrinter> logPrinter,
      bool autoExit, 
      const DtRtiConnectionInfoDataPair& connInfo );

public:

   virtual ~DtRtiExec();

   virtual void shutdownForwarderIfCreated();

   virtual void shutdownFederationShadow(DtHandle handle, const DtString& name);

   virtual void checkVersion(const DtString& version) const;


   virtual void processCreate(const DtCreateMsg& msg);
   virtual void processDestroy(const DtDestroyMsg& msg);
   virtual void processListFederations(const DtListFederationsMsg& msg);
   virtual void processListFederationMembers(const DtListFederationMembersMsg& msg);
   virtual void processJoin(const DtJoinMsg& msg);
   virtual void processDisconnect(const DtDisconnectMsg& msg);
   virtual void processQueueFull( const DtQueueFullMsg& msg );
   virtual void processReconnect(const DtReconnectMsg& msg);
   
   virtual DtFedExec* createFedEx(
      DtConnectionMgr* connMgr, const std::vector<unsigned int> & crcs, const char* fedExName,
      std::string const & timeImplName, MAKRti::DtFomType fedType,
      const std::vector<DtString>& fedFileName, const DtString& momModuleName,
      int fedExHandle, DtRIDParameters* params, unsigned int momModuleCrc);

   DtConnectionMgr* connectMgr();

   virtual bool exists(const DtString& fedExName);


   virtual void destroyFederationByName( const DtString& fullFedexName, 
                                         bool sendDestroyResponse = true,
                                         bool forceDestroy = false );


   int processQuit();

   virtual void listFederates();

   virtual void parseDeleteCommand( const DtString& command,
                                    unsigned int& handle, 
                                    DtString& federationName ) const;
                     
   virtual int deleteFederate( unsigned int handle, 
                                const DtString& federationName );

   virtual void processUpdateNotifyLevel( DtNotifyLevelType level );

   virtual void exit();

   virtual void enableLogging();

   virtual RTI_API::Authorizer* authorizer();

   DtFedExec* fedExec(const DtString& fedExName);
   const DtFedExec* fedExec(const DtString& fedExName) const;

   const std::map<DtString, DtFedExec*>& fedExecs() const;

   const DtRIDParameters& params() const;

   virtual void run();
 
   virtual bool tick( bool noCallbacks = false );

   virtual void wait(DtTime intervalInSeconds);


   virtual void addFedExCreatedCallback(DtFedExCbFn fn, void* usr);
   virtual void removeFedExCreatedCallback(DtFedExCbFn fn, void* usr);

   virtual void addFedExDestroyedCallback(DtFedExCbFn fn, void* usr);
   virtual void removeFedExDestroyedCallback(DtFedExCbFn fn, void* usr);

   virtual void addLogFileNameUpdatedCallback(DtLogFileNameCbFn fn, void* usr);
   virtual void removeLogFileNameUpdatedCallback(DtLogFileNameCbFn fn, void* usr);

   virtual void addTickCallback(DtTickCbFn fn, void* usr, DtTime interval );
   virtual void removeTickCallback(DtTickCbFn fn, void* usr );

   virtual void addTickCallback(DtTickWithExecCbFn fn, void* usr, DtTime interval );
   virtual void removeTickCallback(DtTickWithExecCbFn fn, void* usr );


   virtual void sendCreateResponseMsg(const unsigned long destinationID, DtCreateResponseFlag flag,
      MAKRti::DtString const & errorString);
   virtual void sendDestroyResponseMsg(const char* fedExName, DtDestroyResponseFlag flag);
   virtual void sendReportFederationsMsg(unsigned long destId,
      const std::vector<DtString>& federationNames, const std::vector<DtString>& timeImplNames);
   virtual void sendReportFederationMembersMsg(unsigned long destId, DtString federationName,
      DtReportFederationMembersMsg::DtFederateList* federates);
   virtual void sendJoinResponseMsg(
      unsigned long destinationIDValue,unsigned short requestID, unsigned int crc, 
      DtFederateHandle handle, const char* fedName, int fedExHandle, const char* fedExName,
      const DtString& momModule, const std::vector<DtString>& fedFileName,
      unsigned long flags, bool allowNetworkTesting,
      MAKRti::DtString const & errorString,
      DtJoinResponseMsg::errorCodes errorValue = DtJoinResponseMsg::DT_NO_ERROR);

   virtual void ridRequestCb( const DtRidTestRequestMsg& msg);

public:

   static DtRtiExec* create(DtRIDParameters* p,
      std::shared_ptr<DtFilePrinter> logPrinter,
      bool autoExit = false, 
      const DtRtiConnectionInfoDataPair& connInfo = DtRtiConnectionInfoDataPair() );

   static void setCreatorFunction(DtRtiExecCreator fn);


   static void processRtiExecHandshakeMsg(const DtRtiExecHandshakeMsg& msg, void* usr);
   static void processCreate(const DtCreateMsg& msg, void *usr);
   static void processDestroy(const DtDestroyMsg& msg, void* usr);
   static void processListFederations(const DtListFederationsMsg& msg, void* usr);
   static void processListFederationMembers(const DtListFederationMembersMsg& msg, void* usr);
   static void processJoin(const DtJoinMsg& msg, void* usr);
   static void processDisconnect(const DtDisconnectMsg& msg, void* usr);
   static void processQueueFull( const DtQueueFullMsg& msg, void* usr);
   static void processReconnect(const DtReconnectMsg& msg, void* usr);
   static void ridRequestCb( const DtRidTestRequestMsg& msg, void* usr );

   static bool shutdownSignalCaught(); 
   static void caughtShutdownSignal();

protected:

   void cleanupConstructorException();

   virtual void rtiExecToForwarderHandshake();

   virtual void sendRtiExecHandshakeMsg( DtHandle destId, DtRtiExecHandshakeMsg::DtHandshakeStatus status );

   virtual void processRtiExecHandshakeMsg( const DtRtiExecHandshakeMsg& msg );

   virtual void performMulticastDiscovery( bool reliableTransportDisabled );

   virtual void removeDroppedFederateConnections();

   enum DtStartRtiForwarderResult
   {
      ForwarderSuccessfullyStarted,
      RetryStartingForwarder,
      ForwarderStartupFailed
   };
   virtual DtStartRtiForwarderResult startRtiForwarder(const DtRIDParameters* params);

   virtual bool startFederationShadow(DtHandle federationHandle, const DtString& federationName);

   virtual bool authorizeFederationOperation(const DtCreateMsg& msg, DtString& errorMessage);

protected:

   typedef std::map< unsigned long, DtTime > DtConnIdToTimeMap;
   static bool      theShutdownSignalCaught;   

   DtConnectionMgr* myConnectionMgr;
   std::map<DtString, DtFedExec*> myExecByName;
   std::map<DtFederationHandle, DtFedExec*> myExecByHandle;
   DtString lineOfInput;
  
   bool myHandleForDeleteComplete;
   bool myFedNameForDeleteComplete;
   DtString myFederationNameForDelete;   
   unsigned int myHandleForDelete;

   bool myCreatedRtiForwarder;
   bool myPendingDelete;
   bool myPendingQuit;
   int myFreeFedExHandle;
   DtList myCreateCallbacks;
   DtList myDestroyCallbacks;

   std::list<DtTickCallbackInfo> myTickCallbacks;

   std::list<DtTickWithExecCallbackInfo> myTickWithExecCallbacks;

   std::list<DtLogFileNameCallbackInfo> myLogFileNameCallbacks;

   DtClock myClock;
   DtRtiExecHandshakeMsg::DtHandshakeStatus myHandshakeStatus;
   DtTime myNextHeartbeat;

   DtRtiMsgForwarderSP myRtiForwarder;
   DtForwarderFaultManager* myFaultManager;

   DtMulitcastDiscoveryMgr* myMcastDiscoveryMgr;

   DtConnIdToTimeMap myDisconnectedFederates;

   DtRIDParameters* myParams;   
   bool             myAutoExit;

   bool myExitCommanded;

   std::shared_ptr<DtFilePrinter> myLogPrinter;

   DtRtiConnectionInfoDataPair myConnInfo;

   DtString myHostname;

   DtUniquePtr<RTI_API::Authorizer> myAuthorizer;


protected:

   static DtRtiExecCreator theCreator;
};

inline DtConnectionMgr* DtRtiExec::connectMgr()
{
   return myConnectionMgr;
}

inline const DtRIDParameters& DtRtiExec::params() const
{
   return *myParams;
}

#endif   

#endif