sag_connectivity_chain_managers.hpp

Go to the documentation of this file.

/*
 * $Copyright (c) 2015-2018, 2020, 2022 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 */


#ifndef _SAG_CONNECTIVITY_CHAIN_MANAGERS_HPP_
#define _SAG_CONNECTIVITY_CHAIN_MANAGERS_HPP_

#include <sag_connectivity_plugins.hpp>
#include <memory>
#include <unordered_map>
#include <vector>

namespace com {
namespace softwareag {
namespace _DATAT_INTERNAL_CPP_NAMESPACE { 
namespace chainmanagers {

class ChannelLifecycleListener
{
public:
        virtual ~ChannelLifecycleListener() {}
        virtual void onChannelCreated(const std::string &channel, Direction direction) = 0;

        virtual void onChannelDestroyed(const std::string &channel, Direction direction) = 0;
};

template<typename TRANSPORT>
class AbstractChainManager; // forward decl for Host friend

template<typename TRANSPORT>
class ChainManagerHost; // forward decl for Chain friend

struct PluginConfiguration {
        std::string pluginName;
        map_t config;
        PluginConfiguration(const std::string &pluginName, const map_t &config) : pluginName(pluginName), config(config.copy()) {}
        PluginConfiguration(const PluginConfiguration &other) : pluginName(other.pluginName), config(other.config.copy()) {}
        PluginConfiguration &operator=(const PluginConfiguration &other) {
                if(this != &other) {
                        pluginName = other.pluginName;
                        config=other.config.copy();
                }
                return *this;
        }
        PluginConfiguration(PluginConfiguration&& other) = default; 
        PluginConfiguration &operator=(PluginConfiguration &&other) = default; 
        ~PluginConfiguration() = default; 

        const std::string& getPluginName() const { return pluginName; }
        
        const map_t &getConfiguration() const { return config; }
};


struct ChainDefinition : public std::vector<PluginConfiguration> {
        typedef std::vector<PluginConfiguration> vector_t;
        ChainDefinition() {}
        const map_t& getTransportConfig() const {
                return back().getConfiguration();
        }
};

typedef std::unordered_map<std::string, ChainDefinition> ChainDefinitions;

namespace converters_impl {
ChainDefinitions convertChainDefinitions(const map_t &chainDefinitions);
list_t convertChainDefinition(const ChainDefinition& chainDefinition);
}


template<typename TRANSPORT>
class Chain
{
        // so host can call the private constructor
        friend class ChainManagerHost<TRANSPORT>;
        // not copyable - this is a singleton ptr, but does not own the lifetime.
        Chain(const Chain &other) = delete;
        Chain &operator=(const Chain &other) = delete;
        Chain(const Chain &&other) = delete;
        Chain &operator=(const Chain &&other) = delete;
        void startImpl() const;
public:
        ~Chain() = default; // default destructor is OK, though @private
        const Chain &start() const {
                startImpl();
                return *this;
        }
        Chain &start() {
                startImpl();
                return *this;
        }
        void destroy();

        TRANSPORT *getTransport() const { 
                if (!transport) throw std::runtime_error("Cannot call getTransport after chain has been destroyed");
                return transport; 
        }

        const std::string &getChainId() { return chainId; }

        typedef std::shared_ptr<Chain> ptr_t;


private:
        Chain(TRANSPORT* transport, void* connectivityManager, const std::string &chainId, const std::string &managerName)
                :transport(transport), connectivityManager(connectivityManager), chainId(chainId), managerName(managerName)
        {}

        TRANSPORT* transport;
        void* connectivityManager;
        std::string chainId;
        // just for error messages for now
        std::string managerName;
};

template<typename TRANSPORT>
class ChainManagerHost
{
        // give friend status to ChainManager so it can get the hostptr
        friend class AbstractChainManager<TRANSPORT>;

        ChainManagerHost(void *connectivityManager, const AbstractChainManager<TRANSPORT> *chainManager): connectivityManager(connectivityManager), chainManager(chainManager) {}

public:
        template<typename ... ARGS>
        typename Chain<TRANSPORT>::ptr_t createChain(const std::string &chainInstanceIdSuffix, const std::string &defaultChannelTowardsHost, const list_t &subscribeChannels, const ChainDefinition &chainDefinition, const map_t &substitutions, ARGS ... transportConstructorArgs) const;

        void addChannelLifecycleListener(ChannelLifecycleListener *listener, const std::string &channelPrefix) const;
private:

        template<typename TUPLE>
        typename Chain<TRANSPORT>::ptr_t createChainImpl(const std::string &chainInstanceIdSuffix, const std::string &defaultChannelTowardsHost, const list_t &subscribeChannels, const ChainDefinition &chainDefinition, const map_t &substitutions, const TUPLE& tuple) const;

