client_config.h

/*
 * Copyright (c) 2008-2025, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <memory>
#include <boost/optional.hpp>
 
#include "hazelcast/client/address.h"
#include "hazelcast/client/serialization_config.h"
#include "hazelcast/client/socket_interceptor.h"
#include "hazelcast/client/load_balancer.h"
#include "hazelcast/util/SynchronizedMap.h"
#include "hazelcast/client/config/reliable_topic_config.h"
#include "hazelcast/client/config/near_cache_config.h"
#include "hazelcast/client/config/client_network_config.h"
#include "hazelcast/client/config/client_connection_strategy_config.h"
#include "hazelcast/client/config/client_flake_id_generator_config.h"
#include "hazelcast/client/config/matcher/matching_point_config_pattern_matcher.h"
#include "hazelcast/client/internal/config/ConfigUtils.h"
#include "hazelcast/client/config/logger_config.h"
#include "hazelcast/client/serialization/serialization.h"
#include "hazelcast/client/lifecycle_listener.h"
#include "hazelcast/client/membership_listener.h"
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable : 4251) // for dll export
#endif
 
namespace hazelcast {
namespace client {
class initial_membership_event;
 
namespace connection {
class ClientConnectionManagerImpl;
};
 
namespace security {
class HAZELCAST_API credentials
{
public:
    enum credential_type
    {
        username_password,
        token
    };
 
    credentials(const std::string& name);
 
    virtual ~credentials();
 
    const std::string& name() const;
 
    virtual credential_type type() const = 0;
 
private:
    std::string name_;
};
 
class HAZELCAST_API username_password_credentials : public credentials
{
public:
    username_password_credentials(const std::string& name,
                                  const std::string& password);
 
    const std::string& password() const;
 
    credential_type type() const override;
 
private:
    std::string password_;
};
 
class HAZELCAST_API token_credentials : public credentials
{
public:
    token_credentials(const std::vector<byte>& token);
 
    const std::vector<byte>& token() const;
 
    credential_type type() const override;
 
private:
    std::vector<byte> token_;
};
}; // namespace security

class HAZELCAST_API client_config
{
    friend class spi::impl::ClientClusterServiceImpl;
    friend class connection::ClientConnectionManagerImpl;
 
public:
    client_config();
 
    client_config(const client_config& rhs) = delete;
 
    client_config& operator=(const client_config& rhs) = delete;
 
    client_config(client_config&& rhs);
 
    client_config& operator=(client_config&& rhs);

    const std::string& get_cluster_name() const;
 
    client_config& set_cluster_name(const std::string& cluster_name);

    client_config& set_credentials(
      const std::shared_ptr<security::credentials>& credential);
 
    const std::shared_ptr<security::credentials>& get_credentials() const;

    client_config& set_redo_operation(bool redo_operation);

    bool is_redo_operation() const;

    client_config& set_socket_interceptor(socket_interceptor&& interceptor);

    const socket_interceptor& get_socket_interceptor() const;

    client_config& add_listener(lifecycle_listener&& listener);

    const std::vector<lifecycle_listener>& get_lifecycle_listeners() const;

    client_config& add_listener(membership_listener&& listener);

    const std::vector<membership_listener>& get_membership_listeners() const;

    load_balancer& get_load_balancer();

    client_config& set_load_balancer(load_balancer&& load_balancer);

    serialization_config& get_serialization_config();

    client_config& set_serialization_config(
      serialization_config const& serialization_config);

    const std::unordered_map<std::string, std::string>& get_properties() const;

    client_config& set_property(const std::string& name,
                                const std::string& value);

    client_config& add_reliable_topic_config(
      const config::reliable_topic_config& reliable_topic_config);

    const config::reliable_topic_config& get_reliable_topic_config(
      const std::string& name);

    client_config& add_near_cache_config(
      const config::near_cache_config& near_cache_config);

    const config::near_cache_config* get_near_cache_config(
      const std::string& name) const;

    config::client_network_config& get_network_config();

    client_config& set_network_config(
      const config::client_network_config& network_config);
 
    const boost::optional<std::string>& get_instance_name() const;
 
    client_config& set_instance_name(const std::string& instance_name);

    int32_t get_executor_pool_size() const;

    void set_executor_pool_size(int32_t executor_pool_size);
 
    config::client_connection_strategy_config& get_connection_strategy_config();
 
    client_config& set_connection_strategy_config(
      const config::client_connection_strategy_config&
        connection_strategy_config);

    const config::client_flake_id_generator_config*
    find_flake_id_generator_config(const std::string& name);

    const config::client_flake_id_generator_config*
    get_flake_id_generator_config(const std::string& name);

    client_config& add_flake_id_generator_config(
      const config::client_flake_id_generator_config& config);

    config::logger_config& get_logger_config();
 
    const std::unordered_set<std::string>& get_labels() const;
 
    client_config& set_labels(const std::unordered_set<std::string>& labels);
 
    client_config& add_label(const std::string& label);

    client_config& backup_acks_enabled(bool enabled);

    bool backup_acks_enabled();
 
private:
    friend class reliable_topic;
 
    const config::reliable_topic_config* lookup_reliable_topic_config(
      const std::string& name) const;
 
    std::string cluster_name_;
 
    config::client_network_config network_config_;
 
    serialization_config serialization_config_;
 
    boost::optional<load_balancer> load_balancer_;
 
    std::vector<membership_listener> membership_listeners_;
 
    std::vector<lifecycle_listener> lifecycle_listeners_;
 
    std::unordered_map<std::string, std::string> properties_;
 
    bool redo_operation_;
 
    socket_interceptor socket_interceptor_;
 
    std::shared_ptr<security::credentials> credentials_;
 
    std::unordered_map<std::string, config::reliable_topic_config>
      reliable_topic_config_map_;
 
    std::unordered_map<std::string, config::near_cache_config>
      near_cache_config_map_;
 
    boost::optional<std::string> instance_name_;

    int32_t executor_pool_size_;
 
    config::client_connection_strategy_config connection_strategy_config_;
 
    std::unordered_map<std::string, config::client_flake_id_generator_config>
      flake_id_generator_config_map_;
 
    config::matcher::matching_point_config_pattern_matcher
      config_pattern_matcher_;
 
    config::logger_config logger_config_;
 
    std::unordered_set<std::string> labels_;
 
    bool backup_acks_enabled_ = true;
};
 
} // namespace client
} // namespace hazelcast
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif