/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */
package org.apache.pulsar.broker;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.Set;

import org.apache.pulsar.common.configuration.FieldContext;
import org.apache.pulsar.common.configuration.PulsarConfiguration;

import com.google.common.collect.Sets;

/**
 * Pulsar service configuration object.
 */
public class ServiceConfiguration implements PulsarConfiguration {

    /***** --- pulsar configuration --- ****/
    // Zookeeper quorum connection string
    @FieldContext(required = true)
    private String zookeeperServers;
    // Global Zookeeper quorum connection string
    @FieldContext(required = false)
    private String globalZookeeperServers;
    private int brokerServicePort = 6650;
    private int brokerServicePortTls = 6651;
    // Port to use to server HTTP request
    private int webServicePort = 8080;
    // Port to use to server HTTPS request
    private int webServicePortTls = 8443;

    // Hostname or IP address the service binds on.
    private String bindAddress = "0.0.0.0";

    // Controls which hostname is advertised to the discovery service via ZooKeeper.
    private String advertisedAddress;

    // Enable the WebSocket API service
    private boolean webSocketServiceEnabled = false;

    // Name of the cluster to which this broker belongs to
    @FieldContext(required = true)
    private String clusterName;
    // Zookeeper session timeout in milliseconds
    private long zooKeeperSessionTimeoutMillis = 30000;
    // Time to wait for broker graceful shutdown. After this time elapses, the
    // process will be killed
    @FieldContext(dynamic = true)
    private long brokerShutdownTimeoutMs = 3000;
    // Enable backlog quota check. Enforces action on topic when the quota is
    // reached
    private boolean backlogQuotaCheckEnabled = true;
    // How often to check for topics that have reached the quota
    private int backlogQuotaCheckIntervalInSeconds = 60;
    // Default per-topic backlog quota limit
    private long backlogQuotaDefaultLimitGB = 50;
    // Enable the deletion of inactive topics
    private boolean brokerDeleteInactiveTopicsEnabled = true;
    // How often to check for inactive topics
    private long brokerDeleteInactiveTopicsFrequencySeconds = 60;
    // How frequently to proactively check and purge expired messages
    private int messageExpiryCheckIntervalInMinutes = 5;

    // Set the default behavior for message deduplication in the broker
    // This can be overridden per-namespace. If enabled, broker will reject
    // messages that were already stored in the topic
    private boolean brokerDeduplicationEnabled = false;

    // Maximum number of producer information that it's going to be
    // persisted for deduplication purposes
    private int brokerDeduplicationMaxNumberOfProducers = 10000;

    // Number of entries after which a dedup info snapshot is taken.
    // A bigger interval will lead to less snapshots being taken though it would
    // increase the topic recovery time, when the entries published after the
    // snapshot need to be replayed
    private int brokerDeduplicationEntriesInterval = 1000;

    // Time of inactivity after which the broker will discard the deduplication information
    // relative to a disconnected producer. Default is 6 hours.
    private int brokerDeduplicationProducerInactivityTimeoutMinutes = 360;

    // Enable check for minimum allowed client library version
    private boolean clientLibraryVersionCheckEnabled = false;
    // Allow client libraries with no version information
    private boolean clientLibraryVersionCheckAllowUnversioned = true;
    // Path for the file used to determine the rotation status for the broker
    // when responding to service discovery health checks
    private String statusFilePath;
    // Max number of unacknowledged messages allowed to receive messages by a consumer on a shared subscription. Broker
    // will stop sending messages to consumer once, this limit reaches until consumer starts acknowledging messages back
    // and unack count reaches to maxUnackedMessagesPerConsumer/2 Using a value of 0, is disabling unackedMessage-limit
    // check and consumer can receive messages without any restriction
    private int maxUnackedMessagesPerConsumer = 50000;
    // Max number of unacknowledged messages allowed per shared subscription. Broker will stop dispatching messages to
    // all consumers of the subscription once this limit reaches until consumer starts acknowledging messages back and
    // unack count reaches to limit/2. Using a value of 0, is disabling unackedMessage-limit
    // check and dispatcher can dispatch messages without any restriction
    private int maxUnackedMessagesPerSubscription = 4 * 50000;
    // Max number of unacknowledged messages allowed per broker. Once this limit reaches, broker will stop dispatching
    // messages to all shared subscription which has higher number of unack messages until subscriptions start
    // acknowledging messages back and unack count reaches to limit/2. Using a value of 0, is disabling
    // unackedMessage-limit check and broker doesn't block dispatchers
    private int maxUnackedMessagesPerBroker = 0;
    // Once broker reaches maxUnackedMessagesPerBroker limit, it blocks subscriptions which has higher unacked messages
    // than this percentage limit and subscription will not receive any new messages until that subscription acks back
    // limit/2 messages
    private double maxUnackedMessagesPerSubscriptionOnBrokerBlocked = 0.16;
    // Default number of message dispatching throttling-limit for every topic. Using a value of 0, is disabling default
    // message dispatch-throttling
    @FieldContext(dynamic = true)
    private int dispatchThrottlingRatePerTopicInMsg = 0;
    // Default number of message-bytes dispatching throttling-limit for every topic. Using a value of 0, is disabling
    // default message-byte dispatch-throttling
    @FieldContext(dynamic = true)
    private long dispatchThrottlingRatePerTopicInByte = 0;
    // Default dispatch-throttling is disabled for consumers which already caught-up with published messages and
    // don't have backlog. This enables dispatch-throttling for non-backlog consumers as well.
    @FieldContext(dynamic = true)
    private boolean dispatchThrottlingOnNonBacklogConsumerEnabled = false;
    // Max number of concurrent lookup request broker allows to throttle heavy incoming lookup traffic
    @FieldContext(dynamic = true)
    private int maxConcurrentLookupRequest = 10000;
    // Max number of concurrent topic loading request broker allows to control number of zk-operations
    @FieldContext(dynamic = true)
    private int maxConcurrentTopicLoadRequest = 5000;
    // Max concurrent non-persistent message can be processed per connection
    private int maxConcurrentNonPersistentMessagePerConnection = 1000;
    // Number of worker threads to serve non-persistent topic
    private int numWorkerThreadsForNonPersistentTopic = 8;

    // Enable broker to load persistent topics
    private boolean enablePersistentTopics = true;

    // Enable broker to load non-persistent topics
    private boolean enableNonPersistentTopics = true;

