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 "Builder.h"
#include "Configuration.h"
#include "ConnectionPoolConfigurationBuilder.h"
#include "ServerConfigurationBuilder.h"
#include "SslConfigurationBuilder.h"

namespace infinispan {
namespace hotrod {

// Methods on this class cannot be invoked across library boundary, therefore, it can use STL.
class ConfigurationBuilder
    : public Builder<Configuration>
{
  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))
        sslConfigurationBuilder(*this)
        {}
    ServerConfigurationBuilder& addServer() {
        m_servers.push_back(ServerConfigurationBuilder(*this));
        return m_servers[m_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 sslConfigurationBuilder;
    }

    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();
    }

    virtual Configuration create() {
        std::vector<ServerConfiguration> servers;
        if (m_servers.size() > 0) {
            for (std::vector<ServerConfigurationBuilder>::iterator it = m_servers.begin(); it < m_servers.end(); it++) {
                servers.push_back(it->create());
            }
        } else {
            servers.push_back(ServerConfigurationBuilder(*this).create());
        }

        return Configuration(m_protocolVersion,
            connectionPoolConfigurationBuilder.create(),
            m_connectionTimeout,
            m_forceReturnValue,
            m_keySizeEstimate,
            servers,
            m_socketTimeout,
            sslConfigurationBuilder.create(),
            m_tcpNoDelay,
            m_valueSizeEstimate,
            m_maxRetries,
            m_balancingStrategyProducer);

    }

    virtual 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();
        return *this;
    }

    // DEPRECATED: use Configuration::PROTOCOL_VERSION_12 instead
    HR_EXTERN static const char *PROTOCOL_VERSION_12;

  private:
    int m_connectionTimeout;
    bool m_forceReturnValue;
    int m_keySizeEstimate;
    std::string m_protocolVersion;
    std::vector<ServerConfigurationBuilder> m_servers;
    int m_socketTimeout;
    bool m_tcpNoDelay;
    int m_valueSizeEstimate;
    int m_maxRetries;
    FailOverRequestBalancingStrategy::ProducerFn m_balancingStrategyProducer;

    ConnectionPoolConfigurationBuilder connectionPoolConfigurationBuilder;
    SslConfigurationBuilder sslConfigurationBuilder;
};

inline ServerConfigurationBuilder &ConfigurationChildBuilder::addServer() {
    return m_builder->addServer();
}

inline ConfigurationBuilder &ConfigurationChildBuilder::addServers(const std::string &servers) {
    return m_builder->addServers(servers);
}

inline ConnectionPoolConfigurationBuilder &ConfigurationChildBuilder::connectionPool() {
    return m_builder->connectionPool();
}

inline ConfigurationBuilder &ConfigurationChildBuilder::connectionTimeout(int connectionTimeout_) {
    return m_builder->connectionTimeout(connectionTimeout_);
}

inline ConfigurationBuilder &ConfigurationChildBuilder::forceReturnValues(bool forceReturnValues_) {
    return m_builder->forceReturnValues(forceReturnValues_);
}

inline ConfigurationBuilder &ConfigurationChildBuilder::keySizeEstimate(int keySizeEstimate_) {
    return m_builder->keySizeEstimate(keySizeEstimate_);
}

inline ConfigurationBuilder &ConfigurationChildBuilder::protocolVersion(const std::string &protocolVersion_) {
    return m_builder->protocolVersion(protocolVersion_);
}

inline ConfigurationBuilder &ConfigurationChildBuilder::socketTimeout(int socketTimeout_) {
    return m_builder->socketTimeout(socketTimeout_);
}

inline SslConfigurationBuilder &ConfigurationChildBuilder::ssl() {
    return m_builder->ssl();
}

inline ConfigurationBuilder &ConfigurationChildBuilder::tcpNoDelay(bool tcpNoDelay_) {
    return m_builder->tcpNoDelay(tcpNoDelay_);
}

inline ConfigurationBuilder &ConfigurationChildBuilder::valueSizeEstimate(int valueSizeEstimate_) {
    return m_builder->valueSizeEstimate(valueSizeEstimate_);
}

inline ConfigurationBuilder &ConfigurationChildBuilder::maxRetries(int maxRetries_) {
    return m_builder->maxRetries(maxRetries_);
}
inline ConfigurationBuilder &ConfigurationChildBuilder::balancingStrategyProducer(FailOverRequestBalancingStrategy::ProducerFn bsp) {
    return m_builder->balancingStrategyProducer(bsp);
}

inline Configuration ConfigurationChildBuilder::build() {
    return m_builder->build();
}


}} // namespace

#endif // ISPN_HOTROD_CONFIGURATION_CONFIGURATIONBUILDER_H