broker.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2017 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <broker/filterManager.h>
#include <broker/brokerInitializer.h>
#include <broker/genericUserInterface.h>
#include <broker/baseObjectTranslator.h>
#include <broker/baseInteractionTranslator.h>
#include <broker/translatorFactory.h>

#include <portal/pControlMessage.h>

#include <vlutil/vlStringUtil.h>
#include <vlutil/vlString.h>
#include <vlutil/vlTime.h>

#ifdef __linux__
#include <sys/file.h>
#endif

#include <map>

class DtFilePrinter;
class DtDynamicLibrary;

namespace MAKVrExchange
{

   class DtPortalConnection;
   class DtStatisticsManager;

   class DT_DLL_BROKER DtBroker
   {
   public:

      typedef bool (*PluginInitMethod)( DtBroker* );
      typedef void (*PluginReloadMethod)( DtBroker* );
      typedef void (*PluginPostInitMethod)( DtBroker* );
      typedef void (*PluginUnloadMethod)( DtBroker* );


      typedef void (*BrokerReloadCallback)( void* );

      typedef DtTranslatorFactory<DtInteractionTranslator> DtInteractionTranslatorFactory;
      typedef DtTranslatorFactory<DtObjectTranslator> DtObjectTranslatorFactory;

   protected:

      DtBroker();

      virtual void initialize( DtBrokerInitializer* init );

      virtual void initialize();

      virtual void logBrokerSettings( DtBrokerInitializer* init );

   public:

      virtual ~DtBroker();

      virtual DtPortalConnection* portalConnection() const;

      virtual void initializeUi( DtGenericUserInterface* ui );

      virtual void startBroker();

      virtual void launchGui();

      virtual void launchInfoGui();

      virtual DtInteractionTranslatorFactory* interactionTranslatorFactory();

      virtual DtObjectTranslatorFactory* objectTranslatorFactory();

      virtual void reloadTranslatorDebugging();

      virtual void reloadBrokerSettings();

      virtual const DtString brokerName() const;

      virtual DtU16 brokerId() const;

      virtual DtTime simTime() const;

      virtual void updateSimTime() const;

      virtual bool isRunning() const;

      virtual bool isTimeToQuit() const;

      virtual bool isTranslatorDebuggingOn( const DtString& name ) const;

      virtual DtTime pollingInterval();

      virtual DtBrokerInitializer* brokerInitializer() const;

      // brokers should override to do any periodic processing on the reflection side.
      virtual void tick();

      virtual void processEvents();

      virtual DtFilterManager& objectFilters();

      virtual const DtFilterManager& objectFilters() const;

      virtual void setBrokerId( int id );

      virtual void shutdownWithError( const DtString & error );

      virtual DtObjectTranslator* getObjectTranslator( const DtString& name );

      virtual DtInteractionTranslator* getInteractionTranslator( const DtString& name );

      virtual void loadTranslators();

      virtual void initializeTranslators( DtStringSet& failedTranslators );

      virtual void loadKnownObjectTranslators( DtStringSet& failedTranslators );

      virtual void loadKnownInteractionTranslators( DtStringSet& failedTranslators );

      virtual bool loadObjectTranslator( const DtString& translatorName );

      virtual bool loadInteractionTranslator( const DtString& translatorName );

      virtual void shutdown();

      virtual void addBrokerReloadCallback( BrokerReloadCallback cb, void* usr );

      virtual void callBrokerReloadCallbacks();

   protected:

      virtual void initializeDebuggedAndDisabledFromInit();

      virtual void initFileLogging( const DtBrokerInitializer& init );

      virtual void obtainLock();

      virtual void loadBrokerPlugins();

      virtual void scanForPlugins( const std::string& dir, std::list<std::string>& files ) const;

      virtual void postInitializePlugins();

      virtual void reloadBrokerPlugins();

      virtual void initPortalConnection( const DtBrokerInitializer& init );

      virtual void initStatisticsManager( const DtBrokerInitializer& init );

      virtual void stopFileLogging();

      virtual void processShutdownRequest(const DtPortalBrokerShutdownRequestMessage& obj);