    /***** --- TLS --- ****/
    // Enable TLS
    private boolean tlsEnabled = false;
    // Path for the TLS certificate file
    private String tlsCertificateFilePath;
    // Path for the TLS private key file
    private String tlsKeyFilePath;
    // Path for the trusted TLS certificate file
    private String tlsTrustCertsFilePath = "";
    // Accept untrusted TLS certificate from client
    private boolean tlsAllowInsecureConnection = false;

    /***** --- Authentication --- ****/
    // Enable authentication
    private boolean authenticationEnabled = false;
    // Autentication provider name list, which is a list of class names
    private Set<String> authenticationProviders = Sets.newTreeSet();

    // Enforce authorization
    private boolean authorizationEnabled = false;

    // Role names that are treated as "super-user", meaning they will be able to
    // do all admin operations and publish/consume from all topics
    private Set<String> superUserRoles = Sets.newTreeSet();

    // Allow wildcard matching in authorization
    // (wildcard matching only applicable if wildcard-char:
    // * presents at first or last position eg: *.pulsar.service, pulsar.service.*)
    private boolean authorizationAllowWildcardsMatching = false;

    // Authentication settings of the broker itself. Used when the broker connects
    // to other brokers, either in same or other clusters. Default uses plugin which disables authentication
    private String brokerClientAuthenticationPlugin = "org.apache.pulsar.client.impl.auth.AuthenticationDisabled";
    private String brokerClientAuthenticationParameters = "";

    /**** --- BookKeeper Client --- ****/
    // Authentication plugin to use when connecting to bookies
    private String bookkeeperClientAuthenticationPlugin;
    // BookKeeper auth plugin implementatation specifics parameters name and values
    private String bookkeeperClientAuthenticationParametersName;
    private String bookkeeperClientAuthenticationParameters;

    // Timeout for BK add / read operations
    private long bookkeeperClientTimeoutInSeconds = 30;
    // Speculative reads are initiated if a read request doesn't complete within
    // a certain time Using a value of 0, is disabling the speculative reads
    private int bookkeeperClientSpeculativeReadTimeoutInMillis = 0;
    // Enable bookies health check. Bookies that have more than the configured
    // number of failure within the interval will be quarantined for some time.
    // During this period, new ledgers won't be created on these bookies
    private boolean bookkeeperClientHealthCheckEnabled = true;
    private long bookkeeperClientHealthCheckIntervalSeconds = 60;
    private long bookkeeperClientHealthCheckErrorThresholdPerInterval = 5;
    private long bookkeeperClientHealthCheckQuarantineTimeInSeconds = 1800;
    // Enable rack-aware bookie selection policy. BK will chose bookies from
    // different racks when forming a new bookie ensemble
    private boolean bookkeeperClientRackawarePolicyEnabled = true;
    // Enable bookie isolation by specifying a list of bookie groups to choose
    // from. Any bookie outside the specified groups will not be used by the
    // broker
    @FieldContext(required = false)
    private String bookkeeperClientIsolationGroups;

    /**** --- Managed Ledger --- ****/
    // Number of bookies to use when creating a ledger
    @FieldContext(minValue = 1)
    private int managedLedgerDefaultEnsembleSize = 1;
    // Number of copies to store for each message
    @FieldContext(minValue = 1)
    private int managedLedgerDefaultWriteQuorum = 1;
    // Number of guaranteed copies (acks to wait before write is complete)
    @FieldContext(minValue = 1)
    private int managedLedgerDefaultAckQuorum = 1;
    // Max number of bookies to use when creating a ledger
    @FieldContext(minValue = 1)
    private int managedLedgerMaxEnsembleSize = 5;
    // Max number of copies to store for each message
    @FieldContext(minValue = 1)
    private int managedLedgerMaxWriteQuorum = 5;
    // Max number of guaranteed copies (acks to wait before write is complete)
    @FieldContext(minValue = 1)
    private int managedLedgerMaxAckQuorum = 5;
    // Amount of memory to use for caching data payload in managed ledger. This
    // memory
    // is allocated from JVM direct memory and it's shared across all the topics
    // running in the same broker
    private int managedLedgerCacheSizeMB = 1024;
    // Threshold to which bring down the cache level when eviction is triggered
    private double managedLedgerCacheEvictionWatermark = 0.9f;
    // Rate limit the amount of writes per second generated by consumer acking the messages
    private double managedLedgerDefaultMarkDeleteRateLimit = 1.0;
    // Max number of entries to append to a ledger before triggering a rollover
    // A ledger rollover is triggered on these conditions Either the max
    // rollover time has been reached or max entries have been written to the
    // ledged and at least min-time has passed
    private int managedLedgerMaxEntriesPerLedger = 50000;
    // Minimum time between ledger rollover for a topic
    private int managedLedgerMinLedgerRolloverTimeMinutes = 10;
    // Maximum time before forcing a ledger rollover for a topic
    private int managedLedgerMaxLedgerRolloverTimeMinutes = 240;
    // Max number of entries to append to a cursor ledger
    private int managedLedgerCursorMaxEntriesPerLedger = 50000;
    // Max time before triggering a rollover on a cursor ledger
    private int managedLedgerCursorRolloverTimeInSeconds = 14400;
    // Max number of "acknowledgment holes" that are going to be persistently stored.
    // When acknowledging out of order, a consumer will leave holes that are supposed
    // to be quickly filled by acking all the messages. The information of which
    // messages are acknowledged is persisted by compressing in "ranges" of messages
    // that were acknowledged. After the max number of ranges is reached, the information
    // will only be tracked in memory and messages will be redelivered in case of
    // crashes.
    private int managedLedgerMaxUnackedRangesToPersist = 10000;
    // Max number of "acknowledgment holes" that can be stored in Zookeeper. If number of unack message range is higher
    // than this limit then broker will persist unacked ranges into bookkeeper to avoid additional data overhead into
    // zookeeper.  
    private int managedLedgerMaxUnackedRangesToPersistInZooKeeper = 1000;

