ConfigurationBuilder.h

Go to the documentation of this file.

#ifndef ISPN_HOTROD_CONFIGURATION_CONFIGURATIONBUILDER_H
#define ISPN_HOTROD_CONFIGURATION_CONFIGURATIONBUILDER_H

#include <string>
#include <vector>
#include <sstream>
#include <fstream>
#include <iostream>

#include "infinispan/hotrod/defs.h"
#include "infinispan/hotrod/ImportExport.h"
#include "infinispan/hotrod/EventMarshaller.h"
#include "Configuration.h"
#include "ConnectionPoolConfigurationBuilder.h"
#include "ServerConfigurationBuilder.h"
#include "SecurityConfigurationBuilder.h"
#include "NearCacheConfiguration.h"

using namespace infinispan::hotrod::event;

namespace infinispan {
namespace hotrod {

class ClusterConfigurationBuilder
{
public:
        ClusterConfigurationBuilder(std::vector<ServerConfigurationBuilder>& servers, ConfigurationBuilder &parent) : servers(servers), m_parent(parent) {}
        ClusterConfigurationBuilder& addClusterNode(const std::string host, const int port)
        {
        servers.push_back(ServerConfigurationBuilder(m_parent).host(host).port(port));
        return *this;
        }
private:
    std::vector<ServerConfigurationBuilder>& servers;
    ConfigurationBuilder &m_parent;
};

class NearCacheConfigurationBuilder : public ConfigurationChildBuilder
{
public:
    NearCacheConfigurationBuilder(ConfigurationBuilder& _builder) : ConfigurationChildBuilder(_builder) {}

    int getMaxEntries() const {
        return m_maxEntries;
    }

    NearCacheConfigurationBuilder& maxEntries(unsigned int maxEntries = 0) {
        this->m_maxEntries = maxEntries;
        return *this;
    }

    NearCacheMode getMode() const {
        return m_mode;
    }

    NearCacheConfigurationBuilder& mode(NearCacheMode mode = DISABLED) {
        this->m_mode = mode;
        return *this;
    }

    NearCacheConfiguration create()
    {
        return NearCacheConfiguration(m_mode,m_maxEntries);
    }

    private:
    NearCacheMode m_mode=DISABLED;
    unsigned int m_maxEntries=0;
};

class ConfigurationBuilder
{
  public:
    ConfigurationBuilder():
        m_connectionTimeout(60000),
        m_forceReturnValue(false),
        m_keySizeEstimate(64),
        m_protocolVersion(Configuration::PROTOCOL_VERSION_24),
        m_socketTimeout(60000),
        m_tcpNoDelay(true),
        m_valueSizeEstimate(512),
        m_maxRetries(10),
                m_balancingStrategyProducer(nullptr),
        __pragma(warning(suppress:4355)) // passing uninitialized 'this'
        connectionPoolConfigurationBuilder(*this),
        __pragma(warning(suppress:4355))
        securityConfigurationBuilder(*this),
        nearCacheConfigurationBuilder(*this),
        m_transactional(false)
        {}

     void validate() {}

    ClusterConfigurationBuilder addCluster(const std::string& clusterName) {
                return ClusterConfigurationBuilder(m_serversMap[clusterName],*this);
    }

   ServerConfigurationBuilder& addServer() {
                if (m_serversMap.find(Configuration::DEFAULT_CLUSTER_NAME) == m_serversMap.end())
           {
                        m_serversMap[Configuration::DEFAULT_CLUSTER_NAME];
           }
                auto& servers = m_serversMap[Configuration::DEFAULT_CLUSTER_NAME];
           servers.push_back(ServerConfigurationBuilder(*this));
       return servers[servers.size() - 1];
   }


    ConfigurationBuilder& addServers(std::string servers) {
        std::istringstream originalStream(servers);
        std::string stringHelper;
        std::string hostHelper;
        std::string portHelper;
        int portInt;

        // TODO: handle IPv6 addresses
        while(std::getline(originalStream,stringHelper,';')) {
            std::istringstream singleServerStream(stringHelper);
            std::getline(singleServerStream,hostHelper,':');
            std::getline(singleServerStream,portHelper,':');
            std::istringstream portStream(portHelper);
            portStream >> portInt;
            addServer().host(hostHelper).port(portInt);
        }

        return *this;
    }

    ConnectionPoolConfigurationBuilder& connectionPool() {
        return connectionPoolConfigurationBuilder;
    }

    ConfigurationBuilder& connectionTimeout(int connectionTimeout_) {
        m_connectionTimeout = connectionTimeout_;
        return *this;
    }

    ConfigurationBuilder& forceReturnValues(bool forceReturnValues_) {
        m_forceReturnValue = forceReturnValues_;
        return *this;
    }

