Specify initial serialization buffer capacity for Payloads
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / main / yang / distributed-datastore-provider.yang
1 // vi: set smarttab et sw=4 tabstop=4:
2 module distributed-datastore-provider {
3
4     yang-version 1;
5     namespace "urn:opendaylight:params:xml:ns:yang:controller:config:distributed-datastore-provider";
6     prefix "distributed-datastore-provider";
7
8     description
9         "This module contains the base YANG definitions for
10         the distributed datastore provider implementation";
11
12     revision "2014-06-12" {
13         description
14             "Initial revision.";
15     }
16
17     typedef non-zero-uint32-type {
18         type uint32 {
19             range "1..max";
20         }
21     }
22
23     typedef operation-timeout-type {
24         type uint16 {
25             range "5..max";
26         }
27     }
28
29     typedef heartbeat-interval-type {
30         type uint16 {
31             range "100..max";
32         }
33     }
34
35     typedef percentage {
36         type uint8 {
37             range "0..100";
38         }
39     }
40
41     grouping data-store-properties {
42         leaf max-shard-data-change-executor-queue-size {
43             default 1000;
44             type non-zero-uint32-type;
45             description "The maximum queue size for each shard's data store data change notification executor.";
46         }
47
48         leaf max-shard-data-change-executor-pool-size {
49             default 20;
50             type non-zero-uint32-type;
51             description "The maximum thread pool size for each shard's data store data change notification executor.";
52         }
53
54         leaf max-shard-data-change-listener-queue-size {
55             default 1000;
56             type non-zero-uint32-type;
57             description "The maximum queue size for each shard's data store data change listener.";
58         }
59
60         leaf max-shard-data-store-executor-queue-size {
61             default 5000;
62             type non-zero-uint32-type;
63             description "The maximum queue size for each shard's data store executor.";
64         }
65
66         leaf shard-transaction-idle-timeout-in-minutes {
67             default 10;
68             type non-zero-uint32-type;
69             description "The maximum amount of time a shard transaction can be idle without receiving any messages before it self-destructs.";
70         }
71
72         leaf shard-snapshot-batch-count {
73             default 20000;
74             type non-zero-uint32-type;
75             description "The minimum number of entries to be present in the in-memory journal log before a snapshot is to be taken.";
76         }
77
78         leaf shard-snapshot-data-threshold-percentage {
79             default 12;
80             type percentage;
81             description "The percentage of Runtime.maxMemory() used by the in-memory journal log before a snapshot is to be taken";
82         }
83
84
85         leaf shard-heartbeat-interval-in-millis {
86             default 500;
87             type heartbeat-interval-type;
88             description "The interval at which a shard will send a heart beat message to its remote shard.";
89         }
90
91         leaf shard-election-timeout-factor {
92             default 20;
93             type non-zero-uint32-type;
94             description "The multiplication factor to be used to determine shard election timeout. The shard election timeout
95                          is determined by multiplying shard-heartbeat-interval-in-millis with the shard-election-timeout-factor";
96         }
97
98         leaf operation-timeout-in-seconds {
99             default 5;
100             type operation-timeout-type;
101             description "The maximum amount of time for akka operations (remote or local) to complete before failing.";
102         }
103
104         leaf shard-journal-recovery-log-batch-size {
105             default 1;
106             type non-zero-uint32-type;
107             description "The maximum number of journal log entries to batch on recovery for a shard before committing to the data store.";
108         }
109
110         leaf shard-transaction-commit-timeout-in-seconds {
111             default 30;
112             type non-zero-uint32-type;
113             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";
114         }
115
116         leaf shard-transaction-commit-queue-capacity {
117             default 50000;
118             type non-zero-uint32-type;
119             description "The maximum allowed capacity for each shard's transaction commit queue.";
120         }
121
122         leaf shard-commit-queue-expiry-timeout-in-seconds {
123             default 120; // 2 minutes
124             type non-zero-uint32-type;
125             description "The maximum amount of time a transaction can remain in a shard's commit queue waiting
126                 to begin the CanCommit phase as coordinated by the broker front-end. Normally this should be
127                 quick but latencies can occur in between transaction ready and CanCommit or a remote broker
128                 could lose connection and CanCommit might never occur. Expiring transactions from the queue
129                 allows subsequent pending transaction to be processed.";
130         }
131
132         leaf shard-initialization-timeout-in-seconds {
133             default 300; // 5 minutes
134             type non-zero-uint32-type;
135             description "The maximum amount of time to wait for a shard to initialize from persistence
136                          on startup before failing an operation (eg transaction create and change
137                          listener registration).";
138         }
139
140         leaf shard-leader-election-timeout-in-seconds {
141             default 30;
142             type non-zero-uint32-type;
143             description "The maximum amount of time to wait for a shard to elect a leader before failing
144                           an operation (eg transaction create).";
145         }
146
147         leaf shard-batched-modification-count {
148             default 1000;
149             type non-zero-uint32-type;
150             description "The number of transaction modification operations (put, merge, delete) to
151                         batch before sending to the shard transaction actor. Batching improves
152                         performance as less modifications messages are sent to the actor and thus
153                         lessens the chance that the transaction actor's mailbox queue could get full.";
154         }
155
156         leaf enable-metric-capture {
157             default false;
158             type boolean;
159             description "Enable or disable metric capture.";
160         }
161
162         leaf bounded-mailbox-capacity {
163             default 1000;
164             type non-zero-uint32-type;
165             description "Max queue size that an actor's mailbox can reach";
166         }
167
168         leaf persistent {
169             default true;
170             type boolean;
171             description "Enable or disable data persistence";
172         }
173
174         leaf shard-isolated-leader-check-interval-in-millis {
175             default 5000;
176             type heartbeat-interval-type;
177             description "The interval at which the leader of the shard will check if its majority
178                         followers are active and term itself as isolated";
179         }
180
181         leaf transaction-creation-initial-rate-limit {
182             default 100;
183             type non-zero-uint32-type;
184             description "The initial number of transactions per second that are allowed before the data store
185                          should begin applying back pressure. This number is only used as an initial guidance,
186                          subsequently the datastore measures the latency for a commit and auto-adjusts the rate limit";
187         }
188
189         leaf transaction-debug-context-enabled {
190             default false;
191             type boolean;
192             description "Enable or disable transaction context debug. This will log the call site trace for
193                          transactions that fail";
194         }
195
196         leaf custom-raft-policy-implementation {
197             default "";
198             type string;
199             description "A fully qualified java class name. The class should implement
200                          org.opendaylight.controller.cluster.raft.policy.RaftPolicy. This java class should be
201                          accessible to the distributed data store OSGi module so that it can be dynamically loaded via
202                          reflection. For now let's assume that these classes to customize raft behaviors should be
203                          present in the distributed data store module itself. If this property is set to a class which
204                          cannot be found then the default raft behavior will be applied";
205         }
206
207         leaf shard-snapshot-chunk-size {
208             status deprecated;
209             default 2048000;
210             type non-zero-uint32-type;
211             description "When sending a snapshot to a follower, this is the maximum size in bytes for
212                          a chunk of data.";
213         }
214
215         leaf maximum-message-slice-size {
216             default 2048000;
217             type non-zero-uint32-type;
218             description "When fragmenting messages thru the akka remoting framework, this is the
219                          maximum size in bytes for a message slice.";
220         }
221
222         leaf use-tell-based-protocol {
223             default false;
224             type boolean;
225             description "Use a newer protocol between the frontend and backend. This feature is considered
226                          exprerimental at this point.";
227         }
228
229         leaf file-backed-streaming-threshold-in-megabytes {
230             default 128;
231             type non-zero-uint32-type;
232             description "When streaming large amounts of data, eg when sending a snapshot to a follower, this
233                 is the threshold in terms of number of megabytes before it should switch from storing in memory to
234                 buffering to a file.";
235         }
236
237         leaf sync-index-threshold {
238             default 10;
239             type non-zero-uint32-type;
240             description "Permitted synchronization lag, expressed in terms of RAFT entry count. It a follower's
241                          commitIndex trails the leader's journal by more than this amount of entries the follower
242                          is considered to be out-of-sync.";
243         }
244
245         leaf backend-aliveness-timer-interval-in-seconds {
246             default 30;
247             type non-zero-uint32-type;
248             description "The timer interval whereby, on expiration after response inactivity from the back-end,
249                         the connection to the back-end is torn down and reconnection is attempted.";
250         }
251
252         leaf frontend-request-timeout-in-seconds {
253             default 120; // 2 minutes
254             type non-zero-uint32-type;
255             description "The timeout interval whereby client frontend transaction requests are failed.";
256         }
257
258         leaf frontend-no-progress-timeout-in-seconds {
259             default 900; // 15 minutes
260             type non-zero-uint32-type;
261             description "The timeout interval whereby the client front-end hasn't made progress with the
262                          back-end on any request and terminates.";
263         }
264
265         leaf initial-payload-serialized-buffer-capacity {
266             default 512;
267             type non-zero-uint32-type;
268             description "The initial buffer capacity, in bytes, to use when serializing message payloads.";
269         }
270     }
271
272     container data-store-properties-container {
273         uses data-store-properties;
274     }
275 }

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