    /*** --- Load balancer --- ****/
    // Enable load balancer
    private boolean loadBalancerEnabled = false;
    // load placement strategy
    private String loadBalancerPlacementStrategy = "weightedRandomSelection"; // weighted random selection
    // Percentage of change to trigger load report update
    @FieldContext(dynamic = true)
    private int loadBalancerReportUpdateThresholdPercentage = 10;
    // maximum interval to update load report
    @FieldContext(dynamic = true)
    private int loadBalancerReportUpdateMaxIntervalMinutes = 15;
    // Frequency of report to collect
    private int loadBalancerHostUsageCheckIntervalMinutes = 1;
    // Load shedding interval. Broker periodically checks whether some traffic
    // should be offload from
    // some over-loaded broker to other under-loaded brokers
    private int loadBalancerSheddingIntervalMinutes = 30;
    // Prevent the same topics to be shed and moved to other broker more that
    // once within this timeframe
    private long loadBalancerSheddingGracePeriodMinutes = 30;
    // Usage threshold to determine a broker as under-loaded
    private int loadBalancerBrokerUnderloadedThresholdPercentage = 50;
    // Usage threshold to determine a broker as over-loaded
    private int loadBalancerBrokerOverloadedThresholdPercentage = 85;
    // interval to flush dynamic resource quota to ZooKeeper
    private int loadBalancerResourceQuotaUpdateIntervalMinutes = 15;
    // Usage threshold to defermine a broker is having just right level of load
    private int loadBalancerBrokerComfortLoadLevelPercentage = 65;
    // enable/disable automatic namespace bundle split
    private boolean loadBalancerAutoBundleSplitEnabled = false;
    // maximum topics in a bundle, otherwise bundle split will be triggered
    private int loadBalancerNamespaceBundleMaxTopics = 1000;
    // maximum sessions (producers + consumers) in a bundle, otherwise bundle split will be triggered
    private int loadBalancerNamespaceBundleMaxSessions = 1000;
    // maximum msgRate (in + out) in a bundle, otherwise bundle split will be triggered
    private int loadBalancerNamespaceBundleMaxMsgRate = 1000;
    // maximum bandwidth (in + out) in a bundle, otherwise bundle split will be triggered
    private int loadBalancerNamespaceBundleMaxBandwidthMbytes = 100;
    // maximum number of bundles in a namespace
    private int loadBalancerNamespaceMaximumBundles = 128;

    /**** --- Replication --- ****/
    // Enable replication metrics
    private boolean replicationMetricsEnabled = false;
    // Max number of connections to open for each broker in a remote cluster
    // More connections host-to-host lead to better throughput over high-latency
    // links.
    private int replicationConnectionsPerBroker = 16;
    @FieldContext(required = false)
    // replicator prefix used for replicator producer name and cursor name
    private String replicatorPrefix = "pulsar.repl";
    // Replicator producer queue size;
    private int replicationProducerQueueSize = 1000;
    // Default message retention time
    private int defaultRetentionTimeInMinutes = 0;
    // Default retention size
    private int defaultRetentionSizeInMB = 0;
    // How often to check pulsar connection is still alive
    private int keepAliveIntervalSeconds = 30;
    // How often broker checks for inactive topics to be deleted (topics with no subscriptions and no one connected)
    private int brokerServicePurgeInactiveFrequencyInSeconds = 60;
    private List<String> bootstrapNamespaces = new ArrayList<String>();
    private Properties properties = new Properties();
    // Name of load manager to use
    @FieldContext(dynamic = true)
    private String loadManagerClassName = "org.apache.pulsar.broker.loadbalance.impl.SimpleLoadManagerImpl";
    // If true, (and ModularLoadManagerImpl is being used), the load manager will attempt to
    // use only brokers running the latest software version (to minimize impact to bundles)
    @FieldContext(dynamic = true)
    private boolean preferLaterVersions = false;

    /**** --- WebSocket --- ****/
    // Number of IO threads in Pulsar Client used in WebSocket proxy
    private int webSocketNumIoThreads = Runtime.getRuntime().availableProcessors();
    // Number of connections per Broker in Pulsar Client used in WebSocket proxy
    private int webSocketConnectionsPerBroker = Runtime.getRuntime().availableProcessors();

    public String getZookeeperServers() {
        return zookeeperServers;
    }

    public void setZookeeperServers(String zookeeperServers) {
        this.zookeeperServers = zookeeperServers;
    }

    public String getGlobalZookeeperServers() {
        if (this.globalZookeeperServers == null || this.globalZookeeperServers.isEmpty()) {
            // If the configuration is not set, assuming that the globalZK is not enabled and all data is in the same
            // ZooKeeper cluster
            return this.getZookeeperServers();
        }
        return globalZookeeperServers;
    }

    public void setGlobalZookeeperServers(String globalZookeeperServers) {
        this.globalZookeeperServers = globalZookeeperServers;
    }

    public int getBrokerServicePort() {
        return brokerServicePort;
    }

    public void setBrokerServicePort(int brokerServicePort) {
        this.brokerServicePort = brokerServicePort;
    }

    public int getBrokerServicePortTls() {
        return brokerServicePortTls;
    }

    public void setBrokerServicePortTls(int brokerServicePortTls) {
        this.brokerServicePortTls = brokerServicePortTls;
    }

    public int getWebServicePort() {
        return webServicePort;
    }

    public void setWebServicePort(int webServicePort) {
        this.webServicePort = webServicePort;
    }

    public int getWebServicePortTls() {
        return webServicePortTls;
    }

    public void setWebServicePortTls(int webServicePortTls) {
        this.webServicePortTls = webServicePortTls;
    }

    public String getBindAddress() {
        return this.bindAddress;
    }

    public void setBindAddress(String bindAddress) {
        this.bindAddress = bindAddress;
    }

    public String getAdvertisedAddress() {
        return this.advertisedAddress;
    }

    public void setAdvertisedAddress(String advertisedAddress) {
        this.advertisedAddress = advertisedAddress;
    }

    public boolean isWebSocketServiceEnabled() {
        return webSocketServiceEnabled;
    }

    public void setWebSocketServiceEnabled(boolean webSocketServiceEnabled) {
        this.webSocketServiceEnabled = webSocketServiceEnabled;
    }

    public String getClusterName() {
        return clusterName;
    }

    public void setClusterName(String clusterName) {
        this.clusterName = clusterName;
    }

    public long getBrokerShutdownTimeoutMs() {
        return brokerShutdownTimeoutMs;
    }

    public void setBrokerShutdownTimeoutMs(long brokerShutdownTimeoutMs) {
        this.brokerShutdownTimeoutMs = brokerShutdownTimeoutMs;
    }

    public boolean isBacklogQuotaCheckEnabled() {
        return backlogQuotaCheckEnabled;
    }

