* Copyright 2008-2012 LinkedIn, Inc

*

* 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.

*/

* Configuration parameters for the voldemort server.

*

*

*/

    private static final long serialVersionUID = 1;

    public static final String VOLDEMORT_HOME_VAR_NAME = "VOLDEMORT_HOME";

    public static final String VOLDEMORT_CONFIG_DIR = "VOLDEMORT_CONFIG_DIR";

    private static final String VOLDEMORT_NODE_ID_VAR_NAME = "VOLDEMORT_NODE_ID";

    public static int VOLDEMORT_DEFAULT_ADMIN_PORT = 6660;

    public static final long REPORTING_INTERVAL_BYTES = 25 * 1024 * 1024;

    public static final int DEFAULT_BUFFER_SIZE = 64 * 1024;

    // Kerberos support for read-only fetches (constants)

    public static final String DEFAULT_KERBEROS_PRINCIPAL = "voldemrt";

    public static final String DEFAULT_KEYTAB_PATH = "/voldemrt.headless.keytab";

    private static final String DEFAULT_KERBEROS_KDC = "";

    private static final String DEFAULT_KERBEROS_REALM = "";

    private static final boolean DEFAULT_READONLY_REST_HDFS = false;

    private static final String DEFAULT_FILE_FETCHER_CLASS = null;

    private static final String REST_HDFS_FETCHER_CLASS = "voldemort.server.protocol.hadoop.RestHadoopFetcher";

    private int nodeId;

    private String voldemortHome;

    private String dataDirectory;

    private String metadataDirectory;

    private long bdbCacheSize;

    private boolean bdbWriteTransactions;

    private boolean bdbFlushTransactions;

    private String bdbDataDirectory;

    private long bdbMaxLogFileSize;

    private int bdbBtreeFanout;

    private int bdbMaxDelta;

    private int bdbBinDelta;

    private long bdbCheckpointBytes;

    private long bdbCheckpointMs;

    private boolean bdbOneEnvPerStore;

    private int bdbCleanerMinFileUtilization;

    private int bdbCleanerMinUtilization;

    private int bdbCleanerLookAheadCacheSize;

    private long bdbCleanerBytesInterval;

    private boolean bdbCheckpointerHighPriority;

    private int bdbCleanerMaxBatchFiles;

    private boolean bdbReadUncommitted;

    private int bdbCleanerThreads;

    private long bdbLockTimeoutMs;

    private int bdbLockNLockTables;

    private int bdbLogFaultReadSize;

    private int bdbLogIteratorReadSize;

    private boolean bdbFairLatches;

    private long bdbStatsCacheTtlMs;

    private boolean bdbExposeSpaceUtilization;

    private long bdbMinimumSharedCache;

    private boolean bdbCleanerLazyMigration;

    private boolean bdbCacheModeEvictLN;

    private boolean bdbMinimizeScanImpact;

    private boolean bdbPrefixKeysWithPartitionId;

    private boolean bdbLevelBasedEviction;

    private boolean bdbCheckpointerOffForBatchWrites;

    private boolean bdbCleanerFetchObsoleteSize;

    private boolean bdbCleanerAdjustUtilization;

    private boolean bdbRecoveryForceCheckpoint;

    private String bdbRawPropertyString;

    private String mysqlUsername;

    private String mysqlPassword;

    private String mysqlDatabaseName;

    private String mysqlHost;

    private int mysqlPort;

    private int numReadOnlyVersions;

    private String readOnlyStorageDir;

    private String readOnlySearchStrategy;

    private int readOnlyDeleteBackupTimeMs;

    private long readOnlyFetcherMaxBytesPerSecond;

    private long readOnlyFetcherMinBytesPerSecond;

    private long readOnlyFetcherReportingIntervalBytes;

    private int readOnlyFetchRetryCount;

    private long readOnlyFetchRetryDelayMs;

    private int fetcherBufferSize;

    private String readOnlyKeytabPath;

    private String readOnlyKerberosUser;

    private String hadoopConfigPath;

    private String readOnlyKerberosKdc;

    private String readOnlykerberosRealm;

    private boolean enableReadOnlyRestHdfs;

    private String fileFetcherClass;

    // flag to indicate if we will mlock and pin index pages in memory

    private boolean useMlock;

    private OpTimeMap testingSlowQueueingDelays;

    private OpTimeMap testingSlowConcurrentDelays;

    private int coreThreads;

    private int maxThreads;

    private int socketTimeoutMs;

    private int socketBufferSize;

    private boolean socketKeepAlive;

    private boolean useNioConnector;

    private int nioConnectorSelectors;

    private int nioAdminConnectorSelectors;

    private int nioAcceptorBacklog;

    private int clientSelectors;

    private TimeoutConfig clientTimeoutConfig;

    private int clientMaxConnectionsPerNode;

    private int clientConnectionTimeoutMs;

    private int clientRoutingTimeoutMs;

    private int clientMaxThreads;

    private int clientThreadIdleMs;

    private int clientMaxQueuedRequests;

    private int schedulerThreads;

    private boolean mayInterruptService;

    private int numScanPermits;

    private RequestFormatType requestFormatType;

    private boolean enableSlop;

    private boolean enableSlopPusherJob;

    private boolean enableRepair;

    private boolean enablePruneJob;

    private boolean enableSlopPurgeJob;

    private boolean enableHttpServer;

    private boolean enableSocketServer;

    private boolean enableAdminServer;

    private boolean enableJmx;

    private boolean enableVerboseLogging;

    private boolean enableStatTracking;

    private boolean enableServerRouting;

    private boolean enableMetadataChecking;

    private boolean enableNetworkClassLoader;

    private boolean enableGossip;

    private boolean enableRebalanceService;

    private boolean enableJmxClusterName;

    private boolean enableQuotaLimiting;

    private List<String> storageConfigurations;

    private Props allProps;

    private String slopStoreType;

    private String pusherType;

    private long slopFrequencyMs;

    private long slopMaxWriteBytesPerSec;

    private long slopMaxReadBytesPerSec;

    private int slopBatchSize;

    private int slopZonesDownToTerminate;

    private boolean autoPurgeDeadSlops;

    private int adminCoreThreads;

    private int adminMaxThreads;

    private int adminStreamBufferSize;

    private int adminSocketTimeout;

    private int adminConnectionTimeout;

    private long streamMaxReadBytesPerSec;

    private long streamMaxWriteBytesPerSec;

    private boolean multiVersionStreamingPutsEnabled;

    private int gossipIntervalMs;

    private String failureDetectorImplementation;

    private long failureDetectorBannagePeriod;

    private int failureDetectorThreshold;

    private int failureDetectorThresholdCountMinimum;

    private long failureDetectorThresholdInterval;

    private long failureDetectorAsyncRecoveryInterval;

    private volatile List<String> failureDetectorCatastrophicErrorTypes;

    private long failureDetectorRequestLengthThreshold;

    private int retentionCleanupFirstStartTimeInHour;

    private int retentionCleanupScheduledPeriodInHour;

    private int retentionCleanupFirstStartDayOfWeek;

    private boolean retentionCleanupPinStartTime;

    private boolean enforceRetentionPolicyOnRead;

    private boolean deleteExpiredValuesOnRead;

    private long rebalancingTimeoutSec;

    private int maxParallelStoresRebalancing;

    private boolean usePartitionScanForRebalance;

    private int maxProxyPutThreads;

    @Deprecated

    // Should be removed once the proxy put implementation is stable.

    private boolean proxyPutsDuringRebalance;

    private boolean enableRestService;

    private int numRestServiceNettyServerBacklog;

    private int numRestServiceNettyBossThreads;

    private int numRestServiceNettyWorkerThreads;

    private int numRestServiceStorageThreads;

    private int restServiceStorageThreadPoolQueueSize;

    private int maxHttpAggregatedContentLength;

    private int repairJobMaxKeysScannedPerSec;

    private int pruneJobMaxKeysScannedPerSec;

    private int slopPurgeJobMaxKeysScannedPerSec;

    public VoldemortConfig(Properties props) {

        this(new Props(props));

    }

    public VoldemortConfig(Props props) {

        try {

            this.nodeId = props.getInt("node.id");

        } catch(UndefinedPropertyException e) {

            this.nodeId = getIntEnvVariable(VOLDEMORT_NODE_ID_VAR_NAME);

        }

        this.voldemortHome = props.getString("voldemort.home");

        this.dataDirectory = props.getString("data.directory", this.voldemortHome + File.separator

                                                               + "data");

        this.metadataDirectory = props.getString("metadata.directory", voldemortHome

                                                                       + File.separator + "config");

        this.bdbCacheSize = props.getBytes("bdb.cache.size", 200 * 1024 * 1024);

        this.bdbWriteTransactions = props.getBoolean("bdb.write.transactions", false);

        this.bdbFlushTransactions = props.getBoolean("bdb.flush.transactions", false);

        this.bdbDataDirectory = props.getString("bdb.data.directory", this.dataDirectory

                                                                      + File.separator + "bdb");

        this.bdbMaxLogFileSize = props.getBytes("bdb.max.logfile.size", 60 * 1024 * 1024);

        this.bdbBtreeFanout = props.getInt("bdb.btree.fanout", 512);

        this.bdbMaxDelta = props.getInt("bdb.max.delta", 100);

        this.bdbBinDelta = props.getInt("bdb.bin.delta", 75);

        this.bdbCheckpointBytes = props.getLong("bdb.checkpoint.interval.bytes", 200 * 1024 * 1024);

        this.bdbCheckpointMs = props.getLong("bdb.checkpoint.interval.ms", 30 * Time.MS_PER_SECOND);

        this.bdbOneEnvPerStore = props.getBoolean("bdb.one.env.per.store", false);

        this.bdbCleanerMinFileUtilization = props.getInt("bdb.cleaner.min.file.utilization", 0);

        this.bdbCleanerMinUtilization = props.getInt("bdb.cleaner.minUtilization", 50);

        this.bdbCleanerThreads = props.getInt("bdb.cleaner.threads", 1);

        // by default, wake up the cleaner everytime we write log file size *

        // utilization% bytes. So, by default 30MB

        this.bdbCleanerBytesInterval = props.getLong("bdb.cleaner.interval.bytes", 30 * 1024 * 1024);

        this.bdbCleanerLookAheadCacheSize = props.getInt("bdb.cleaner.lookahead.cache.size", 8192);

        this.bdbLockTimeoutMs = props.getLong("bdb.lock.timeout.ms", 500);

        this.bdbLockNLockTables = props.getInt("bdb.lock.nLockTables", 7);

        this.bdbLogFaultReadSize = props.getInt("bdb.log.fault.read.size", 2048);

        this.bdbLogIteratorReadSize = props.getInt("bdb.log.iterator.read.size", 8192);

        this.bdbFairLatches = props.getBoolean("bdb.fair.latches", false);

        this.bdbCheckpointerHighPriority = props.getBoolean("bdb.checkpointer.high.priority", false);

        this.bdbCleanerMaxBatchFiles = props.getInt("bdb.cleaner.max.batch.files", 0);

        this.bdbReadUncommitted = props.getBoolean("bdb.lock.read_uncommitted", true);

        this.bdbStatsCacheTtlMs = props.getLong("bdb.stats.cache.ttl.ms", 5 * Time.MS_PER_SECOND);

        this.bdbExposeSpaceUtilization = props.getBoolean("bdb.expose.space.utilization", true);

        this.bdbMinimumSharedCache = props.getLong("bdb.minimum.shared.cache", 0);

        this.bdbCleanerLazyMigration = props.getBoolean("bdb.cleaner.lazy.migration", false);

        this.bdbCacheModeEvictLN = props.getBoolean("bdb.cache.evictln", true);

        this.bdbMinimizeScanImpact = props.getBoolean("bdb.minimize.scan.impact", true);

        this.bdbPrefixKeysWithPartitionId = props.getBoolean("bdb.prefix.keys.with.partitionid",

                                                             true);

        this.bdbLevelBasedEviction = props.getBoolean("bdb.evict.by.level", false);

        this.bdbCheckpointerOffForBatchWrites = props.getBoolean("bdb.checkpointer.off.batch.writes",

                                                                 false);

        this.bdbCleanerFetchObsoleteSize = props.getBoolean("bdb.cleaner.fetch.obsolete.size", true);

        this.bdbCleanerAdjustUtilization = props.getBoolean("bdb.cleaner.adjust.utilization", false);

        this.bdbRecoveryForceCheckpoint = props.getBoolean("bdb.recovery.force.checkpoint", false);

        this.bdbRawPropertyString = props.getString("bdb.raw.property.string", null);

        this.numReadOnlyVersions = props.getInt("readonly.backups", 1);

        this.readOnlySearchStrategy = props.getString("readonly.search.strategy",

                                                      BinarySearchStrategy.class.getName());

        this.readOnlyStorageDir = props.getString("readonly.data.directory", this.dataDirectory

                                                                             + File.separator

                                                                             + "read-only");

        this.readOnlyDeleteBackupTimeMs = props.getInt("readonly.delete.backup.ms", 0);

        this.readOnlyFetcherMaxBytesPerSecond = props.getBytes("fetcher.max.bytes.per.sec", 0);

        this.readOnlyFetcherMinBytesPerSecond = props.getBytes("fetcher.min.bytes.per.sec", 0);

        this.readOnlyFetcherReportingIntervalBytes = props.getBytes("fetcher.reporting.interval.bytes",

                                                                    REPORTING_INTERVAL_BYTES);

        this.readOnlyFetchRetryCount = props.getInt("fetcher.retry.count", 5);

        this.readOnlyFetchRetryDelayMs = props.getLong("fetcher.retry.delay.ms", 5000);

        this.fetcherBufferSize = (int) props.getBytes("hdfs.fetcher.buffer.size",

                                                      DEFAULT_BUFFER_SIZE);

        this.readOnlyKeytabPath = props.getString("readonly.keytab.path",

                                                  this.metadataDirectory