      virtual void processRestartRequest( bool shouldEnableOneToOne );

      static void shutdownRequestCb( const DtPortalBrokerShutdownRequestMessage& obj, void* usr );

      static void processDisableOneToOneCb( const DtPortalBrokerDisableOneToOneMessage& msg, void* usr );

      static void processEnableOneToOneCb( const DtPortalBrokerEnableOneToOneMessage& msg, void* usr );

      static void startRequestCb( const DtBrokerStartRequest& obj, void* usr );

      static void launchGuiRequestCb( const DtBrokerLaunchGuiRequest& obj, void* usr );


      static void filterObjectCallback( const DtFilterObjectMessage& object, void* userData );

      virtual void filterObjectCallback( const DtFilterObjectMessage& object );


      virtual void reportLoadTranslatorFailures( const DtStringSet& failedTranslators ) const;

   protected:

      static void objectDiscoveredCallback( const DtBrokerObject* brokerObject, void* usr );
      static void objectUpdatedCallback( const DtBrokerObject* brokerObject, void* usr );
      static void objectRemovedCallback( const DtBrokerObject* brokerObject, void* usr );


      virtual void objectDiscovered( const DtBrokerObject* brokerObject );

      virtual void objectUpdated( const DtBrokerObject* brokerObject );

      virtual void objectRemoved( const DtBrokerObject* brokerObject );

      virtual bool addTranslator( DtInteractionTranslator* intTrans, bool reflectEnabled, bool publishEnabled );

      virtual bool addTranslator( DtObjectTranslator* objTrans, bool reflectEnabled, bool publishEnabled );

   private:

      DtBroker( const DtBroker& other );

      DtBroker& operator = ( const DtBroker& other );

   protected:

      static const char* theVrxPluginInitMethod;
      static const char* theVrxPluginReloadMethod;
      static const char* theVrxPluginPostInitMethod;
      static const char* theVrxPluginUnloadMethod;

      typedef std::map<const DtString,DtInteractionTranslator*> NamedInteractionTranslatorMap;
      typedef std::map<const DtString,DtObjectTranslator*> NamedObjectTranslatorMap;
      NamedInteractionTranslatorMap myInteractionTranslatorMap;
      NamedObjectTranslatorMap myObjectTranslatorMap;

      DtInteractionTranslatorFactory myInteractionTranslatorFactory;
      DtObjectTranslatorFactory myObjectTranslatorFactory;

      typedef std::map<std::string,DtDynamicLibrary*> BrokerPluginsMap;
      BrokerPluginsMap myBrokerPlugins;

      struct CallbackPair { BrokerReloadCallback fcn; void* usr; };
      typedef std::list<CallbackPair> CallbackPairList;
      CallbackPairList myBrokerReloadCallbacks;

      DtGenericUserInterface* myUi;

      DtU16 myBrokerId;
      DtU32 myBrokerType;

      bool myBrokerIsRunning;
      bool myShutdownRequestedFlag;
      DtPortalConnection* myPortalConn;

      DtBrokerInitializer* myBrokerInitializer;

      std::set<DtString> myDebuggedTranslators;

      DtFilterManager myFilterManager;
      DtStatisticsManager* myStatisticsManager;
      DtFilePrinter* myFilePrinter;
#ifdef _WIN32
      HANDLE myMutexOneAppHandle;
#endif
      // this section defines variables used for lock files in Linux
#ifdef __linux__
      DtString lockFilename;
      struct flock lock;
      int lockFileDes;
#endif

   };


   //
   // Inline method definitions.
   //

   inline DtBrokerInitializer* DtBroker::brokerInitializer() const
   {
      return myBrokerInitializer;
   }

   inline DtFilterManager& DtBroker::objectFilters()
   {
      return myFilterManager;
   }

   inline const DtFilterManager& DtBroker::objectFilters() const
   {
      return myFilterManager;
   }

   inline DtTime DtBroker::pollingInterval()
   {
      return myBrokerInitializer->pollingInterval();
   }

   inline const DtString DtBroker::brokerName() const
   {
      return myBrokerInitializer->brokerName();
   }

}