    public void setBacklogQuotaCheckEnabled(boolean backlogQuotaCheckEnabled) {
        this.backlogQuotaCheckEnabled = backlogQuotaCheckEnabled;
    }

    public int getBacklogQuotaCheckIntervalInSeconds() {
        return backlogQuotaCheckIntervalInSeconds;
    }

    public void setBacklogQuotaCheckIntervalInSeconds(int backlogQuotaCheckIntervalInSeconds) {
        this.backlogQuotaCheckIntervalInSeconds = backlogQuotaCheckIntervalInSeconds;
    }

    public long getBacklogQuotaDefaultLimitGB() {
        return backlogQuotaDefaultLimitGB;
    }

    public void setBacklogQuotaDefaultLimitGB(long backlogQuotaDefaultLimitGB) {
        this.backlogQuotaDefaultLimitGB = backlogQuotaDefaultLimitGB;
    }

    public boolean isBrokerDeleteInactiveTopicsEnabled() {
        return brokerDeleteInactiveTopicsEnabled;
    }

    public void setBrokerDeleteInactiveTopicsEnabled(boolean brokerDeleteInactiveTopicsEnabled) {
        this.brokerDeleteInactiveTopicsEnabled = brokerDeleteInactiveTopicsEnabled;
    }

    public int getBrokerDeduplicationMaxNumberOfProducers() {
        return brokerDeduplicationMaxNumberOfProducers;
    }

    public void setBrokerDeduplicationMaxNumberOfProducers(int brokerDeduplicationMaxNumberOfProducers) {
        this.brokerDeduplicationMaxNumberOfProducers = brokerDeduplicationMaxNumberOfProducers;
    }

    public int getBrokerDeduplicationEntriesInterval() {
        return brokerDeduplicationEntriesInterval;
    }

    public void setBrokerDeduplicationEntriesInterval(int brokerDeduplicationEntriesInterval) {
        this.brokerDeduplicationEntriesInterval = brokerDeduplicationEntriesInterval;
    }

    public int getBrokerDeduplicationProducerInactivityTimeoutMinutes() {
        return brokerDeduplicationProducerInactivityTimeoutMinutes;
    }

    public void setBrokerDeduplicationProducerInactivityTimeoutMinutes(
            int brokerDeduplicationProducerInactivityTimeoutMinutes) {
        this.brokerDeduplicationProducerInactivityTimeoutMinutes = brokerDeduplicationProducerInactivityTimeoutMinutes;
    }

    public long getBrokerDeleteInactiveTopicsFrequencySeconds() {
        return brokerDeleteInactiveTopicsFrequencySeconds;
    }

    public void setBrokerDeleteInactiveTopicsFrequencySeconds(long brokerDeleteInactiveTopicsFrequencySeconds) {
        this.brokerDeleteInactiveTopicsFrequencySeconds = brokerDeleteInactiveTopicsFrequencySeconds;
    }

    public int getMessageExpiryCheckIntervalInMinutes() {
        return messageExpiryCheckIntervalInMinutes;
    }

    public void setMessageExpiryCheckIntervalInMinutes(int messageExpiryCheckIntervalInMinutes) {
        this.messageExpiryCheckIntervalInMinutes = messageExpiryCheckIntervalInMinutes;
    }

    public boolean isBrokerDeduplicationEnabled() {
        return brokerDeduplicationEnabled;
    }

    public void setBrokerDeduplicationEnabled(boolean brokerDeduplicationEnabled) {
        this.brokerDeduplicationEnabled = brokerDeduplicationEnabled;
    }

    public boolean isClientLibraryVersionCheckEnabled() {
        return clientLibraryVersionCheckEnabled;
    }

    public void setClientLibraryVersionCheckEnabled(boolean clientLibraryVersionCheckEnabled) {
        this.clientLibraryVersionCheckEnabled = clientLibraryVersionCheckEnabled;
    }

    public boolean isClientLibraryVersionCheckAllowUnversioned() {
        return clientLibraryVersionCheckAllowUnversioned;
    }

    public void setClientLibraryVersionCheckAllowUnversioned(boolean clientLibraryVersionCheckAllowUnversioned) {
        this.clientLibraryVersionCheckAllowUnversioned = clientLibraryVersionCheckAllowUnversioned;
    }

    public String getStatusFilePath() {
        return statusFilePath;
    }

    public void setStatusFilePath(String statusFilePath) {
        this.statusFilePath = statusFilePath;
    }

    public int getMaxUnackedMessagesPerConsumer() {
        return maxUnackedMessagesPerConsumer;
    }

    public void setMaxUnackedMessagesPerConsumer(int maxUnackedMessagesPerConsumer) {
        this.maxUnackedMessagesPerConsumer = maxUnackedMessagesPerConsumer;
    }

    public int getMaxUnackedMessagesPerSubscription() {
        return maxUnackedMessagesPerSubscription;
    }

    public void setMaxUnackedMessagesPerSubscription(int maxUnackedMessagesPerSubscription) {
        this.maxUnackedMessagesPerSubscription = maxUnackedMessagesPerSubscription;
    }

    public int getMaxUnackedMessagesPerBroker() {
        return maxUnackedMessagesPerBroker;
    }

    public void setMaxUnackedMessagesPerBroker(int maxUnackedMessagesPerBroker) {
        this.maxUnackedMessagesPerBroker = maxUnackedMessagesPerBroker;
    }

    public double getMaxUnackedMessagesPerSubscriptionOnBrokerBlocked() {
        return maxUnackedMessagesPerSubscriptionOnBrokerBlocked;
    }

    public void setMaxUnackedMessagesPerSubscriptionOnBrokerBlocked(
            double maxUnackedMessagesPerSubscriptionOnBrokerBlocked) {
        this.maxUnackedMessagesPerSubscriptionOnBrokerBlocked = maxUnackedMessagesPerSubscriptionOnBrokerBlocked;
    }

    public int getDispatchThrottlingRatePerTopicInMsg() {
        return dispatchThrottlingRatePerTopicInMsg;
    }

    public void setDispatchThrottlingRatePerTopicInMsg(int dispatchThrottlingRatePerTopicInMsg) {
        this.dispatchThrottlingRatePerTopicInMsg = dispatchThrottlingRatePerTopicInMsg;
    }

    public long getDispatchThrottlingRatePerTopicInByte() {
        return dispatchThrottlingRatePerTopicInByte;
    }

