DaemonController.h

Go to the documentation of this file.

#pragma once

#include "DpaHandler.h"
#include "ISerializer.h"
#include "IMessaging.h"
#include "IService.h"
#include "TaskQueue.h"
#include "IDaemon.h"
#include "JsonUtils.h"
#include "IqrfLogging.h"
#include <map>
#include <string>
#include <atomic>
#include <vector>

class IChannel;
class IDpaMessageForwarding;
class IDpaExclusiveAccess;

class ComponentDescriptor {
public:
  
  ComponentDescriptor(const std::string& componentName, bool enabled)
    : m_componentName(componentName)
    , m_enabled(enabled)
  {}

  void loadConfiguration(const std::string configurationDir);

  rapidjson::Value& getConfiguration() {
    return m_doc;
  }

  std::string m_componentName;
  std::string m_interfaceName;
  bool m_enabled = false;
  rapidjson::Document m_doc;
};

class DaemonController : public IDaemon
{
public:
  enum class Mode {
    Operational,
    Service,
    Forwarding
  };

  DaemonController(const DaemonController &) = delete;

  static DaemonController& getController();
  
  void run(const std::string& cfgFileName);

  // IDaemon override methods
  void executeDpaTransaction(DpaTransaction& dpaTransaction) override;
  void registerAsyncMessageHandler(const std::string& serviceId, AsyncMessageHandlerFunc fun) override;
  void unregisterAsyncMessageHandler(const std::string& serviceId) override;
  IScheduler* getScheduler() override { return m_scheduler; }
  std::string doCommand(const std::string& cmd) override;
  const std::string& getModuleId() override { return m_moduleId; }
  const std::string& getOsVersion() override { return m_osVersion; }
  const std::string& getTrType() override { return m_trType; }
  const std::string& getMcuType() override { return m_mcuType; }
  const std::string& getOsBuild() override { return m_osBuild; }
  const std::string& getDaemonVersion() override { return m_version; }
  const std::string& getDaemonVersionBuild() override { return m_versionBuild; }

  void exit();

  void setMode(Mode mode);

private:
  std::mutex m_modeMtx;
  Mode m_mode;

  std::map<std::string, AsyncMessageHandlerFunc> m_asyncMessageHandlers;
  std::mutex m_asyncMessageHandlersMutex;
  void asyncDpaMessageHandler(const DpaMessage& dpaMessage);

  DaemonController();
  virtual ~DaemonController();

  void startTrace();
  void startIqrfIf();
  void startDpa();
  void startServices();
  void startScheduler();

  void stopIqrfIf();
  void stopDpa();
  void stopServices();
  void stopTrace();

  void start();
  void stop();

  void * getFunction(const std::string& methodName, bool mandatory) const;
  void * getCreateFunction(const std::string& componentName, bool mandatory) const;

  IChannel* m_iqrfInterface;
  DpaHandler* m_dpaHandler;
  
  void executeDpaTransactionFunc(DpaTransaction* dpaTransaction);

  TaskQueue<DpaTransaction*> *m_dpaTransactionQueue;

  std::map<std::string, std::unique_ptr<ISerializer>> m_serializers;
  std::map<std::string, std::unique_ptr<IService>> m_services;
  std::map<std::string, std::unique_ptr<IMessaging>> m_messagings;

  IDpaMessageForwarding* m_dpaMessageForwarding = nullptr;
  IDpaExclusiveAccess* m_dpaExclusiveAccess = nullptr;

  IScheduler* m_scheduler = nullptr;

  void watchDogPet();
  bool m_running = false;
  std::mutex m_stopConditionMutex;
  std::condition_variable m_stopConditionVariable;
  std::chrono::system_clock::time_point m_lastRefreshTime;
  std::chrono::milliseconds m_timeout;

  void loadConfiguration(const std::string& cfgFileName);
  rapidjson::Document m_configuration;
  std::string m_cfgFileName;
  const std::string m_cfgVersion = "v1.0";
  std::string m_traceFileName;
  int m_traceFileSize = 0;
  iqrf::Level m_level;
  std::string m_iqrfInterfaceName;
  int m_dpaHandlerTimeout = 400;
  IqrfRfCommunicationMode m_communicationMode = IqrfRfCommunicationMode::kStd;

  std::string m_configurationDir;
  std::string m_modeStr;
  int m_watchDogTimeoutMilis = 0;
  std::map<std::string, ComponentDescriptor> m_componentMap;

  void loadSerializerComponent(const ComponentDescriptor& componentDescriptor);
  void loadMessagingComponent(const ComponentDescriptor& componentDescriptor);
  void loadServiceComponent(const ComponentDescriptor& componentDescriptor);

  std::string m_moduleId;
  std::string m_osVersion;
  std::string m_trType;
  bool m_fcc = false;
  std::string m_mcuType;
  std::string m_osBuild;

  std::string m_version;
  std::string m_versionBuild;
};