// vi: set smarttab et sw=4 tabstop=4:
module distributed-datastore-provider {

    yang-version 1;
    namespace "urn:opendaylight:params:xml:ns:yang:controller:config:distributed-datastore-provider";
    prefix "distributed-datastore-provider";

    description
        "This module contains the base YANG definitions for
        the distributed datastore provider implementation";

    revision "2014-06-12" {
        description
            "Initial revision.";
    }

    typedef non-zero-uint32-type {
        type uint32 {
            range "1..max";
        }
    }

    typedef operation-timeout-type {
        type uint16 {
            range "5..max";
        }
    }

    typedef heartbeat-interval-type {
        type uint16 {
            range "100..max";
        }
    }

    typedef percentage {
        type uint8 {
            range "0..100";
        }
    }

    grouping data-store-properties {
        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 {
            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 {
            default 12;
            type percentage;
            description "The percentage of Runtime.maxMemory() used by the in-memory journal log before a snapshot is to be taken.
                         Disabled, if direct threshold is enabled.";
        }

        leaf shard-snapshot-data-threshold {
            default 0;
            type uint32 {
                range "0..max";
            }
            description "The threshold of in-memory journal size before a snapshot is to be taken. If set to 0, direct threshold
                         is disabled and percentage is used instead.";
        }


        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 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 {
            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 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 {
            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 50000;
            type non-zero-uint32-type;
            description "The maximum allowed capacity for each shard's transaction commit queue.";
        }

        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 {
            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 initial-settle-timeout-multiplier {
            default 3;
            type uint32;
            description "Multiplier for the maximum amount of time to wait for a shard to elect a leader.
                         Zero value means wait indefinitely (as long as it takes).";
        }

        leaf recovery-snapshot-interval-seconds {
            default 0;
            type uint32;
            description "Interval after which a snapshot should be taken during the recovery process.";
        }

        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 {
            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 persistent {
            default true;
            type boolean;
            description "Enable or disable data persistence";
        }

        leaf snapshotOnRootOverwrite {
            default false;
            type boolean;
            description "Enable or disable capturing snapshots on DataTree root overwrites";
        }

        leaf shard-isolated-leader-check-interval-in-millis {
            default 5000;
            type heartbeat-interval-type;
            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 {
            status deprecated;
            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 maximum-message-slice-size {
            default 2048000;
            type non-zero-uint32-type;
            description "When fragmenting messages thru the akka remoting framework, this is the
                         maximum size in bytes for a message slice.";
        }

        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.";
        }

        leaf sync-index-threshold {
            default 10;
            type non-zero-uint32-type;
            description "Permitted synchronization lag, expressed in terms of RAFT entry count. It a follower's
                         commitIndex trails the leader's journal by more than this amount of entries the follower
                         is considered to be out-of-sync.";
        }

        leaf backend-aliveness-timer-interval-in-seconds {
            default 30;
            type non-zero-uint32-type;
            description "The timer interval whereby, on expiration after response inactivity from the back-end,
                        the connection to the back-end is torn down and reconnection is attempted.";
        }

        leaf frontend-request-timeout-in-seconds {
            default 120; // 2 minutes
            type non-zero-uint32-type;
            description "The timeout interval whereby client frontend transaction requests are failed.";
        }

        leaf frontend-no-progress-timeout-in-seconds {
            default 900; // 15 minutes
            type non-zero-uint32-type;
            description "The timeout interval whereby the client front-end hasn't made progress with the
                         back-end on any request and terminates.";
        }

        leaf initial-payload-serialized-buffer-capacity {
            default 512;
            type non-zero-uint32-type;
            description "The initial buffer capacity, in bytes, to use when serializing message payloads.";
        }

        leaf use-lz4-compression {
            default false;
            type boolean;
            description "Use lz4 compression for snapshots, sent from leader to follower, for snapshots stored
                        by LocalSnapshotStore, use akka.conf configuration.";
        }

        leaf export-on-recovery {
            default off;
            type enumeration {
                enum off;
                enum json;
            }
            description "Export snapshot and journal during recovery. Possible modes: off(default),
                        json(export to json files). Note that in case of large snapshot,
                        export will take a lot of time.";
        }

        leaf recovery-export-base-dir {
            default persistence-export;
            type string;
            description "Directory name for snapshot and journal dumps.";
        }
    }

    container data-store-properties-container {
        uses data-store-properties;
    }
}