    public void setDispatchThrottlingRatePerTopicInByte(long dispatchThrottlingRatePerTopicInByte) {
        this.dispatchThrottlingRatePerTopicInByte = dispatchThrottlingRatePerTopicInByte;
    }

    public boolean isDispatchThrottlingOnNonBacklogConsumerEnabled() {
        return dispatchThrottlingOnNonBacklogConsumerEnabled;
    }

    public void setDispatchThrottlingOnNonBacklogConsumerEnabled(boolean dispatchThrottlingOnNonBacklogConsumerEnabled) {
        this.dispatchThrottlingOnNonBacklogConsumerEnabled = dispatchThrottlingOnNonBacklogConsumerEnabled;
    }

    public int getMaxConcurrentLookupRequest() {
        return maxConcurrentLookupRequest;
    }

    public void setMaxConcurrentLookupRequest(int maxConcurrentLookupRequest) {
        this.maxConcurrentLookupRequest = maxConcurrentLookupRequest;
    }

    public int getMaxConcurrentTopicLoadRequest() {
        return maxConcurrentTopicLoadRequest;
    }

    public void setMaxConcurrentTopicLoadRequest(int maxConcurrentTopicLoadRequest) {
        this.maxConcurrentTopicLoadRequest = maxConcurrentTopicLoadRequest;
    }

    public int getMaxConcurrentNonPersistentMessagePerConnection() {
        return maxConcurrentNonPersistentMessagePerConnection;
    }

    public void setMaxConcurrentNonPersistentMessagePerConnection(int maxConcurrentNonPersistentMessagePerConnection) {
        this.maxConcurrentNonPersistentMessagePerConnection = maxConcurrentNonPersistentMessagePerConnection;
    }

    public int getNumWorkerThreadsForNonPersistentTopic() {
        return numWorkerThreadsForNonPersistentTopic;
    }

    public void setNumWorkerThreadsForNonPersistentTopic(int numWorkerThreadsForNonPersistentTopic) {
        this.numWorkerThreadsForNonPersistentTopic = numWorkerThreadsForNonPersistentTopic;
    }

    public boolean isEnablePersistentTopics() {
        return enablePersistentTopics;
    }

    public void setEnablePersistentTopics(boolean enablePersistentTopics) {
        this.enablePersistentTopics = enablePersistentTopics;
    }

    public boolean isEnableNonPersistentTopics() {
        return enableNonPersistentTopics;
    }

    public void setEnableNonPersistentTopics(boolean enableNonPersistentTopics) {
        this.enableNonPersistentTopics = enableNonPersistentTopics;
    }

    public boolean isTlsEnabled() {
        return tlsEnabled;
    }

    public void setTlsEnabled(boolean tlsEnabled) {
        this.tlsEnabled = tlsEnabled;
    }

    public String getTlsCertificateFilePath() {
        return tlsCertificateFilePath;
    }

    public void setTlsCertificateFilePath(String tlsCertificateFilePath) {
        this.tlsCertificateFilePath = tlsCertificateFilePath;
    }

    public String getTlsKeyFilePath() {
        return tlsKeyFilePath;
    }

    public void setTlsKeyFilePath(String tlsKeyFilePath) {
        this.tlsKeyFilePath = tlsKeyFilePath;
    }

    public String getTlsTrustCertsFilePath() {
        return tlsTrustCertsFilePath;
    }

    public void setTlsTrustCertsFilePath(String tlsTrustCertsFilePath) {
        this.tlsTrustCertsFilePath = tlsTrustCertsFilePath;
    }

    public boolean isTlsAllowInsecureConnection() {
        return tlsAllowInsecureConnection;
    }

    public void setTlsAllowInsecureConnection(boolean tlsAllowInsecureConnection) {
        this.tlsAllowInsecureConnection = tlsAllowInsecureConnection;
    }

    public boolean isAuthenticationEnabled() {
        return authenticationEnabled;
    }

    public void setAuthenticationEnabled(boolean authenticationEnabled) {
        this.authenticationEnabled = authenticationEnabled;
    }

    public void setAuthenticationProviders(Set<String> providersClassNames) {
        authenticationProviders = providersClassNames;
    }

    public Set<String> getAuthenticationProviders() {
        return authenticationProviders;
    }

    public boolean isAuthorizationEnabled() {
        return authorizationEnabled;
    }

    public void setAuthorizationEnabled(boolean authorizationEnabled) {
        this.authorizationEnabled = authorizationEnabled;
    }

    public Set<String> getSuperUserRoles() {
        return superUserRoles;
    }

    public boolean getAuthorizationAllowWildcardsMatching() {
        return authorizationAllowWildcardsMatching;
    }

    public void setAuthorizationAllowWildcardsMatching(boolean authorizationAllowWildcardsMatching) {
        this.authorizationAllowWildcardsMatching = authorizationAllowWildcardsMatching;
    }

    public void setSuperUserRoles(Set<String> superUserRoles) {
        this.superUserRoles = superUserRoles;
    }

    public String getBrokerClientAuthenticationPlugin() {
        return brokerClientAuthenticationPlugin;
    }

    public void setBrokerClientAuthenticationPlugin(String brokerClientAuthenticationPlugin) {
        this.brokerClientAuthenticationPlugin = brokerClientAuthenticationPlugin;
    }

    public String getBrokerClientAuthenticationParameters() {
        return brokerClientAuthenticationParameters;
    }

    public void setBrokerClientAuthenticationParameters(String brokerClientAuthenticationParameters) {
        this.brokerClientAuthenticationParameters = brokerClientAuthenticationParameters;
    }

    public String getBookkeeperClientAuthenticationPlugin() {
        return bookkeeperClientAuthenticationPlugin;
    }

    public void setBookkeeperClientAuthenticationPlugin(String bookkeeperClientAuthenticationPlugin) {
        this.bookkeeperClientAuthenticationPlugin = bookkeeperClientAuthenticationPlugin;
    }

    public String getBookkeeperClientAuthenticationParametersName() {
        return bookkeeperClientAuthenticationParametersName;
    }

    public void setBookkeeperClientAuthenticationParametersName(String bookkeeperClientAuthenticationParametersName) {
        this.bookkeeperClientAuthenticationParametersName = bookkeeperClientAuthenticationParametersName;
    }

    public String getBookkeeperClientAuthenticationParameters() {
        return bookkeeperClientAuthenticationParameters;
    }

    public void setBookkeeperClientAuthenticationParameters(String bookkeeperClientAuthenticationParameters) {
        this.bookkeeperClientAuthenticationParameters = bookkeeperClientAuthenticationParameters;
    }

