PluginServices.h

/********************************************************************************
 *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/

#ifndef FAIR_MQ_PLUGINSERVICES_H
#define FAIR_MQ_PLUGINSERVICES_H

#include <fairmq/States.h>
#include <FairMQDevice.h>
#include <fairmq/ProgOptions.h>
#include <fairmq/Properties.h>

#include <boost/optional.hpp>
#include <boost/optional/optional_io.hpp>

#include <functional>
#include <string>
#include <unordered_map>
#include <mutex>
#include <map>
#include <condition_variable>
#include <stdexcept>

namespace fair
{
namespace mq
{

class PluginServices
{
  public:
    PluginServices() = delete;
    PluginServices(ProgOptions& config, FairMQDevice& device)
        : fConfig(config)
        , fDevice(device)
        , fDeviceController()
        , fDeviceControllerMutex()
        , fReleaseDeviceControlCondition()
    {
    }

    ~PluginServices()
    {
        LOG(debug) << "Shutting down Plugin Services";
    }

    PluginServices(const PluginServices&) = delete;
    PluginServices operator=(const PluginServices&) = delete;

    using DeviceState = fair::mq::State;
    using DeviceStateTransition = fair::mq::Transition;

    // Control API

    static auto ToDeviceState(const std::string& state) -> DeviceState { return GetState(state); }

    static auto ToDeviceStateTransition(const std::string& transition) -> DeviceStateTransition { return GetTransition(transition); }

    static auto ToStr(DeviceState state) -> std::string { return GetStateName(state); }

    static auto ToStr(DeviceStateTransition transition) -> std::string { return GetTransitionName(transition); }

    auto GetCurrentDeviceState() const -> DeviceState { return fDevice.GetCurrentState(); }

    auto TakeDeviceControl(const std::string& controller) -> void;
    struct DeviceControlError : std::runtime_error { using std::runtime_error::runtime_error; };

    auto StealDeviceControl(const std::string& controller) -> void;

    auto ReleaseDeviceControl(const std::string& controller) -> void;

    auto GetDeviceController() const -> boost::optional<std::string>;

    auto WaitForReleaseDeviceControl() -> void;

    auto ChangeDeviceState(const std::string& controller, const DeviceStateTransition next) -> bool;

    auto SubscribeToDeviceStateChange(const std::string& subscriber, std::function<void(DeviceState /*newState*/)> callback) -> void
    {
        fDevice.SubscribeToStateChange(subscriber, [&,callback](fair::mq::State newState){
            callback(newState);
        });
    }

    auto UnsubscribeFromDeviceStateChange(const std::string& subscriber) -> void { fDevice.UnsubscribeFromStateChange(subscriber); }

    // Config API

    auto PropertyExists(const std::string& key) const -> bool { return fConfig.Count(key) > 0; }

    template<typename T>
    auto SetProperty(const std::string& key, T val) -> void { fConfig.SetProperty(key, val); }
    void SetProperties(const fair::mq::Properties& props) { fConfig.SetProperties(props); }
    template<typename T>
    bool UpdateProperty(const std::string& key, T val) { return fConfig.UpdateProperty(key, val); }
    bool UpdateProperties(const fair::mq::Properties& input) { return fConfig.UpdateProperties(input); }

    void DeleteProperty(const std::string& key) { fConfig.DeleteProperty(key); }

    template<typename T>
    auto GetProperty(const std::string& key) const -> T { return fConfig.GetProperty<T>(key); }

    template<typename T>
    T GetProperty(const std::string& key, const T& ifNotFound) const { return fConfig.GetProperty(key, ifNotFound); }

    auto GetPropertyAsString(const std::string& key) const -> std::string { return fConfig.GetPropertyAsString(key); }

    auto GetPropertyAsString(const std::string& key, const std::string& ifNotFound) const -> std::string { return fConfig.GetPropertyAsString(key, ifNotFound); }

    fair::mq::Properties GetProperties(const std::string& q) const { return fConfig.GetProperties(q); }
    fair::mq::Properties GetPropertiesStartingWith(const std::string& q) const { return fConfig.GetPropertiesStartingWith(q); }
    std::map<std::string, std::string> GetPropertiesAsString(const std::string& q) const { return fConfig.GetPropertiesAsString(q); }
    std::map<std::string, std::string> GetPropertiesAsStringStartingWith(const std::string& q) const { return fConfig.GetPropertiesAsStringStartingWith(q); }

    auto GetChannelInfo() const -> std::unordered_map<std::string, int> { return fConfig.GetChannelInfo(); }

    auto GetPropertyKeys() const -> std::vector<std::string> { return fConfig.GetPropertyKeys(); }

    template<typename T>
    auto SubscribeToPropertyChange(const std::string& subscriber, std::function<void(const std::string& key, T)> callback) const -> void
    {
        fConfig.Subscribe<T>(subscriber, callback);
    }

    template<typename T>
    auto UnsubscribeFromPropertyChange(const std::string& subscriber) -> void { fConfig.Unsubscribe<T>(subscriber); }

    auto SubscribeToPropertyChangeAsString(const std::string& subscriber, std::function<void(const std::string& key, std::string)> callback) const -> void
    {
        fConfig.SubscribeAsString(subscriber, callback);
    }

    auto UnsubscribeFromPropertyChangeAsString(const std::string& subscriber) -> void { fConfig.UnsubscribeAsString(subscriber); }

    auto CycleLogConsoleSeverityUp() -> void { Logger::CycleConsoleSeverityUp(); }
    auto CycleLogConsoleSeverityDown() -> void { Logger::CycleConsoleSeverityDown(); }
    auto CycleLogVerbosityUp() -> void { Logger::CycleVerbosityUp(); }
    auto CycleLogVerbosityDown() -> void { Logger::CycleVerbosityDown(); }

  private:
    fair::mq::ProgOptions& fConfig;
    FairMQDevice& fDevice;
    boost::optional<std::string> fDeviceController;
    mutable std::mutex fDeviceControllerMutex;
    std::condition_variable fReleaseDeviceControlCondition;
}; /* class PluginServices */

} /* namespace mq */
} /* namespace fair */

#endif /* FAIR_MQ_PLUGINSERVICES_H */