opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/ConfigParams.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.cluster.raft;
   9
  10 import org.eclipse.jdt.annotation.NonNull;
  11 import org.opendaylight.controller.cluster.raft.policy.RaftPolicy;
  12 import scala.concurrent.duration.FiniteDuration;
  13
  14 /**
  15  * Configuration Parameter interface for configuring the Raft consensus system
  16  *
  17  * <p>
  18  * Any component using this implementation might want to provide an implementation of
  19  * this interface to configure
  20  *
  21  * <p>
  22  * A default implementation will be used if none is provided.
  23  *
  24  * @author Kamal Rameshan
  25  */
  26 public interface ConfigParams {
  27     int MEGABYTE = 1048576;
  28
  29     /**
  30      * Returns the minimum number of entries to be present in the in-memory Raft log for a snapshot to be taken.
  31      *
  32      * @return the minimum number of entries.
  33      */
  34     long getSnapshotBatchCount();
  35
  36     /**
  37      * Returns the percentage of total memory used in the in-memory Raft log before a snapshot should be taken.
  38      *
  39      * @return the percentage.
  40      */
  41     int getSnapshotDataThresholdPercentage();
  42
  43
  44     /**
  45      * Returns the interval(in seconds) after which a snapshot should be taken during recovery.
  46      * Negative value means don't take snapshots.
  47      *
  48      * @return the interval of recovery snapshot in seconds
  49      */
  50     int getRecoverySnapshotIntervalSeconds();
  51
  52     /**
  53      * Returns the interval at which a heart beat message should be sent to remote followers.
  54      *
  55      * @return the interval as a FiniteDuration.
  56      */
  57     FiniteDuration getHeartBeatInterval();
  58
  59     /**
  60      * Returns the interval after which a new election should be triggered if no leader is available.
  61      *
  62      * @return the interval as a FiniteDuration.
  63      */
  64     FiniteDuration getElectionTimeOutInterval();
  65
  66     /**
  67      * Returns the number by which a candidate should divide the election timeout it has calculated. This serves
  68      * to speed up retries when elections result in a stalemate.
  69      *
  70      * @return the interval as a FiniteDuration.
  71      */
  72     long getCandidateElectionTimeoutDivisor();
  73
  74     /**
  75      * Returns the maximum election time variance. The election is scheduled using both the election timeout
  76      * and variance.
  77      *
  78      * @return the election time variance.
  79      */
  80     int getElectionTimeVariance();
  81
  82     /**
  83      * Returns the maximum size (in bytes) for the snapshot chunk sent from a Leader.
  84      *
  85      * @return the maximum size (in bytes).
  86      */
  87     int getSnapshotChunkSize();
  88
  89     /**
  90      * Returns the maximum number of journal log entries to batch on recovery before applying.
  91      *
  92      * @return the maximum number of journal log entries.
  93      */
  94     int getJournalRecoveryLogBatchSize();
  95
  96     /**
  97      * Returns the interval in which the leader needs to check if its isolated.
  98      *
  99      * @return the interval in ms.
 100      */
 101     long getIsolatedCheckIntervalInMillis();
 102
 103
 104     /**
 105      * Returns the multiplication factor to be used to determine the shard election timeout. The election timeout
 106      * is determined by multiplying the election timeout factor with the heart beat duration.
 107      *
 108      * @return the election timeout factor.
 109      */
 110     long getElectionTimeoutFactor();
 111
 112
 113     /**
 114      * Returns the RaftPolicy used to determine certain Raft behaviors.
 115      *
 116      * @return an instance of RaftPolicy, if set, or an instance of the DefaultRaftPolicy.
 117      */
 118     @NonNull RaftPolicy getRaftPolicy();
 119
 120     /**
 121      * Returns the PeerAddressResolver.
 122      *
 123      * @return the PeerAddressResolver instance.
 124      */
 125     @NonNull PeerAddressResolver getPeerAddressResolver();
 126
 127     /**
 128      * Returns the custom RaftPolicy class name.
 129      *
 130      * @return the RaftPolicy class name or null if none set.
 131      */
 132     String getCustomRaftPolicyImplementationClass();
 133
 134     /**
 135      * Returns the directory in which to create temp files.
 136      *
 137      * @return the directory in which to create temp files.
 138      */
 139     @NonNull String getTempFileDirectory();
 140
 141     /**
 142      * Returns the threshold in terms of number of bytes when streaming data before it should switch from storing in
 143      * memory to buffering to a file.
 144      *
 145      * @return the threshold in terms of number of bytes.
 146      */
 147     int getFileBackedStreamingThreshold();
 148
 149     /**
 150      * Returns the threshold in terms of number journal entries that we can lag behind a leader until we raise a
 151      * 'not synced' transition.
 152      *
 153      * @return the threshold in terms of number of journal entries.
 154      */
 155     long getSyncIndexThreshold();
 156 }