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 initial-settle-timeout-multiplier {
 148             default 3;
 149             type uint32;
 150             description "Multiplier for the maximum amount of time to wait for a shard to elect a leader.
 151                          Zero value means wait indefinitely (as long as it takes).";
 152         }
 153
 154         leaf recovery-snapshot-interval-seconds {
 155             default 0;
 156             type uint32;
 157             description "Interval after which a snapshot should be taken during the recovery process.";
 158         }
 159
 160         leaf shard-batched-modification-count {
 161             default 1000;
 162             type non-zero-uint32-type;
 163             description "The number of transaction modification operations (put, merge, delete) to
 164                         batch before sending to the shard transaction actor. Batching improves
 165                         performance as less modifications messages are sent to the actor and thus
 166                         lessens the chance that the transaction actor's mailbox queue could get full.";
 167         }
 168
 169         leaf enable-metric-capture {
 170             default false;
 171             type boolean;
 172             description "Enable or disable metric capture.";
 173         }
 174
 175         leaf bounded-mailbox-capacity {
 176             default 1000;
 177             type non-zero-uint32-type;
 178             description "Max queue size that an actor's mailbox can reach";
 179         }
 180
 181         leaf persistent {
 182             default true;
 183             type boolean;
 184             description "Enable or disable data persistence";
 185         }
 186
 187         leaf snapshotOnRootOverwrite {
 188             default false;
 189             type boolean;
 190             description "Enable or disable capturing snapshots on DataTree root overwrites";
 191         }
 192
 193         leaf shard-isolated-leader-check-interval-in-millis {
 194             default 5000;
 195             type heartbeat-interval-type;
 196             description "The interval at which the leader of the shard will check if its majority
 197                         followers are active and term itself as isolated";
 198         }
 199
 200         leaf transaction-creation-initial-rate-limit {
 201             default 100;
 202             type non-zero-uint32-type;
 203             description "The initial number of transactions per second that are allowed before the data store
 204                          should begin applying back pressure. This number is only used as an initial guidance,
 205                          subsequently the datastore measures the latency for a commit and auto-adjusts the rate limit";
 206         }
 207
 208         leaf transaction-debug-context-enabled {
 209             default false;
 210             type boolean;
 211             description "Enable or disable transaction context debug. This will log the call site trace for
 212                          transactions that fail";
 213         }
 214
 215         leaf custom-raft-policy-implementation {
 216             default "";
 217             type string;
 218             description "A fully qualified java class name. The class should implement
 219                          org.opendaylight.controller.cluster.raft.policy.RaftPolicy. This java class should be
 220                          accessible to the distributed data store OSGi module so that it can be dynamically loaded via
 221                          reflection. For now let's assume that these classes to customize raft behaviors should be
 222                          present in the distributed data store module itself. If this property is set to a class which
 223                          cannot be found then the default raft behavior will be applied";
 224         }
 225
 226         leaf shard-snapshot-chunk-size {
 227             status deprecated;
 228             default 2048000;
 229             type non-zero-uint32-type;
 230             description "When sending a snapshot to a follower, this is the maximum size in bytes for
 231                          a chunk of data.";
 232         }
 233
 234         leaf maximum-message-slice-size {
 235             default 2048000;
 236             type non-zero-uint32-type;
 237             description "When fragmenting messages thru the akka remoting framework, this is the
 238                          maximum size in bytes for a message slice.";
 239         }
 240
 241         leaf use-tell-based-protocol {
 242             default false;
 243             type boolean;
 244             description "Use a newer protocol between the frontend and backend. This feature is considered
 245                          exprerimental at this point.";
 246         }
 247
 248         leaf file-backed-streaming-threshold-in-megabytes {
 249             default 128;
 250             type non-zero-uint32-type;
 251             description "When streaming large amounts of data, eg when sending a snapshot to a follower, this
 252                 is the threshold in terms of number of megabytes before it should switch from storing in memory to
 253                 buffering to a file.";
 254         }
 255
 256         leaf sync-index-threshold {
 257             default 10;
 258             type non-zero-uint32-type;
 259             description "Permitted synchronization lag, expressed in terms of RAFT entry count. It a follower's
 260                          commitIndex trails the leader's journal by more than this amount of entries the follower
 261                          is considered to be out-of-sync.";
 262         }
 263
 264         leaf backend-aliveness-timer-interval-in-seconds {
 265             default 30;
 266             type non-zero-uint32-type;
 267             description "The timer interval whereby, on expiration after response inactivity from the back-end,
 268                         the connection to the back-end is torn down and reconnection is attempted.";
 269         }
 270
 271         leaf frontend-request-timeout-in-seconds {
 272             default 120; // 2 minutes
 273             type non-zero-uint32-type;
 274             description "The timeout interval whereby client frontend transaction requests are failed.";
 275         }
 276
 277         leaf frontend-no-progress-timeout-in-seconds {
 278             default 900; // 15 minutes
 279             type non-zero-uint32-type;
 280             description "The timeout interval whereby the client front-end hasn't made progress with the
 281                          back-end on any request and terminates.";
 282         }
 283
 284         leaf initial-payload-serialized-buffer-capacity {
 285             default 512;
 286             type non-zero-uint32-type;
 287             description "The initial buffer capacity, in bytes, to use when serializing message payloads.";
 288         }
 289
 290         leaf use-lz4-compression {
 291             default false;
 292             type boolean;
 293             description "Use lz4 compression for snapshots, sent from leader to follower, for snapshots stored
 294                         by LocalSnapshotStore, use akka.conf configuration.";
 295         }
 296     }
 297
 298     container data-store-properties-container {
 299         uses data-store-properties;
 300     }
 301 }