Allow incremental recovery
[controller.git] / 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 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.