1 // vi: set smarttab et sw=4 tabstop=4:
2 module distributed-datastore-provider {
5 namespace "urn:opendaylight:params:xml:ns:yang:controller:config:distributed-datastore-provider";
6 prefix "distributed-datastore-provider";
9 "This module contains the base YANG definitions for
10 the distributed datastore provider implementation";
12 revision "2014-06-12" {
17 typedef non-zero-uint32-type {
23 typedef operation-timeout-type {
29 typedef heartbeat-interval-type {
41 grouping data-store-properties {
42 leaf shard-transaction-idle-timeout-in-minutes {
44 type non-zero-uint32-type;
45 description "The maximum amount of time a shard transaction can be idle without receiving any messages before it self-destructs.";
48 leaf shard-snapshot-batch-count {
50 type non-zero-uint32-type;
51 description "The minimum number of entries to be present in the in-memory journal log before a snapshot is to be taken.";
54 leaf shard-snapshot-data-threshold-percentage {
57 description "The percentage of Runtime.maxMemory() used by the in-memory journal log before a snapshot is to be taken.
58 Disabled, if direct threshold is enabled.";
61 leaf shard-snapshot-data-threshold {
66 description "The threshold of in-memory journal size before a snapshot is to be taken. If set to 0, direct threshold
67 is disabled and percentage is used instead.";
71 leaf shard-heartbeat-interval-in-millis {
73 type heartbeat-interval-type;
74 description "The interval at which a shard will send a heart beat message to its remote shard.";
77 leaf shard-election-timeout-factor {
79 type non-zero-uint32-type;
80 description "The multiplication factor to be used to determine shard election timeout. The shard election timeout
81 is determined by multiplying shard-heartbeat-interval-in-millis with the shard-election-timeout-factor";
84 leaf operation-timeout-in-seconds {
86 type operation-timeout-type;
87 description "The maximum amount of time for akka operations (remote or local) to complete before failing.";
90 leaf shard-journal-recovery-log-batch-size {
92 type non-zero-uint32-type;
93 description "The maximum number of journal log entries to batch on recovery for a shard before committing to the data store.";
96 leaf shard-transaction-commit-timeout-in-seconds {
98 type non-zero-uint32-type;
99 description "The maximum amount of time a shard transaction three-phase commit can be idle without receiving the next messages before it aborts the transaction";
102 leaf shard-transaction-commit-queue-capacity {
104 type non-zero-uint32-type;
105 description "The maximum allowed capacity for each shard's transaction commit queue.";
108 leaf shard-commit-queue-expiry-timeout-in-seconds {
109 default 120; // 2 minutes
110 type non-zero-uint32-type;
111 description "The maximum amount of time a transaction can remain in a shard's commit queue waiting
112 to begin the CanCommit phase as coordinated by the broker front-end. Normally this should be
113 quick but latencies can occur in between transaction ready and CanCommit or a remote broker
114 could lose connection and CanCommit might never occur. Expiring transactions from the queue
115 allows subsequent pending transaction to be processed.";
118 leaf shard-initialization-timeout-in-seconds {
119 default 300; // 5 minutes
120 type non-zero-uint32-type;
121 description "The maximum amount of time to wait for a shard to initialize from persistence
122 on startup before failing an operation (eg transaction create and change
123 listener registration).";
126 leaf shard-leader-election-timeout-in-seconds {
128 type non-zero-uint32-type;
129 description "The maximum amount of time to wait for a shard to elect a leader before failing
130 an operation (eg transaction create).";
133 leaf initial-settle-timeout-multiplier {
136 description "Multiplier for the maximum amount of time to wait for a shard to elect a leader.
137 Zero value means wait indefinitely (as long as it takes).";
140 leaf recovery-snapshot-interval-seconds {
143 description "Interval after which a snapshot should be taken during the recovery process.";
146 leaf shard-batched-modification-count {
148 type non-zero-uint32-type;
149 description "The number of transaction modification operations (put, merge, delete) to
150 batch before sending to the shard transaction actor. Batching improves
151 performance as less modifications messages are sent to the actor and thus
152 lessens the chance that the transaction actor's mailbox queue could get full.";
155 leaf enable-metric-capture {
158 description "Enable or disable metric capture.";
161 leaf bounded-mailbox-capacity {
163 type non-zero-uint32-type;
164 description "Max queue size that an actor's mailbox can reach";
170 description "Enable or disable data persistence";
173 leaf snapshotOnRootOverwrite {
176 description "Enable or disable capturing snapshots on DataTree root overwrites";
179 leaf shard-isolated-leader-check-interval-in-millis {
181 type heartbeat-interval-type;
182 description "The interval at which the leader of the shard will check if its majority
183 followers are active and term itself as isolated";
186 leaf transaction-creation-initial-rate-limit {
188 type non-zero-uint32-type;
189 description "The initial number of transactions per second that are allowed before the data store
190 should begin applying back pressure. This number is only used as an initial guidance,
191 subsequently the datastore measures the latency for a commit and auto-adjusts the rate limit";
194 leaf transaction-debug-context-enabled {
197 description "Enable or disable transaction context debug. This will log the call site trace for
198 transactions that fail";
201 leaf custom-raft-policy-implementation {
204 description "A fully qualified java class name. The class should implement
205 org.opendaylight.controller.cluster.raft.policy.RaftPolicy. This java class should be
206 accessible to the distributed data store OSGi module so that it can be dynamically loaded via
207 reflection. For now let's assume that these classes to customize raft behaviors should be
208 present in the distributed data store module itself. If this property is set to a class which
209 cannot be found then the default raft behavior will be applied";
212 leaf shard-snapshot-chunk-size {
215 type non-zero-uint32-type;
216 description "When sending a snapshot to a follower, this is the maximum size in bytes for
220 leaf maximum-message-slice-size {
222 type non-zero-uint32-type;
223 description "When fragmenting messages thru the akka remoting framework, this is the
224 maximum size in bytes for a message slice.";
227 leaf use-tell-based-protocol {
230 description "Use a newer protocol between the frontend and backend. This feature is considered
231 exprerimental at this point.";
234 leaf file-backed-streaming-threshold-in-megabytes {
236 type non-zero-uint32-type;
237 description "When streaming large amounts of data, eg when sending a snapshot to a follower, this
238 is the threshold in terms of number of megabytes before it should switch from storing in memory to
239 buffering to a file.";
242 leaf sync-index-threshold {
244 type non-zero-uint32-type;
245 description "Permitted synchronization lag, expressed in terms of RAFT entry count. It a follower's
246 commitIndex trails the leader's journal by more than this amount of entries the follower
247 is considered to be out-of-sync.";
250 leaf backend-aliveness-timer-interval-in-seconds {
252 type non-zero-uint32-type;
253 description "The timer interval whereby, on expiration after response inactivity from the back-end,
254 the connection to the back-end is torn down and reconnection is attempted.";
257 leaf frontend-request-timeout-in-seconds {
258 default 120; // 2 minutes
259 type non-zero-uint32-type;
260 description "The timeout interval whereby client frontend transaction requests are failed.";
263 leaf frontend-no-progress-timeout-in-seconds {
264 default 900; // 15 minutes
265 type non-zero-uint32-type;
266 description "The timeout interval whereby the client front-end hasn't made progress with the
267 back-end on any request and terminates.";
270 leaf initial-payload-serialized-buffer-capacity {
272 type non-zero-uint32-type;
273 description "The initial buffer capacity, in bytes, to use when serializing message payloads.";
276 leaf use-lz4-compression {
279 description "Use lz4 compression for snapshots, sent from leader to follower, for snapshots stored
280 by LocalSnapshotStore, use akka.conf configuration.";
283 leaf export-on-recovery {
289 description "Export snapshot and journal during recovery. Possible modes: off(default),
290 json(export to json files). Note that in case of large snapshot,
291 export will take a lot of time.";
294 leaf recovery-export-base-dir {
295 default persistence-export;
297 description "Directory name for snapshot and journal dumps.";
301 container data-store-properties-container {
302 uses data-store-properties;