X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fyang%2Fdistributed-datastore-provider.yang;h=d14c828809e727eb8bf8dca08f1cae8cbc8f4d8e;hp=46cd50d0c158b6a7e316364a588d28f8364fffce;hb=28e9832cc97a345d5ceb69262784e5c8fef77e37;hpb=58b7b56639e983e6fecdaff9508b9f0fd9afb514 diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/yang/distributed-datastore-provider.yang b/opendaylight/md-sal/sal-distributed-datastore/src/main/yang/distributed-datastore-provider.yang index 46cd50d0c1..d14c828809 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/yang/distributed-datastore-provider.yang +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/yang/distributed-datastore-provider.yang @@ -10,6 +10,7 @@ module distributed-datastore-provider { import opendaylight-config-dom-datastore {prefix config-dom-store-spi;} import opendaylight-operational-dom-datastore {prefix operational-dom-store-spi;} import opendaylight-md-sal-dom {prefix sal;} + import actor-system-provider-service {prefix actor-system;} description "This module contains the base YANG definitions for @@ -65,114 +66,133 @@ module distributed-datastore-provider { default 1000; type non-zero-uint32-type; description "The maximum queue size for each shard's data store data change notification executor."; - } + } - leaf max-shard-data-change-executor-pool-size { + leaf max-shard-data-change-executor-pool-size { default 20; type non-zero-uint32-type; description "The maximum thread pool size for each shard's data store data change notification executor."; - } + } - leaf max-shard-data-change-listener-queue-size { + leaf max-shard-data-change-listener-queue-size { default 1000; type non-zero-uint32-type; description "The maximum queue size for each shard's data store data change listener."; - } + } - leaf max-shard-data-store-executor-queue-size { + leaf max-shard-data-store-executor-queue-size { default 5000; type non-zero-uint32-type; description "The maximum queue size for each shard's data store executor."; - } + } - leaf shard-transaction-idle-timeout-in-minutes { + leaf shard-transaction-idle-timeout-in-minutes { default 10; type non-zero-uint32-type; description "The maximum amount of time a shard transaction can be idle without receiving any messages before it self-destructs."; - } + } - leaf shard-snapshot-batch-count { + leaf shard-snapshot-batch-count { default 20000; type non-zero-uint32-type; description "The minimum number of entries to be present in the in-memory journal log before a snapshot is to be taken."; - } + } - leaf shard-snapshot-data-threshold-percentage { + leaf shard-snapshot-data-threshold-percentage { default 12; type percentage; - description "The percentage of Runtime.totalMemory() used by the in-memory journal log before a snapshot is to be taken"; - } + description "The percentage of Runtime.maxMemory() used by the in-memory journal log before a snapshot is to be taken"; + } - leaf shard-hearbeat-interval-in-millis { + leaf shard-heartbeat-interval-in-millis { default 500; type heartbeat-interval-type; description "The interval at which a shard will send a heart beat message to its remote shard."; - } + } - leaf shard-election-timeout-factor { - default 2; + leaf shard-election-timeout-factor { + default 20; type non-zero-uint32-type; description "The multiplication factor to be used to determine shard election timeout. The shard election timeout is determined by multiplying shard-heartbeat-interval-in-millis with the shard-election-timeout-factor"; - } + } - leaf operation-timeout-in-seconds { + leaf operation-timeout-in-seconds { default 5; type operation-timeout-type; description "The maximum amount of time for akka operations (remote or local) to complete before failing."; - } + } - leaf shard-journal-recovery-log-batch-size { - default 5000; + leaf shard-journal-recovery-log-batch-size { + default 1; type non-zero-uint32-type; description "The maximum number of journal log entries to batch on recovery for a shard before committing to the data store."; - } + } - leaf shard-transaction-commit-timeout-in-seconds { + leaf shard-transaction-commit-timeout-in-seconds { default 30; type non-zero-uint32-type; 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"; - } + } - leaf shard-transaction-commit-queue-capacity { - default 20000; + leaf shard-transaction-commit-queue-capacity { + default 50000; type non-zero-uint32-type; description "The maximum allowed capacity for each shard's transaction commit queue."; - } + } - leaf shard-initialization-timeout-in-seconds { + leaf shard-commit-queue-expiry-timeout-in-seconds { + default 120; // 2 minutes + type non-zero-uint32-type; + description "The maximum amount of time a transaction can remain in a shard's commit queue waiting + to begin the CanCommit phase as coordinated by the broker front-end. Normally this should be + quick but latencies can occur in between transaction ready and CanCommit or a remote broker + could lose connection and CanCommit might never occur. Expiring transactions from the queue + allows subsequent pending transaction to be processed."; + } + + leaf shard-initialization-timeout-in-seconds { default 300; // 5 minutes type non-zero-uint32-type; description "The maximum amount of time to wait for a shard to initialize from persistence on startup before failing an operation (eg transaction create and change listener registration)."; - } + } - leaf shard-leader-election-timeout-in-seconds { + leaf shard-leader-election-timeout-in-seconds { default 30; type non-zero-uint32-type; description "The maximum amount of time to wait for a shard to elect a leader before failing an operation (eg transaction create)."; - } + } + + leaf shard-batched-modification-count { + default 1000; + type non-zero-uint32-type; + description "The number of transaction modification operations (put, merge, delete) to + batch before sending to the shard transaction actor. Batching improves + performance as less modifications messages are sent to the actor and thus + lessens the chance that the transaction actor's mailbox queue could get full."; + } - leaf enable-metric-capture { + leaf enable-metric-capture { default false; type boolean; description "Enable or disable metric capture."; - } + } - leaf bounded-mailbox-capacity { - default 1000; - type non-zero-uint32-type; - description "Max queue size that an actor's mailbox can reach"; - } + leaf bounded-mailbox-capacity { + default 1000; + type non-zero-uint32-type; + description "Max queue size that an actor's mailbox can reach"; + } - leaf persistent { + leaf persistent { default true; type boolean; description "Enable or disable data persistence"; - } + } leaf shard-isolated-leader-check-interval-in-millis { default 5000; @@ -180,6 +200,54 @@ module distributed-datastore-provider { description "The interval at which the leader of the shard will check if its majority followers are active and term itself as isolated"; } + + leaf transaction-creation-initial-rate-limit { + default 100; + type non-zero-uint32-type; + description "The initial number of transactions per second that are allowed before the data store + should begin applying back pressure. This number is only used as an initial guidance, + subsequently the datastore measures the latency for a commit and auto-adjusts the rate limit"; + } + + leaf transaction-debug-context-enabled { + default false; + type boolean; + description "Enable or disable transaction context debug. This will log the call site trace for + transactions that fail"; + } + + leaf custom-raft-policy-implementation { + default ""; + type string; + description "A fully qualified java class name. The class should implement + org.opendaylight.controller.cluster.raft.policy.RaftPolicy. This java class should be + accessible to the distributed data store OSGi module so that it can be dynamically loaded via + reflection. For now let's assume that these classes to customize raft behaviors should be + present in the distributed data store module itself. If this property is set to a class which + cannot be found then the default raft behavior will be applied"; + } + + leaf shard-snapshot-chunk-size { + default 2048000; + type non-zero-uint32-type; + description "When sending a snapshot to a follower, this is the maximum size in bytes for + a chunk of data."; + } + + leaf use-tell-based-protocol { + default false; + type boolean; + description "Use a newer protocol between the frontend and backend. This feature is considered + exprerimental at this point."; + } + + leaf file-backed-streaming-threshold-in-megabytes { + default 128; + type non-zero-uint32-type; + description "When streaming large amounts of data, eg when sending a snapshot to a follower, this + is the threshold in terms of number of megabytes before it should switch from storing in memory to + buffering to a file."; + } } // Augments the 'configuration' choice node under modules/module. @@ -195,6 +263,15 @@ module distributed-datastore-provider { } } + container config-actor-system-provider { + uses config:service-ref { + refine type { + mandatory false; + config:required-identity actor-system:actor-system-provider-service; + } + } + } + container config-properties { uses data-store-properties; } @@ -214,6 +291,15 @@ module distributed-datastore-provider { } } + container operational-actor-system-provider { + uses config:service-ref { + refine type { + mandatory false; + config:required-identity actor-system:actor-system-provider-service; + } + } + } + container operational-properties { uses data-store-properties; }