    public long getBookkeeperClientTimeoutInSeconds() {
        return bookkeeperClientTimeoutInSeconds;
    }

    public void setBookkeeperClientTimeoutInSeconds(long bookkeeperClientTimeoutInSeconds) {
        this.bookkeeperClientTimeoutInSeconds = bookkeeperClientTimeoutInSeconds;
    }

    public int getBookkeeperClientSpeculativeReadTimeoutInMillis() {
        return bookkeeperClientSpeculativeReadTimeoutInMillis;
    }

    public void setBookkeeperClientSpeculativeReadTimeoutInMillis(int bookkeeperClientSpeculativeReadTimeoutInMillis) {
        this.bookkeeperClientSpeculativeReadTimeoutInMillis = bookkeeperClientSpeculativeReadTimeoutInMillis;
    }

    public boolean isBookkeeperClientHealthCheckEnabled() {
        return bookkeeperClientHealthCheckEnabled;
    }

    public void setBookkeeperClientHealthCheckEnabled(boolean bookkeeperClientHealthCheckEnabled) {
        this.bookkeeperClientHealthCheckEnabled = bookkeeperClientHealthCheckEnabled;
    }

    public long getBookkeeperClientHealthCheckIntervalSeconds() {
        return bookkeeperClientHealthCheckIntervalSeconds;
    }

    public void setBookkeeperClientHealthCheckIntervalSeconds(long bookkeeperClientHealthCheckIntervalSeconds) {
        this.bookkeeperClientHealthCheckIntervalSeconds = bookkeeperClientHealthCheckIntervalSeconds;
    }

    public long getBookkeeperClientHealthCheckErrorThresholdPerInterval() {
        return bookkeeperClientHealthCheckErrorThresholdPerInterval;
    }

    public void setBookkeeperClientHealthCheckErrorThresholdPerInterval(
            long bookkeeperClientHealthCheckErrorThresholdPerInterval) {
        this.bookkeeperClientHealthCheckErrorThresholdPerInterval = bookkeeperClientHealthCheckErrorThresholdPerInterval;
    }

    public long getBookkeeperClientHealthCheckQuarantineTimeInSeconds() {
        return bookkeeperClientHealthCheckQuarantineTimeInSeconds;
    }

    public void setBookkeeperClientHealthCheckQuarantineTimeInSeconds(
            long bookkeeperClientHealthCheckQuarantineTimeInSeconds) {
        this.bookkeeperClientHealthCheckQuarantineTimeInSeconds = bookkeeperClientHealthCheckQuarantineTimeInSeconds;
    }

    public boolean isBookkeeperClientRackawarePolicyEnabled() {
        return bookkeeperClientRackawarePolicyEnabled;
    }

    public void setBookkeeperClientRackawarePolicyEnabled(boolean bookkeeperClientRackawarePolicyEnabled) {
        this.bookkeeperClientRackawarePolicyEnabled = bookkeeperClientRackawarePolicyEnabled;
    }

    public String getBookkeeperClientIsolationGroups() {
        return bookkeeperClientIsolationGroups;
    }

    public void setBookkeeperClientIsolationGroups(String bookkeeperClientIsolationGroups) {
        this.bookkeeperClientIsolationGroups = bookkeeperClientIsolationGroups;
    }

    public int getManagedLedgerDefaultEnsembleSize() {
        return managedLedgerDefaultEnsembleSize;
    }

    public void setManagedLedgerDefaultEnsembleSize(int managedLedgerDefaultEnsembleSize) {
        this.managedLedgerDefaultEnsembleSize = managedLedgerDefaultEnsembleSize;
    }

    public int getManagedLedgerDefaultWriteQuorum() {
        return managedLedgerDefaultWriteQuorum;
    }

    public void setManagedLedgerDefaultWriteQuorum(int managedLedgerDefaultWriteQuorum) {
        this.managedLedgerDefaultWriteQuorum = managedLedgerDefaultWriteQuorum;
    }

    public int getManagedLedgerDefaultAckQuorum() {
        return managedLedgerDefaultAckQuorum;
    }

    public void setManagedLedgerDefaultAckQuorum(int managedLedgerDefaultAckQuorum) {
        this.managedLedgerDefaultAckQuorum = managedLedgerDefaultAckQuorum;
    }

    public int getManagedLedgerMaxEnsembleSize() {
        return managedLedgerMaxEnsembleSize;
    }

    public void setManagedLedgerMaxEnsembleSize(int managedLedgerMaxEnsembleSize) {
        this.managedLedgerMaxEnsembleSize = managedLedgerMaxEnsembleSize;
    }

    public int getManagedLedgerMaxWriteQuorum() {
        return managedLedgerMaxWriteQuorum;
    }

    public void setManagedLedgerMaxWriteQuorum(int managedLedgerMaxWriteQuorum) {
        this.managedLedgerMaxWriteQuorum = managedLedgerMaxWriteQuorum;
    }

    public int getManagedLedgerMaxAckQuorum() {
        return managedLedgerMaxAckQuorum;
    }

    public void setManagedLedgerMaxAckQuorum(int managedLedgerMaxAckQuorum) {
        this.managedLedgerMaxAckQuorum = managedLedgerMaxAckQuorum;
    }

    public int getManagedLedgerCacheSizeMB() {
        return managedLedgerCacheSizeMB;
    }

    public void setManagedLedgerCacheSizeMB(int managedLedgerCacheSizeMB) {
        this.managedLedgerCacheSizeMB = managedLedgerCacheSizeMB;
    }

    public double getManagedLedgerCacheEvictionWatermark() {
        return managedLedgerCacheEvictionWatermark;
    }

    public void setManagedLedgerCacheEvictionWatermark(double managedLedgerCacheEvictionWatermark) {
        this.managedLedgerCacheEvictionWatermark = managedLedgerCacheEvictionWatermark;
    }

    public double getManagedLedgerDefaultMarkDeleteRateLimit() {
        return managedLedgerDefaultMarkDeleteRateLimit;
    }

    public void setManagedLedgerDefaultMarkDeleteRateLimit(double managedLedgerDefaultMarkDeleteRateLimit) {
        this.managedLedgerDefaultMarkDeleteRateLimit = managedLedgerDefaultMarkDeleteRateLimit;
    }

    public int getManagedLedgerMaxEntriesPerLedger() {
        return managedLedgerMaxEntriesPerLedger;
    }