        static sag_error_t deleteChannelLifecycleListener(sag_plugin_t callback);
        static sag_error_t callOnChannelCreated(const char *managerLogName, sag_plugin_t callback, const char*, bool);
        static sag_error_t callOnChannelDestroyed(const char *managerLogName, sag_plugin_t callback, const char*, bool);
        void *connectivityManager;
        const AbstractChainManager<TRANSPORT> *chainManager;
};


class ManagedTransportConstructorParameters : public PluginConstructorParameters::TransportConstructorParameters
{
public:
        const list_t &getSubscribeChannels() const { return subscribeChannels; }

        const std::string &getDefaultChannelTowardsHost() const { return defaultChannelTowardsHost; }

        ManagedTransportConstructorParameters(const std::string &pluginName, const std::string &chainId, const map_t &config, void* connectivityManager,
                const std::string &defaultChannelTowardsHost, const list_t subscribeChannels, void* reserved)
                : TransportConstructorParameters(pluginName, chainId, config, connectivityManager, reserved),
                defaultChannelTowardsHost(defaultChannelTowardsHost), subscribeChannels(subscribeChannels.copy())
        {}

private:
        std::string defaultChannelTowardsHost;
        list_t subscribeChannels;
};

class ChainManagerConstructorParameters
{
        template <typename TRANSPORT> friend class AbstractChainManager;
        // not copyable: ChainManagers should use the config, etc that are their field members.
        ChainManagerConstructorParameters(const ChainManagerConstructorParameters &params) = delete;
        ChainManagerConstructorParameters& operator=(const ChainManagerConstructorParameters &params) = delete;
public:
        const map_t &getManagerConfig() const { return managerConfig; }

        const std::string &getManagerName() const { return managerName; }

        const std::string &getTransportPluginName() const { return transportPluginName; }

        ChainManagerConstructorParameters(const map_t &managerConfig, const std::string &managerName, const std::string &transportPluginName, void* connectivityManager, const map_t &chainDefs, void* reserved)
                : managerName(managerName), transportPluginName(transportPluginName), managerConfig(managerConfig), chainDefs(chainDefs), connectivityManager(connectivityManager), reserved(reserved)
        {}

private:
        std::string managerName;
        std::string transportPluginName;
        const map_t &managerConfig;
        const map_t &chainDefs;
        void* connectivityManager;
        void* reserved;
};



template<typename TRANSPORT>
class AbstractChainManager
{

public:

        typedef TRANSPORT transport_t;

        AbstractChainManager(const ChainManagerConstructorParameters &params)
                : 
                logger("connectivity." + params.getManagerName() + "." + (params.getManagerName() == params.getTransportPluginName() ? "manager" : params.getTransportPluginName())),
                managerName(params.getManagerName()), transportPluginName(params.getTransportPluginName()),
                chainDefinitions(converters_impl::convertChainDefinitions(params.chainDefs)), 
                host(params.connectivityManager, this),
                config(params.getManagerConfig().copy()),
                statusReporter(new StatusReporter(params.connectivityManager))
        {}
        virtual ~AbstractChainManager() {}

        virtual void start() {}

        virtual void shutdown() {}

        StatusReporter &getStatusReporter() {
                return *statusReporter;
        }

        const Logger logger;

        const std::string managerName; 

        const std::string transportPluginName;

protected:
        // typedefs for templated classes that are useful when writing subclasses

        typedef typename Chain<TRANSPORT>::ptr_t chain_t;
        typedef AbstractChainManager<TRANSPORT> abstract_chain_manager_t;

        ChainDefinitions chainDefinitions;

        const ChainManagerHost<TRANSPORT> host;

        map_t config;

        const ChainDefinition &getChainDefinition() {
                if(chainDefinitions.size() != 1) throw std::runtime_error("This manager only supports a single chain definition, but there was not exactly one specified.");
                return chainDefinitions.begin()->second;
        }
        const ChainDefinition &getChainDefinition(const std::string &str) {
                auto it = chainDefinitions.find(str);
                if(it == chainDefinitions.end()) throw std::runtime_error("Cannot find chain definition "+str);
                return it->second;
        }

private:
        std::unique_ptr<StatusReporter> statusReporter;
};


// ***********************************************************************************************



}}

namespace connectivity { namespace chainmanagers { using namespace _DATAT_INTERNAL_CPP_NAMESPACE::chainmanagers; } }

}} // com.softwareag.connectivity.chainmanagers

#include <sag_internal/chain_managers.hpp>


#define SAG_DECLARE_CONNECTIVITY_TRANSPORT_CHAIN_MANAGER_CLASS(Class) _SAG_DECLARE_CONNECTIVITY_TRANSPORT_CHAIN_MANAGER_CLASS(Class)

#endif // _SAG_CONNECTIVITY_CHAIN_MANAGERS_HPP_