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     import config { prefix config; revision-date 2013-04-05; }
   9     import rpc-context { prefix rpcx; revision-date 2013-06-17; }
  10     import opendaylight-config-dom-datastore {prefix config-dom-store-spi;}
  11     import opendaylight-operational-dom-datastore {prefix operational-dom-store-spi;}
  12     import opendaylight-md-sal-dom {prefix sal;}
  13
  14     description
  15         "This module contains the base YANG definitions for
  16         the distributed datastore provider implementation";
  17
  18     revision "2014-06-12" {
  19         description
  20             "Initial revision.";
  21     }
  22
  23     // This is the definition of the service implementation as a module identity.
  24     identity distributed-config-datastore-provider {
  25             base config:module-type;
  26             config:provided-service config-dom-store-spi:config-dom-datastore;
  27             // Specifies the prefix for generated java classes.
  28             config:java-name-prefix DistributedConfigDataStoreProvider;
  29     }
  30
  31      // This is the definition of the service implementation as a module identity.
  32      identity distributed-operational-datastore-provider {
  33                 base config:module-type;
  34                 config:provided-service operational-dom-store-spi:operational-dom-datastore;
  35                 // Specifies the prefix for generated java classes.
  36                 config:java-name-prefix DistributedOperationalDataStoreProvider;
  37      }
  38
  39     typedef non-zero-uint32-type {
  40         type uint32 {
  41             range "1..max";
  42         }
  43     }
  44
  45     typedef operation-timeout-type {
  46         type uint16 {
  47             range "5..max";
  48         }
  49     }
  50
  51     typedef heartbeat-interval-type {
  52         type uint16 {
  53             range "100..max";
  54         }
  55     }
  56
  57     typedef percentage {
  58         type uint8 {
  59             range "0..100";
  60         }
  61     }
  62
  63     grouping data-store-properties {
  64         leaf max-shard-data-change-executor-queue-size {
  65             default 1000;
  66             type non-zero-uint32-type;
  67             description "The maximum queue size for each shard's data store data change notification executor.";
  68          }
  69
  70          leaf max-shard-data-change-executor-pool-size {
  71             default 20;
  72             type non-zero-uint32-type;
  73             description "The maximum thread pool size for each shard's data store data change notification executor.";
  74          }
  75
  76          leaf max-shard-data-change-listener-queue-size {
  77             default 1000;
  78             type non-zero-uint32-type;
  79             description "The maximum queue size for each shard's data store data change listener.";
  80          }
  81
  82          leaf max-shard-data-store-executor-queue-size {
  83             default 5000;
  84             type non-zero-uint32-type;
  85             description "The maximum queue size for each shard's data store executor.";
  86          }
  87
  88          leaf shard-transaction-idle-timeout-in-minutes {
  89             default 10;
  90             type non-zero-uint32-type;
  91             description "The maximum amount of time a shard transaction can be idle without receiving any messages before it self-destructs.";
  92          }
  93
  94          leaf shard-snapshot-batch-count {
  95             default 20000;
  96             type non-zero-uint32-type;
  97             description "The minimum number of entries to be present in the in-memory journal log before a snapshot is to be taken.";
  98          }
  99
 100          leaf shard-snapshot-data-threshold-percentage {
 101             default 12;
 102             type percentage;
 103             description "The percentage of Runtime.totalMemory() used by the in-memory journal log before a snapshot is to be taken";
 104          }
 105
 106
 107          leaf shard-heartbeat-interval-in-millis {
 108             default 500;
 109             type heartbeat-interval-type;
 110             description "The interval at which a shard will send a heart beat message to its remote shard.";
 111          }
 112
 113          leaf shard-election-timeout-factor {
 114             default 2;
 115             type non-zero-uint32-type;
 116             description "The multiplication factor to be used to determine shard election timeout. The shard election timeout
 117                          is determined by multiplying shard-heartbeat-interval-in-millis with the shard-election-timeout-factor";
 118          }
 119
 120          leaf operation-timeout-in-seconds {
 121             default 5;
 122             type operation-timeout-type;
 123             description "The maximum amount of time for akka operations (remote or local) to complete before failing.";
 124          }
 125
 126          leaf shard-journal-recovery-log-batch-size {
 127             default 1000;
 128             type non-zero-uint32-type;
 129             description "The maximum number of journal log entries to batch on recovery for a shard before committing to the data store.";
 130          }
 131
 132          leaf shard-transaction-commit-timeout-in-seconds {
 133             default 30;
 134             type non-zero-uint32-type;
 135             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";
 136          }
 137
 138          leaf shard-transaction-commit-queue-capacity {
 139             default 50000;
 140             type non-zero-uint32-type;
 141             description "The maximum allowed capacity for each shard's transaction commit queue.";
 142          }
 143
 144          leaf shard-commit-queue-expiry-timeout-in-seconds {
 145              default 120; // 2 minutes
 146              type non-zero-uint32-type;
 147              description "The maximum amount of time a transaction can remain in a shard's commit queue waiting
 148                  to begin the CanCommit phase as coordinated by the broker front-end. Normally this should be
 149                  quick but latencies can occur in between transaction ready and CanCommit or a remote broker
 150                  could lose connection and CanCommit might never occur. Expiring transactions from the queue
 151                  allows subsequent pending transaction to be processed.";
 152          }
 153
 154          leaf shard-initialization-timeout-in-seconds {
 155             default 300; // 5 minutes
 156             type non-zero-uint32-type;
 157             description "The maximum amount of time to wait for a shard to initialize from persistence
 158                          on startup before failing an operation (eg transaction create and change
 159                          listener registration).";
 160          }
 161
 162          leaf shard-leader-election-timeout-in-seconds {
 163             default 30;
 164             type non-zero-uint32-type;
 165             description "The maximum amount of time to wait for a shard to elect a leader before failing
 166                           an operation (eg transaction create).";
 167          }
 168
 169          leaf shard-batched-modification-count {
 170             default 1000;
 171             type non-zero-uint32-type;
 172             description "The number of transaction modification operations (put, merge, delete) to
 173                         batch before sending to the shard transaction actor. Batching improves
 174                         performance as less modifications messages are sent to the actor and thus
 175                         lessens the chance that the transaction actor's mailbox queue could get full.";
 176          }
 177
 178          leaf enable-metric-capture {
 179             default false;
 180             type boolean;
 181             description "Enable or disable metric capture.";
 182          }
 183
 184          leaf bounded-mailbox-capacity {
 185              default 1000;
 186              type non-zero-uint32-type;
 187              description "Max queue size that an actor's mailbox can reach";
 188          }
 189
 190          leaf persistent {
 191             default true;
 192             type boolean;
 193             description "Enable or disable data persistence";
 194          }
 195
 196          leaf shard-isolated-leader-check-interval-in-millis {
 197             default 5000;
 198             type heartbeat-interval-type;
 199             description "The interval at which the leader of the shard will check if its majority
 200                         followers are active and term itself as isolated";
 201          }
 202
 203          leaf transaction-creation-initial-rate-limit {
 204             default 100;
 205             type non-zero-uint32-type;
 206             description "The initial number of transactions per second that are allowed before the data store
 207                          should begin applying back pressure. This number is only used as an initial guidance,
 208                          subsequently the datastore measures the latency for a commit and auto-adjusts the rate limit";
 209          }
 210
 211          leaf transaction-debug-context-enabled {
 212              default false;
 213              type boolean;
 214              description "Enable or disable transaction context debug. This will log the call site trace for
 215                           transactions that fail";
 216          }
 217
 218          leaf custom-raft-policy-implementation {
 219             default "";
 220             type string;
 221             description "A fully qualified java class name. The class should implement
 222                          org.opendaylight.controller.cluster.raft.policy.RaftPolicy. This java class should be
 223                          accessible to the distributed data store OSGi module so that it can be dynamically loaded via
 224                          reflection. For now let's assume that these classes to customize raft behaviors should be
 225                          present in the distributed data store module itself. If this property is set to a class which
 226                          cannot be found then the default raft behavior will be applied";
 227          }
 228     }
 229
 230     // Augments the 'configuration' choice node under modules/module.
 231     augment "/config:modules/config:module/config:configuration" {
 232         case distributed-config-datastore-provider {
 233             when "/config:modules/config:module/config:type = 'distributed-config-datastore-provider'";
 234                 container config-schema-service {
 235                     uses config:service-ref {
 236                         refine type {
 237                             mandatory false;
 238                             config:required-identity sal:schema-service;
 239                         }
 240                     }
 241                 }
 242
 243                 container config-properties {
 244                     uses data-store-properties;
 245                 }
 246         }
 247     }
 248
 249     // Augments the 'configuration' choice node under modules/module.
 250     augment "/config:modules/config:module/config:configuration" {
 251         case distributed-operational-datastore-provider {
 252             when "/config:modules/config:module/config:type = 'distributed-operational-datastore-provider'";
 253                 container operational-schema-service {
 254                     uses config:service-ref {
 255                         refine type {
 256                             mandatory false;
 257                             config:required-identity sal:schema-service;
 258                         }
 259                     }
 260                 }
 261
 262                 container operational-properties {
 263                     uses data-store-properties;
 264                 }
 265         }
 266     }
 267 }