    public void setManagedLedgerMaxEntriesPerLedger(int managedLedgerMaxEntriesPerLedger) {
        this.managedLedgerMaxEntriesPerLedger = managedLedgerMaxEntriesPerLedger;
    }

    public int getManagedLedgerMinLedgerRolloverTimeMinutes() {
        return managedLedgerMinLedgerRolloverTimeMinutes;
    }

    public void setManagedLedgerMinLedgerRolloverTimeMinutes(int managedLedgerMinLedgerRolloverTimeMinutes) {
        this.managedLedgerMinLedgerRolloverTimeMinutes = managedLedgerMinLedgerRolloverTimeMinutes;
    }

    public int getManagedLedgerMaxLedgerRolloverTimeMinutes() {
        return managedLedgerMaxLedgerRolloverTimeMinutes;
    }

    public void setManagedLedgerMaxLedgerRolloverTimeMinutes(int managedLedgerMaxLedgerRolloverTimeMinutes) {
        this.managedLedgerMaxLedgerRolloverTimeMinutes = managedLedgerMaxLedgerRolloverTimeMinutes;
    }

    public int getManagedLedgerCursorMaxEntriesPerLedger() {
        return managedLedgerCursorMaxEntriesPerLedger;
    }

    public void setManagedLedgerCursorMaxEntriesPerLedger(int managedLedgerCursorMaxEntriesPerLedger) {
        this.managedLedgerCursorMaxEntriesPerLedger = managedLedgerCursorMaxEntriesPerLedger;
    }

    public int getManagedLedgerCursorRolloverTimeInSeconds() {
        return managedLedgerCursorRolloverTimeInSeconds;
    }

    public void setManagedLedgerCursorRolloverTimeInSeconds(int managedLedgerCursorRolloverTimeInSeconds) {
        this.managedLedgerCursorRolloverTimeInSeconds = managedLedgerCursorRolloverTimeInSeconds;
    }

    public int getManagedLedgerMaxUnackedRangesToPersist() {
        return managedLedgerMaxUnackedRangesToPersist;
    }

    public void setManagedLedgerMaxUnackedRangesToPersist(int managedLedgerMaxUnackedRangesToPersist) {
        this.managedLedgerMaxUnackedRangesToPersist = managedLedgerMaxUnackedRangesToPersist;
    }

    public int getManagedLedgerMaxUnackedRangesToPersistInZooKeeper() {
        return managedLedgerMaxUnackedRangesToPersistInZooKeeper;
    }

    public void setManagedLedgerMaxUnackedRangesToPersistInZooKeeper(
            int managedLedgerMaxUnackedRangesToPersistInZookeeper) {
        this.managedLedgerMaxUnackedRangesToPersistInZooKeeper = managedLedgerMaxUnackedRangesToPersistInZookeeper;
    }

    public boolean isLoadBalancerEnabled() {
        return loadBalancerEnabled;
    }

    public void setLoadBalancerEnabled(boolean loadBalancerEnabled) {
        this.loadBalancerEnabled = loadBalancerEnabled;
    }

    public void setLoadBalancerPlacementStrategy(String placementStrategy) {
        this.loadBalancerPlacementStrategy = placementStrategy;
    }

    public String getLoadBalancerPlacementStrategy() {
        return this.loadBalancerPlacementStrategy;
    }

    public int getLoadBalancerReportUpdateThresholdPercentage() {
        return loadBalancerReportUpdateThresholdPercentage;
    }

    public void setLoadBalancerReportUpdateThresholdPercentage(int loadBalancerReportUpdateThresholdPercentage) {
        this.loadBalancerReportUpdateThresholdPercentage = loadBalancerReportUpdateThresholdPercentage;
    }

    public int getLoadBalancerReportUpdateMaxIntervalMinutes() {
        return loadBalancerReportUpdateMaxIntervalMinutes;
    }

    public void setLoadBalancerReportUpdateMaxIntervalMinutes(int loadBalancerReportUpdateMaxIntervalMinutes) {
        this.loadBalancerReportUpdateMaxIntervalMinutes = loadBalancerReportUpdateMaxIntervalMinutes;
    }

    public int getLoadBalancerHostUsageCheckIntervalMinutes() {
        return loadBalancerHostUsageCheckIntervalMinutes;
    }

    public void setLoadBalancerHostUsageCheckIntervalMinutes(int loadBalancerHostUsageCheckIntervalMinutes) {
        this.loadBalancerHostUsageCheckIntervalMinutes = loadBalancerHostUsageCheckIntervalMinutes;
    }

    public int getLoadBalancerSheddingIntervalMinutes() {
        return loadBalancerSheddingIntervalMinutes;
    }

    public void setLoadBalancerSheddingIntervalMinutes(int loadBalancerSheddingIntervalMinutes) {
        this.loadBalancerSheddingIntervalMinutes = loadBalancerSheddingIntervalMinutes;
    }

    public long getLoadBalancerSheddingGracePeriodMinutes() {
        return loadBalancerSheddingGracePeriodMinutes;
    }

    public void setLoadBalancerSheddingGracePeriodMinutes(long loadBalancerSheddingGracePeriodMinutes) {
        this.loadBalancerSheddingGracePeriodMinutes = loadBalancerSheddingGracePeriodMinutes;
    }

    public int getLoadBalancerResourceQuotaUpdateIntervalMinutes() {
        return this.loadBalancerResourceQuotaUpdateIntervalMinutes;
    }

    public void setLoadBalancerResourceQuotaUpdateIntervalMinutes(int interval) {
        this.loadBalancerResourceQuotaUpdateIntervalMinutes = interval;
    }

    public int getLoadBalancerBrokerUnderloadedThresholdPercentage() {
        return loadBalancerBrokerUnderloadedThresholdPercentage;
    }

    public void setLoadBalancerBrokerUnderloadedThresholdPercentage(
            int loadBalancerBrokerUnderloadedThresholdPercentage) {
        this.loadBalancerBrokerUnderloadedThresholdPercentage = loadBalancerBrokerUnderloadedThresholdPercentage;
    }

    public int getLoadBalancerBrokerOverloadedThresholdPercentage() {
        return loadBalancerBrokerOverloadedThresholdPercentage;
    }

    public void setLoadBalancerNamespaceBundleMaxTopics(int topics) {
        this.loadBalancerNamespaceBundleMaxTopics = topics;
    }