    ConfigurationBuilder& keySizeEstimate(int keySizeEstimate_) {
        m_keySizeEstimate = keySizeEstimate_;
        return *this;
    }

    ConfigurationBuilder& protocolVersion(const std::string &protocolVersion_) {
        m_protocolVersion = protocolVersion_;
        return *this;
    }

    ConfigurationBuilder& socketTimeout(int socketTimeout_) {
        m_socketTimeout = socketTimeout_;
        return *this;
    }

    SslConfigurationBuilder& ssl() {
        return securityConfigurationBuilder.getSslConfigurationBuilder();
    }

    NearCacheConfigurationBuilder& nearCache() {
        return nearCacheConfigurationBuilder;
    }

    ConfigurationBuilder& tcpNoDelay(bool tcpNoDelay_) {
        m_tcpNoDelay = tcpNoDelay_;
        return *this;
    }

    ConfigurationBuilder& valueSizeEstimate(int valueSizeEstimate_) {
        m_valueSizeEstimate = valueSizeEstimate_;
        return *this;
    }

    ConfigurationBuilder& maxRetries(int maxRetries_) {
        m_maxRetries = maxRetries_;
        return *this;
    }

    ConfigurationBuilder& balancingStrategyProducer(FailOverRequestBalancingStrategy::ProducerFn bsp) {
        m_balancingStrategyProducer = bsp;
        return *this;
    }

    Configuration build() {
        return create();
    }

    Configuration create() {
        std::map<std::string,std::vector<ServerConfiguration>> serversMap;
        for (auto p: m_serversMap)
        {
                std::vector<ServerConfiguration> scVec;
                for (auto e : p.second)
                {
                        scVec.push_back(e.create());
                }
                serversMap.insert(std::make_pair(p.first, scVec));
        }
        if (serversMap.size()==0)
        {
                std::vector<ServerConfiguration> scVec;
                scVec.push_back(ServerConfigurationBuilder(*this).create());
                        serversMap.insert(std::make_pair(Configuration::DEFAULT_CLUSTER_NAME, scVec));
        }

        return Configuration(m_protocolVersion,
            connectionPoolConfigurationBuilder.create(),
            m_connectionTimeout,
            m_forceReturnValue,
            m_keySizeEstimate,
            serversMap,
            m_socketTimeout,
            securityConfigurationBuilder.create(),
            m_tcpNoDelay,
            m_valueSizeEstimate,
            m_maxRetries,
            nearCacheConfigurationBuilder.create(),
            m_balancingStrategyProducer,
            m_eventMarshaller, m_transactional);

    }

    ConfigurationBuilder& read(Configuration& configuration) {
        // FIXME: read pool, ssl and server configs
        m_protocolVersion = configuration.getProtocolVersionCString();
        m_connectionTimeout = configuration.getConnectionTimeout();
        m_forceReturnValue = configuration.isForceReturnValue();
        m_socketTimeout = configuration.getSocketTimeout();
        m_tcpNoDelay = configuration.isTcpNoDelay();
        m_keySizeEstimate = configuration.getKeySizeEstimate();
        m_valueSizeEstimate = configuration.getValueSizeEstimate();
        m_maxRetries = configuration.getMaxRetries();
        m_eventMarshaller = configuration.getEventMarshaller();
        m_transactional = configuration.isTransactional();
        return *this;
    }
    SecurityConfigurationBuilder& security()
    {
        return securityConfigurationBuilder;
    }

    bool isTransactional() const
    {
        return m_transactional;
    }

    ConfigurationBuilder& setTransactional(bool transactional)
            {
        m_transactional = transactional;
        return *this;
    }

  private:
    int m_connectionTimeout;
    bool m_forceReturnValue;
    int m_keySizeEstimate;
    std::string m_protocolVersion;
    std::map<std::string,std::vector<ServerConfigurationBuilder> >m_serversMap;
    int m_socketTimeout;
    bool m_tcpNoDelay;
    int m_valueSizeEstimate;
    unsigned int m_maxRetries;
    FailOverRequestBalancingStrategy::ProducerFn m_balancingStrategyProducer;
    ConnectionPoolConfigurationBuilder connectionPoolConfigurationBuilder;
    SecurityConfigurationBuilder securityConfigurationBuilder;
    JBasicEventMarshaller m_defaultEventMarshaller;
    NearCacheConfigurationBuilder nearCacheConfigurationBuilder;
    bool m_transactional;

    EventMarshaller &m_eventMarshaller=m_defaultEventMarshaller;
};

}} // namespace

#endif // ISPN_HOTROD_CONFIGURATION_CONFIGURATIONBUILDER_H