    public int getLoadBalancerNamespaceBundleMaxTopics() {
        return this.loadBalancerNamespaceBundleMaxTopics;
    }

    public void setLoadBalancerNamespaceBundleMaxSessions(int sessions) {
        this.loadBalancerNamespaceBundleMaxSessions = sessions;
    }

    public int getLoadBalancerNamespaceBundleMaxSessions() {
        return this.loadBalancerNamespaceBundleMaxSessions;
    }

    public void setLoadBalancerNamespaceBundleMaxMsgRate(int msgRate) {
        this.loadBalancerNamespaceBundleMaxMsgRate = msgRate;
    }

    public int getLoadBalancerNamespaceBundleMaxMsgRate() {
        return this.loadBalancerNamespaceBundleMaxMsgRate;
    }

    public void setLoadBalancerNamespaceBundleMaxBandwidthMbytes(int bandwidth) {
        this.loadBalancerNamespaceBundleMaxBandwidthMbytes = bandwidth;
    }

    public int getLoadBalancerNamespaceBundleMaxBandwidthMbytes() {
        return this.loadBalancerNamespaceBundleMaxBandwidthMbytes;
    }

    public void setLoadBalancerBrokerOverloadedThresholdPercentage(
            int loadBalancerBrokerOverloadedThresholdPercentage) {
        this.loadBalancerBrokerOverloadedThresholdPercentage = loadBalancerBrokerOverloadedThresholdPercentage;
    }

    public int getLoadBalancerBrokerComfortLoadLevelPercentage() {
        return this.loadBalancerBrokerComfortLoadLevelPercentage;
    }

    public void setLoadBalancerBrokerComfortLoadLevelPercentage(int percentage) {
        this.loadBalancerBrokerComfortLoadLevelPercentage = percentage;
    }

    public boolean getLoadBalancerAutoBundleSplitEnabled() {
        return this.loadBalancerAutoBundleSplitEnabled;
    }

    public void setLoadBalancerAutoBundleSplitEnabled(boolean enabled) {
        this.loadBalancerAutoBundleSplitEnabled = enabled;
    }

    public void setLoadBalancerNamespaceMaximumBundles(int bundles) {
        this.loadBalancerNamespaceMaximumBundles = bundles;
    }

    public int getLoadBalancerNamespaceMaximumBundles() {
        return this.loadBalancerNamespaceMaximumBundles;
    }

    public boolean isReplicationMetricsEnabled() {
        return replicationMetricsEnabled;
    }

    public void setReplicationMetricsEnabled(boolean replicationMetricsEnabled) {
        this.replicationMetricsEnabled = replicationMetricsEnabled;
    }

    public int getReplicationConnectionsPerBroker() {
        return replicationConnectionsPerBroker;
    }

    public void setReplicationConnectionsPerBroker(int replicationConnectionsPerBroker) {
        this.replicationConnectionsPerBroker = replicationConnectionsPerBroker;
    }

    public int getReplicationProducerQueueSize() {
        return replicationProducerQueueSize;
    }

    public void setReplicationProducerQueueSize(int replicationProducerQueueSize) {
        this.replicationProducerQueueSize = replicationProducerQueueSize;
    }

    public List<String> getBootstrapNamespaces() {
        return bootstrapNamespaces;
    }

    public Object getProperty(String key) {
        return properties.get(key);
    }

    @Override
    public Properties getProperties() {
        return properties;
    }

    @Override
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public int getDefaultRetentionTimeInMinutes() {
        return defaultRetentionTimeInMinutes;
    }

    public void setDefaultRetentionTimeInMinutes(int defaultRetentionTimeInMinutes) {
        this.defaultRetentionTimeInMinutes = defaultRetentionTimeInMinutes;
    }

    public int getDefaultRetentionSizeInMB() {
        return defaultRetentionSizeInMB;
    }

    public void setDefaultRetentionSizeInMB(int defaultRetentionSizeInMB) {
        this.defaultRetentionSizeInMB = defaultRetentionSizeInMB;
    }

    public int getBookkeeperHealthCheckIntervalSec() {
        return (int) bookkeeperClientHealthCheckIntervalSeconds;
    }

    public void setBootstrapNamespaces(List<String> bootstrapNamespaces) {
        this.bootstrapNamespaces = bootstrapNamespaces;
    }

    public void setBrokerServicePurgeInactiveFrequencyInSeconds(int brokerServicePurgeInactiveFrequencyInSeconds) {
        this.brokerServicePurgeInactiveFrequencyInSeconds = brokerServicePurgeInactiveFrequencyInSeconds;
    }

    public int getKeepAliveIntervalSeconds() {
        return keepAliveIntervalSeconds;
    }

    public void setKeepAliveIntervalSeconds(int keepAliveIntervalSeconds) {
        this.keepAliveIntervalSeconds = keepAliveIntervalSeconds;
    }

    public int getBrokerServicePurgeInactiveFrequencyInSeconds() {
        return brokerServicePurgeInactiveFrequencyInSeconds;
    }

    public long getZooKeeperSessionTimeoutMillis() {
        return zooKeeperSessionTimeoutMillis;
    }

    public void setZooKeeperSessionTimeoutMillis(long zooKeeperSessionTimeoutMillis) {
        this.zooKeeperSessionTimeoutMillis = zooKeeperSessionTimeoutMillis;
    }

    public String getReplicatorPrefix() {
        return replicatorPrefix;
    }

    public void setReplicatorPrefix(String replicatorPrefix) {
        this.replicatorPrefix = replicatorPrefix;
    }

    public String getLoadManagerClassName() {
        return loadManagerClassName;
    }

    public void setLoadManagerClassName(String loadManagerClassName) {
        this.loadManagerClassName = loadManagerClassName;
    }

    public boolean isPreferLaterVersions() {
        return preferLaterVersions;
    }

    public void setPreferLaterVersions(boolean preferLaterVersions) {
        this.preferLaterVersions = preferLaterVersions;
    }

    public int getWebSocketNumIoThreads() { return webSocketNumIoThreads; }

    public void setWebSocketNumIoThreads(int webSocketNumIoThreads) { this.webSocketNumIoThreads = webSocketNumIoThreads; }

    public int getWebSocketConnectionsPerBroker() { return webSocketConnectionsPerBroker; }

    public void setWebSocketConnectionsPerBroker(int webSocketConnectionsPerBroker) { this.webSocketConnectionsPerBroker = webSocketConnectionsPerBroker; }
}