diff options
Diffstat (limited to 'cps-rest/src/test/resources')
| -rw-r--r-- | cps-rest/src/test/resources/model-over-1mb.yang | 28273 |
1 files changed, 28273 insertions, 0 deletions
diff --git a/cps-rest/src/test/resources/model-over-1mb.yang b/cps-rest/src/test/resources/model-over-1mb.yang new file mode 100644 index 0000000000..a92637b5cd --- /dev/null +++ b/cps-rest/src/test/resources/model-over-1mb.yang @@ -0,0 +1,28273 @@ +submodule nokia-conf-groups { + + yang-version "1.1"; + + belongs-to nokia-conf { prefix "conf"; } + + import ietf-yang-types { prefix "yang"; } + import nokia-sros-yang-extensions { prefix "sros-ext"; } + import nokia-types-bgp { prefix "types-bgp"; } + import nokia-types-card { prefix "types-card"; } + import nokia-types-cellular { prefix "types-cellular"; } + import nokia-types-cflowd { prefix "types-cflowd"; } + import nokia-types-diameter { prefix "types-diam"; } + import nokia-types-eth-cfm { prefix "types-eth-cfm"; } + import nokia-types-filter { prefix "types-filter"; } + import nokia-types-igmp { prefix "types-igmp"; } + import nokia-types-igp { prefix "types-igp"; } + import nokia-types-ipsec { prefix "types-ipsec"; } + import nokia-types-isa { prefix "types-isa"; } + import nokia-types-isis { prefix "types-isis"; } + import nokia-types-l2tp { prefix "types-l2tp"; } + import nokia-types-lldp { prefix "types-lldp"; } + import nokia-types-log { prefix "types-log"; } + import nokia-types-mcast-cac { prefix "types-mcast-cac"; } + import nokia-types-mpls { prefix "types-mpls"; } + import nokia-types-nat { prefix "types-nat"; } + import nokia-types-oam { prefix "types-oam"; } + import nokia-types-port { prefix "types-port"; } + import nokia-types-ppp { prefix "types-ppp"; } + import nokia-types-ptp { prefix "types-ptp"; } + import nokia-types-qos { prefix "types-qos"; } + import nokia-types-router { prefix "types-router"; } + import nokia-types-rsvp { prefix "types-rsvp"; } + import nokia-types-security { prefix "types-security"; } + import nokia-types-services { prefix "types-services"; } + import nokia-types-sros { prefix "types-sros"; } + import nokia-types-subscriber-mgmt { prefix "types-submgt"; } + import nokia-types-system { prefix "types-system"; } + import nokia-types-wlangw { prefix "types-wlangw"; } + + + sros-ext:sros-major-release "rel19"; + + organization "Nokia"; + + contact + "Nokia SR OS Support + Web: <http://www.nokia.com>"; + + description + "Nokia YANG Data model to configure Configuration groups on SR OS based routers. + + Copyright 2016 Nokia. All rights reserved. Reproduction of this document + is authorized on the condition that the foregoing copyright notice is included. + + This nokia-conf-groups YANG module embodies Nokia's proprietary + intellectual property. Nokia retains all title and ownership in the + specification, including any revisions. + + Nokia grants all interested parties a non-exclusive license to use + and distribute an unmodified copy of this specification in connection with + management of Nokia products, and without fee, provided this + copyright notice and license appear on all copies. + + This specification is supplied `as is', and Nokia makes no warranty, + either express or implied, as to the use, operation, condition, or performance + of the specification."; + + revision "2019-01-23"; + + grouping conf-groups { + container groups { + description "Enter the groups context"; + + list group { + key "name"; + max-elements 64; + description "Enter the group context"; + + leaf name { + type types-sros:named-item-64; + description "The name of this configuration group."; + } + + list card { + key "slot-number"; + description "Enter the card context"; + + leaf slot-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-card:card-slot; + } + description "IOM slot within a chassis"; + } + + list mda { + key "mda-slot"; + description "Enter the mda context"; + + leaf mda-slot { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..6"; + } + } + description "MDA slot"; + } + + container network { + description "Enter the network context"; + + container ingress { + description "Enter the ingress context"; + + leaf queue-policy { + status obsolete; + type types-sros:named-item; + description "Network-queue policy"; + } + + list pool { + status obsolete; + key "name"; + description "Enter the pool context"; + + leaf name { + status obsolete; + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Unique pool name for MDA"; + } + + leaf amber-alarm-threshold { + status obsolete; + type uint32 { + range "1..1000"; + } + units "percent"; + description "Configure amber alarm threshold allowed on over-subscription."; + } + + leaf red-alarm-threshold { + status obsolete; + type uint32 { + range "1..1000"; + } + units "percent"; + description "Configure red alarm threshold allowed on over-subscription."; + } + + leaf slope-policy { + status obsolete; + type types-sros:named-item; + description "Configure the slope policy."; + } + + container resv-cbs { + status obsolete; + description "Enter the resv-cbs context"; + + leaf cbs { + status obsolete; + type int32 { + range "0..100"; + } + units "percent"; + description + "Configure the percentage of pool size reserved for CBS. + + For network, the default value is computed as the sum of the + CBS request by the entities using the pool. + + For access, the default value is 30%."; + } + + container amber-alarm-action { + status obsolete; + description "Enter the amber-alarm-action context"; + + leaf step { + status obsolete; + type uint32 { + range "1..100"; + } + units "percent"; + description + "Configure the step-size percentage for the reserved CBS size of the + pool. + + When set to a value of zero (0), the adaptive CBS sizing is disabled. + + To enable adaptive CBS sizing, both this leaf and amber-alarm-action/max + must be set to non-default values. + + Adaptive CBS sizing can only be enabled when resv-cbs is non-default."; + } + + leaf max { + status obsolete; + type uint32 { + range "1..100"; + } + units "percent"; + description + "Configure the maximum percentage for the reserved CBS size of the pool. + + When set to a value of zero (0), the adaptive CBS sizing is disabled. + + To enable adaptive CBS sizing, both this leaf and amber-alarm-action/step + must be set to non-default values. + + Adaptive CBS sizing can only be enabled when resv-cbs is non-default. + + This value must not be more than resv-cbs."; + } + + } // container amber-alarm-action + + } // container resv-cbs + + } // list pool + + } // container ingress + + } // container network + + } // list mda + + list fp { + key "fp-number"; + description "Enter the fp context"; + + leaf fp-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Forwarding plane within a specific IOM card"; + } + + leaf ingress-buffer-allocation { + type decimal64 { + range "20.00..80.00"; + fraction-digits 2; + } + units "percent"; + default "50.00"; + description "Ingress buffer pool percentage for forwarding plane"; + } + + leaf init-extract-prio-mode { + type enumeration { + enum "uniform" { value 1; } + enum "l3-classify" { value 2; } + } + default "uniform"; + description "Scheme to select initial drop priority of extracted control plane traffic"; + } + + leaf policy-accounting { + type uint32 { + range "1000..128000"; + } + description "Number of stats resources for policy accounting for the forwarding plane"; + } + + leaf stable-pool-sizing { + type boolean; + default "false"; + description "Use a stable buffer pool allocation environment for all default port buffer pools on an FP"; + } + + container dist-cpu-protection { + description "Enter the dist-cpu-protection context"; + + leaf dynamic-enforcement-policer-pool { + type uint32 { + range "1000..32000"; + } + description "Number of policers reserved for use as dynamic enforcement policers on forwarding plane"; + } + + } // container dist-cpu-protection + + container egress { + description "Enter the egress context"; + + leaf hs-fixed-high-thresh-delta { + type int32 { + range "0..65536"; + } + description "High threshold delta on forwarding plane"; + } + + leaf hs-pool-policy { + type types-sros:named-item; + description "HS pool policy"; + } + + container wred-queue-control { + description "Enter the wred-queue-control context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of WRED queue control"; + } + + leaf buffer-allocation { + type decimal64 { + range "0.01..99.99"; + fraction-digits 2; + } + units "percent"; + default "25.00"; + description + "Configure the WRED queue aggregate buffer allocation + which will be set aside for WRED queue buffer pools"; + } + + leaf reserved-cbs { + type decimal64 { + range "0.01..99.99"; + fraction-digits 2; + } + units "percent"; + default "25.00"; + description + "Configure the buffers within the WRED pool that will + be set aside for WRED queues operating within their configured + CBS thresholds."; + } + + leaf slope-policy { + type types-sros:named-item; + description "Egress WRED queue control slope policy for forwarding plane"; + } + + } // container wred-queue-control + + } // container egress + + container hi-bw-mcast-src { + presence "Enable/disable high bandwidth multicast source functionality."; + description "Enter the hi-bw-mcast-src context"; + + leaf alarm { + type boolean; + default "false"; + description "Raise an alarm when more than one high bandwidth multicast traffic taps share a plane"; + } + + leaf group { + type uint32 { + range "0..32"; + } + default "0"; + description "Logical MSFP group of the MDA"; + } + + leaf default-paths-only { + type boolean; + default "false"; + description "Allocate only the two default paths (one high priority and one low priority) to dedicated MSFPs"; + } + + } // container hi-bw-mcast-src + + container ingress { + description "Enter the ingress context"; + + container access { + description "Enter the access context"; + + list queue-group { + key "queue-group-name instance-id"; + description "Enter the queue-group context"; + + leaf queue-group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Queue group name"; + } + + leaf instance-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint16 { + range "1..65535"; + } + } + description "Instance ID"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy for the FP ingress queue group"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics on FP ingress queue group"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container policer-control-policy { + description "Enter the policer-control-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Policer control policy"; + } + + container overrides { + presence "Enable policer control policy overrides."; + description "Enter the overrides context"; + + leaf max-rate { + type types-qos:queue-pir-rate-override; + units "kilobps"; + description "Maximum rate override"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-threshold-separation { + type types-qos:policer-burst-size-override; + units "bytes"; + description "Minimum threshold separation override"; + } + + list priority { + key "level"; + description "Enter the priority context"; + + leaf level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type types-qos:policer-burst-size-override; + units "bytes"; + description "MBS contribution size override"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container overrides + + } // container policer-control-policy + + container policer-overrides { + description "Enter the policer-overrides context"; + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id { + range "1..32"; + } + } + description "Policer identifier"; + } + + leaf cbs { + type types-qos:policer-burst-size-override; + units "bytes"; + description "CBS parameter override"; + } + + leaf mbs { + type types-qos:policer-burst-size-override; + units "bytes"; + description "MBS parameter override"; + } + + leaf packet-byte-offset { + type types-qos:ingress-per-packet-offset-override; + description "Size of each packet handled by the policer"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + description "Stat mode for the policer"; + } + + container rate { + description "Enter the rate context"; + + leaf cir { + type types-qos:queue-cir-rate-override; + description "CIR rate"; + } + + leaf pir { + type types-qos:queue-pir-rate-override; + description "PIR rate"; + } + + } // container rate + + } // list policer + + } // container policer-overrides + + } // list queue-group + + } // container access + + container mcast-path-management { + description "Enter the mcast-path-management context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ingress multicast path management"; + } + + leaf bandwidth-policy { + type types-sros:named-item; + description "Bandwidth policy associated with the MDA or forwarding plane for ingress multicast path management"; + } + + } // container mcast-path-management + + container network { + description "Enter the network context"; + + leaf queue-policy { + type types-sros:named-item; + description "Configure the network policy queue policy."; + } + + list queue-group { + key "queue-group-name instance-id"; + description "Enter the queue-group context"; + + leaf queue-group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Queue group name"; + } + + leaf instance-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint16 { + range "1..65535"; + } + } + description "Instance ID"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy for the FP ingress queue group"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics on FP ingress queue group"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container policer-control-policy { + description "Enter the policer-control-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Policer control policy"; + } + + container overrides { + presence "Enable policer control policy overrides."; + description "Enter the overrides context"; + + leaf max-rate { + type types-qos:queue-pir-rate-override; + units "kilobps"; + description "Maximum rate override"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-threshold-separation { + type types-qos:policer-burst-size-override; + units "bytes"; + description "Minimum threshold separation override"; + } + + list priority { + key "level"; + description "Enter the priority context"; + + leaf level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type types-qos:policer-burst-size-override; + units "bytes"; + description "MBS contribution size override"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container overrides + + } // container policer-control-policy + + container policer-overrides { + description "Enter the policer-overrides context"; + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id { + range "1..32"; + } + } + description "Policer identifier"; + } + + leaf cbs { + type types-qos:policer-burst-size-override; + units "bytes"; + description "CBS parameter override"; + } + + leaf mbs { + type types-qos:policer-burst-size-override; + units "bytes"; + description "MBS parameter override"; + } + + leaf packet-byte-offset { + type types-qos:ingress-per-packet-offset-override; + description "Size of each packet handled by the policer"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + description "Stat mode for the policer"; + } + + container rate { + description "Enter the rate context"; + + leaf cir { + type types-qos:queue-cir-rate-override; + description "CIR rate"; + } + + leaf pir { + type types-qos:queue-pir-rate-override; + description "PIR rate"; + } + + } // container rate + + } // list policer + + } // container policer-overrides + + } // list queue-group + + list pool { + key "name"; + description "The list of FP ingress network pool parameters."; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Specifies the unique name of the pool for the FP."; + } + + leaf amber-alarm-threshold { + type uint32 { + range "1..1000"; + } + units "percent"; + description "Configure amber alarm threshold allowed on over-subscription."; + } + + leaf red-alarm-threshold { + type uint32 { + range "1..1000"; + } + units "percent"; + description "Configure red alarm threshold allowed on over-subscription."; + } + + leaf slope-policy { + type types-sros:named-item; + description "Configure the slope policy."; + } + + container resv-cbs { + description "Enter the resv-cbs context"; + + leaf cbs { + type int32 { + range "0..100"; + } + units "percent"; + description + "Configure the percentage of pool size reserved for CBS. + + For network, the default value is computed as the sum of the + CBS request by the entities using the pool. + + For access, the default value is 30%."; + } + + container amber-alarm-action { + description "Enter the amber-alarm-action context"; + + leaf step { + type uint32 { + range "1..100"; + } + units "percent"; + description + "Configure the step-size percentage for the reserved CBS size of the + pool. + + When set to a value of zero (0), the adaptive CBS sizing is disabled. + + To enable adaptive CBS sizing, both this leaf and amber-alarm-action/max + must be set to non-default values. + + Adaptive CBS sizing can only be enabled when resv-cbs is non-default."; + } + + leaf max { + type uint32 { + range "1..100"; + } + units "percent"; + description + "Configure the maximum percentage for the reserved CBS size of the pool. + + When set to a value of zero (0), the adaptive CBS sizing is disabled. + + To enable adaptive CBS sizing, both this leaf and amber-alarm-action/step + must be set to non-default values. + + Adaptive CBS sizing can only be enabled when resv-cbs is non-default. + + This value must not be more than resv-cbs."; + } + + } // container amber-alarm-action + + } // container resv-cbs + + } // list pool + + } // container network + + } // container ingress + + } // list fp + + } // list card + + list port { + key "port-id"; + description "Enter the port context"; + + leaf port-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:port; + } + description "Unique port ID"; + } + + container ethernet { + description "Enter the ethernet context"; + + container egress { + description "Enter the egress context"; + + leaf hs-port-pool-policy { + type types-sros:named-item; + description "HS port pool policy"; + } + + leaf hsmda-scheduler-policy { + type types-sros:named-item; + description "HSMDA scheduler policy"; + } + + leaf monitor-port-scheduler { + type boolean; + default "false"; + description + "Enable/disable monitoring of egress scheduler on the Ethernet + port."; + } + + leaf rate { + type int32 { + range "1..400000000"; + } + units "kilobps"; + description "Maximum egress bandwidth that this Ethernet port can receive"; + } + + leaf eth-bn-rate-changes { + type boolean; + default "false"; + description "Receive rate changes in Ethernet Bandwidth Notification (Eth-BN) messages to update egress rate"; + } + + container port-qos-policy { + description "Attach an egress port-qos-policy."; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Port qos policy name"; + } + + } // container port-qos-policy + + list expanded-secondary-shaper { + key "secondary-shaper-name"; + description "Enter the expanded-secondary-shaper context"; + + leaf secondary-shaper-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name for the expanded secondary shaper"; + } + + leaf low-burst-max-class { + type uint32 { + range "1..8"; + } + default "8"; + description "Class to associate with the Ethernet egress expanded secondary shaper"; + } + + leaf monitor-threshold { + type types-qos:secondary-shaper-class-threshold; + description "Monitoring threshold for non-conformance burst"; + } + + leaf rate { + type types-qos:secondary-shaper-pir-rate; + default "max"; + description "Rate of the expanded secondary shaper"; + } + + container aggregate-burst { + description "Enter the aggregate-burst context"; + + leaf high-burst-increase { + type int32 { + range "0..65528"; + } + units "bytes"; + description "High burst increase"; + } + + leaf low-burst-limit { + type types-qos:class-burst-limit; + units "bytes"; + description "Low burst limit"; + } + + } // container aggregate-burst + + list class { + key "class-number"; + description "Enter the class context"; + + leaf class-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Unique value of the class"; + } + + leaf rate { + type types-qos:secondary-shaper-pir-rate; + default "max"; + description "Class rate"; + } + + leaf monitor-threshold { + type types-qos:secondary-shaper-class-threshold; + description "Monitoring threshold for non-conformance burst of the class"; + } + + leaf burst-limit { + type types-qos:class-burst-limit; + units "bytes"; + description "Class identifier of the low burst maximum class"; + } + + } // list class + + } // list expanded-secondary-shaper + + container hs-scheduler-policy { + description "Enter the hs-scheduler-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "HS port pool policy"; + } + + } // container hs-scheduler-policy + + container port-scheduler-policy { + description "Enter the port-scheduler-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Configure an egress scheduler policy."; + } + + container overrides { + presence "Enable port-scheduler-overrides."; + description "Enter the overrides context"; + + container max-rate { + description "Enter the max-rate context"; + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type types-qos:sched-pir-rate; + units "kilobps"; + default "max"; + description "Configure the PIR rate as a rate."; + } + + } + case percent-rate { + + leaf percent-rate { + type decimal64 { + range "0.01..100"; + fraction-digits 2; + } + units "percent"; + default "100"; + description "Configure the PIR rate as a percent."; + } + + } + } + } // container max-rate + + list level { + key "priority-level"; + description "Enter the level context"; + + leaf priority-level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Specifies the priority level of the port scheduler override."; + } + + choice rate-or-percent-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:sched-pir-rate-ovr; + units "kilobps"; + description "Configure the PIR rate in kbps."; + } + + leaf cir { + type types-qos:sched-cir-rate-ovr; + units "kilobps"; + description "Configure the CIR rate in kbps."; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type types-qos:pir-percent-override; + units "percent"; + description "Configure the PIR rate as a percent."; + } + + leaf cir { + type types-qos:cir-percent-override; + units "percent"; + description "Configure Che CIR rate as a percent."; + } + + } // container percent-rate + + } + } + } // list level + + } // container overrides + + } // container port-scheduler-policy + + } // container egress + + container network { + description "Enter the network context"; + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy that applies to the Ethernet network port"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistical data on the Ethernet port"; + } + + container egress { + description "Enter the egress context"; + + leaf queue-policy { + type types-sros:named-item; + description "Configure the queue policy on the Ethernet network port."; + } + + list queue-group { + key "queue-group-name instance-id"; + description "Enter the queue-group context"; + + leaf queue-group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Queue group name"; + } + + leaf instance-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint16 { + range "1..65535"; + } + } + description "Instance ID"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy for the Ethernet port egress queue group"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics on this queue group"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf hs-turbo { + type boolean; + default "false"; + description "Allow corresponding HSQ queue group queues to achieve a higher throughput"; + } + + leaf policer-control-policy { + type types-sros:named-item; + description "Policer control policy for the QoS egress queue group"; + } + + leaf scheduler-policy { + type types-sros:named-item; + description "Scheduler policy for the QoS egress queue group"; + } + + container aggregate-rate { + description "Enter the aggregate-rate context"; + + leaf queue-frame-based-accounting { + type boolean; + default "false"; + description "Enable frame-based accounting on all policers and queues associated with context"; + } + + leaf limit-unused-bandwidth { + type boolean; + default "false"; + description "Specify whether to enable limit unused bandwidth."; + } + + leaf rate { + type union { + type uint32 { + range "1..3200000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "max"; + description "Specify aggregate rate limit."; + } + + } // container aggregate-rate + + container queue-overrides { + description "Enter the queue-overrides context"; + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "HSMDA queue overrides queue ID"; + } + + leaf cbs { + type types-qos:burst-size-override; + description "CBS rate"; + } + + leaf mbs { + type types-qos:queue-burst-size-override; + units "bytes"; + description "MBS rate"; + } + + leaf monitor-depth { + type boolean; + default "false"; + description "Enable queue depth monitoring"; + } + + choice queue-override-rate { + default "rate"; + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf cir { + type types-qos:cir-percent-override; + units "percent"; + description "CIR percent rate"; + } + + leaf pir { + type types-qos:pir-percent-override; + units "percent"; + description "PIR percent rate"; + } + + } // container percent-rate + + } + case rate { + + container rate { + description "Enter the rate context"; + + leaf cir { + type types-qos:queue-cir-rate-override; + units "kilobps"; + description "CIR rate"; + } + + leaf pir { + type types-qos:queue-pir-rate-override; + units "kilobps"; + description "PIR rate"; + } + + } // container rate + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf cir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational CIR value"; + } + + leaf pir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent-or-default-override; + description "Percentage reduction from the MBS for a queue drop tail"; + } + + } // container low + + } // container drop-tail + + } // list queue + + } // container queue-overrides + + } // list queue-group + + } // container egress + + } // container network + + } // container ethernet + + } // list port + + container qos { + description "Enter the qos context"; + + container md-auto-id { + description "Enter the md-auto-id context"; + + container qos-policy-id-range { + presence "Qos policy Id range for MD Auto assignment"; + description "Enter the qos-policy-id-range context"; + + leaf start { + type types-qos:qos-policy-id { + range "2..65535"; + } + sros-ext:immutable; + mandatory true; + description "Lower value of the ID range, must be less than or equal to end value"; + } + + leaf end { + type types-qos:qos-policy-id { + range "2..65535"; + } + sros-ext:immutable; + mandatory true; + description "Upper value of the ID range, must be greater than or equal to start value"; + } + + } // container qos-policy-id-range + + } // container md-auto-id + + list sap-ingress { + key "sap-ingress-policy-name"; + description "Enter the sap-ingress context"; + + leaf sap-ingress-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "Name of this SAP-ingress QoS policy"; + } + + leaf policy-id { + type types-qos:qos-policy-id; + sros-ext:immutable; + description "The sap-ingress QoS policy identifier."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf default-fc { + type types-qos:sap-ingress-fc-name; + description "Default forwarding class or sub forwarding class for traffic not matching specific classification"; + } + + leaf default-priority { + type types-qos:default-priority; + default "low"; + description "Priority to assign to traffic ingressing as the default action queue"; + } + + leaf ingress-classification-policy { + type types-qos:qos-policy-name; + description "Attach ingress classification policy."; + } + + container subscriber-mgmt { + description "Enter the subscriber-mgmt context"; + + container pcc-rule-entry { + description "Enter the pcc-rule-entry context"; + + container range { + presence "true"; + description "Enter the range context"; + + leaf start { + type types-qos:entry-id; + mandatory true; + description "Starting entry at which the PCC-rule IP criteria entries are shared across several hosts"; + } + + leaf end { + type types-qos:entry-id; + mandatory true; + description "Ending entry at which the PCC-rule IP criteria entries are shared across several hosts"; + } + + } // container range + + } // container pcc-rule-entry + + container dynamic-policer { + description "Enter the dynamic-policer context"; + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Exceed threshold of the CIR leaky bucket of this policer"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "High priority violate threshold of PIR leaky bucket of this policer"; + } + + leaf packet-byte-offset { + type types-qos:per-packet-offset; + default "0"; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + default "minimal"; + description "Mode of statistics collected by the policer"; + } + + container policer-id-range { + presence "true"; + description "Enter the policer-id-range context"; + + leaf start { + type types-qos:ingress-policer-id; + mandatory true; + description "Starting place at which dynamic policers, required for PCC-rule IP criteria entries, will be inserted"; + } + + leaf end { + type types-qos:ingress-policer-id; + mandatory true; + description "Ending place at which dynamic policers, required for PCC-rule IP criteria entries, will be inserted"; + } + + } // container policer-id-range + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Arbiter to which this policer feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Weight to be used by the arbiter for feeding this policer"; + } + + } // container arbiter-parent + + } // container dynamic-policer + + } // container subscriber-mgmt + + container mac-criteria { + description "Enter the mac-criteria context"; + + leaf type { + type types-qos:mac-criteria-type; + sros-ext:immutable; + default "normal"; + description "MAC criteria filter type"; + } + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "Identifier for MAC match criteria and the corresponding action for a SAP-ingress policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf frame-type { + type types-qos:mac-frame-type; + default "802dot3"; + description "Match MAC criteria for ingress SAP QoS policy"; + } + + leaf etype { + type types-services:etype-value; + description "Ethernet type"; + } + + leaf snap-pid { + type int32 { + range "0..65535"; + } + description "Parameter snap-pid as MAC filter match criteria"; + } + + leaf snap-oui { + type enumeration { + enum "zero" { value 2; } + enum "non-zero" { value 3; } + } + description "Parameter snap-oui as MAC filter match criteria"; + } + + leaf atm-vci { + type types-qos:atm-vc-indentifier; + description "ATM VC Identifier to match as part of the MAC match criteria"; + } + + container src-mac { + presence "Enable source MAC address match criteria."; + description "Enter the src-mac context"; + + leaf address { + type yang:mac-address; + mandatory true; + description "Source MAC address"; + } + + leaf mask { + type yang:mac-address; + default "ff:ff:ff:ff:ff:ff"; + description "Mask for source MAC address"; + } + + } // container src-mac + + container dst-mac { + presence "Enable destination MAC address match criteria."; + description "Enter the dst-mac context"; + + leaf address { + type yang:mac-address; + mandatory true; + description "Destination MAC address"; + } + + leaf mask { + type yang:mac-address; + default "ff:ff:ff:ff:ff:ff"; + description "Mask for destination MAC address"; + } + + } // container dst-mac + + container dot1p { + presence "Enable 802.1P Priority Match Criteria."; + description "Enter the dot1p context"; + + leaf priority { + type types-qos:dot1p-priority; + mandatory true; + description "Value of 802.1P priority to use as a MAC filter match criterion"; + } + + leaf mask { + type types-qos:dot1p-priority; + default "7"; + description "Value of 802.1P mask to use as a MAC filter match criterion"; + } + + } // container dot1p + + container llc-dsap { + presence "Enable DSAP criteria matching."; + description "Enter the llc-dsap context"; + + leaf dsap { + type types-qos:service-access-point; + mandatory true; + description "DSAP value"; + } + + leaf mask { + type types-qos:service-access-point; + default "255"; + description "DSAP mask"; + } + + } // container llc-dsap + + container llc-ssap { + presence "Enable SSAP criteria matching."; + description "Enter the llc-ssap context"; + + leaf ssap { + type types-qos:service-access-point; + mandatory true; + description "SSAP value"; + } + + leaf mask { + type types-qos:service-access-point; + default "255"; + description "Source SAP mask"; + } + + } // container llc-ssap + + container inner-tag { + presence "Enable inner tag criteria matching."; + description "Enter the inner-tag context"; + + leaf vlan { + type int32 { + range "0..4095"; + } + mandatory true; + description "Match against VID of the second or first VLAN tag in the packet carried transparently through service"; + } + + leaf mask { + type uint32 { + range "1..4095"; + } + default "4095"; + description "Mask to VID of the inner VLAN tag before comparing it with the inner-tag or outer-tag value"; + } + + } // container inner-tag + + container outer-tag { + presence "Enable outer tag criteria matching."; + description "Enter the outer-tag context"; + + leaf vlan { + type int32 { + range "0..4095"; + } + mandatory true; + description "Match against VID of the first VLAN tag in the packet carried transparently through service"; + } + + leaf mask { + type uint32 { + range "1..4095"; + } + default "4095"; + description "First tag carried transparently through the service"; + } + + } // container outer-tag + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for the packet"; + } + + leaf policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the traffic matching MAC Criteria"; + } + + } // container action + + } // list entry + + } // container mac-criteria + + container ip-criteria { + description "Enter the ip-criteria context"; + + leaf type { + type types-qos:ip-filter-type; + sros-ext:immutable; + default "normal"; + description "IP filter type"; + } + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "IP criteria entry to create or edit for the policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf protocol { + type types-sros:ipv4-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + } + description "Match performed when the packet is either a fragment or not, or matches all packets"; + } + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet"; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address to match with source IP of the packet"; + } + + } + case ip-prefix-list { + + leaf ip-prefix-list { + type types-sros:named-item; + description "IP-prefix list as match criterion"; + } + + } + } + } // container dst-ip + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address to match with source IP of the packet"; + } + + } + case ip-prefix-list { + + leaf ip-prefix-list { + type types-sros:named-item; + description "IP-prefix list as match criterion"; + } + + } + } + } // container src-ip + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + container vxlan-vni { + description "Enter the vxlan-vni context"; + + choice vxlan-vni-mapping { + case eq { + + leaf eq { + type uint32 { + range "1..16777215"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type uint32 { + range "1..16777215"; + } + description "Start value of range"; + } + + leaf end { + type uint32 { + range "1..16777215"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container vxlan-vni + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for the packet"; + } + + leaf policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the traffic matching MAC Criteria"; + } + + } // container action + + } // list entry + + } // container ip-criteria + + container ipv6-criteria { + description "Enter the ipv6-criteria context"; + + leaf type { + type types-qos:ip-filter-type; + sros-ext:immutable; + default "normal"; + description "IPv6 filter type"; + } + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "IPv6 criteria entry to create or edit for the policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf next-header { + type types-sros:ipv6-match-protocol; + description "Next Header to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + enum "first-only" { value 4; } + enum "non-first-only" { value 5; } + } + description "Match performed when the packet is either a fragment or not, or matches all packets"; + } + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet"; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address to match with source IP of the packet"; + } + + } + } + } // container dst-ip + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address to match with source IP of the packet"; + } + + } + } + } // container src-ip + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + container vxlan-vni { + description "Enter the vxlan-vni context"; + + choice vxlan-vni-mapping { + case eq { + + leaf eq { + type uint32 { + range "1..16777215"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type uint32 { + range "1..16777215"; + } + description "Start value of range"; + } + + leaf end { + type uint32 { + range "1..16777215"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container vxlan-vni + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for the packet"; + } + + leaf policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the traffic matching MAC Criteria"; + } + + } // container action + + } // list entry + + } // container ipv6-criteria + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-queue-id; + } + description "SAP-ingress policer identifier"; + } + + leaf multipoint { + type boolean; + sros-ext:immutable; + default "false"; + description "Apply as a multicast queue"; + } + + leaf queue-type { + type types-qos:queue-type; + sros-ext:immutable; + default "auto-expedited"; + description "Priority that this queue receives from the hardware level schedulers"; + } + + leaf queue-mode { + type enumeration { + enum "priority" { value 1; } + enum "profile" { value 2; } + } + sros-ext:immutable; + default "priority"; + description "Operating mode for this queue"; + } + + leaf cbs { + type union { + type int32 { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + default "auto"; + description "Reserved buffer space for the queue"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Maximum buffer space that is allowed for queue"; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..14000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy to apply with this queue"; + } + + leaf packet-byte-offset { + type types-qos:per-packet-offset { + range "-32..30"; + } + default "0"; + description "Value of the adjustment on the size of each packet for queue accounting"; + } + + leaf cir-non-profiling { + type boolean; + default "false"; + description "Prevents the CIR to be used for re-profiling a packet's state."; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:queue-pir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + choice rate-cir-fir-or-police { + default "cir-fir"; + case cir-fir { + + leaf cir { + type types-qos:queue-cir-rate-maximum; + units "kilobps"; + default "0"; + description "Specifies the administrative CIR."; + } + + leaf fir { + type types-qos:queue-fir-rate-maximum; + units "kilobps"; + default "0"; + description "Specifies the administrative FIR."; + } + + } + case police { + + leaf police { + type empty; + description + "Specifies that the out of profile traffic feeding into the physical queue + instance should be dropped"; + } + + } + } + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf reference-rate { + type enumeration { + enum "port-limit" { value 2; } + enum "local-limit" { value 3; } + } + default "port-limit"; + description "Reference rate as percentage"; + } + + choice percent-rate-cir-fir-or-police { + default "cir-fir"; + case cir-fir { + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Specifies the administrative CIR percent."; + } + + leaf fir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Specifies the administrative FIR percent."; + } + + } + case police { + + leaf police { + type empty; + description + "Specifies that the out of profile traffic feeding into the physical queue + instance should be dropped"; + } + + } + } + } // container percent-rate + + } + } + container scheduler-parent { + description "Enter the scheduler-parent context"; + + leaf scheduler-name { + type types-sros:named-item; + description "Scheduler to which this queue feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Level of priority while feeding to the parent"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "1"; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container scheduler-parent + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf fir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the operational FIR + value. The adaptation rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Low drop-tail percent from MBS that is reduced"; + } + + } // container low + + } // container drop-tail + + } // list queue + + list dscp { + key "dscp-name"; + description "Enter the dscp context"; + + leaf dscp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dscp-name; + } + description "Name for the Differentiated Services Code Point (DSCP)"; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for the packet"; + } + + } // list dscp + + list dot1p { + key "dot1p-value"; + description "Enter the dot1p context"; + + leaf dot1p-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dot1p-priority; + } + description "Dot1p value to match in the packet"; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for packets that match the Dot1p value"; + } + + } // list dot1p + + list prec { + key "prec-value"; + description "Enter the prec context"; + + leaf prec-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:precedence-value; + } + description "Precedence value for which mapping is performed"; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for the matching traffic"; + } + + } // list prec + + list lsp-exp { + key "lsp-exp-value"; + description "Enter the lsp-exp context"; + + leaf lsp-exp-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:lsp-exp-value; + } + description "Value to assign the unique MPLS LSP EXP value that will match the lsp-exp rule"; + } + + leaf fc { + type types-qos:sap-ingress-fc-name; + description "Forwarding class or sub forwarding class to classify traffic matching the MAC criteria"; + } + + leaf priority { + type types-qos:priority; + description "Priority for the matching traffic"; + } + + } // list lsp-exp + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:sap-ingress-fc-name; + } + description "Forwarding class or the sub forwarding class for which this mapping is performed"; + } + + leaf profile { + type types-qos:profile; + description "Profile of the packets associated with this forwarding class"; + } + + leaf de-1-out-profile { + type boolean; + default "false"; + description "Frames with DE value to be assigned as out of profile"; + } + + leaf egress-fc { + type types-sros:fc-name; + description "Forwarding class to override the forwarding class determined by ingress classification"; + } + + choice queue-policer-mapping { + case queue { + + leaf queue { + type types-qos:ingress-queue-id; + description "Queue to assign for packets in this forwarding class"; + } + + } + case queue-group-queue { + + container queue-group-queue { + presence "Sap-Ingress Forwarding Class (FC) queue-group mappings."; + description "Enter the queue-group-queue context"; + + leaf queue-group-name { + type types-sros:named-item; + mandatory true; + description "Queue group name associated with queue"; + } + + leaf queue { + type types-qos:ingress-queue-id; + mandatory true; + description "Queue to assign for packets in this forwarding class"; + } + + } // container queue-group-queue + + } + case policer { + + leaf policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the normal traffic in this forwarding class"; + } + + leaf fp-redirect-group-policer { + type empty; + description "Specified policer to be used as defined in the FP (forwarding-plane)"; + } + + } + } + choice multicast-queue-policer-mapping { + case multicast-queue { + + leaf multicast-queue { + type types-qos:ingress-queue-id; + description "Broadcast queue to assign for packets in this forwarding class"; + } + + } + case multicast-queue-group-queue { + + container multicast-queue-group-queue { + presence "Sap-Ingress Forwarding Class (FC) queue-group mappings."; + description "Enter the unknown-queue-group-queue context"; + + leaf queue-group-name { + type types-sros:named-item; + mandatory true; + description "Queue group name associated with broadcast queue"; + } + + leaf queue { + type types-qos:ingress-queue-id; + mandatory true; + description "Broadcast queue to assign for packets in this forwarding class"; + } + + } // container multicast-queue-group-queue + + } + case multicast-policer { + + leaf multicast-policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the broadcast traffic in this forwarding class"; + } + + leaf fp-redirect-group-multicast-policer { + type empty; + description "Broadcast policer to be used as defined in the FP (forwarding-plane)"; + } + + } + } + choice broadcast-queue-policer-mapping { + case broadcast-queue { + + leaf broadcast-queue { + type types-qos:ingress-queue-id; + description "Broadcast queue to assign for packets in this forwarding class"; + } + + } + case broadcast-queue-group-queue { + + container broadcast-queue-group-queue { + presence "Sap-Ingress Forwarding Class (FC) queue-group mappings."; + description "Enter the unknown-queue-group-queue context"; + + leaf queue-group-name { + type types-sros:named-item; + mandatory true; + description "Queue group name associated with broadcast queue"; + } + + leaf queue { + type types-qos:ingress-queue-id; + mandatory true; + description "Broadcast queue to assign for packets in this forwarding class"; + } + + } // container broadcast-queue-group-queue + + } + case broadcast-policer { + + leaf broadcast-policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the broadcast traffic in this forwarding class"; + } + + leaf fp-redirect-group-broadcast-policer { + type empty; + description "Broadcast policer to be used as defined in the FP (forwarding-plane)"; + } + + } + } + choice unknown-queue-policer-mapping { + case unknown-queue { + + leaf unknown-queue { + type types-qos:ingress-queue-id; + description "Broadcast queue to assign for packets in this forwarding class"; + } + + } + case unknown-queue-group-queue { + + container unknown-queue-group-queue { + presence "Sap-Ingress Forwarding Class (FC) queue-group mappings."; + description "Enter the unknown-queue-group-queue context"; + + leaf queue-group-name { + type types-sros:named-item; + mandatory true; + description "Queue group name associated with broadcast queue"; + } + + leaf queue { + type types-qos:ingress-queue-id; + mandatory true; + description "Broadcast queue to assign for packets in this forwarding class"; + } + + } // container unknown-queue-group-queue + + } + case unknown-policer { + + leaf unknown-policer { + type types-qos:ingress-policer-id; + description "Policer identifier for the broadcast traffic in this forwarding class"; + } + + leaf fp-redirect-group-unknown-policer { + type empty; + description "Broadcast policer to be used as defined in the FP (forwarding-plane)"; + } + + } + } + container in-remark { + description "Enter the in-remark context"; + + choice in-profile { + case dscp { + + leaf dscp { + type types-qos:dscp-name; + description + "Specifies the DSCP to be used while remarking the in profile packets when + the in-profile remarking type is 'dscp'."; + } + + } + case prec { + + leaf prec { + type types-qos:precedence-value; + description + "Specifies the precedence value to be used while remarking the in profile + packets when the in-profile remarking type is 'precedence'."; + } + + } + } + } // container in-remark + + container out-remark { + description "Enter the out-remark context"; + + choice out-profile { + case dscp { + + leaf dscp { + type types-qos:dscp-name; + description + "Specifies the DSCP to be used while remarking the out profile packets when + the out-profile remarking type is 'dscp'."; + } + + } + case prec { + + leaf prec { + type types-qos:precedence-value; + description + "Specifies the precedence value to be used while remarking the out profile + packets when the out-profile remarking type is 'precedence'."; + } + + } + } + } // container out-remark + + } // list fc + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id; + } + description "SAP-ingress policer identifier"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + default "minimal"; + description "Mode of statistics collected by the policer"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "High priority for the violate threshold of PIR leaky bucket of this policer"; + } + + leaf high-prio-only { + type types-qos:burst-percent; + description "Percentage of PIR leaky bucket's MBS of this policer that is reserved for high priority traffic"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Exceed threshold of the CIR leaky bucket of this policer"; + } + + leaf packet-byte-offset { + type types-qos:per-packet-offset; + default "0"; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy to apply with this queue"; + } + + leaf profile-capped { + type boolean; + default "false"; + description "Enforce an overall in-profile burst limit to the CIR bucket at ingress policer"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:policer-pir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:policer-cir-rate-maximum; + units "kilobps"; + default "0"; + description "Administrative CIR"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Administrative CIR percent"; + } + + } // container percent-rate + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Arbiter to which this policer feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Weight to be used by the arbiter for feeding this policer"; + } + + } // container arbiter-parent + + } // list policer + + } // list sap-ingress + + list slope-policy { + key "slope-policy-name"; + max-elements 511; + description "Enter the slope-policy context"; + + leaf slope-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Slope policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf time-average-factor { + type uint32 { + range "0..15"; + } + default "7"; + description "Apply time average factor to weight between previous and new shared buffer utilization result"; + } + + container highplus-slope { + description "Enter the highplus-slope context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the highplus priority RED slope"; + } + + leaf start-avg { + type uint32 { + range "0..100"; + } + default "85"; + description "Buffer percentage after which the drop probability starts to rise above value"; + } + + leaf max-avg { + type uint32 { + range "0..100"; + } + default "100"; + description "Buffer percentage after which the drop probability reaches maximum average"; + } + + leaf max-prob { + type uint32 { + range "0..100"; + } + default "80"; + description "Drop probability increase at highplus start-average"; + } + + } // container highplus-slope + + container high-slope { + description "Enter the high-slope context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the high priority RED slope"; + } + + leaf start-avg { + type uint32 { + range "0..100"; + } + default "70"; + description "Buffer percentage after which the drop probability starts to rise above value"; + } + + leaf max-avg { + type uint32 { + range "0..100"; + } + default "90"; + description "Buffer percentage after which the drop probability reaches maximum average"; + } + + leaf max-prob { + type uint32 { + range "0..100"; + } + default "80"; + description "Drop probability to increase at high start-average"; + } + + } // container high-slope + + container low-slope { + description "Enter the low-slope context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the low priority RED slope"; + } + + leaf start-avg { + type uint32 { + range "0..100"; + } + default "50"; + description "Buffer percentage after which the drop probability starts to rise above value"; + } + + leaf max-avg { + type uint32 { + range "0..100"; + } + default "75"; + description "Buffer percentage after which the drop probability reaches maximum average"; + } + + leaf max-prob { + type uint32 { + range "0..100"; + } + default "80"; + description "Drop probability to increase at low start-average"; + } + + } // container low-slope + + container exceed-slope { + description "Enter the exceed-slope context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the exceed priority RED slope"; + } + + leaf start-avg { + type uint32 { + range "0..100"; + } + default "30"; + description "Buffer percentage after which the drop probability starts to rise above value"; + } + + leaf max-avg { + type uint32 { + range "0..100"; + } + default "55"; + description "Buffer percentage after which the drop probability reaches maximum average"; + } + + leaf max-prob { + type uint32 { + range "0..100"; + } + default "80"; + description "Drop probability to increase at exceed start-average"; + } + + } // container exceed-slope + + } // list slope-policy + + list hsmda-slope-policy { + key "hsmda-slope-policy-name"; + description "Enter the hsmda-slope-policy context"; + + leaf hsmda-slope-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "HSMDA slope policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container high-slope { + description "Enter the high-slope context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the high priority RED slope"; + } + + leaf start-depth { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Buffer percentage after which the drop probability starts to rise above value"; + } + + leaf max-depth { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Buffer percentage after which the drop probability reaches maximum average"; + } + + leaf max-prob { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Drop probability when the HSMDA queue depth reaches maximum depth"; + } + + } // container high-slope + + container low-slope { + description "Enter the low-slope context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the low priority RED slope"; + } + + leaf start-depth { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "90.00"; + description "Buffer percentage after which the drop probability starts to rise above value"; + } + + leaf max-depth { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "90.00"; + description "Buffer percentage after which the drop probability reaches maximum average"; + } + + leaf max-prob { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Drop probability when the HSMDA queue depth reaches maximum depth"; + } + + } // container low-slope + + } // list hsmda-slope-policy + + list hsmda-wrr-policy { + key "hsmda-wrr-policy-name"; + description "Enter the hsmda-wrr-policy context"; + + leaf hsmda-wrr-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "HSMDA WRR policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf include-queues { + type enumeration { + enum "1-2" { value 1; } + enum "1-3" { value 2; } + } + default "1-2"; + description "Queues to include includes into the HSMDA WRR scheduling loop policy"; + } + + leaf schedule-using-class { + type int32 { + range "1..3"; + } + default "1"; + description "Class to schedule the queues specified within the HSMDA scheduler"; + } + + leaf class-agg-weight { + type int32 { + range "1|2|4|8"; + } + default "1"; + description "Weight assigned to the group of queues specified within the HSMDA scheduler"; + } + + } // list hsmda-wrr-policy + + list hsmda-pool-policy { + key "hsmda-pool-policy-name"; + description "Enter the hsmda-pool-policy context"; + + leaf hsmda-pool-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "The name of the HSMDA Pool Policy."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf system-reserve { + type decimal64 { + range "1.00..30.00"; + fraction-digits 2; + } + default "10.00"; + description "Specifies the percentage of HSMDA buffers reserved for internal system use."; + } + + container root-tier { + description "Enter the root-tier context"; + + list root-pool { + key "root-pool-id"; + description "Enter the root-pool context"; + + leaf root-pool-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Root pool identifier for the HSMDA pool policy"; + } + + leaf allocation-weight { + type uint32 { + range "0..100"; + } + default "0"; + description + "Specifies the weight that will be applied to the + first root pool and is divided by the sum of all root pool + weights to derive the pool's buffer allocation factor."; + } + + } // list root-pool + + } // container root-tier + + container class-tier { + description "Enter the class-tier context"; + + list class-pool { + key "class-pool-id"; + description "Enter the class-pool context"; + + leaf class-pool-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Class pool for the HSMDA pool policy"; + } + + leaf root-parent { + type uint32 { + range "1..8"; + } + default "1"; + description "Specifies the parent root to which this class-pool is associated."; + } + + leaf allocation-percent { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description + "Specifies the percentage of the root-pool with which it is associated, + as specified by root-parent will be available to this class-pool."; + } + + } // list class-pool + + } // container class-tier + + } // list hsmda-pool-policy + + list hsmda-scheduler-policy { + key "hsmda-scheduler-policy-name"; + description "Enter the hsmda-scheduler-policy context"; + + leaf hsmda-scheduler-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "The name of the HSMDA scheduler policy."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf max-rate { + type union { + type uint32 { + range "1..100000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "megabps"; + default "max"; + description "Specifies the maximum rate for this HSMDA scheduler policy."; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..327680"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + list group { + key "group-id"; + description "Enter the group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..2"; + } + } + description "Group ID for the HSMDA scheduler policy"; + } + + leaf rate { + type union { + type uint32 { + range "1..100000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "megabps"; + default "max"; + description "Specifies the group maximum rate."; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..327680"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + } // list group + + list scheduling-class { + key "class-id"; + description "Enter the scheduling-class context"; + + leaf class-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Class identifier for the HSMDA scheduler policy scheduling class"; + } + + choice rate-or-group { + default "rate"; + case rate { + + leaf rate { + type union { + type uint32 { + range "1..100000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "megabps"; + default "max"; + description "Specifies the scheduling class maximum rate."; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..327680"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + } + case group { + + container group { + presence "Specifies the group and weight configuration."; + description "Enter the group context"; + + leaf group-id { + type uint32 { + range "1..2"; + } + mandatory true; + description "Specifies the group associated with this scheduling class."; + } + + leaf weight { + type int32 { + range "1..100"; + } + default "1"; + description "Specifies the weight in group associated with this scheduling class."; + } + + } // container group + + } + } + } // list scheduling-class + + } // list hsmda-scheduler-policy + + list atm-td-profile { + key "atm-td-profile-id"; + description "Enter the atm-td-profile context"; + + leaf atm-td-profile-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:atm-traffic-descr-idx; + } + description "ATM traffic descriptor ID"; + } + + leaf shaping { + type boolean; + default "false"; + description "Enable cell level shaping when the ATP traffic description profile is applied to an ATM SAP queue"; + } + + leaf service-category { + type types-qos:atm-service-category; + default "ubr"; + description "ATM service category"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf descriptor-type { + type enumeration { + enum "p01" { value 0; } + enum "p01-and-s01" { value 1; } + enum "p01-and-s0" { value 2; } + enum "p01-and-s0-tag" { value 3; } + } + default "p01-and-s01"; + description "Select the type of ATM traffic descriptor"; + } + + leaf policing { + type boolean; + default "false"; + description "Allow ingress traffic policing"; + } + + leaf clp-tagging { + type boolean; + default "false"; + description "Control the setting of the CLP bit in the ATM cell header for egress traffic on IES or VPRN SAP"; + } + + leaf weight { + type int32 { + range "1..255"; + } + default "1"; + description "Relative weight for the ATM traffic descriptor based on ATM VP shaper scheduling"; + } + + container traffic { + description "Enter the traffic context"; + + leaf sir { + type uint32; + units "kilobps"; + default "0"; + description "Sustained information rate"; + } + + leaf pir { + type uint32; + units "kilobps"; + default "0"; + description "Peak information rate"; + } + + leaf mir { + type uint32; + units "kilobps"; + default "0"; + description "Minimum information rate"; + } + + leaf mbs { + type uint32; + default "0"; + description "Maximum burst size in cell"; + } + + leaf cdvt { + type uint32; + units "microseconds"; + default "250"; + description "Cell Delay Variation Tolerance"; + } + + } // container traffic + + } // list atm-td-profile + + list network-queue { + key "network-queue-policy"; + max-elements 255; + description "Enter the network-queue context"; + + leaf network-queue-policy { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name for network queue policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf hs-attachment-policy { + type types-sros:named-item; + description "HS attachment policy applied"; + } + + container egress-hsmda { + description "Enter the egress-hsmda context"; + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Packet byte offset to use for the HSMDA egress queues"; + } + + leaf wrr-policy { + type types-sros:named-item; + description "WRR policy to use on this HSMDA egress queue"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress HSMDA queue ID"; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..1000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..2688000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Percentage of buffer space allowed for the queue"; + } + + leaf percent-rate { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "PIR percentage rate"; + } + + leaf slope-policy { + type types-sros:named-item; + description "Slop policy name to override the default slope policy for the named buffer pool"; + } + + leaf wrr-weight { + type types-qos:hsmda-wrr-weight; + default "1"; + description "Weight value for the HSMDA queue"; + } + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + } // list queue + + } // container egress-hsmda + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name"; + } + + leaf queue { + type types-qos:network-queue-queue-id; + default "1"; + description "Queue for packets in this forwarding class"; + } + + leaf multicast-queue { + type types-qos:network-queue-queue-id; + default "9"; + description "Multicast queue for packets in this forwarding class"; + } + + container egress-hsmda { + description "Enter the egress-hsmda context"; + + leaf queue { + type types-qos:egress-queue-id; + description "Egress HSDMA queue for packets in this forwarding class"; + } + + } // container egress-hsmda + + } // list fc + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:network-queue-queue-id; + } + description "HSMDA queue for packets in this forwarding class"; + } + + leaf multipoint { + type boolean; + sros-ext:immutable; + default "false"; + description "Apply as a multicast queue"; + } + + leaf queue-type { + type enumeration { + enum "expedited" { value 1; } + enum "auto-expedited" { value 2; } + enum "best-effort" { value 3; } + } + sros-ext:immutable; + default "auto-expedited"; + description "Priority that this queue receives from the hardware level schedulers"; + } + + leaf cbs { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "1.00"; + description "Reserved buffer space for the queue"; + } + + leaf mbs { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Percentage of buffer space allowed for the queue"; + } + + leaf avg-frame-overhead { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Encapsulation overhead to translate the packet based rate to frame based rate and vice versa"; + } + + leaf hs-alt-port-class-pool { + type boolean; + default "false"; + description "Use HS alternate class port pool buffer for traffic"; + } + + leaf hs-wrr-weight { + type types-qos:hs-wrr-weight; + default "1"; + description "Weighted Round Robin (WRR) weight to parent with this queue into the scheduler"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight; + default "1"; + description "Scheduling class weight"; + } + + leaf hs-mbs { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Percentage of buffer space allowed for the HS queue"; + } + + container rate { + description "Enter the rate context"; + + leaf pir { + type int32 { + range "1..100"; + } + units "percent"; + default "100"; + description "PIR percentage rate"; + } + + leaf cir { + type int32 { + range "0..100"; + } + units "percent"; + default "0"; + description "CIR percentage rate"; + } + + leaf fir { + type int32 { + range "0..100"; + } + units "percent"; + default "0"; + description "Specifies the FIR percentage rate."; + } + + } // container rate + + container port-parent { + presence "Specifies whether this queue is parented by port-level scheduler."; + description "Enter the port-parent context"; + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "0"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + } // container port-parent + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + leaf fir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the operational FIR + value. The adaptation rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Low drop-tail percent from MBS that is reduced"; + } + + } // container low + + } // container drop-tail + + container hs-wred-queue { + description "Enter the hs-wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Slope policy name"; + } + + } // container hs-wred-queue + + } // list queue + + list hs-wrr-group { + key "group-id"; + description "Enter the hs-wrr-group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hs-wrr-group-id; + } + description "HS WRR group identifier"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight; + default "1"; + description "Weight of scheduling class"; + } + + leaf rate { + type uint32 { + range "1..100"; + } + default "100"; + description "PIR rate"; + } + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + } // list hs-wrr-group + + } // list network-queue + + list shared-queue { + key "shared-queue-policy-name"; + description "Enter the shared-queue context"; + + leaf shared-queue-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name for the shared queue policy"; + } + + leaf description { + type types-sros:description-or-empty; + description "Text description"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..32"; + } + } + description "Shared queue identifier"; + } + + leaf multipoint { + type boolean; + default "false"; + description "Apply as a multicast queue"; + } + + leaf queue-type { + type enumeration { + enum "expedited" { value 1; } + enum "auto-expedited" { value 2; } + enum "best-effort" { value 3; } + } + default "auto-expedited"; + description "Priority that this queue receives from the hardware level schedulers"; + } + + leaf cbs { + type int32 { + range "0..100"; + } + units "percent"; + default "0"; + description "Committed burst size as a percentage of the maximum reserved buffer space for the queue"; + } + + leaf mbs { + type int32 { + range "0..100"; + } + units "percent"; + default "100"; + description "Maximum burst size as a percentage of maximum reserved buffer space for the queue"; + } + + container rate { + description "Enter the rate context"; + + leaf pir { + type int32 { + range "1..100"; + } + units "percent"; + default "100"; + description "PIR percentage rate"; + } + + leaf cir { + type int32 { + range "0..100"; + } + units "percent"; + default "0"; + description "CIR percentage rate"; + } + + leaf fir { + type int32 { + range "0..100"; + } + units "percent"; + default "0"; + description "Specifies the FIR percentage rate."; + } + + } // container rate + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Low drop-tail percent from MBS that is reduced"; + } + + } // container low + + } // container drop-tail + + } // list queue + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class mapping to queue mappings"; + } + + leaf queue { + type int32 { + range "1..8"; + } + default "1"; + description "Logical queue that the traffic, classified into this forwarding class, should use"; + } + + leaf broadcast-queue { + type int32 { + range "9..32"; + } + default "17"; + description "Logical queue that the broadcast traffic, classified into this forwarding class, should use"; + } + + leaf multicast-queue { + type int32 { + range "9..32"; + } + default "9"; + description "Logical queue that the multicast traffic, classified into this forwarding class, should use"; + } + + leaf unknown-queue { + type int32 { + range "9..32"; + } + default "25"; + description "Logical queue that the unknown traffic, classified into this forwarding class, should use"; + } + + } // list fc + + } // list shared-queue + + list adv-config-policy { + key "adv-config-policy-name"; + max-elements 255; + description "Enter the adv-config-policy context"; + + leaf adv-config-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Advanced QoS policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container child-control { + description "Enter the child-control context"; + + container bandwidth-distribution { + description "Enter the bandwidth-distribution context"; + + leaf enqueue-on-pir-zero { + type boolean; + default "false"; + description "Enqueue the packets when bandwidth-distribution granularity rate is set to zero"; + } + + leaf internal-scheduler-weight-mode { + type types-qos:internal-scheduler-weight-mode; + description "Weight mode applied to this advanced QoS policy"; + } + + leaf limit-pir-zero-drain { + type boolean; + default "false"; + description "Throttle the queue draining based on bandwidth-distribution granularity rate"; + } + + leaf lub-init-min-pir { + type boolean; + default "false"; + description "Apply minimum rate operational PIR to queue for use by enqueued packets prior to an HQoS iteration"; + } + + container above-offered-cap { + description "Enter the above-offered-cap context"; + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type union { + type int64 { + range "0..100000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + description "Explicit number to assign as limit to the child's fair share increase"; + } + + } + case percent { + + leaf percent { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "Percentage of the child's administrative PIR that is used as the fair share increase limit"; + } + + } + } + } // container above-offered-cap + + container granularity { + description "Enter the granularity context"; + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type int64 { + range "0..100000000"; + } + description "Rounding rate step value"; + } + + } + case percent { + + leaf percent { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "Rounding percentage value for administratiive PIR"; + } + + } + } + } // container granularity + + } // container bandwidth-distribution + + container offered-measurement { + description "Enter the offered-measurement context"; + + leaf fast-start { + type boolean; + default "false"; + description "Allow fast detection of initial bandwidth on a child policer or queue associated with policy"; + } + + leaf fast-stop { + type boolean; + default "false"; + description "Allow fast detection of lack of offered rate on a child policer or queue associated with the policy"; + } + + leaf sample-interval { + type uint32 { + range "1..8"; + } + default "1"; + description "Interval for sampling the child's offered rate"; + } + + container add { + description "Enter the add context"; + + leaf min-only { + type boolean; + default "false"; + description "Use specified increase value as a minimum offered rate even for inactive queues or policers"; + } + + leaf active-min-only { + type boolean; + default "false"; + description "Use increase in rate or percentage as minimum offered rate only for active queues or policers"; + } + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type int64 { + range "0..100000000"; + } + description "Rate value to add to child's offered rate"; + } + + } + case percent { + + leaf percent { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "Percentage of child's administrative PIR to add to child's offered rate"; + } + + } + } + } // container add + + container granularity { + description "Enter the granularity context"; + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type int64 { + range "0..100000000"; + } + description "Value to use as child's offered rate change sensitivity value"; + } + + } + case percent { + + leaf percent { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "Percentage of child's administrative PIR used as threshold sensitivity to offered rate change"; + } + + } + } + } // container granularity + + container hold-time { + description "Enter the hold-time context"; + + leaf high-rate { + type uint32 { + range "0..60"; + } + default "0"; + description "Time during which current offered rate is maintained for a child policer or queue"; + } + + leaf active-min-only { + type boolean; + default "false"; + description "Use specified increase value as minimum offered rate only for active queues or policers"; + } + + } // container hold-time + + container max-decrement { + description "Enter the max-decrement context"; + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type int64 { + range "0..100000000"; + } + description "Value to use as the decrement limit to offered rate change"; + } + + } + case percent { + + leaf percent { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "Value of the child's administrative PIR to use as the decrement limit to offered rate change"; + } + + } + } + } // container max-decrement + + container time-average-factor { + description "Enter the time-average-factor context"; + + leaf weighting-factor { + type uint32 { + range "0..64"; + } + default "0"; + description "New offered rate with a sample of the previous offered rate"; + } + + leaf dec-only { + type boolean; + default "false"; + description "Apply time average factor adjustment when the offered rate decreases compared to previous"; + } + + } // container time-average-factor + + } // container offered-measurement + + } // container child-control + + } // list adv-config-policy + + list mlppp-profile-ingress { + key "mc-mlppp-ingress-prof-index"; + max-elements 128; + description "Enter the mlppp-profile-ingress context"; + + leaf mc-mlppp-ingress-prof-index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..65535"; + } + } + description "Index of the ingress MultiClass MLPPP profile"; + } + + leaf description { + type types-sros:description-or-empty; + description "Text description"; + } + + list class { + key "class-id"; + description "Enter the class context"; + + leaf class-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "0..3"; + } + } + description "Policy class"; + } + + leaf reassembly-timeout { + type uint32 { + range "1..1000"; + } + default "10"; + description "Reassembly timeout for this policy"; + } + + } // list class + + } // list mlppp-profile-ingress + + list mlppp-profile-egress { + key "mc-mlppp-egress-prof-index"; + max-elements 128; + description "Enter the mlppp-profile-egress context"; + + leaf mc-mlppp-egress-prof-index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..65535"; + } + } + description "Index of the egress MultiClass MLPPP profile"; + } + + leaf description { + type types-sros:description-or-empty; + description "Text description"; + } + + list class { + key "class-id"; + description "Enter the class context"; + + leaf class-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "0..3"; + } + } + description "Policy class"; + } + + leaf mir { + type uint32 { + range "1..100"; + } + description "Minimum information rate (MIR) as percentage"; + } + + leaf max-queue-size { + type uint32 { + range "1..1000"; + } + default "25"; + description "Buffer queue size"; + } + + leaf weight { + type uint32 { + range "1..100"; + } + description "Weight of this multiclass class as a percentage"; + } + + } // list class + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name"; + } + + leaf mlppp-class { + type uint32 { + range "0..3"; + } + default "0"; + description "Mapping of the system forwarding class to the MLPPP classes"; + } + + } // list fc + + } // list mlppp-profile-egress + + list mc-fr-profile-ingress { + key "mc-fr-ingress-prof-index"; + max-elements 128; + description "Enter the mc-fr-profile-ingress context"; + + leaf mc-fr-ingress-prof-index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..65535"; + } + } + description "Index of the ingress MultiClass Frame Relay profile"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + list class { + key "class-id"; + description "Enter the class context"; + + leaf class-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "0..3"; + } + } + description "Frame-relay ingress class per multi-class frame-relay ingress profile"; + } + + leaf reassembly-timeout { + type uint32 { + range "1..1000"; + } + default "25"; + description "Reassembly timeout for a specific frame-relay multi-class ingress class"; + } + + } // list class + + } // list mc-fr-profile-ingress + + list mc-fr-profile-egress { + key "mc-fr-egress-prof-index"; + max-elements 128; + description "Enter the mc-fr-profile-egress context"; + + leaf mc-fr-egress-prof-index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..65535"; + } + } + description "Egress MultiClass Frame Relay Profile Index"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + list class { + key "class-id"; + description "Enter the class context"; + + leaf class-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "0..3"; + } + } + description "Frame-relay egress class per multi-class frame-relay egress profile"; + } + + leaf mir { + type uint32 { + range "1..100"; + } + description "Minimum information rate (MIR) as percentage"; + } + + leaf max-queue-size { + type uint32 { + range "1..1000"; + } + default "10"; + description "Buffer queue size"; + } + + leaf weight { + type uint32 { + range "1..100"; + } + description "Weight of this multiclass class as a percentage"; + } + + } // list class + + } // list mc-fr-profile-egress + + list policer-control-policy { + key "policer-control-policy-name"; + max-elements 2047; + description "Enter the policer-control-policy context"; + + leaf policer-control-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of Policer Control Policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container root { + description "Enter the root context"; + + leaf max-rate { + type types-qos:max-rate; + default "max"; + description "Maximum frame based bandwidth limit of this policer"; + } + + leaf profile-preferred { + type boolean; + default "false"; + description "Provide a preference to consume PIR bucket tokens at a given priority level"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-thresh-separation { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Minimum amount of separation buffer space"; + } + + list priority { + key "priority-level"; + description "Enter the priority context"; + + leaf priority-level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Minimum amount of cumulative buffer space"; + } + + leaf fixed-mbs { + type boolean; + default "false"; + description "Consider cumulative buffer space to be fixed"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container root + + list tier { + key "tier-id"; + description "Enter the tier context"; + + leaf tier-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..2"; + } + } + description "Tier for policer control policer arbiter"; + } + + list arbiter { + key "arbiter-name"; + description "Enter the arbiter context"; + + leaf arbiter-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Arbiter name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf rate { + type types-qos:max-rate; + default "max"; + description "Maximum frame based bandwidth limit"; + } + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Specifies the arbiter to which this policer is feeding to."; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Specifies the level of priority while feeding to the parent."; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description + "Specifies the weight that needs to be used by the arbiter to which + this policer is feeding to."; + } + + } // container arbiter-parent + + } // list arbiter + + } // list tier + + } // list policer-control-policy + + container queue-group-templates { + description "Enter the queue-group-templates context"; + + container ingress { + description "Enter the ingress context"; + + list queue-group { + key "ingress-queue-group-name"; + description "Enter the queue-group context"; + + leaf ingress-queue-group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of Ingress Queue Group"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-queue-id; + } + description "Ingress Queue-Group Queue identifier"; + } + + leaf multipoint { + type boolean; + sros-ext:immutable; + default "false"; + description "Create an ingress multipoint queue"; + } + + leaf queue-type { + type types-qos:queue-group-queue-type; + sros-ext:immutable; + default "best-effort"; + description "Priority that this queue receives from the hardware level schedulers"; + } + + leaf queue-mode { + type types-qos:queue-mode; + sros-ext:immutable; + default "priority"; + description + "Specifies the mode in which the queue is operating. + + This attribute is associated with the queue at the time of creation and + cannot be modified thereafter."; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + default "auto"; + description "Reserved buffer space for the queue"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Maximum buffer space that is allowed for queue"; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..14000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy to apply with this queue"; + } + + leaf packet-byte-offset { + type types-qos:per-packet-offset; + default "0"; + description "Value of the adjustment on the size of each packet for queue accounting"; + } + + leaf cir-non-profiling { + type boolean; + default "false"; + description + "Specifies that the CIR affect the scheduling priority of a queue but + does not modify the profile of packets depending on the specified CIR."; + } + + container scheduler-parent { + description "Enter the scheduler-parent context"; + + leaf scheduler-name { + type types-sros:named-item; + description "Scheduler to which this queue feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Level of priority while feeding to the parent"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "1"; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container scheduler-parent + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Adaptation rule to apply when assigning the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + leaf fir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the operational FIR + value. The adaptation rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + } // container adaptation-rule + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:queue-pir-rate; + units "kilobps"; + default "max"; + description "CIR"; + } + + choice cir-and-fir-or-policed { + default "cir-and-fir"; + case cir-and-fir { + + leaf cir { + type types-qos:queue-cir-rate; + units "kilobps"; + default "0"; + description "Specifies administrative CIR."; + } + + leaf fir { + type types-qos:queue-cir-rate; + units "kilobps"; + default "0"; + description "Specifies administrative FIR."; + } + + } + case police { + + leaf police { + type empty; + description + "Specifies that the out of profile traffic feeding into the physical queue + instance should be dropped"; + } + + } + } + } // container rate + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Low drop-tail percent from MBS that is reduced"; + } + + } // container low + + } // container drop-tail + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id { + range "1..32"; + } + } + description "Ingress Queue-Group Policer identifier"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Exceed threshold of the CIR leaky bucket of this policer"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "High priority 'violate' threshold of PIR leaky bucket of this policer"; + } + + leaf high-prio-only { + type types-qos:burst-percent; + description "Percentage of PIR leaky bucket's MBS of this policer that is reserved for high priority traffic"; + } + + leaf packet-byte-offset { + type types-qos:per-packet-offset; + default "0"; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf profile-capped { + type boolean; + default "false"; + description "Enforce a limit on the profile"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + default "minimal"; + description "Mode of statistics collected by the policer"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy to apply with this queue"; + } + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Arbiter to which this policer feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Weight to be used by the arbiter for feeding this policer"; + } + + } // container arbiter-parent + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:policer-pir-rate; + units "kilobps"; + default "max"; + description "CIR"; + } + + leaf cir { + type types-qos:policer-cir-rate; + units "kilobps"; + default "0"; + description "CIR"; + } + + } // container rate + + } // list policer + + } // list queue-group + + } // container ingress + + container egress { + description "Enter the egress context"; + + list queue-group { + key "egress-queue-group-name"; + description "Enter the queue-group context"; + + leaf egress-queue-group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of Egress Queue Group"; + } + + leaf description { + type types-sros:description-or-empty; + description "Text description"; + } + + leaf queues-hqos-manageable { + type boolean; + default "true"; + description "Manage queues through the Hierarchical QoS process"; + } + + leaf hs-attachment-policy { + type types-sros:named-item; + description "HS attachment policy applied"; + } + + container hsmda-queues { + description "Enter the hsmda-queues context"; + + leaf low-burst-max-class { + type uint32 { + range "1..8"; + } + default "8"; + description + "Specifies which class should use the low priority burst threshold. + + Use the low priority burst threshold for all classes starting from 1, + up to and including that specified by this value. + + Use the high priority burst threshold for all classes greater than the this + value, up to and including class 8."; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Packet byte offset to use for the HSMDA egress queues"; + } + + leaf wrr-policy { + type types-sros:named-item; + description "WRR policy to use on this HSMDA egress queue"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress HSMDA queue ID"; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..1000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf mbs { + type types-qos:hsmda-queue-burst-size; + units "bytes"; + description "Buffer space allowed for the queue"; + } + + leaf rate { + type types-qos:hsmda-queue-pir-rate; + default "max"; + description "PIR rate"; + } + + leaf slope-policy { + type types-sros:named-item; + description "Name of the slope policy which overrides the default policy for the named buffer pool"; + } + + leaf wrr-weight { + type types-qos:hsmda-wrr-weight; + default "1"; + description "Weight value for the HSMDA queue"; + } + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + } // list queue + + } // container hsmda-queues + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name"; + } + + container queue { + description "Enter the queue context"; + + choice queue-or-none { + default "none"; + case queue-id { + + leaf queue-id { + type types-qos:egress-queue-id; + description "Queue defined in forwarding class mapping"; + } + + } + case none { + + leaf none { + type empty; + description "No mid-pool is associated with this parent-pool"; + } + + } + } + } // container queue + + } // list fc + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress Queue-Group queue identifier"; + } + + leaf queue-type { + type enumeration { + enum "expedited" { value 1; } + enum "best-effort" { value 3; } + } + default "best-effort"; + description "Priority that this queue receives from the hardware level schedulers"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy"; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..14000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf cbs { + type union { + type int32 { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + default "auto"; + description "Reserved buffer space for the queue"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Buffer space allowed for the queue"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Packet byte offset for addition of policing information"; + } + + leaf dynamic-mbs { + type boolean; + default "false"; + description "Allow modifying of the MBS size for a queue to maintain maximum latency for traffic"; + } + + leaf queue-delay { + type uint32 { + range "1..5000"; + } + units "milliseconds"; + description "Target queue delay for forwarding packets through this queue"; + } + + leaf hs-alt-port-class-pool { + type boolean; + default "false"; + description "Use HS alternate class port pool buffer for traffic"; + } + + leaf hs-wrr-weight { + type types-qos:hs-wrr-weight; + default "1"; + description "Weighted Round Robin (WRR) weight to parent with this queue into the scheduler"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight; + default "1"; + description "Scheduling class weight"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:queue-pir-rate; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:queue-cir-rate; + units "kilobps"; + default "0"; + description "Administrative CIR"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Administrative CIR percent"; + } + + } // container percent-rate + + } + } + choice parent-mapping { + case scheduler-parent { + + container scheduler-parent { + presence "Specifies whether this queue is parented by scheduler."; + description "Enter the scheduler-parent context"; + + leaf scheduler-name { + type types-sros:named-item; + mandatory true; + description "Scheduler to which this queue feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Level of priority while feeding to the parent"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "1"; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container scheduler-parent + + } + case port-parent { + + container port-parent { + presence "Specifies whether this queue is parented by port-level scheduler."; + description "Enter the port-parent context"; + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "0"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + } // container port-parent + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container wred-queue { + description "Enter the wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Slope policy name"; + } + + leaf mode { + type types-qos:wred-queue-mode; + description "Generic pool association of the queue to allow queue-specific WRED slopes"; + } + + leaf usage { + type types-qos:wred-queue-slope-usage; + description "Specifies which slopes are active for given slope-mode"; + } + + } // container wred-queue + + container drop-tail { + description "Enter the drop-tail context"; + + container highplus { + description "Enter the highplus context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Percentage of drop-tail being that is reduced from MBS for high plus profile packets"; + } + + } // container highplus + + container high { + description "Enter the high context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Percentage of drop-tail being that is reduced from MBS for high profile packets"; + } + + } // container high + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Low drop-tail percent from MBS that is reduced"; + } + + } // container low + + container exceed { + description "Enter the exceed context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Percentage of drop-tail that is reduced from MBS for exceed profile packets"; + } + + } // container exceed + + } // container drop-tail + + container hs-wred-queue { + description "Enter the hs-wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Slope policy name"; + } + + } // container hs-wred-queue + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-policer-id; + } + description "Egress Queue-Group Policer identifier"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Exceed threshold of the CIR leaky bucket of this policer"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "High priority 'violate' threshold of PIR leaky bucket of this policer"; + } + + leaf high-prio-only { + type types-qos:burst-percent; + description "Percentage of PIR leaky bucket's MBS of this policer that is reserved for high priority traffic"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf profile-capped { + type boolean; + default "false"; + description "Enforce a limit on the profile"; + } + + leaf stat-mode { + type types-qos:egress-policer-stat-mode; + default "minimal"; + description "Mode of statistics collected by the policer"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy to apply with this queue"; + } + + leaf exceed-pir { + type boolean; + default "false"; + description "Allow forwarding of packets with an exceed-profile state and traffic exceeding the PIR"; + } + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Arbiter to which this policer feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Weight to be used by the arbiter for feeding this policer"; + } + + } // container arbiter-parent + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:policer-pir-rate; + units "kilobps"; + default "max"; + description "CIR"; + } + + leaf cir { + type types-qos:policer-cir-rate; + units "kilobps"; + default "0"; + description "CIR"; + } + + } // container rate + + } // list policer + + list hs-wrr-group { + key "group-id"; + description "Enter the hs-wrr-group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hs-wrr-group-id; + } + description "HS WRR group identifier"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight; + default "1"; + description "Weight of scheduling class"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + leaf rate { + type union { + type uint32 { + range "1..2000000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + } + case percent-rate { + + leaf percent-rate { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + } // list hs-wrr-group + + } // list queue-group + + } // container egress + + } // container queue-group-templates + + list network { + key "network-policy-name"; + max-elements 255; + description "Enter the network context"; + + leaf network-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:network-policy-name; + } + description "Name of this network QoS policy"; + } + + leaf policy-id { + type types-qos:qos-policy-id; + sros-ext:immutable; + description "Network QoS policy identifier."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy"; + } + + container ingress { + description "Enter the ingress context"; + + leaf ler-use-dscp { + type boolean; + default "false"; + description "Honor the DSCP markings instead of the LSP-EXP bits"; + } + + container default-action { + description "Enter the default-action context"; + + leaf fc { + type types-sros:fc-name; + default "be"; + description "Default forwarding class to use while classifying the ingress traffic"; + } + + leaf profile { + type types-qos:profile; + default "out"; + description "Default profile for the ingressing traffic"; + } + + } // container default-action + + list dot1p { + key "dot1p-value"; + description "Enter the dot1p context"; + + leaf dot1p-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dot1p-priority; + } + description "Dot1p value to match in the packet"; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Forwarding class"; + } + + leaf profile { + type types-qos:profile-de; + mandatory true; + description "Default profile to be used for the ingressing traffic"; + } + + } // list dot1p + + list dscp { + key "dscp-name"; + description "Enter the dscp context"; + + leaf dscp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dscp-name; + } + description + "Specifies the Differentiated Services Code Point (DSCP) name for + which mapping is done."; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Forwarding class"; + } + + leaf profile { + type types-qos:profile; + mandatory true; + description "Default profile to use for the ingressing traffic"; + } + + } // list dscp + + list lsp-exp { + key "lsp-exp-value"; + description "Enter the lsp-exp context"; + + leaf lsp-exp-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:lsp-exp-value; + } + description "Value to assign the unique MPLS LSP EXP value that will match the lsp-exp rule"; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Forwarding class"; + } + + leaf profile { + type types-qos:profile; + mandatory true; + description "Default profile to use for the ingressing traffic"; + } + + } // list lsp-exp + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name"; + } + + container fp-redirect-group { + description "Enter the fp-redirect-group context"; + + leaf multicast-policer { + type types-qos:network-ingress-policer-id; + description "Policer to be used for multicast traffic"; + } + + leaf policer { + type types-qos:network-ingress-policer-id; + description "Policer to be used for unicast traffic"; + } + + leaf broadcast-policer { + type types-qos:network-ingress-policer-id; + description "Policer to be used for broadcast traffic"; + } + + leaf unknown-policer { + type types-qos:network-ingress-policer-id; + description "Plicer to be used for unknown traffic"; + } + + } // container fp-redirect-group + + } // list fc + + container ip-criteria { + description "Enter the ip-criteria context"; + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "Network Ingress IP Criteria Entry Index"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf protocol { + type types-sros:ipv4-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet."; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + } + description + "Matches when the packet is a fragment (true) or when the packet is not + a fragment (false) or matches all packets fragmented or not (off)"; + } + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet"; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address to match with source IP of the packet"; + } + + } + case ip-prefix-list { + + leaf ip-prefix-list { + type types-sros:named-item; + description "Specifies ip-prefix-list used as match criterion."; + } + + } + } + } // container dst-ip + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address to match with source IP of the packet"; + } + + } + case ip-prefix-list { + + leaf ip-prefix-list { + type types-sros:named-item; + description "Specifies ip-prefix-list used as match criterion."; + } + + } + } + } // container src-ip + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Specifies the less than value as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Specifies the equal than value as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Specifies the greater than value as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Specifies the less than value as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Specifies the equal than value as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Specifies the greater than value as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:profile; + description "Default profile for the matching traffic"; + } + + } // container action + + } // list entry + + } // container ip-criteria + + container ipv6-criteria { + description "Enter the ipv6-criteria context"; + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "Network Ingress IPv6 Criteria Entry Index"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf next-header { + type types-sros:ipv6-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + enum "first-only" { value 4; } + enum "non-first-only" { value 5; } + } + description + "Matches when the packet is a fragment (true) or when the packet is not + a fragment (false) or matches all packets fragmented or not (off)"; + } + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet"; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address to match with source IP of the packet"; + } + + } + case ipv6-prefix-list { + + leaf ipv6-prefix-list { + type types-sros:named-item; + description + "Specifies the ip-prefix-list used as match criterion for the + ip address."; + } + + } + } + } // container dst-ip + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address to match with source IP of the packet"; + } + + } + case ipv6-prefix-list { + + leaf ipv6-prefix-list { + type types-sros:named-item; + description + "Specifies the ip-prefix-list used as match criterion for the + ip address."; + } + + } + } + } // container src-ip + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Specifies the less than value as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Specifies the equal than value as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Specifies the greater than value as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Specifies the less than value as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Specifies the equal than value as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Specifies the greater than value as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:profile; + description "Default profile for the matching traffic"; + } + + } // container action + + } // list entry + + } // container ipv6-criteria + + } // container ingress + + container egress { + description "Enter the egress context"; + + container remark-trusted { + presence "Specifies if the system will remark the egress packets or not."; + description "Enter the remark-trusted context"; + + leaf force-egress-marking { + type boolean; + default "false"; + description "Remark DSCP bits in the internal IP header"; + } + + } // container remark-trusted + + list dscp { + key "dscp-name"; + description "Enter the dscp context"; + + leaf dscp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dscp-name; + } + description + "Specifies the Differentiated Services Code Point (DSCP) name for + which mapping is done."; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + mandatory true; + description "Default profile to use for the ingressing traffic"; + } + + } // list dscp + + list prec { + key "prec-value"; + description "Enter the prec context"; + + leaf prec-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:precedence-value; + } + description "Precedence value for which mapping is performed"; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + mandatory true; + description "Default profile to use for the ingressing traffic"; + } + + } // list prec + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name"; + } + + leaf dot1p-in-profile { + type types-qos:dot1p-priority; + description "Dot1p marking for in-profile marking"; + } + + leaf dot1p-out-profile { + type types-qos:dot1p-priority; + description "Dot1p marking for out-of-profile marking"; + } + + leaf dscp-in-profile { + type types-qos:network-egress-dscp-name; + default "be"; + description "DSCP marking for in-profile marking"; + } + + leaf dscp-out-profile { + type types-qos:network-egress-dscp-name; + default "be"; + description "DSCP marking for out-of-profile marking"; + } + + leaf lsp-exp-in-profile { + type types-qos:lsp-exp-value; + description "LSP-EXP marking for in-profile marking"; + } + + leaf lsp-exp-out-profile { + type types-qos:lsp-exp-value; + description "LSP-EXP marking for out-of-profile marking"; + } + + container de-mark { + presence "Specifies whether to set DE value in the frames."; + description "Enter the de-mark context"; + + leaf force { + type types-qos:de-value; + description "DE value"; + } + + } // container de-mark + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf queue { + type types-qos:egress-queue-id; + description "Queue to be used"; + } + + leaf policer { + type types-qos:egress-policer-id; + description "Policer to be used"; + } + + } // container port-redirect-group + + } // list fc + + container ip-criteria { + description "Enter the ip-criteria context"; + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "Network Egress IP Criteria Entry Index."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf protocol { + type types-sros:ipv4-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + } + description + "Matches when the packet is a fragment (true) or when the packet is not + a fragment (false) or matches all packets fragmented or not (off)."; + } + + leaf icmp-type { + type types-filter:ipv4-match-icmp-types; + description "ICMP type to match."; + } + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet."; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address to match with source IP of the packet."; + } + + } + } + } // container dst-ip + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet."; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address to match with source IP of the packet."; + } + + } + } + } // container src-ip + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + description "Specifies the default profile to be used for the matching traffic."; + } + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf queue { + type types-qos:egress-queue-id; + description "Specifies the queue to use once the matched traffic has been policed."; + } + + leaf policer { + type types-qos:network-egress-policer-id; + description "Specifies the policer identifier to be used for the matched traffic."; + } + + } // container port-redirect-group + + } // container action + + } // list entry + + } // container ip-criteria + + container ipv6-criteria { + description "Enter the ipv6-criteria context"; + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:entry-id; + } + description "Network Egress IPv6 Criteria Entry Index."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf next-header { + type types-sros:ipv6-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + enum "first-only" { value 4; } + enum "non-first-only" { value 5; } + } + description + "Matches when the packet is a fragment (true) or when the packet is not + a fragment (false) or matches all packets fragmented or not (off)."; + } + + leaf icmp-type { + type types-filter:ipv6-match-icmp-types; + description "ICMP type to match."; + } + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet."; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address to match with source IP of the packet."; + } + + } + } + } // container dst-ip + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet."; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address to match with source IP of the packet."; + } + + } + } + } // container src-ip + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' assigned as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' assigned as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' assigned as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + description "Specifies the default profile to be used for the matching traffic."; + } + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf queue { + type types-qos:egress-queue-id; + description "Specifies the queue to use once the matched traffic has been policed."; + } + + leaf policer { + type types-qos:network-egress-policer-id; + description "Specifies the policer identifier to be used for the matched traffic."; + } + + } // container port-redirect-group + + } // container action + + } // list entry + + } // container ipv6-criteria + + } // container egress + + } // list network + + list port-qos-policy { + key "port-qos-policy-name"; + description "Port QoS Policy Configurations."; + + leaf port-qos-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "The name of this Port QoS policy."; + } + + leaf description { + type types-sros:description; + description "Description for this port-qos policy."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy."; + } + + list fc { + key "fc-name"; + description "Port QoS Policy Forwarding Class (FC) Mappings."; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Specifies the forwarding class."; + } + + leaf queue { + type types-qos:egress-queue-id; + description "Specifies the queue to forward the traffic."; + } + + } // list fc + + list queue { + key "queue-id"; + description "Queue Configurations."; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "The port qos policy queue identifier."; + } + + leaf queue-mgmt { + type types-qos:qos-policy-name; + description + "Queue Management determines the queue management policy + attached to this queue."; + } + + leaf wrr-weights { + type uint32 { + range "1..8"; + } + description + "The unicast-multicast Weighted Round Robin(WRR) profile associated + with this queue"; + } + + container adaptation-rule { + description "Specifies PIR and CIR adaptation rules."; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing + the operational PIR value. The adaptation + rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the + operational CIR value. The adaptation rule + specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + } // container adaptation-rule + + container scheduler-mode { + description "Specifies Scheduler Mode of this queue."; + + choice wfq-or-strict-priority { + default "wfq"; + case wfq { + + container wfq { + description "Specifies Wfq of this queue."; + + leaf pir-weight { + type uint32 { + range "1..255"; + } + default "1"; + description + "Specifies the weight that needs to be + used by the arbiter to which this + queue would be feeding to."; + } + + container percent-rate { + description "Specifies PIR and CIR Percent Rate."; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Specifies the administrative PIR percent."; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Specifies the administrative CIR percent."; + } + + } // container percent-rate + + } // container wfq + + } + } + } // container scheduler-mode + + } // list queue + + list wrr-weights { + key "wrr-weights-id"; + description "Wrr Weights Configurations."; + + leaf wrr-weights-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "The port qos policy wrr weights identifier."; + } + + leaf mc-weight { + type types-qos:port-qos-policy-wrr-weight; + default "1"; + description + "The weight to be used by the multicast queue that feeds + into this WRR scheduler."; + } + + leaf uc-weight { + type types-qos:port-qos-policy-wrr-weight; + default "1"; + description + "The weight to be used by the unicast queue that feeds + into this WRR scheduler."; + } + + } // list wrr-weights + + } // list port-qos-policy + + list vlan-qos-policy { + key "vlan-qos-policy-name"; + description "Vlan QoS Policy Configurations."; + + leaf vlan-qos-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "The name of this Vlan QoS policy."; + } + + leaf description { + type types-sros:description; + description "Description for this vlan-qos policy."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy."; + } + + list cir-weight-profile { + key "cir-weight-profile-id"; + description "CIR Weight Profile Configurations."; + + leaf cir-weight-profile-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..2"; + } + } + description "The vlan qos policy cir weight profile identifier."; + } + + leaf weight { + type uint32 { + range "1..1024"; + } + default "1"; + description + "The weight that needs to be used until the + committed rate by the vlan policy to which this queue + would be feeding to."; + } + + } // list cir-weight-profile + + list fc { + key "fc-name"; + description "Vlan QoS Policy Forwarding Class (FC) Mappings."; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Specifies the forwarding class."; + } + + leaf queue { + type types-qos:egress-queue-id; + description "Specifies the queue to forward the traffic."; + } + + } // list fc + + list queue { + key "queue-id"; + description "Queue Configurations."; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "The vlan qos policy queue identifier."; + } + + leaf queue-mgmt { + type types-qos:qos-policy-name; + description + "Queue Management determines the queue management policy + attached to this queue."; + } + + container adaptation-rule { + description "Specifies PIR and CIR adaptation rules."; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing + the operational PIR value. The adaptation + rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the + operational CIR value. The adaptation rule + specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + } // container adaptation-rule + + container queue-type { + description "Specifies Queue Type of this queue."; + + choice best-effort-hi-low { + default "best-effort"; + case best-effort { + + container best-effort { + description "Indicates that the queue is non-expedited."; + + leaf cir-weight-profile { + type uint32 { + range "1..2"; + } + default "1"; + description + "Specifies the weight profile identifier of + vlan-qos policy that needs to be used by the + arbiter to which this + queue would be feeding to."; + } + + container percent-rate { + description "Specifies PIR and CIR Percent Rate."; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Specifies the administrative PIR percent."; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Specifies the administrative CIR percent."; + } + + } // container percent-rate + + } // container best-effort + + } + case expedite-hi { + + container expedite-hi { + description + "Indicates that the queue will be expedited at the + highest level until it reaches its committed rate."; + + container percent-rate { + description "Specifies PIR and CIR Percent Rate."; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Specifies the administrative PIR percent."; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Specifies the administrative CIR percent."; + } + + } // container percent-rate + + } // container expedite-hi + + } + case expedite-lo { + + container expedite-lo { + description + "Indicates that the committed rate of the queue will be + expedited at a level lower than the 'expedite-hi' queues."; + + container percent-rate { + description "Specifies PIR and CIR Percent Rate."; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Specifies the administrative PIR percent."; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Specifies the administrative CIR percent."; + } + + } // container percent-rate + + } // container expedite-lo + + } + } + } // container queue-type + + } // list queue + + } // list vlan-qos-policy + + list queue-mgmt-policy { + key "queue-mgmt-policy-name"; + description "Queue Management Policy Configurations."; + + leaf queue-mgmt-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "The name of this Queue Management policy."; + } + + leaf description { + type types-sros:description; + description "Description for this queue-mgmt-policy."; + } + + leaf mbs { + type union { + type types-qos:kilobytes { + range "1..1500000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + default "6250"; + description "The amount of buffer space allowed for the queue."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy."; + } + + leaf time-average-factor { + type uint32 { + range "0..31"; + } + default "7"; + description "Time average factor of the policy."; + } + + container high-slope { + description "High Priority RED slope parameters."; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Specifies the admin state for the high priority RED slope."; + } + + leaf start-avg { + type uint32 { + range "0..100"; + } + default "70"; + description + "The percentage of the buffer utilized after which the + drop probability starts to rise above 0."; + } + + leaf max-avg { + type uint32 { + range "0..100"; + } + default "90"; + description + "The percentage of the buffer utilized after which the + drop probability is 100 percent. This implies that + all packets beyond this point will be dropped."; + } + + leaf max-prob { + type uint32 { + range "1..99"; + } + default "75"; + description + "The drop probability increases steadily from 0 at + high start-average up to high max-probability at + high max-average."; + } + + } // container high-slope + + container low-slope { + description "Low Priority RED slope parameters."; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Specifies the admin state for the low priority RED slope."; + } + + leaf start-avg { + type uint32 { + range "0..100"; + } + default "50"; + description + "The percentage of the buffer utilized after which the + drop probability starts to rise above 0."; + } + + leaf max-avg { + type uint32 { + range "0..100"; + } + default "75"; + description + "The percentage of the buffer utilized after which the + drop probability is 100 percent. This implies that all + packets beyond this point will be dropped."; + } + + leaf max-prob { + type uint32 { + range "1..99"; + } + default "75"; + description + "The drop probability increases steadily from 0 at low + start-average up to low max-probability at + low max-average."; + } + + } // container low-slope + + } // list queue-mgmt-policy + + list ingress-classification-policy { + key "ingress-classification-policy-name"; + description "Ingress classification Qos policies"; + + leaf ingress-classification-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "The name of this ingress classification QoS policy."; + } + + leaf description { + type types-sros:description; + description "Description for this ingress classifcation policy."; + } + + leaf allow-egress-dscp-exp-remarking { + type boolean; + default "false"; + description + "Specifies whether to enable remarking for DSCP and Precedence based on + the profile state of a packet being forwarded."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy."; + } + + container default-action { + description "Configuration default-action parameters."; + + leaf fc { + type types-sros:fc-name; + default "be"; + description + "Specifies the default forwarding class to be used while classifying + the ingress traffic."; + } + + leaf profile { + type types-qos:profile; + default "out"; + description "Specifies the default profile to be used for the ingressing traffic."; + } + + } // container default-action + + list dot1p { + key "dot1p-value"; + description "Ingress classification Policy Ingress 802.1 priority Mappings."; + + leaf dot1p-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dot1p-priority; + } + description "The dot1p value to match in the packet."; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Specifies the forwarding class."; + } + + leaf profile { + type types-qos:profile-de; + mandatory true; + description "Specifies the default profile to be used for the ingressing traffic."; + } + + } // list dot1p + + list dscp { + key "dscp-name"; + description "Ingress classification Policy Ingress DSCP Mappings."; + + leaf dscp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dscp-name; + } + description + "Specifies the Differentiated Services Code Point (DSCP) name for + which mapping is done."; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Specifies the forwarding class."; + } + + leaf profile { + type types-qos:profile; + mandatory true; + description "Specifies the default profile to be used for the ingressing traffic."; + } + + } // list dscp + + list lsp-exp { + key "lsp-exp-value"; + description "Ingress classification Policy Ingress LSP-EXP mappings."; + + leaf lsp-exp-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:lsp-exp-value; + } + description "The lsp-exp bit value for which mapping is done."; + } + + leaf fc { + type types-sros:fc-name; + mandatory true; + description "Specifies the forwarding class."; + } + + leaf profile { + type types-qos:profile; + mandatory true; + description "Specifies the default profile to be used for the ingressing traffic."; + } + + } // list lsp-exp + + } // list ingress-classification-policy + + list network-ingress { + key "network-ingress-policy-name"; + description "Network-Ingress QoS policies."; + + leaf network-ingress-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "The name of this network-ingress QoS policy."; + } + + leaf description { + type types-sros:description; + description "Description for this network-ingress policy."; + } + + leaf ingress-classification-policy { + type types-qos:qos-policy-name; + default "network-default"; + description "Attach ingress classification policy."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy."; + } + + list fc { + key "fc-name"; + description "Network-ingress forwarding-class to policer mappings."; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:sap-ingress-fc-name; + } + description "Forwarding class for which this mapping is performed"; + } + + leaf multicast-policer { + type types-qos:ingress-policer-id; + description + "Specifies the policer identifier to be used for the multicast traffic + in this forwarding class."; + } + + leaf policer { + type types-qos:ingress-policer-id; + description + "Specifies the policer identifier to be used for the normal traffic + in this forwarding class."; + } + + } // list fc + + list policer { + key "policer-id"; + description "Network-Ingress Policer."; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id; + } + description "SAP-ingress policer identifier"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Specifies the 'exceed' threshold of the CIR leaky bucket of this policer."; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Specifies the maximum burst size to be used in conjunction with the PIR."; + } + + leaf stat-mode { + type enumeration { + enum "no-stats" { value 0; } + enum "offered-profile-with-discards" { value 10; } + } + default "no-stats"; + description "Specifies the mode of statistics collected."; + } + + container adaptation-rule { + description "Specifies PIR and CIR adaptation rules."; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the operational PIR + value. The adaptation rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description + "The adaptation rule to be used while computing the operational CIR + value. The adaptation rule specifies the rules to compute the + operational values while maintaining minimum offset."; + } + + } // container adaptation-rule + + container rate { + description "Specifies PIR and CIR Kbps Rate."; + + leaf pir { + type union { + type uint32 { + range "1..2000000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "max"; + description "Specifies the administrative PIR."; + } + + leaf cir { + type union { + type uint32 { + range "0..2000000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "0"; + description "Specifies the administrative CIR."; + } + + } // container rate + + } // list policer + + } // list network-ingress + + list sap-egress { + key "sap-egress-policy-name"; + description "Enter the sap-egress context"; + + leaf sap-egress-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "Name of this sap-egress QoS policy"; + } + + leaf policy-id { + type types-qos:qos-policy-id; + sros-ext:immutable; + description "The sap-egress QoS policy identifier."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf ethernet-ctag { + type boolean; + default "false"; + description "Tag value for dot1p and DE (Drop-Eligible) that are used by all dot1-p entries"; + } + + leaf parent-location { + type enumeration { + enum "auto" { value 1; } + enum "sla" { value 2; } + } + default "auto"; + description "Location in which queues can find their parent scheduler in case the parent scheduler if not found"; + } + + leaf policers-hqos-manageable { + type boolean; + default "false"; + description "Manage policers through the Hierarchical QoS process"; + } + + leaf post-policer-mapping { + type types-sros:named-item; + description "Post policer mapping policy applied to this policy"; + } + + leaf hs-attachment-policy { + type types-sros:named-item; + description "HS attachment policy applied"; + } + + container subscriber-mgmt { + description "Enter the subscriber-mgmt context"; + + container pcc-rule-entry { + description "Enter the pcc-rule-entry context"; + + container range { + presence "true"; + description "Enter the range context"; + + leaf start { + type types-qos:entry-id; + mandatory true; + description + "Specifies the starting entry at which the pcc-rule ip-criteria entries that are + received from Diameter and that are shared across several hosts."; + } + + leaf end { + type types-qos:entry-id; + mandatory true; + description + "Specifies the ending entry at which the pcc-rule ip-criteria entries that are + received from Diameter and that are shared across several hosts."; + } + + } // container range + + } // container pcc-rule-entry + + container dynamic-policer { + description "Enter the dynamic-policer context"; + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Exceed threshold of the CIR leaky bucket of this policer"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "High priority 'violate' threshold of PIR leaky bucket of this policer"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf stat-mode { + type enumeration { + enum "no-stats" { value 0; } + enum "minimal" { value 1; } + enum "offered-profile-no-cir" { value 2; } + enum "offered-total-cir" { value 3; } + enum "offered-profile-cir" { value 4; } + enum "offered-limited-capped-cir" { value 5; } + enum "offered-profile-capped-cir" { value 6; } + } + default "minimal"; + description "Mode of statistics collected by the policer"; + } + + container policer-id-range { + presence "true"; + description "Enter the policer-id-range context"; + + leaf start { + type types-qos:ingress-policer-id; + mandatory true; + description + "Specifies the starting place at which dynamic policers required for the pcc-rule + ip-criteria entries that are received from Diameter and that are shared + across several hosts will be inserted."; + } + + leaf end { + type types-qos:ingress-policer-id; + mandatory true; + description + "Specifies the ending place at which dynamic policers required for the pcc-rule + ip-criteria entries that are received from Diameter and that are shared + across several hosts will be inserted."; + } + + } // container policer-id-range + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Arbiter to which this policer feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Weight to be used by the arbiter for feeding this policer"; + } + + } // container arbiter-parent + + } // container dynamic-policer + + } // container subscriber-mgmt + + container hsmda-queues { + description "Enter the hsmda-queues context"; + + leaf low-burst-max-class { + type uint32 { + range "1..8"; + } + default "8"; + description "Class that uses low priority burst threshold"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Packet byte offset to use for the HSMDA egress queues"; + } + + leaf wrr-policy { + type types-sros:named-item; + description "Weighted Round Robin (WRR) policy"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress HSMDA queue ID"; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..1000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf mbs { + type types-qos:hsmda-queue-burst-size; + units "bytes"; + description "Buffer space allowed for the queue"; + } + + leaf rate { + type types-qos:hsmda-queue-pir-rate; + default "max"; + description "PIR rate"; + } + + leaf slope-policy { + type types-sros:named-item; + description "Name of the slope policy which overrides the default policy for the named buffer pool"; + } + + leaf wrr-weight { + type types-qos:hsmda-wrr-weight; + default "1"; + description "Weight value for the HSMDA queue"; + } + + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + } // list queue + + } // container hsmda-queues + + list dot1p { + key "dot1p-value"; + description "Enter the dot1p context"; + + leaf dot1p-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dot1p-priority; + } + description "Dot1p value to match in the packet"; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile-de; + description "Default profile for the ingressing traffic"; + } + + } // list dot1p + + list dscp { + key "dscp-name"; + description "Enter the dscp context"; + + leaf dscp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:dscp-name; + } + description + "Specifies the Differentiated Services Code Point (DSCP) name for + which mapping is done."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + description "Default profile for the ingressing traffic"; + } + + leaf hsmda-counter-override { + type types-qos:egress-hsmda-counter-id; + description + "Specifies the counter to use for all the traffic that matches the specific precedence. + A value of zero implies that the default counters should be used."; + } + + } // list dscp + + list prec { + key "prec-value"; + description "Enter the prec context"; + + leaf prec-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:precedence-value; + } + description "Precedence value for which mapping is performed"; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + description "Default profile for the ingressing traffic"; + } + + leaf hsmda-counter-override { + type types-qos:egress-hsmda-counter-id; + description + "Specifies the counter to use for all the traffic that matches the specific precedence. + A value of zero implies that the default counters should be used."; + } + + } // list prec + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class"; + } + + leaf policer { + type types-qos:sap-egress-policer-id; + description "Policer to forward the traffic"; + } + + choice dscp-or-prec { + case dscp { + + container dscp { + description "Enter the dscp context"; + + leaf in-profile { + type types-qos:dscp-name; + description "DSCP name for in-profile frames"; + } + + leaf out-profile { + type types-qos:dscp-name; + description "DSCP name for out-of-profile frames"; + } + + leaf exceed-profile { + type types-qos:dscp-name; + description "DSCP name for exceed-profile frames"; + } + + } // container dscp + + } + case prec { + + container prec { + description "Enter the prec context"; + + leaf in-profile { + type types-qos:precedence-value; + description "Precedence value for in-profile frames"; + } + + leaf out-profile { + type types-qos:precedence-value; + description "Precedence value for out-of-profile frames"; + } + + leaf exceed-profile { + type types-qos:precedence-value; + description "Precedence for exceed-profile frames"; + } + + } // container prec + + } + } + choice queue-redirection-mapping { + case queue { + + leaf queue { + type types-qos:egress-queue-id; + description "Queue to forward the traffic"; + } + + } + case port-redirect-group-queue { + + container port-redirect-group-queue { + presence "port-redirect-group-queue mappings"; + description "Enter the port-redirect-group-queue context"; + + leaf queue { + type types-qos:egress-queue-id; + description "Queue to forward the traffic"; + } + + } // container port-redirect-group-queue + + } + case queue-group-queue { + + container queue-group-queue { + presence "queue-group mappings"; + description "Enter the queue-group-queue context"; + + leaf queue-group-name { + type types-sros:named-item; + mandatory true; + description "Queue group to which the traffic is forwarded"; + } + + leaf queue { + type types-qos:egress-queue-id; + description "Specifies the queue to forward the traffic."; + } + + leaf instance { + type uint32 { + range "1..65535"; + } + description "SRRP instance whose state is tracked on this IP address"; + } + + } // container queue-group-queue + + } + } + container de-mark { + presence "Specifies whether to set DE value in the frames."; + description "Enter the de-mark context"; + + leaf force { + type types-qos:de-value; + description "DE value"; + } + + } // container de-mark + + container de-mark-inner { + presence "Specifies whether to set DE value in the inner VLAN tag."; + description "Enter the de-mark-inner context"; + + leaf force { + type types-qos:de-value; + description "DE value to set in inner VLAN tag"; + } + + } // container de-mark-inner + + container de-mark-outer { + presence "Specifies whether to set DE value in the outer VLAN tag."; + description "Enter the de-mark-outer context"; + + leaf force { + type types-qos:de-value; + description "DE value to set in outer VLAN tag"; + } + + } // container de-mark-outer + + container dot1p { + description "Enter the dot1p context"; + + leaf in-profile { + type types-qos:dot1p-priority; + description "Dot1p value for in-profile frames"; + } + + leaf out-profile { + type types-qos:dot1p-priority; + description "Dot1p value for out-of-profile frames"; + } + + leaf exceed-profile { + type types-qos:dot1p-priority; + description "Dot1p value for exceed-profile frames"; + } + + } // container dot1p + + container dot1p-inner { + description "Enter the dot1p-inner context"; + + leaf in-profile { + type types-qos:dot1p-priority; + description "Inner Dot1p value for in-profile frames"; + } + + leaf out-profile { + type types-qos:dot1p-priority; + description "Inner Dot1p value for out-of-profile frames"; + } + + } // container dot1p-inner + + container dot1p-outer { + description "Enter the dot1p-outer context"; + + leaf in-profile { + type types-qos:dot1p-priority; + description "Outer Dot1p value for in-profile frames"; + } + + leaf out-profile { + type types-qos:dot1p-priority; + description "Outer Dot1p value for out-of-profile frames"; + } + + leaf exceed-profile { + type types-qos:dot1p-priority; + description "Outer Dot1p value for exceed-profile frames"; + } + + } // container dot1p-outer + + container hsmda { + description "Enter the hsmda context"; + + choice hsmda-queue-redirection-mapping { + case queue { + + leaf queue { + type types-qos:egress-queue-id; + description "HSMDA queue to which traffic is forwarded"; + } + + } + case port-redirect-group-queue { + + container port-redirect-group-queue { + presence "Sap Egress Forwarding Class (FC) hsmda-queue mappings."; + description "Enter the port-redirect-group-queue context"; + + leaf queue { + type types-qos:egress-queue-id; + mandatory true; + description "HSMDA queue to which traffic is forwarded"; + } + + } // container port-redirect-group-queue + + } + } + } // container hsmda + + } // list fc + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress Queue-Group queue identifier"; + } + + leaf queue-type { + type enumeration { + enum "expedited" { value 1; } + enum "auto-expedited" { value 2; } + enum "best-effort" { value 3; } + } + sros-ext:immutable; + default "auto-expedited"; + description "Priority that this queue receives from the hardware level schedulers"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy"; + } + + leaf avg-frame-overhead { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description + "Specifies the encapsulation overhead, in centipercent, used to + translate packet-based rate to frame-based rate and vice versa."; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..14000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + default "auto"; + description "Explicit shaping burst size of a queue"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + default "auto"; + description "Reserved buffer space for the queue"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Buffer space allowed for the queue"; + } + + leaf packet-byte-offset { + type int32 { + range "-64..32"; + } + default "0"; + description "Packet byte offset for addition of policing information"; + } + + leaf hs-alt-port-class-pool { + type boolean; + default "false"; + description "Use HS alternate class port pool buffer for traffic"; + } + + leaf hs-wrr-weight { + type types-qos:hs-wrr-weight; + default "1"; + description "Weighted Round Robin (WRR) weight to parent with this queue into the scheduler"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight; + default "1"; + description "Scheduling class weight"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:queue-pir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:queue-cir-rate-maximum; + units "kilobps"; + default "0"; + description "Administrative CIR"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Administrative CIR percent"; + } + + leaf reference-rate { + type enumeration { + enum "port-limit" { value 2; } + enum "local-limit" { value 3; } + } + default "port-limit"; + description "Reference rate as percentage"; + } + + } // container percent-rate + + } + } + choice parent-mapping { + case scheduler-parent { + + container scheduler-parent { + presence "Specifies whether this queue is parented by scheduler."; + description "Enter the scheduler-parent context"; + + leaf scheduler-name { + type types-sros:named-item; + mandatory true; + description "Scheduler to which this queue feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Level of priority while feeding to the parent"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "1"; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container scheduler-parent + + } + case port-parent { + + container port-parent { + presence "Specifies whether this queue is parented by port-level scheduler."; + description "Enter the port-parent context"; + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "0"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + } // container port-parent + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container wred-queue { + description "Enter the wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Slope policy name"; + } + + leaf mode { + type enumeration { + enum "native" { value 1; } + enum "pool-per-queue" { value 2; } + } + description "Generic pool association of the queue to allow queue-specific WRED slopes"; + } + + leaf usage { + type types-qos:wred-queue-slope-usage; + description "Specifies which slopes are active for given slope-mode"; + } + + } // container wred-queue + + container drop-tail { + description "Enter the drop-tail context"; + + container highplus { + description "Enter the highplus context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Percentage of drop-tail being that is reduced from MBS for high plus profile packets"; + } + + } // container highplus + + container high { + description "Enter the high context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Percentage of drop-tail being that is reduced from MBS for high profile packets"; + } + + } // container high + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Low drop-tail percent from MBS that is reduced"; + } + + } // container low + + container exceed { + description "Enter the exceed context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent; + description "Percentage of drop-tail that is reduced from MBS for exceed profile packets"; + } + + } // container exceed + + } // container drop-tail + + container hs-wred-queue { + description "Enter the hs-wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Slope policy name"; + } + + } // container hs-wred-queue + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:sap-egress-policer-id; + } + description "Sap-Egress Policer identifier."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf adv-config-policy { + type types-sros:named-item; + description "Name of the advanced configuration policy to apply with this queue"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "Exceed threshold of the CIR leaky bucket of this policer"; + } + + leaf dscp-prec-remarking { + type boolean; + default "false"; + description "Remark DSCP and precedence based on the profile state of a forwarding packet"; + } + + leaf exceed-pir { + type boolean; + default "false"; + description "Allow forwarding of packets with an exceed-profile state and traffic exceeding the PIR"; + } + + leaf high-prio-only { + type types-qos:burst-percent; + description "Percentage of PIR leaky bucket's MBS of this policer that is reserved for high priority traffic"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + default "auto"; + description "High priority 'violate' threshold of PIR leaky bucket of this policer"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset; + default "0"; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf profile-capped { + type boolean; + default "false"; + description "Enforce an overall in-profile burst limit to the CIR bucket at egress policer"; + } + + leaf profile-out-preserve { + type boolean; + default "false"; + description "Preserve the color of offered out-of-profile traffic at SAP-egress policer"; + } + + leaf stat-mode { + type types-qos:egress-policer-stat-mode; + default "minimal"; + description "Mode of statistics collected by the policer"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:policer-pir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:policer-cir-rate-maximum; + units "kilobps"; + default "0"; + description "Administrative CIR"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "0.00"; + description "Administrative CIR percent"; + } + + } // container percent-rate + + } + } + choice parent-mapping { + case scheduler-parent { + + container scheduler-parent { + presence "Specifies whether this queue is parented by scheduler."; + description "Enter the scheduler-parent context"; + + leaf scheduler-name { + type types-sros:named-item; + mandatory true; + description "Specifies the scheduler to which this queue would be feeding to."; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Specifies the level of priority while feeding to the parent."; + } + + leaf weight { + type types-qos:weight; + default "1"; + description + "Specifies the weight that needs to be used by the scheduler to which + this queue would be feeding to."; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description + "Specifies the level of priority while feeding to the parent. + The level '0' means treat all offered load for this queue as for + the above CIR traffic."; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "1"; + description + "The weight that needs to be used until the committed rate by the + scheduler to which this queue would be feeding to."; + } + + } // container scheduler-parent + + } + case port-parent { + + container port-parent { + presence "Specifies whether this queue is parented by port-level scheduler."; + description "Enter the port-parent context"; + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description + "Specifies the port priority this queue will use to receive bandwidth from + the port-level scheduler for its above-cir offered load."; + } + + leaf weight { + type types-qos:weight; + default "1"; + description + "Specifies the weight this queue will use to receive bandwidth from the + port-level scheduler for its above-cir offered load."; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description + "Specifies the port priority this queue will use to receive bandwidth from + the port-level scheduler for its within-cir offered load."; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "0"; + description + "Specifies the weight this queue will use to receive bandwidth from the + port-level scheduler for its within-cir offered load."; + } + + } // container port-parent + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container arbiter-parent { + description "Enter the arbiter-parent context"; + + leaf arbiter-name { + type types-sros:named-item; + description "Arbiter to which this policer feeds"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Weight to be used by the arbiter for feeding this policer"; + } + + } // container arbiter-parent + + } // list policer + + list hs-wrr-group { + key "group-id"; + description "Enter the hs-wrr-group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hs-wrr-group-id; + } + description "HS WRR group identifier"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight; + default "1"; + description "Weight of scheduling class"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + leaf rate { + type union { + type uint32 { + range "1..2000000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + } + case percent-rate { + + leaf percent-rate { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule; + default "closest"; + description "Constraint used when deriving the operational PIR value"; + } + + } // container adaptation-rule + + } // list hs-wrr-group + + container ip-criteria { + description "Enter the ip-criteria context"; + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..65535"; + } + } + description "IP Criteria Entry Index"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf protocol { + type types-sros:ipv4-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + leaf fragment { + type enumeration { + enum "false" { value 2; } + enum "true" { value 3; } + } + description "Matching criteria to be used for fragmented or non-fragmented packets"; + } + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address mask to match with source IP of the packet"; + } + + } + case ip-prefix-list { + + leaf ip-prefix-list { + type types-sros:named-item; + description "Specifies ip-prefix-list used as match criterion."; + } + + } + } + } // container src-ip + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv4-address; + type types-sros:ipv4-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv4-address; + description "IP address mask to match with source IP of the packet"; + } + + } + case ip-prefix-list { + + leaf ip-prefix-list { + type types-sros:named-item; + description "Specifies ip-prefix-list used as match criterion."; + } + + } + } + } // container dst-ip + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + description "Default profile for the matching traffic"; + } + + leaf hsmda-counter-override { + type uint32 { + range "1..8"; + } + description "HSMDA counter to use for matching packets"; + } + + leaf policer { + type types-qos:sap-egress-policer-id; + description "Policer identifier for the matched traffic"; + } + + leaf port-redirect-group-queue { + type boolean; + default "false"; + description "Use the queue specified in egress access port queue-group instance"; + } + + leaf queue { + type types-qos:egress-queue-id; + description "Queue to use when the matched traffic is policed by the local policer"; + } + + leaf use-fc-mapped-queue { + type boolean; + default "false"; + description "Redirect policer output to the configured queues"; + } + + } // container action + + } // list entry + + } // container ip-criteria + + container ipv6-criteria { + description "Enter the ipv6-criteria context"; + + list entry { + key "entry-id"; + description "Enter the entry context"; + + leaf entry-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..65535"; + } + } + description "IP Criteria Entry Index"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container match { + description "Enter the match context"; + + leaf next-header { + type types-sros:ipv6-match-protocol; + description "IP protocol to match"; + } + + leaf dscp { + type types-qos:dscp-name; + description "DSCP value to match in the packet"; + } + + container src-port { + description "Enter the src-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container src-port + + container dst-port { + description "Enter the dst-port context"; + + choice port-match-mapping { + case lt { + + leaf lt { + type int32 { + range "0..65535"; + } + description "Value 'less than' as match condition"; + } + + } + case eq { + + leaf eq { + type int32 { + range "0..65535"; + } + description "Value 'equal to' as match condition"; + } + + } + case gt { + + leaf gt { + type int32 { + range "0..65535"; + } + description "Value 'greater than' as match condition"; + } + + } + case range { + + container range { + description "Enter the range context"; + + leaf start { + type int32 { + range "0..65535"; + } + description "Start value of range"; + } + + leaf end { + type int32 { + range "0..65535"; + } + description "End value for range"; + } + + } // container range + + } + } + } // container dst-port + + container src-ip { + description "Enter the src-ip context"; + + choice src-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with source IP of the packet"; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address mask to match with source IP of the packet"; + } + + } + } + } // container src-ip + + container dst-ip { + description "Enter the dst-ip context"; + + choice dst-ip { + case address-and-mask-or-prefix { + + leaf address { + type union { + type types-sros:ipv6-address; + type types-sros:ipv6-prefix-with-host-bits; + } + description "IP address to match with destination IP of the packet"; + } + + leaf mask { + type types-sros:ipv6-address; + description "IP address mask to match with destination IP of the packet"; + } + + } + } + } // container dst-ip + + } // container match + + container action { + description "Enter the action context"; + + leaf type { + type types-qos:criteria-action-type; + default "ignore-match"; + description "Specified whether the criteria entry is active or in-active."; + } + + leaf fc { + type types-sros:fc-name; + description "Forwarding class"; + } + + leaf profile { + type types-qos:egress-profile; + description "Default profile for the matching traffic"; + } + + leaf hsmda-counter-override { + type uint32 { + range "1..8"; + } + description "HSMDA counter to use for matching packets"; + } + + leaf policer { + type types-qos:sap-egress-policer-id; + description "Policer identifier for the matched traffic"; + } + + leaf port-redirect-group-queue { + type boolean; + default "false"; + description "Use the queue specified in egress access port queue-group instance"; + } + + leaf queue { + type types-qos:egress-queue-id; + description "Queue to use when the matched traffic is policed by the local policer"; + } + + leaf use-fc-mapped-queue { + type boolean; + default "false"; + description "Redirect policer output to the configured queues"; + } + + } // container action + + } // list entry + + } // container ipv6-criteria + + } // list sap-egress + + list scheduler-policy { + key "scheduler-policy-name"; + max-elements 2047; + description "Enter the scheduler-policy context"; + + leaf scheduler-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Scheduler policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf frame-based-accounting { + type boolean; + default "false"; + description "Use frame-based accounting for schedulers and children within scheduler policy"; + } + + list tier { + key "tier-id"; + description "Enter the tier context"; + + leaf tier-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..3"; + } + } + description "Tier for scheduler-policy scheduler"; + } + + leaf parent-location { + type enumeration { + enum "auto" { value 1; } + enum "sub" { value 2; } + enum "vport" { value 3; } + } + default "auto"; + description "Location in which the tier 1 schedulers can find their parent"; + } + + list scheduler { + key "scheduler-name"; + description "Enter the scheduler context"; + + leaf scheduler-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Scheduler name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf limit-unused-bandwidth { + type boolean; + default "false"; + description "Enable aggregate rate overrun protection"; + } + + choice parent-mapping { + case scheduler-parent { + + container scheduler-parent { + presence "Specifies whether this queue is parented by scheduler."; + description "Enter the scheduler-parent context"; + + leaf scheduler-name { + type types-sros:named-item; + mandatory true; + description "Scheduler to which this queue would be feeding to"; + } + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Level of priority while feeding to the parent"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Level of priority while feeding to the parent"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "1"; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container scheduler-parent + + } + case port-parent { + + container port-parent { + presence "Specifies whether this queue is parented by port-level scheduler."; + description "Enter the port-parent context"; + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf weight { + type types-qos:weight; + default "1"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Port priority that this queue uses to receive bandwidth from the port level scheduler"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "0"; + description "Weight that this queue uses to receive bandwidth from the port level scheduler"; + } + + } // container port-parent + + } + } + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:sched-pir-rate; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:sched-cir-rate; + units "kilobps"; + default "sum"; + description "Administrative CIR"; + } + + } // container rate + + } // list scheduler + + } // list tier + + } // list scheduler-policy + + list port-scheduler-policy { + key "name"; + description "Enter the port-scheduler-policy context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of this port scheduler policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf dist-lag-rate-shared { + type boolean; + default "false"; + description "Share rates when the port is part of a LAG configured in distribute mode"; + } + + leaf monitor-threshold { + type uint32 { + range "0..100"; + } + default "0"; + description + "Specifies the threshold level that should be monitored. + It is a percentage of the max-rate or max-rate-percent"; + } + + choice max-rate-or-percent-rate { + default "max-rate"; + case max-rate { + + leaf max-rate { + type types-qos:max-rate; + default "max"; + description "Explicit maximum frame based bandwidth limit"; + } + + } + case max-percent-rate { + + leaf max-percent-rate { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Specifies the explicit maximum frame based bandwidth percentage"; + } + + } + } + container orphan-overrides { + description "Enter the orphan-overrides context"; + + leaf level { + type types-qos:hierarchy-level; + default "1"; + description "Specifies the port priority of orphaned queues and scheduler that are above-cir"; + } + + leaf weight { + type types-qos:weight; + default "0"; + description "Specifies the weight of orphaned queues and scheduler that are above-cir"; + } + + leaf cir-level { + type types-qos:cir-level; + default "0"; + description "Specifies the port priority of orphaned queues and scheduler that are within-cir"; + } + + leaf cir-weight { + type types-qos:cir-weight; + default "0"; + description "Specifies the weight of orphaned queues and scheduler that are within-cir"; + } + + } // container orphan-overrides + + list group { + key "group-name"; + description "Enter the group context"; + + leaf group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of this port scheduler policy group"; + } + + leaf monitor-threshold { + type uint32 { + range "0..100"; + } + default "0"; + description + "Specifies the threshold level that should be monitored. + It is percentage of the max-rate or max-rate-percent"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:queue-pir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:queue-cir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative CIR"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Administrative CIR percent"; + } + + } // container percent-rate + + } + } + } // list group + + list level { + key "level-id"; + description "Enter the level context"; + + leaf level-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..8"; + } + } + description "Priority level this port scheduler policy"; + } + + leaf group { + type types-sros:named-item; + description "Associated group"; + } + + leaf weight { + type types-qos:weight { + range "1..100"; + } + default "1"; + description "Specifies the weight associated with the group"; + } + + leaf monitor-threshold { + type uint32 { + range "0..100"; + } + default "0"; + description + "Specifies the threshold level that should be monitored. + It is percentage of the max-rate or max-rate-percent"; + } + + choice rate-or-percent-rate { + default "rate"; + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-qos:queue-pir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative PIR"; + } + + leaf cir { + type types-qos:queue-cir-rate-maximum; + units "kilobps"; + default "max"; + description "Administrative CIR"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + default "100.00"; + description "Administrative CIR percent"; + } + + } // container percent-rate + + } + } + } // list level + + } // list port-scheduler-policy + + list hs-scheduler-policy { + key "name"; + max-elements 127; + description "Enter the hs-scheduler-policy context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "HS scheduler policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf max-rate { + type union { + type uint32 { + range "1..100000"; + } + type enumeration { + enum "max" { value -1; } + } + } + default "max"; + description "Maximum rate for this HS scheduler policy"; + } + + list group { + key "group-id"; + description "Enter the group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1"; + } + } + description "Group ID for the HS scheduler policy"; + } + + leaf rate { + type union { + type uint32 { + range "1..100000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "megabps"; + default "max"; + description "Group maximum rate"; + } + + } // list group + + list scheduling-class { + key "class-id"; + description "Enter the scheduling-class context"; + + leaf class-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..6"; + } + } + description "Class identifier for the HS scheduler policy scheduling class"; + } + + choice rate-or-group { + default "rate"; + case rate { + + leaf rate { + type union { + type uint32 { + range "1..100000"; + } + type enumeration { + enum "max" { value -1; } + } + } + default "max"; + description "Group maximum rate"; + } + + } + case group { + + container group { + presence "Specifies the group and weight configuration."; + description "Enter the group context"; + + leaf group-id { + type int32 { + range "1"; + } + mandatory true; + description "Associated group associated with this scheduling class"; + } + + leaf weight { + type int32 { + range "1..127"; + } + default "1"; + description "Weight associated with this scheduling class"; + } + + } // container group + + } + } + } // list scheduling-class + + } // list hs-scheduler-policy + + list hs-pool-policy { + key "name"; + max-elements 63; + description "Enter the hs-pool-policy context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "HS pool policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf system-reserve { + type decimal64 { + range "1.00..30.00"; + fraction-digits 2; + } + default "5.00"; + description "Percentage of HS buffers reserved for internal system use"; + } + + container root-tier { + description "Enter the root-tier context"; + + list root-pool { + key "root-pool-id"; + description "Enter the root-pool context"; + + leaf root-pool-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..16"; + } + } + description "Root pool identifier for the HS pool policy"; + } + + leaf allocation-weight { + type uint32 { + range "0..100"; + } + default "0"; + description + "Specifies the weight that will be applied to the + first root pool and is divided by the sum of all root pool + weights to derive the pool's buffer allocation factor."; + } + + leaf slope-policy { + type types-sros:named-item; + description "Specifies the slope policy associated with this pool policy."; + } + + } // list root-pool + + } // container root-tier + + container mid-tier { + description "Enter the mid-tier context"; + + list mid-pool { + key "mid-pool-id"; + description "Enter the mid-pool context"; + + leaf mid-pool-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..16"; + } + } + description "Mid-pool identifier for the HS pool policy"; + } + + leaf allocation-percent { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + default "1.00"; + description + "Specifies the percentage of the root-pool with which it is associated, + as specified by root-parent will be available to this mid-pool."; + } + + leaf slope-policy { + type types-sros:named-item; + description "Specifies the slope policy associated with this pool policy."; + } + + leaf port-bw-oversubscription-factor { + type uint32 { + range "1..10"; + } + default "1"; + description "Specifies the factor by which port bandwidth can be over subscribed."; + } + + container parent-root-pool { + description "Enter the parent-root-pool context"; + + choice map-pool { + default "pool-id"; + case pool-id { + + leaf pool-id { + type uint32 { + range "1..16"; + } + description "Specifies the parent root to which this mid-pool is associated."; + } + + } + case none { + + leaf none { + type empty; + description "Specifies none mid-pool is associated with this parent-pool."; + } + + } + } + } // container parent-root-pool + + } // list mid-pool + + } // container mid-tier + + } // list hs-pool-policy + + list hs-port-pool-policy { + key "name"; + max-elements 2047; + description "Enter the hs-port-pool-policy context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name for HS port pool policy"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + container std-port-class-pools { + description "Enter the std-port-class-pools context"; + + list class-pool { + key "std-class-pool-id"; + description "Enter the class-pool context"; + + leaf std-class-pool-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..6"; + } + } + description "Standard port class identifier for the HS port pool policy"; + } + + leaf slope-policy { + type types-sros:named-item; + description "Specifies the slope policy associated with this pool policy."; + } + + container parent-mid-pool { + description "Enter the parent-mid-pool context"; + + choice map-pool { + default "pool-id"; + case pool-id { + + leaf pool-id { + type uint32 { + range "1..16"; + } + description "Specifies the mid-pool parent."; + } + + } + case none { + + leaf none { + type empty; + description "Specifies none mid-pool is associated with this parent-pool."; + } + + } + } + } // container parent-mid-pool + + container allocation { + description "Enter the allocation context"; + + choice port-weight-or-percent { + default "port-bw-weight"; + case port-bw-weight { + + leaf port-bw-weight { + type uint32 { + range "1..100"; + } + default "1"; + description "Specifies the port share weight."; + } + + } + case explicit-percent { + + leaf explicit-percent { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Specifies the percentage of parent pool to be allocated."; + } + + } + } + } // container allocation + + } // list class-pool + + } // container std-port-class-pools + + container alt-port-class-pools { + description "Enter the alt-port-class-pools context"; + + list class-pool { + key "alt-class-pool-id"; + description "Enter the class-pool context"; + + leaf alt-class-pool-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..6"; + } + } + description "The alt-port-class-pool identifier for the HS port pool policy."; + } + + leaf slope-policy { + type types-sros:named-item; + description "Specifies the slope policy associated with this pool policy."; + } + + container parent-mid-pool { + description "Enter the parent-mid-pool context"; + + choice map-pool { + default "none"; + case pool-id { + + leaf pool-id { + type uint32 { + range "1..16"; + } + description "Specifies the mid-pool parent."; + } + + } + case none { + + leaf none { + type empty; + description "Specifies none mid-pool is associated with this parent-pool."; + } + + } + } + } // container parent-mid-pool + + container allocation { + description "Enter the allocation context"; + + choice port-weight-or-percent { + default "port-bw-weight"; + case port-bw-weight { + + leaf port-bw-weight { + type uint32 { + range "1..100"; + } + default "1"; + description "Specifies the port share weight."; + } + + } + case explicit-percent { + + leaf explicit-percent { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Specifies the percentage of parent pool to be allocated."; + } + + } + } + } // container allocation + + } // list class-pool + + } // container alt-port-class-pools + + } // list hs-port-pool-policy + + list hs-attachment-policy { + key "name"; + max-elements 31; + description "Enter the hs-attachment-policy context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "HS attachment policy name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf low-burst-max-class { + type uint32 { + range "1..6"; + } + default "6"; + description "Low priority burst threshold"; + } + + list wrr-group { + key "wrr-group-id"; + description "Enter the wrr-group context"; + + leaf wrr-group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..2"; + } + } + description "WRR group ID for the HS attachment policy"; + } + + choice wrr-group-mapping { + default "unattached"; + case sched-class-id { + + leaf sched-class { + type int32 { + range "1..6"; + } + description "Specifies scheduling class associated with this WRR group."; + } + + } + case unattached { + + leaf unattached { + type empty; + description + "Specifies the mapping type associated with this WRR group is + unattached."; + } + + } + } + } // list wrr-group + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..8"; + } + } + description "Queue identifier for the HS attachment policy"; + } + + choice hs-attach-queue-mapping { + default "unattached"; + case sched-class-id { + + leaf sched-class { + type int32 { + range "1..6"; + } + description "Specifies scheduling class associated with this queue."; + } + + } + case wrr-group-id { + + leaf wrr-group { + type int32 { + range "1..2"; + } + description "Specifies wrr group associated with this queue."; + } + + } + case unattached { + + leaf unattached { + type empty; + description + "Specifies the mapping type associated with this WRR group is + unattached."; + } + + } + } + } // list queue + + } // list hs-attachment-policy + + list post-policer-mapping { + key "name"; + max-elements 7; + description "Enter the post-policer-mapping context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of post policer mapping policy."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + list fc { + key "fc-name profile"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Name of forwarding class to be remapped"; + } + + leaf profile { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-profile; + } + description "Packet Profile that needs to be remapped."; + } + + container maps-to { + description "Enter the maps-to context"; + + leaf fc { + type types-sros:fc-name; + description "Name of forwarding class to be remapped"; + } + + leaf profile { + type types-qos:egress-profile; + description "Packet Profile that needs to be remapped."; + } + + } // container maps-to + + } // list fc + + } // list post-policer-mapping + + list queue-group-redirect-list { + key "name"; + max-elements 2047; + description "Enter the queue-group-redirect-list context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of queue-group redirect list."; + } + + leaf type { + type enumeration { + enum "vxlan-vni" { value 1; } + } + default "vxlan-vni"; + description "Type for queue-group redirect list"; + } + + list match { + key "field-value"; + max-elements 16; + description "Enter the match context"; + + leaf field-value { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..16777215"; + } + } + description + "Specifies the value of the field in the ingress or egress + packet which, when matched, will redirect the packet to the + queue-group instance"; + } + + leaf instance { + type uint32 { + range "1..65535"; + } + mandatory true; + description "Specifies the queue-group instance to which packet will be forwarded."; + } + + } // list match + + } // list queue-group-redirect-list + + list egress-remark-policy { + key "egress-remark-policy-name"; + description "Egress-remark QoS policies."; + + leaf egress-remark-policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:qos-policy-name; + } + description "The name of this egress-remark-policy QoS policy."; + } + + leaf description { + type types-sros:description; + description "The description of this egress-remark QoS policy."; + } + + leaf scope { + type types-qos:item-scope; + default "template"; + description "Scope of the policy."; + } + + list fc { + key "fc-name"; + description "Egress Remark Policy Forwarding Class (FC) Mappings."; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Specifies the forwarding class."; + } + + container de-mark { + presence "Specifies whether to set DE of the frames."; + description "Configure DE Value for Marking."; + + leaf force { + type types-qos:de-value; + description "Specifies the DE value to set."; + } + + } // container de-mark + + container dot1p { + description "Specifies Dot1p Markings."; + + leaf in-profile { + type types-qos:dot1p-priority; + description "Specifies Dot1p value for in-profile frames."; + } + + leaf out-profile { + type types-qos:dot1p-priority; + description "Specifies Dot1p value for out-of-profile frames."; + } + + } // container dot1p + + container dscp { + description "Configures DSCP Markings."; + + leaf in-profile { + type types-qos:dscp-name; + description "Specifies DSCP name for in-profile frames."; + } + + leaf out-profile { + type types-qos:dscp-name; + description "Specifies DSCP value for out-of-profile frames."; + } + + } // container dscp + + container lsp-exp { + description "Specifies details of LSP-EXP."; + + leaf in-profile { + type types-qos:lsp-exp-value; + description "Specifies LSP-EXP marking for in-profile frames."; + } + + leaf out-profile { + type types-qos:lsp-exp-value; + description "Specifies LSP-EXP value for out-of-profile frames."; + } + + } // container lsp-exp + + } // list fc + + } // list egress-remark-policy + + container match-list { + description "Enter the match-list context"; + + list ip-prefix-list { + key "prefix-list-name"; + max-elements 512; + description "Enter the ip-prefix-list context"; + + leaf prefix-list-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Specifies the name given to this prefix list."; + } + + leaf description { + type types-sros:description; + description "The description of ip-prefix-list."; + } + + list prefix { + key "ip-prefix"; + max-elements 256; + description "Enter the prefix context"; + + leaf ip-prefix { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-prefix; + } + description "Specifies the IPv4 prefix for this prefix list."; + } + + } // list prefix + + } // list ip-prefix-list + + list ipv6-prefix-list { + key "prefix-list-name"; + max-elements 128; + description "Enter the ipv6-prefix-list context"; + + leaf prefix-list-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Specifies the name given to this prefix list."; + } + + leaf description { + type types-sros:description; + description "The description of ipv6-prefix-list."; + } + + list prefix { + key "ipv6-prefix"; + max-elements 128; + description "Enter the prefix context"; + + leaf ipv6-prefix { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-prefix; + } + description "Specifies the IPv6 prefix for this prefix list."; + } + + } // list prefix + + } // list ipv6-prefix-list + + } // container match-list + + } // container qos + + list router { + key "router-name"; + max-elements 3; + description "Enter the router context"; + + leaf router-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64 { + pattern ".{1,32}" { + error-message "vRtrName needs to be extended to 64 to support this name"; + } + } + } + description + "The administrative name for this virtual router. + + The router name must be unique among all virtual routers in the system."; + } + + container aggregates { + description "Enter the aggregates context"; + + list aggregate { + key "ip-prefix"; + description "Enter the aggregate context"; + + leaf ip-prefix { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-unicast-prefix; + } + description "IP address prefix to match for aggregation"; + } + + leaf as-set { + type boolean; + default "false"; + description "Allow aggregate route as an AS-SET option"; + } + + leaf-list community { + type types-sros:community; + max-elements 12; + ordered-by user; + description "Community name that is added to aggregate route"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf summary-only { + type boolean; + default "false"; + description "Advertise only the aggregate route and not the specific routes that make up the aggregate"; + } + + leaf local-preference { + type int64 { + range "0..4294967295"; + } + description "Default local preference if aggregate route is exported and advertised to BGP peers"; + } + + choice next-hop { + case blackhole { + + container blackhole { + presence "blackhole"; + description "Enter the blackhole context"; + + leaf generate-icmp { + type boolean; + default "false"; + description "Send ICMP unreachable messages when packets match an aggregate route with black-hole next-hop"; + } + + } // container blackhole + + } + case indirect { + + leaf indirect { + type types-sros:ip-unicast-address; + sros-ext:immutable; + description "Address of indirect next hop"; + } + + } + } + container aggregator { + description "Enter the aggregator context"; + + leaf as-number { + type uint32 { + range "1..max"; + } + description "Aggregator Autonomous System Number (ASN)"; + } + + leaf address { + type types-sros:ipv4-unicast-address; + description "Aggregator IP address"; + } + + } // container aggregator + + } // list aggregate + + } // container aggregates + + list interface { + key "interface-name"; + description "Enter the interface context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Router interface name"; + } + + container qos { + description "Enter the qos context"; + + leaf network-policy { + type types-qos:network-policy-name; + description "Pre-existing network policy ID associated with a network interface"; + } + + leaf egress-port-redirect-group { + type types-sros:named-item; + description "QoS queue group name"; + } + + leaf egress-instance { + type types-services:qos-qgrp-instance-id; + description "Instance of the port egress queue group for this interface"; + } + + leaf ingress-fp-redirect-group { + type types-sros:named-item; + description "Forwarding-plane queue group policy for this interface"; + } + + leaf ingress-instance { + type types-services:qos-qgrp-instance-id; + description "Instance of the forwarding-plane ingress queue group for this interface"; + } + + } // container qos + + } // list interface + + container tunnel-interface { + description "Enter the tunnel-interface context"; + + } // container tunnel-interface + + container bgp { + presence "Enables bgp functionality on this router"; + description "Enter the bgp context"; + + list group { + key "group-name"; + description "Enter the group context"; + + leaf group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "BGP peer group"; + } + + list prefix-limit { + key "family"; + description "Enter the prefix-limit context"; + + leaf family { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-bgp:ip-family-identifier; + } + description "Address family to which the limit applies"; + } + + leaf maximum { + type uint32 { + range "1..4294967295"; + } + mandatory true; + description "Specifies the maximum number of routes that can be learned from this peer."; + } + + leaf log-only { + type boolean; + default "false"; + description "Send warning message if specified threshold or limit is reached, without disabling BGP peer session"; + } + + leaf threshold { + type uint32 { + range "1..100"; + } + default "90"; + description "Threshold value that triggers a warning message"; + } + + leaf idle-timeout { + type int32 { + range "1..1024"; + } + description "Time that BGP peering remains idle before reconnecting to peers"; + } + + leaf post-import { + type boolean; + default "false"; + description "Apply prefix limit only to number of routes accepted by import policies"; + } + + } // list prefix-limit + + } // list group + + list neighbor { + key "ip-address"; + description "Enter the neighbor context"; + + leaf ip-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-address-with-zone; + } + description "BGP group neighbor"; + } + + list prefix-limit { + key "family"; + description "Enter the prefix-limit context"; + + leaf family { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-bgp:ip-family-identifier; + } + description "Address family to which the limit applies"; + } + + leaf maximum { + type uint32 { + range "1..4294967295"; + } + mandatory true; + description "Specifies the maximum number of routes that can be learned from this peer."; + } + + leaf log-only { + type boolean; + default "false"; + description "Send warning message if specified threshold or limit is reached, without disabling BGP peer session"; + } + + leaf threshold { + type uint32 { + range "1..100"; + } + default "90"; + description "Threshold value that triggers a warning message"; + } + + leaf idle-timeout { + type int32 { + range "1..1024"; + } + description "Time that BGP peering remains idle before reconnecting to peers"; + } + + leaf post-import { + type boolean; + default "false"; + description "Apply prefix limit only to number of routes accepted by import policies"; + } + + } // list prefix-limit + + } // list neighbor + + } // container bgp + + list isis { + key "isis-instance"; + description "Enter the isis context"; + + leaf isis-instance { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "0..31"; + } + } + description "Instance ID for IS-IS instance"; + } + + leaf authentication-keychain { + type types-sros:named-item; + description "The keychain used to sign and/or authenticate."; + } + + leaf authentication-key { + type types-sros:encrypted-leaf { + length "1..366"; + } + description "Authentication key to verify PDUs sent by neighboring routers"; + } + + leaf authentication-type { + type types-isis:auth-type; + description "Authentication type"; + } + + leaf csnp-authentication { + type boolean; + default "true"; + description "Authenticate individual IS-IS protocol packets of complete sequence number PDU (CSNP) type"; + } + + leaf psnp-authentication { + type boolean; + default "true"; + description "Authenticate individual IS-IS protocol packets of partial sequence number PDU (PSNP) type"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of IS-IS instance"; + } + + leaf advertise-passive-only { + type boolean; + default "false"; + description "Advertise only prefixes that belong to passive interfaces"; + } + + leaf advertise-router-capability { + type enumeration { + enum "area" { value 2; } + enum "as" { value 3; } + } + description "Advertise router capabilities to neighbors for information and troubleshooting purposes"; + } + + leaf advertise-tunnel-link { + type boolean; + default "false"; + description "Allow use of forwarding adjacency"; + } + + leaf all-l1isis { + type yang:mac-address; + default "01:80:C2:00:00:14"; + description "Destination MAC address for all L1 ISIS neighbors on the link for this ISIS instance"; + } + + leaf all-l2isis { + type yang:mac-address; + default "01:80:C2:00:00:15"; + description "Destination MAC address for all L1 ISIS routers"; + } + + leaf authentication-check { + type boolean; + default "true"; + description "Perform authentication check to reject PDUs that do not match the type or key requirements"; + } + + leaf default-route-tag { + type uint32 { + range "1..max"; + } + description "Route tag for default route"; + } + + leaf ldp-sync { + type boolean; + default "true"; + description "Use IGP-LDP synchronization feature on all interfaces participating in IS-IS routing protocol"; + } + + leaf hello-authentication { + type boolean; + default "true"; + description "Authenticate individual IS-IS protocol packets of Hello type"; + } + + leaf ignore-attached-bit { + type boolean; + default "false"; + description "Ignore attached bit on received L1 LSPs to disable installation of default routes"; + } + + leaf ignore-lsp-errors { + type boolean; + default "false"; + description "Ignore LSP packets with errors"; + } + + leaf ignore-narrow-metric { + type boolean; + default "false"; + description "Ignore links with narrow metrics when wide-metrics support is enabled"; + } + + leaf iid-tlv { + type boolean; + default "false"; + description "Use IID TLVs with IS-IS multi-instance (MI)"; + } + + leaf ipv4-multicast-routing { + type types-isis:routing-topology; + default "native"; + description "IS-IS topology for IPv4 multicast routing"; + } + + leaf ipv4-routing { + type boolean; + default "true"; + description "Support IPv4 routing for IS-IS instance"; + } + + leaf ipv6-multicast-routing { + type types-isis:routing-topology; + default "false"; + description "Topology to populate the IPv6 multicast RTM"; + } + + leaf ipv6-routing { + type types-isis:routing-topology; + default "false"; + description "Routing topology for IPv6"; + } + + leaf hello-padding { + type types-isis:hello-padding-type; + description "Padding on IS-IS Hello packets"; + } + + leaf ldp-over-rsvp { + type boolean; + default "false"; + description "Allow LDP over RSVP processing"; + } + + leaf level-capability { + type types-isis:level; + description "Routing level for instance"; + } + + leaf lsp-lifetime { + type uint32 { + range "350..65535"; + } + units "seconds"; + sros-ext:manual-restart-to-modify; + default "1200"; + description "Amount of time during which an LSP is considered valid"; + } + + leaf lsp-mtu-size { + type types-isis:lsp-buffer-size; + units "bytes"; + sros-ext:manual-restart-to-modify; + default "1492"; + description "LSP MTU size"; + } + + leaf overload-export-interlevel { + type boolean; + default "false"; + description "Advertise the inter-level routes when router is overloaded"; + } + + leaf overload-export-external { + type boolean; + default "false"; + description "Advertise the external routes when router is in overloaded"; + } + + leaf poi-tlv { + type boolean; + default "false"; + description "Purge Originator Identification TLV"; + } + + leaf prefix-attributes-tlv { + type boolean; + default "false"; + description "Use IS-IS Prefix Attributes TLV to exchange extended IPv4 and IPv6 reachability information"; + } + + leaf reference-bandwidth { + type types-sros:reference-bandwidth-ext; + units "kilobps"; + description "Reference bandwidth for bandwidth relative costing"; + } + + leaf router-id { + type types-igp:router-id; + description "Unique router ID for ISIS instance"; + } + + leaf standard-multi-instance { + type boolean; + default "false"; + description "Enable RFC standards compliant multi-instance behavior"; + } + + leaf strict-adjacency-check { + type boolean; + default "false"; + description "Enable strict checking of address families for IS-IS adjacencies"; + } + + leaf suppress-attached-bit { + type boolean; + default "false"; + description "Allow IS-IS to suppress setting the attached bit on LSPs"; + } + + leaf system-id { + type types-igp:system-id; + sros-ext:manual-restart-to-modify; + description "System ID"; + } + + leaf traffic-engineering { + type boolean; + default "false"; + description "Traffic engineering for router"; + } + + leaf-list export-policy { + type types-sros:named-item-64; + max-elements 5; + ordered-by user; + description + "Configure names of export policies to be used for determining which routes are exported + from the routing table to this IGP."; + } + + leaf-list import-policy { + type types-sros:named-item-64; + max-elements 5; + ordered-by user; + description + "Configure names of import policies to be used for determining which routes are imported + from this IGP to the routing table."; + } + + leaf-list area-address { + type types-isis:area-address; + max-elements 3; + description "Area address portion of NSAP address"; + } + + container export-limit { + presence "Maximum number of routes (prefixes) that can be exported into IS-IS from the route table."; + description "Enter the export-limit context"; + + leaf number { + type uint32 { + range "1..max"; + } + mandatory true; + description "Maximum number of routes or prefixes to be exported into IGP instance from route table"; + } + + leaf log-percent { + type uint32 { + range "1..100"; + } + description "Export limit at which warning a log message and SNMP notification are sent"; + } + + } // container export-limit + + container graceful-restart { + presence "Enables/disables graceful restart for ISIS."; + description "Enter the graceful-restart context"; + + leaf helper-mode { + type boolean; + default "true"; + description "Enable graceful restart helper for IS-IS"; + } + + } // container graceful-restart + + container entropy-label { + description "Enter the entropy-label context"; + + leaf override-tunnel-elc { + type boolean; + default "false"; + description "Received entropy label capability advertisement to override"; + } + + } // container entropy-label + + container multi-topology { + presence "Configure multi-topologies support in this ISIS instance."; + description "Enter the multi-topology context"; + + leaf ipv6-unicast { + type boolean; + default "false"; + description "Support multi-topology TLVs"; + } + + leaf ipv4-multicast { + type boolean; + default "false"; + description "Support IPv4 topology (MT3)"; + } + + leaf ipv6-multicast { + type boolean; + default "false"; + description "Support IPv6 topology (MT4)"; + } + + } // container multi-topology + + container multicast-import { + description "Enter the multicast-import context"; + + leaf ipv4 { + type boolean; + default "false"; + description "Submit IPv4 routes into the multicast RPF of the RTM"; + } + + leaf ipv6 { + type boolean; + default "false"; + description "Submit IPv6 routes into the multicast RPF of the RTM"; + } + + } // container multicast-import + + container overload { + presence "Configure the local router so that it appears to be overload."; + description "Enter the overload context"; + + leaf max-metric { + type boolean; + default "false"; + description "Advertise transit links with maximum metric instead of setting overload bit"; + } + + } // container overload + + container overload-on-boot { + presence "Configure the local router so that it appears to be overloaded at boot up."; + description "Enter the overload-on-boot context"; + + leaf timeout { + type uint32 { + range "60..1800"; + } + units "seconds"; + description "Time during which the router operates in overload state after reboot"; + } + + leaf max-metric { + type boolean; + default "false"; + description "Advertise transit links with maximum metric instead of setting overload bit"; + } + + } // container overload-on-boot + + container prefix-limit { + presence "Configure the limit for maximum number of prefixes IS-IS can support."; + description "Enter the prefix-limit context"; + + leaf limit { + type uint32 { + range "1..max"; + } + mandatory true; + description "Maximum number of prefixes for IS-IS instance"; + } + + leaf log-only { + type boolean; + default "false"; + description "Send warning message at specified threshold or when limit is reached, without going into overload"; + } + + leaf warning-threshold { + type uint32 { + range "0..100"; + } + units "percent"; + default "0"; + description + "Specifies the percentage of the value defined by prefix-limit, at which a warning log message + and SNMP notification would be sent. + + This would only be a warning and additional prefixes will be learned up to 100% of prefix-limit. + + A value of 0 indicates that the threshold is disabled and no log message or SNMP notification will be sent."; + } + + leaf overload-timeout { + type types-igp:overload-timeout; + default "forever"; + description "Time router remains in overload after prefix limit is exceeded before restarting"; + } + + } // container prefix-limit + + container lsp-refresh { + description "Enter the lsp-refresh context"; + + leaf interval { + type uint32 { + range "150..65535"; + } + units "seconds"; + default "600"; + description "Refresh timer interval"; + } + + leaf half-lifetime { + type boolean; + default "true"; + description "Set the refresh interval to always be half the LSP lifetime"; + } + + } // container lsp-refresh + + container rib-priority { + description "Enter the rib-priority context"; + + container high { + description "Enter the high context"; + + choice type { + case prefix-list { + + leaf prefix-list { + type types-sros:named-item; + description "List used to select routes processed at higher priority through OSPF route calculation process"; + } + + } + case tag { + + leaf tag { + type uint32 { + range "1..max"; + } + description "Value that matches IS-IS routes processed at higher priority through route calculation process"; + } + + } + } + } // container high + + } // container rib-priority + + container timers { + description "Enter the timers context"; + + container spf-wait { + description "Enter the spf-wait context"; + + leaf spf-max-wait { + type uint32 { + range "10..120000"; + } + units "milliseconds"; + default "10000"; + description "Maximum interval between two consecutive SPF calculations"; + } + + leaf spf-initial-wait { + type uint32 { + range "10..100000"; + } + units "milliseconds"; + default "1000"; + description "Initial SPF calculation delay after topology change"; + } + + leaf spf-second-wait { + type uint32 { + range "10..100000"; + } + units "milliseconds"; + default "1000"; + description "Hold time between first and second SPF calculations"; + } + + } // container spf-wait + + container lsp-wait { + description "Enter the lsp-wait context"; + + leaf lsp-max-wait { + type uint32 { + range "10..120000"; + } + units "milliseconds"; + default "5000"; + description "Maximum time between two consecutive occurrences of LSP generation"; + } + + leaf lsp-initial-wait { + type uint32 { + range "10..100000"; + } + units "milliseconds"; + default "10"; + description "Initial LSP generation delay"; + } + + leaf lsp-second-wait { + type uint32 { + range "10..100000"; + } + units "milliseconds"; + default "1000"; + description "Delay between first and second LSP generation"; + } + + } // container lsp-wait + + } // container timers + + container unicast-import { + description "Enter the unicast-import context"; + + leaf ipv4 { + type boolean; + default "true"; + description "Submit IPv4 routes into unicast RTM"; + } + + leaf ipv6 { + type boolean; + default "true"; + description "Submit IPv6 routes into unicast RTM"; + } + + } // container unicast-import + + container loopfree-alternate { + presence "Enable/disable fast re-route capability for ISIS"; + description "Enter the loopfree-alternate context"; + + container exclude { + description "Enter the exclude context"; + + leaf-list prefix-policy { + type types-sros:named-item-64; + max-elements 5; + ordered-by user; + description + "Loopfree Alternative (LFA) exclude policies from which prefixes are excluded. + Prefixes excluded from LFA this way will not be used in the LFA calculation, regardless of their priority."; + } + + } // container exclude + + container remote-lfa { + presence "Enable/disable Remote LFA"; + description "Enter the remote-lfa context"; + + leaf max-pq-cost { + type uint32; + default "4261412864"; + description "Maximum cost of destination node during reverse SPF calculation"; + } + + container node-protect { + presence "Configure node-protection support in this ISIS instance."; + description "Enter the node-protect context"; + + leaf max-pq-nodes { + type uint32 { + range "1..32"; + } + default "16"; + description "Specifies the maximum number of PQ nodes."; + } + + } // container node-protect + + } // container remote-lfa + + container ti-lfa { + presence "Enable/disable topology Independent LFA"; + description "Enter the ti-lfa context"; + + leaf max-sr-frr-labels { + type uint32 { + range "0..3"; + } + default "2"; + description "Maximum number of labels that TI-LFA backup next hop can use"; + } + + container node-protect { + presence "Configure node-protection support in this ISIS instance."; + description "Enter the node-protect context"; + + } // container node-protect + + } // container ti-lfa + + } // container loopfree-alternate + + container database-export { + presence "Enable/disable database export."; + description "Enter the database-export context"; + + leaf igp-identifier { + type uint64; + description "Unique identifier of the IGP instance in the BGP-LS NLRI"; + } + + container bgp-ls-identifier { + presence "Enable/disable BGP-LS instance-identifier."; + description "Enter the bgp-ls-identifier context"; + + leaf value { + type uint32; + default "0"; + description "BGP-LS identifier that is sent in the BGP-LS NLRI"; + } + + } // container bgp-ls-identifier + + } // container database-export + + container segment-routing { + description "Enter the segment-routing context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of segment routing"; + } + + leaf adj-sid-hold { + type types-igp:adj-sid-hold-type; + units "seconds"; + default "15"; + description "Adjacency SID hold time"; + } + + leaf entropy-label { + type boolean; + default "true"; + description "Entropy label capability"; + } + + leaf export-tunnel-table { + type enumeration { + enum "ldp" { value 1; } + } + description "Tunnel table export policies to export tunneled routes"; + } + + leaf srlb { + type types-sros:named-item-64; + description "Routing local block"; + } + + leaf tunnel-mtu { + type uint32 { + range "512..9198"; + } + description "Tunnel MTU size"; + } + + leaf tunnel-table-pref { + type uint32 { + range "1..255"; + } + default "11"; + description "Preference of SR tunnels created by the IGP instance"; + } + + container prefix-sid-range { + presence "Configure prefix-sid-range"; + description "Enter the prefix-sid-range context"; + + choice type { + case global { + + leaf global { + type empty; + description "Use global SR range"; + } + + } + case local { + + leaf start-label { + type uint32 { + range "0..524287"; + } + default "0"; + description "Value for the local label starting offset"; + } + + leaf max-index { + type uint32 { + range "1..524287"; + } + default "1"; + description "Maximum local SID index"; + } + + } + } + } // container prefix-sid-range + + list adjacency-set { + key "id"; + description "Enter the adjacency-set context"; + + leaf id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..max"; + } + } + description "Identifier for specified adjacency set"; + } + + leaf family { + type types-sros:adjacency-set-family-type; + default "ipv4"; + description "Address family for the adjacency set"; + } + + leaf parallel { + type boolean; + default "true"; + description "Require all members of the adjacency set to terminate on the same neighboring node"; + } + + leaf advertise { + type boolean; + default "true"; + description "Advertise the adjacency set when all links terminate on the same neighboring node"; + } + + container sid { + presence "Assign a static SID value to this adj-set"; + description "Enter the sid context"; + + choice type { + case label { + + leaf label { + type int64 { + range "1..1048575"; + } + description "Adjacency SID"; + } + + } + } + } // container sid + + } // list adjacency-set + + container mapping-server { + description "Enter the mapping-server context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ISIS segment routing mapping server"; + } + + list node-sid-map { + key "sid-index"; + description "Enter the node-sid-map context"; + + leaf sid-index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32; + } + description "SID index of a mapping server Prefix-SID"; + } + + leaf ip-prefix { + type types-sros:ipv4-unicast-prefix; + mandatory true; + description "Prefix of a mapping server Prefix-SID"; + } + + leaf range { + type uint32 { + range "0..65535"; + } + default "1"; + description "Range of addresses and their associated prefix SIDs"; + } + + leaf level-capability { + type types-isis:level; + description "Flags to assign in SID Label Binding TLV advertised by Segment Routing Mapping Server"; + } + + leaf clear-n-flag { + type boolean; + default "false"; + description "Clear the node-sid flag (N-flag)"; + } + + container set-flags { + description "Enter the set-flags context"; + + leaf bit-s { + type boolean; + default "false"; + description "SID Label Binding TLV to be flooded across the entire routing domain"; + } + + } // container set-flags + + } // list node-sid-map + + } // container mapping-server + + } // container segment-routing + + container igp-shortcut { + description "Enter the igp-shortcut context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of RSVP-TE or SR-TE shortcut"; + } + + container tunnel-next-hop { + description "Enter the tunnel-next-hop context"; + + list family { + key "family-type"; + description "Enter the family context"; + + leaf family-type { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-igp:tunn-next-hop-family-type; + } + description "Address family type for tunnel next-hop"; + } + + leaf resolution { + type types-sros:resolution-type; + description "Resolution state for IGP shortcut tunnels"; + } + + container resolution-filter { + description "Enter the resolution-filter context"; + + leaf rsvp { + type boolean; + default "false"; + description "Use RSVP tunneling for next-hop resolution"; + } + + leaf sr-te { + type boolean; + default "false"; + description "Use SR-TE tunneling for next-hop resolution"; + } + + } // container resolution-filter + + } // list family + + } // container tunnel-next-hop + + } // container igp-shortcut + + list interface { + key "interface-name"; + description "Enter the interface context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Router interface name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of interface"; + } + + leaf hello-authentication-key { + type types-sros:encrypted-leaf { + length "1..366"; + } + description "Authentication key or hash string for Hello PDUs"; + } + + leaf hello-authentication-keychain { + type types-sros:named-item; + description "Authentication keychain to use for the session."; + } + + leaf hello-authentication-type { + type types-isis:auth-type; + description "Hello authentication type"; + } + + leaf hello-padding { + type types-isis:hello-padding-type; + description "Padding on IS-IS Hello packets"; + } + + leaf passive { + type boolean; + default "false"; + description "Passive interface"; + } + + leaf csnp-interval { + type uint32 { + range "1..65535"; + } + units "seconds"; + default "10"; + description "Time interval between successive CSN PDUs sent from interface"; + } + + leaf default-instance { + type boolean; + default "false"; + description "Allow non-MI capable router to establish an adjacency and operate with a router in non-zero instance"; + } + + leaf hello-authentication { + type boolean; + default "true"; + description "Authenticate individual IS-IS protocol packets of Hello type"; + } + + leaf interface-type { + type types-isis:interface-type; + description "Interface type to broadcast, point-to-point, or to be default"; + } + + leaf ipv4-multicast { + type boolean; + default "true"; + description "Clear IPv4 multicast routing for interface"; + } + + leaf ipv6-multicast { + type boolean; + default "true"; + description "Clear IPv4 multicast routing for interface"; + } + + leaf ipv6-unicast { + type boolean; + default "true"; + description "Clear IPv4 multicast routing for interface"; + } + + leaf level-capability { + type types-isis:level; + description "IS-IS levels for this interface"; + } + + leaf load-balancing-weight { + type uint32; + description "Load balancing weight"; + } + + leaf lsp-pacing-interval { + type uint32 { + range "0..65535"; + } + default "100"; + description "Interval for sending LSPs from interface"; + } + + leaf retransmit-interval { + type uint32 { + range "1..65535"; + } + units "seconds"; + default "5"; + description "Minimum time between LSP PDU retransmissions on point-to-point interface"; + } + + leaf sid-protection { + type boolean; + default "true"; + description "Allow adjacency SID protection by LFA and remote LFA"; + } + + leaf tag { + type uint32 { + range "1..max"; + } + description "Route tag for IP address of interface"; + } + + container ipv4-adjacency-sid { + presence "Assign IPv4 static adjacency sid to interface"; + description "Enter the ipv4-adjacency-sid context"; + + choice type { + case label { + + leaf label { + type int64 { + range "1..1048575"; + } + description "Adjacency SID"; + } + + } + } + } // container ipv4-adjacency-sid + + container ipv6-adjacency-sid { + presence "Assign IPv6 static adjacency sid to interface"; + description "Enter the ipv6-adjacency-sid context"; + + choice type { + case label { + + leaf label { + type int64 { + range "1..1048575"; + } + description "Adjacency SID"; + } + + } + } + } // container ipv6-adjacency-sid + + container loopfree-alternate { + description "Enter the loopfree-alternate context"; + + leaf exclude { + type boolean; + default "false"; + description "Enable/disable Loopfree Alternative at interface level."; + } + + container policy-map { + presence "Configure a route-next-hop template"; + description "Enter the policy-map context"; + + leaf route-nh-template { + type types-sros:named-item; + mandatory true; + description "Route next hop policy template that is applied to interface"; + } + + } // container policy-map + + } // container loopfree-alternate + + container mesh-group { + presence "Configure mesh groups"; + description "Enter the mesh-group context"; + + choice type { + case value { + + leaf value { + type int32 { + range "1..2000000000"; + } + description "Mesh group for the interface"; + } + + } + case blocked { + + leaf blocked { + type empty; + description "Prevent the interface from flooding LSPs"; + } + + } + } + } // container mesh-group + + container bfd-liveness { + description "Enter the bfd-liveness context"; + + container ipv4 { + presence "Enable BFD for IPv4"; + description "Enter the ipv4 context"; + + leaf include-bfd-tlv { + type boolean; + default "false"; + description "BFD-enabled TLV for IPv4 to include on this IS-IS interface"; + } + + } // container ipv4 + + container ipv6 { + presence "Enable BFD for IPv6"; + description "Enter the ipv6 context"; + + leaf include-bfd-tlv { + type boolean; + default "false"; + description "BFD-enabled TLV for IPv4 to include on this IS-IS interface"; + } + + } // container ipv6 + + } // container bfd-liveness + + container ipv4-node-sid { + presence "Configure IPv4 node SID for this interface"; + description "Enter the ipv4-node-sid context"; + + leaf clear-n-flag { + type boolean; + default "false"; + description "Clear the node-sid flag (N-flag)"; + } + + choice type { + case label { + + leaf label { + type int64 { + range "1..4294967295"; + } + description "Specifies IPvX node SID label for this interface."; + } + + } + case index { + + leaf index { + type int64 { + range "0..4294967295"; + } + description "IPvX node SID index for this interface"; + } + + } + } + } // container ipv4-node-sid + + container ipv6-node-sid { + presence "Configure IPv6 node SID for this interface"; + description "Enter the ipv6-node-sid context"; + + leaf clear-n-flag { + type boolean; + default "false"; + description "Clear the node-sid flag (N-flag)"; + } + + choice type { + case label { + + leaf label { + type int64 { + range "1..4294967295"; + } + description "Specifies IPvX node SID label for this interface."; + } + + } + case index { + + leaf index { + type int64 { + range "0..4294967295"; + } + description "IPvX node SID index for this interface"; + } + + } + } + } // container ipv6-node-sid + + list adjacency-set { + key "id"; + description "Enter the adjacency-set context"; + + leaf id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..max"; + } + } + description "Adjacency set identity"; + } + + } // list adjacency-set + + list level { + key "level-number"; + max-elements 2; + description "Enter the level context"; + + leaf level-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type enumeration { + enum "1" { value 1; } + enum "2" { value 2; } + } + } + description "IS-IS protocol level to which these attributes apply"; + } + + leaf hello-authentication-key { + type types-sros:encrypted-leaf { + length "1..366"; + } + description "Authentication or hash key string."; + } + + leaf hello-authentication-keychain { + type types-sros:named-item; + description "Authentication keychain to use for the session."; + } + + leaf hello-authentication-type { + type types-isis:auth-type; + description "Hello-authentication-type to be enabled."; + } + + leaf hello-padding { + type types-isis:hello-padding-type; + description "Padding on IS-IS Hello packets"; + } + + leaf passive { + type boolean; + default "false"; + description "Passive interface"; + } + + leaf hello-interval { + type uint32 { + range "1..20000"; + } + default "9"; + description "Interval between Hello messages sent on this level"; + } + + leaf hello-multiplier { + type int32 { + range "2..100"; + } + default "3"; + description "Hello messages missed from neighbor before router declares adjacency down"; + } + + leaf ipv4-multicast-metric { + type types-isis:metric; + description "IS-IS interface metric applied for IPv4 multicast"; + } + + leaf ipv6-multicast-metric { + type types-isis:metric; + description "IS-IS interface metric applied for IPv6 multicast"; + } + + leaf ipv6-unicast-metric { + type types-isis:metric; + description "IS-IS interface metric applied for for IPv6 unicast"; + } + + leaf metric { + type types-isis:metric; + description "IS-IS interface metric applied for for IPv4 unicast"; + } + + leaf priority { + type uint32 { + range "0..127"; + } + default "64"; + description "Router to become the designated router on a multi-access network"; + } + + leaf sd-offset { + type types-isis:metric; + description "Value of the signal degrade offset"; + } + + leaf sf-offset { + type types-isis:metric; + description "Value of the signal fail offset"; + } + + } // list level + + } // list interface + + list level { + key "level-number"; + max-elements 2; + description "Enter the level context"; + + leaf level-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type enumeration { + enum "1" { value 1; } + enum "2" { value 2; } + } + } + description "IS-IS protocol level to which these attributes apply"; + } + + leaf authentication-keychain { + type types-sros:named-item; + description "The keychain used to sign and/or authenticate."; + } + + leaf authentication-key { + type types-sros:encrypted-leaf { + length "1..366"; + } + description "Authentication or hash key string."; + } + + leaf authentication-type { + type types-isis:auth-type; + description "Configure the authentication type to be used."; + } + + leaf csnp-authentication { + type boolean; + default "true"; + description "Enable/disable authentication on received ISIS protocol packets of type CSNP."; + } + + leaf psnp-authentication { + type boolean; + default "true"; + description "Enable/disable authentication on received ISIS protocol packets of type PSNP."; + } + + leaf advertise-router-capability { + type boolean; + default "true"; + description "Allow router advertisement capabilities"; + } + + leaf database-export-exclude { + type boolean; + default "false"; + description "Exclude IGP link-state information of a specific IS-IS level from being exported into extended TE-DB"; + } + + leaf default-ipv4-multicast-metric { + type types-isis:metric; + default "10"; + description "Default metric for IPv4 unicast"; + } + + leaf default-ipv6-multicast-metric { + type types-isis:metric; + default "10"; + description "Default metric for IPv6 unicast"; + } + + leaf default-ipv6-unicast-metric { + type types-isis:metric; + default "10"; + description "Default metric for IPv6 unicast"; + } + + leaf default-metric { + type types-isis:metric; + default "10"; + description "Default metric"; + } + + leaf external-preference { + type uint32 { + range "1..255"; + } + default "165"; + description "External route preference for IS-IS level"; + } + + leaf hello-authentication { + type boolean; + default "true"; + description "Authenticate individual IS-IS protocol packets of Hello type"; + } + + leaf hello-padding { + type types-isis:hello-padding-type; + description "Padding on IS-IS Hello packets"; + } + + leaf loopfree-alternate-exclude { + type boolean; + default "false"; + description "Exclude interface participating in specific IS-IS level in SPF LFA computation"; + } + + leaf lsp-mtu-size { + type types-isis:lsp-buffer-size; + units "bytes"; + sros-ext:manual-restart-to-modify; + default "1492"; + description "LSP MTU size"; + } + + leaf preference { + type uint32 { + range "1..255"; + } + default "18"; + description "External route preference at level"; + } + + leaf wide-metrics-only { + type boolean; + default "false"; + description "Use wide metrics advertisements in the LSPs"; + } + + container bier { + description "Enter the bier context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administratively enable/disable BIER."; + } + + leaf template { + type types-sros:named-item; + description "Specify BIER template name."; + } + + } // container bier + + } // list level + + list link-group { + key "link-group-name"; + description "Enter the link-group context"; + + leaf link-group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Link group name for the IS-IS protocol"; + } + + leaf description { + type types-sros:very-long-description; + description "Text description"; + } + + list level { + key "level-number"; + max-elements 2; + description "Enter the level context"; + + leaf level-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type enumeration { + enum "1" { value 1; } + enum "2" { value 2; } + } + } + description "IS-IS protocol level to which these attributes apply"; + } + + leaf ipv4-multicast-metric-offset { + type types-isis:metric; + description "Offset value for the IPv4 multicast address family"; + } + + leaf ipv4-unicast-metric-offset { + type types-isis:metric; + description "Offset value for the IPv4 unicast address family"; + } + + leaf ipv6-multicast-metric-offset { + type types-isis:metric; + description "Offset value for the IPv6 multicast address family"; + } + + leaf ipv6-unicast-metric-offset { + type types-isis:metric; + description "Offset value for the IPv6 unicast address family"; + } + + leaf oper-members { + type uint32 { + range "1..8"; + } + description "Minimum number of operational links"; + } + + leaf revert-members { + type uint32 { + range "1..8"; + } + description "Minimum number of operational links to return link group to normal state and remove offsets"; + } + + list member { + key "interface-name"; + max-elements 8; + description "Enter the member context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Router interface name for this link group"; + } + + } // list member + + } // list level + + } // list link-group + + list summary-address { + key "ip-prefix"; + description "Enter the summary-address context"; + + leaf ip-prefix { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-prefix; + } + description "Summary IP prefix"; + } + + leaf level-capability { + type types-isis:level; + description "IS-IS Level from which the prefix should be summarized"; + } + + leaf route-tag { + type uint32 { + range "1..max"; + } + description "Route tag assigned to the summary address"; + } + + } // list summary-address + + } // list isis + + container mpls { + presence "Enables mpls functionality on this router."; + description "Enter the mpls context"; + + leaf admin-group-frr { + type boolean; + default "false"; + description "Use admin group constraints for FRR path computation"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the MPLS instance"; + } + + leaf bypass-resignal-timer { + type uint32 { + range "30..10080"; + } + units "minutes"; + description "Value for the LSP resignal timer"; + } + + leaf cspf-on-loose-hop { + type boolean; + default "false"; + description "Calculate CSPF until next loose hop on LSR"; + } + + leaf dynamic-bypass { + type boolean; + default "true"; + description "Create dynamic bypass LSPs in FRR"; + } + + leaf exponential-backoff-retry { + type boolean; + default "false"; + description "Use exponential back-off timer when retrying an LSP"; + } + + leaf frr-object { + type boolean; + default "true"; + description "Signal with fast reroute object"; + } + + leaf hold-timer { + type uint32 { + range "0..10"; + } + units "seconds"; + default "1"; + description "Hold timer value"; + } + + leaf least-fill-min-thd { + type types-sros:percent; + default "5"; + description "Percentage of the least fill minimum threshold value"; + } + + leaf least-fill-reoptim-thd { + type types-sros:percent; + default "10"; + description "Percentage of the least fill reoptimization threshold value"; + } + + leaf logger-event-bundling { + type boolean; + default "false"; + description "Merge and bundle MPLS traps"; + } + + leaf lsp-init-retry-timeout { + type uint32 { + range "10..600"; + } + units "seconds"; + default "30"; + description "LSP initial retry timeout"; + } + + leaf max-bypass-associations { + type uint32 { + range "100..131072"; + } + default "1000"; + description "Maximum number of LSPs to be associated with a bypass tunnel"; + } + + leaf mbb-prefer-current-hops { + type boolean; + default "false"; + description "Select preference to use the current hops for Make-Before-Break (MBB)"; + } + + leaf p2mp-resignal-timer { + type uint32 { + range "60..10080"; + } + units "minutes"; + description "Resignal timer for P2MP LSPs"; + } + + leaf p2mp-s2l-fast-retry { + type uint32 { + range "1..10"; + } + units "seconds"; + description "Fast retry timer for P2MP S2L paths"; + } + + leaf p2p-active-path-fast-retry { + type uint32 { + range "1..10"; + } + units "seconds"; + description "Fast retry timer for P2P active paths"; + } + + leaf resignal-timer { + type uint32 { + range "30..10080"; + } + units "minutes"; + description "Resignal timer for P2MP LSPs"; + } + + leaf retry-on-igp-overload { + type boolean; + default "false"; + description "Tear down LSPs when IGP is in overload state"; + } + + leaf secondary-fast-retry-timer { + type uint32 { + range "1..10"; + } + units "seconds"; + description "Fast retry timer for secondary paths"; + } + + leaf shortcut-local-ttl-propagate { + type boolean; + default "true"; + description "Propagate TTL over LSP shortcut for local packets"; + } + + leaf shortcut-transit-ttl-propagate { + type boolean; + default "true"; + description "Propagate TTL over LSP shortcut for local packets for transit packets"; + } + + leaf srlg-frr { + type enumeration { + enum "loose" { value 1; } + enum "strict" { value 2; } + } + description "Use of Shared Risk Link Group (SRLG) constraint for FRR path computation"; + } + + leaf static-lsp-fast-retry { + type uint32 { + range "1..30"; + } + units "seconds"; + default "30"; + description "Fast retry timer for static LSPs"; + } + + leaf user-srlg-db { + type boolean; + default "false"; + description "Enable/disable use of user SRLG database."; + } + + container auto-bandwidth-multipliers { + description "Enter the auto-bandwidth-multipliers context"; + + leaf sample-multiplier { + type uint32 { + range "1..511"; + } + default "1"; + description "Collection intervals in a sample interval"; + } + + leaf adjust-multiplier { + type uint32 { + range "1..16383"; + } + default "288"; + description "Collection intervals in a sample interval"; + } + + } // container auto-bandwidth-multipliers + + container entropy-label { + description "Enter the entropy-label context"; + + leaf rsvp-te { + type boolean; + default "true"; + description "Apply entropy labels to RSVP-TE LSPs"; + } + + leaf sr-te { + type boolean; + default "true"; + description "Apply entropy labels to SR-TE LSPs"; + } + + } // container entropy-label + + container pce-report { + description "Enter the pce-report context"; + + leaf sr-te { + type boolean; + default "false"; + description "Allow PCE reporting for all TE LSPs of SR-TE type"; + } + + leaf rsvp-te { + type boolean; + default "false"; + description "Allow PCE reporting for all TE LSPs of RSVP-TE type"; + } + + } // container pce-report + + container srlg-database { + description "Enter the srlg-database context"; + + list router-id { + key "router-address"; + description "Enter the router-id context"; + + leaf router-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-address; + } + description + "Specifies a unique identifier of the router + in the Autonomous System."; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the interface"; + } + + list interface { + key "interface-address srlg-group"; + description "Enter the interface context"; + + leaf interface-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-address; + } + description "Indicates the IP address of the interface."; + } + + leaf srlg-group { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "SRLG group name"; + } + + } // list interface + + } // list router-id + + } // container srlg-database + + list interface { + key "interface-name"; + description "Enter the interface context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Router interface name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of MPLS"; + } + + leaf te-metric { + type uint32 { + range "1..16777215"; + } + description "TE metric for the interface"; + } + + leaf-list admin-group { + type types-sros:named-item; + max-elements 32; + description "Name of the admin group membership of the MPLS interface"; + } + + list srlg-group { + key "name"; + max-elements 64; + description "Enter the srlg-group context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Shared Risk Link Group (SRLG) name"; + } + + } // list srlg-group + + list label-map { + key "in-label"; + description "Enter the label-map context"; + + leaf in-label { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:mpls-label; + } + description "Match the incoming MPLS label"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the label map"; + } + + choice label-map-choice { + case pop { + + leaf pop { + type empty; + sros-ext:immutable; + description "Pop (remove) the incoming label and forward packet based on service header"; + } + + } + case swap { + + container swap { + presence "The swap action on the incoming label."; + description "Enter the swap context"; + + leaf out-label { + type union { + type uint32 { + range "16..1048575"; + } + type enumeration { + enum "implicit-null-label" { value 3; } + } + } + mandatory true; + description "Push specific label onto the top of the outgoing packet's label stack"; + } + + leaf next-hop { + type types-sros:ipv4-unicast-address; + mandatory true; + description "IP address for the next hop"; + } + + } // container swap + + } + } + } // list label-map + + } // list interface + + list class-forwarding-policy { + key "policy-name"; + max-elements 15; + description "Enter the class-forwarding-policy context"; + + leaf policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of class forwarding policy"; + } + + leaf default-set { + type uint32 { + range "1..6"; + } + default "1"; + description "Default forwarding set ID"; + } + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name for LSP"; + } + + leaf forwarding-set { + type uint32 { + range "1..6"; + } + default "1"; + description "Forwarding set ID for forwarding classes"; + } + + } // list fc + + } // list class-forwarding-policy + + list path { + key "path-name"; + max-elements 65535; + description "Enter the path context"; + + leaf path-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Name for this LSP path"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of this tunnel"; + } + + list hop { + key "hop-index"; + max-elements 255; + description "Enter the hop context"; + + leaf hop-index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..1024"; + } + } + description "Index to identify a particular hop"; + } + + leaf ip-address { + type types-sros:ip-address; + sros-ext:immutable; + mandatory true; + description "IPv4 address of this hop"; + } + + leaf type { + type enumeration { + enum "strict" { value 1; } + enum "loose" { value 2; } + } + mandatory true; + description "Tunnel hop type"; + } + + } // list hop + + } // list path + + list lsp-template { + key "template-name"; + max-elements 4096; + description "Enter the lsp-template context"; + + leaf template-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of the LSP template to automatically create and signal multiple LSP instances"; + } + + leaf type { + type enumeration { + enum "p2mp-rsvp" { value 1; } + enum "p2p-rsvp-one-hop" { value 2; } + enum "p2p-rsvp-mesh" { value 3; } + enum "p2p-sr-te-one-hop" { value 4; } + enum "p2p-sr-te-mesh" { value 5; } + enum "p2p-sr-te-pce-init" { value 6; } + } + sros-ext:immutable; + mandatory true; + description "Configure type of the LSP template."; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of LSP template"; + } + + leaf backup-class-type { + type types-mpls:class-type; + default "0"; + description "Configure backup-class-type for this LSP template."; + } + + leaf bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Specify bandwidth in mbps for LSP instances created using this LSP template."; + } + + leaf bgp-shortcut { + type boolean; + default "true"; + description "Enable/disable use of RSVP LSP for IPv4 BGP routes."; + } + + leaf bgp-transport-tunnel { + type boolean; + default "true"; + description "Include/exclude use of RSVP LSP as transport LSP for labeled IPv4 BGP routes."; + } + + leaf default-path { + type types-sros:named-item-64; + sros-ext:immutable; + description + "Specify default path to be used for signaling LSP instances created using this + LSP template."; + } + + leaf from { + type types-sros:ip-address; + description "IP address of the ingress router for the LSP template."; + } + + leaf hop-limit { + type uint16 { + range "2..255"; + } + default "255"; + description + "Configure maximum number of hops that can be traversed by LSP instances + created using this LSP template."; + } + + leaf ldp-over-rsvp { + type boolean; + default "true"; + description "Configure if this LSP will be included in LDP over RSVP."; + } + + leaf metric { + type uint32 { + range "0..16777215"; + } + default "0"; + description "Configure LSP template metric."; + } + + leaf vprn-auto-bind { + type boolean; + default "true"; + description "Configure if this LSP will be included in auto-bind for VPRN services."; + } + + leaf pce-report { + type types-sros:bool-with-inherit; + description "Specifies whether to override the global configuration of reporting to PCE."; + } + + leaf entropy-label { + type types-sros:bool-with-inherit; + description "Configure Entropy Label for LSP Template."; + } + + leaf adaptive { + type boolean; + default "true"; + description "Enable/disable make-before-break functionality."; + } + + leaf adspec { + type boolean; + default "false"; + description "Enable/disable inclusion of ADSPEC objects in RSVP messages."; + } + + leaf class-type { + type types-mpls:class-type; + default "0"; + description "Configure class-type."; + } + + leaf least-fill { + type boolean; + default "false"; + description "Configure use of least-fill path selection method."; + } + + leaf load-balancing-weight { + type uint32 { + range "1..max"; + } + description "Configure load balancing weight."; + } + + leaf main-ct-retry-limit { + type uint32 { + range "1..10000"; + } + description "Max number of attempts before switching to backup class type."; + } + + leaf propagate-admin-group { + type boolean; + default "false"; + description "Enable/disable admin groups via session attribute object."; + } + + leaf retry-limit { + type uint32 { + range "1..10000"; + } + description "Max number of attempts made to reestablish the LSP after it has failed."; + } + + leaf retry-timer { + type uint32 { + range "1..600"; + } + units "seconds"; + default "30"; + description "Time between attempts to reestablish the LSP after it has failed."; + } + + leaf record { + type boolean; + default "true"; + description "Enable/disable recording of all hops."; + } + + leaf record-label { + type boolean; + default "true"; + description "Enable/disable recording of labels at each node or instance."; + } + + leaf template-id { + type union { + type uint32 { + range "1..max"; + } + type enumeration { + enum "default" { value 0; } + } + } + sros-ext:immutable; + description "The value indicates lsp template-id. Configure this if LSP Template is of type p2p-sr-te-pce-init."; + } + + leaf-list include-admin-group { + type types-sros:named-item; + max-elements 32; + description "Admin group name included when LSP is set up"; + } + + leaf-list exclude-admin-group { + type types-sros:named-item; + max-elements 32; + description "Admin group name excluded when LSP is set up"; + } + + container class-forwarding { + presence "Configure class based forwarding."; + description "Enter the class-forwarding context"; + + choice cbf-choice { + default "default-lsp-and-fc"; + case default-lsp-and-fc { + + leaf default-lsp { + type boolean; + default "false"; + description "Use the default LSP configuration for specified LSP or LSP template"; + } + + leaf-list fc { + type enumeration { + enum "be" { value 0; } + enum "l2" { value 1; } + enum "af" { value 2; } + enum "l1" { value 3; } + enum "h2" { value 4; } + enum "ef" { value 5; } + enum "h1" { value 6; } + enum "nc" { value 7; } + } + max-elements 8; + description "One or more forwarding classes for LSP instances"; + } + + } + case forwarding-set { + + container forwarding-set { + description "Enter the forwarding-set context"; + + leaf policy { + type types-sros:named-item; + description "Name for the class based forwarding policy for LSP instances"; + } + + leaf set { + type uint32 { + range "1..6"; + } + description "Forwarding set ID"; + } + + } // container forwarding-set + + } + } + } // container class-forwarding + + container cspf { + description "Enter the cspf context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the CSPF support for LSP"; + } + + leaf use-te-metric { + type boolean; + default "false"; + description "TE metric for the LSP path computation by CSPF"; + } + + } // container cspf + + container priority { + description "Enter the priority context"; + + leaf setup-priority { + type types-mpls:priority; + default "7"; + description "Setup priority when insufficient bandwidth is available to set up LSP"; + } + + leaf hold-priority { + type types-mpls:priority; + default "0"; + description "Hold priority when insufficient bandwidth is available to set up LSP"; + } + + } // container priority + + container fast-reroute { + presence "Enable/Disable fast reroute for LSP Template instances."; + description "Enter the fast-reroute context"; + + leaf hop-limit { + type uint32 { + range "0..255"; + } + default "16"; + description "Total number of hops a detour or backup LSP can take before merging back onto the main LSP path"; + } + + leaf propagate-admin-group { + type boolean; + default "false"; + description "Enable signaling of the primary LSP path admin-group constraints in the FRR object at ingress"; + } + + leaf frr-method { + type types-mpls:frr-method-type; + default "facility"; + description "Fast Reroute method for the LSPs that are dynamically created using this LSP template"; + } + + leaf node-protect { + type boolean; + default "false"; + description "Enable node and link protection for the specified LSP"; + } + + } // container fast-reroute + + container igp-shortcut { + description "Enter the igp-shortcut context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the RSVP LSP to be used as a shortcut while resolving IGP routes"; + } + + choice igp-choice { + case lfa-type { + + leaf lfa-type { + type enumeration { + enum "lfa-protect" { value 1; } + enum "lfa-only" { value 2; } + } + description "Specific RSVP LSP by IS-IS and OSPF routing protocols to assign as shortcut or as forwarding adjacency"; + } + + } + case relative-metric { + + leaf relative-metric { + type int32 { + range "-10..10"; + } + description "Shortest IGP cost between the endpoints of the LSP plus the configured offset"; + } + + } + } + } // container igp-shortcut + + container max-sr-labels { + description "Enter the max-sr-labels context"; + + leaf label-stack-size { + type uint32 { + range "1..11"; + } + default "6"; + description "Size for the maximum segment routing label stack"; + } + + leaf additional-frr-labels { + type uint32 { + range "0..4"; + } + default "1"; + description "Maximum number of additional overhead labels"; + } + + } // container max-sr-labels + + list admin-tag { + key "name"; + max-elements 4; + description "Enter the admin-tag context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type string { + length "1..32"; + } + } + description "Name of the admin tags"; + } + + } // list admin-tag + + container auto-bandwidth { + presence "Enable/disable auto bandwidth for LSP template."; + description "Enter the auto-bandwidth context"; + + leaf max-bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "100000"; + description "Maximum bandwidth of auto-bandwidth to request for the LSP"; + } + + leaf min-bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Minimum bandwidth of auto-bandwidth to request for the LSP"; + } + + leaf monitor-bandwidth { + type boolean; + default "false"; + description "Collect and display auto-bandwidth measurements for the LSP"; + } + + list fc { + key "fc-name"; + max-elements 8; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name for LSP"; + } + + leaf sampling-weight { + type types-sros:percent; + default "100"; + description "Forwarding class weight for LSP"; + } + + } // list fc + + container adjust-down { + description "Enter the adjust-down context"; + + leaf percent { + type types-sros:percent; + default "5"; + description "Minimum difference in percent between LSP bandwidth reservation and the maximum average data rate"; + } + + leaf bw { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Minimum difference in absolute bandwidth between LSP bandwidth reservation and max average data rate"; + } + + } // container adjust-down + + container adjust-up { + description "Enter the adjust-up context"; + + leaf percent { + type types-sros:percent; + default "5"; + description "Minimum difference in percent between LSP bandwidth reservation and the maximum average data rate"; + } + + leaf bw { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Minimum difference in absolute bandwidth between LSP bandwidth reservation and max average data rate"; + } + + } // container adjust-up + + container multipliers { + description "Enter the multipliers context"; + + leaf sample-multiplier { + type uint32 { + range "1..511"; + } + description "Multiplier for collection intervals in a sample interval"; + } + + leaf adjust-multiplier { + type uint32 { + range "1..16383"; + } + description "Number of collection intervals in the adjust interval"; + } + + } // container multipliers + + container overflow-limit { + presence "Configure overflow limit for auto-bandwidth for LSP."; + description "Enter the overflow-limit context"; + + leaf threshold { + type types-sros:percent; + default "0"; + description "Minimum difference in percent between the LSP bandwidth and the sampled data rate"; + } + + leaf bw { + type uint32 { + range "1..100000"; + } + units "megabps"; + description "Minimum difference in absolute bandwidth between the LSP bandwidth and the sampled data rate"; + } + + leaf number { + type uint32 { + range "1..10"; + } + mandatory true; + description "Number of overflow samples to trigger an overflow auto-bandwidth adjustment attempt"; + } + + } // container overflow-limit + + container underflow-limit { + presence "Configure underflow limit for auto-bandwidth for LSP."; + description "Enter the underflow-limit context"; + + leaf threshold { + type types-sros:percent; + default "0"; + description "Minimum difference in percent between the LSP bandwidth and the sampled data rate"; + } + + leaf bw { + type uint32 { + range "1..100000"; + } + units "megabps"; + description "Minimum difference in absolute bandwidth between the LSP bandwidth and the sampled data rate"; + } + + leaf number { + type uint32 { + range "1..10"; + } + mandatory true; + description "Number of overflow samples to trigger an overflow auto-bandwidth adjustment attempt"; + } + + } // container underflow-limit + + } // container auto-bandwidth + + container egress-statistics { + presence "Configures LSP template Egress statistics."; + description "Enter the egress-statistics context"; + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy ID"; + } + + } // container egress-statistics + + container bfd { + description "Enter the bfd context"; + + leaf bfd-liveness { + type boolean; + default "false"; + description "Enable BFD"; + } + + leaf bfd-template { + type types-sros:named-item; + description "BFD template"; + } + + leaf lsp-ping-interval { + type union { + type uint32 { + range "60..300"; + } + type enumeration { + enum "none" { value 0; } + } + } + units "seconds"; + default "60"; + description "Interval for periodic LSP ping for BFD bootstrapping"; + } + + leaf failure-action { + type enumeration { + enum "none" { value 0; } + enum "down" { value 1; } + } + default "none"; + description "Indicates the action to be taken when LSP BFD session fails"; + } + + } // container bfd + + } // list lsp-template + + list lsp { + key "lsp-name"; + description "Enter the lsp context"; + + leaf lsp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Labeled Switch path name"; + } + + leaf type { + type enumeration { + enum "p2p-rsvp" { value 2; } + enum "p2p-static-mpls" { value 3; } + enum "p2p-rsvp-bypass" { value 4; } + enum "p2mp-rsvp" { value 5; } + enum "p2mp-rsvp-auto" { value 6; } + enum "p2p-rsvp-mesh" { value 8; } + enum "p2p-rsvp-one-hop" { value 9; } + enum "p2p-sr-te" { value 10; } + enum "p2p-sr-te-mesh" { value 11; } + enum "p2p-sr-te-one-hop" { value 12; } + enum "p2p-sr-te-pce-init" { value 13; } + } + sros-ext:immutable; + mandatory true; + description "LSP for bypass protection, point to multipoint, segment routing or MPLS-TP static LSP"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the LSP"; + } + + leaf exclude-node { + type types-sros:ip-address; + description "Exclude Routers object to be included in the bypass path message"; + } + + leaf from { + type types-sros:ip-address; + description "Source IP address of this LSP"; + } + + leaf to { + type types-sros:ip-address; + description "Destination IP address or the egress router for the LSP"; + } + + leaf hop-limit { + type uint32 { + range "2..255"; + } + default "255"; + description "Maximum number of hops that an LSP can traverse including ingress and egress routers"; + } + + leaf p2mp-id { + type uint32 { + range "1..65535"; + } + description "Unique identifier as Point-to-Multipoint (P2MP) identifier"; + } + + leaf pce-computation { + type boolean; + default "false"; + description "LSP path computation request sent to local CSPF or to PCE"; + } + + leaf pce-control { + type boolean; + default "false"; + description "Control of path (delegation) to Path Computation Engine (PCE) to be used"; + } + + leaf revert-timer { + type uint32 { + range "1..4320"; + } + units "minutes"; + description "Revert timer for this LSP"; + } + + leaf rsvp-resv-style { + type enumeration { + enum "se" { value 1; } + enum "ff" { value 2; } + } + default "se"; + description "Reservation style for RSVP"; + } + + leaf bgp-shortcut { + type boolean; + default "true"; + description "Include LSP for BGP routes"; + } + + leaf bgp-transport-tunnel { + type boolean; + default "true"; + description "Include LSP as transport LSP for labeled BGP routes"; + } + + leaf ldp-over-rsvp { + type boolean; + default "true"; + description "Include this LSP in LDP over RSVP"; + } + + leaf metric { + type uint32 { + range "0..16777215"; + } + default "0"; + description "LSP metric that forces to a constant value"; + } + + leaf vprn-auto-bind { + type boolean; + default "true"; + description "Include this LSP in auto-bind for VPRN services"; + } + + leaf pce-report { + type types-sros:bool-with-inherit; + description "Global configuration of reporting to PCE to override"; + } + + leaf entropy-label { + type types-sros:bool-with-inherit; + description "Entropy label"; + } + + leaf adaptive { + type boolean; + default "true"; + description "Enable/disable make-before-break functionality."; + } + + leaf adspec { + type boolean; + default "false"; + description "Enable/disable inclusion of ADSPEC object in RSVP messages."; + } + + leaf class-type { + type types-mpls:class-type; + default "0"; + description "Configure class type."; + } + + leaf least-fill { + type boolean; + default "false"; + description "Configure use of least-fill path selection method."; + } + + leaf load-balancing-weight { + type uint32 { + range "1..max"; + } + description "Configure load balancing weight."; + } + + leaf main-ct-retry-limit { + type uint32 { + range "1..10000"; + } + description "Max number of attempts before switching to backup class type."; + } + + leaf propagate-admin-group { + type boolean; + default "false"; + description "Enable/disable admin groups via session attribute object."; + } + + leaf retry-limit { + type uint32 { + range "1..10000"; + } + description "Max number of attempts made to reestablish the LSP after it has failed."; + } + + leaf retry-timer { + type uint32 { + range "1..600"; + } + units "seconds"; + default "30"; + description "Time between attempts to reestablish the LSP after it has failed."; + } + + leaf-list include-admin-group { + type types-sros:named-item; + max-elements 32; + description "Admin group name included when LSP is set up"; + } + + leaf-list exclude-admin-group { + type types-sros:named-item; + max-elements 32; + description "Name of admin group excluded when LSP is set up"; + } + + container class-forwarding { + presence "Configure class based forwarding."; + description "Enter the class-forwarding context"; + + choice cbf-choice { + default "default-lsp-and-fc"; + case default-lsp-and-fc { + + leaf default-lsp { + type boolean; + default "false"; + description "Use the default LSP configuration for specified LSP or LSP template"; + } + + leaf-list fc { + type enumeration { + enum "be" { value 0; } + enum "l2" { value 1; } + enum "af" { value 2; } + enum "l1" { value 3; } + enum "h2" { value 4; } + enum "ef" { value 5; } + enum "h1" { value 6; } + enum "nc" { value 7; } + } + max-elements 8; + description "One or more forwarding classes for LSP instances"; + } + + } + case forwarding-set { + + container forwarding-set { + description "Enter the forwarding-set context"; + + leaf policy { + type types-sros:named-item; + description "Name for the class based forwarding policy for LSP instances"; + } + + leaf set { + type uint32 { + range "1..6"; + } + description "Forwarding set ID"; + } + + } // container forwarding-set + + } + } + } // container class-forwarding + + container cspf { + presence "Enable/disable CSPF support"; + description "Enter the cspf context"; + + leaf use-te-metric { + type boolean; + default "false"; + description "TE metric to the LSP path computation by CSPF"; + } + + } // container cspf + + container igp-shortcut { + description "Enter the igp-shortcut context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the LSP to be used as a shortcut while resolving IGP routes"; + } + + choice igp-choice { + case lfa-type { + + leaf lfa-type { + type enumeration { + enum "lfa-protect" { value 1; } + enum "lfa-only" { value 2; } + } + description "Specific RSVP LSP by IS-IS and OSPF routing protocols to assign as shortcut or as forwarding adjacency"; + } + + } + case relative-metric { + + leaf relative-metric { + type int32 { + range "-10..10"; + } + description "Shortest IGP cost between the endpoints of the LSP plus the configured offset"; + } + + } + } + } // container igp-shortcut + + container fast-reroute { + presence "Enable/Disable the fast reroute method."; + description "Enter the fast-reroute context"; + + leaf hop-limit { + type uint32 { + range "0..255"; + } + default "16"; + description "Total number of hops a detour or backup LSP can take before merging back onto the main LSP path"; + } + + leaf propagate-admin-group { + type boolean; + default "false"; + description "Enable signaling of the primary LSP path admin-group constraints in the FRR object at ingress"; + } + + leaf frr-method { + type types-mpls:frr-method-type; + default "one-to-one"; + description "Fast Reroute method"; + } + + leaf node-protect { + type boolean; + default "true"; + description "Enable node and link protection for the specified LSP"; + } + + } // container fast-reroute + + container max-sr-labels { + description "Enter the max-sr-labels context"; + + leaf label-stack-size { + type uint32 { + range "1..11"; + } + default "6"; + description "Maximum Label Stack size"; + } + + leaf additional-frr-labels { + type uint32 { + range "0..4"; + } + default "1"; + description "Value for the maximum additional overhead labels"; + } + + } // container max-sr-labels + + list admin-tag { + key "name"; + max-elements 4; + description "Enter the admin-tag context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type string { + length "1..32"; + } + } + description "Name of the admin tags"; + } + + } // list admin-tag + + container auto-bandwidth { + presence "Enable/disable auto bandwidth for LSP."; + description "Enter the auto-bandwidth context"; + + leaf max-bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "100000"; + description "Maximum bandwidth of auto-bandwidth to request for the LSP"; + } + + leaf min-bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Minimum bandwidth of auto-bandwidth to request for the LSP"; + } + + leaf monitor-bandwidth { + type boolean; + default "false"; + description "Collect and display auto-bandwidth measurements for the LSP"; + } + + list fc { + key "fc-name"; + max-elements 8; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class name for LSP"; + } + + leaf sampling-weight { + type types-sros:percent; + default "100"; + description "Forwarding class weight for LSP"; + } + + } // list fc + + container adjust-down { + description "Enter the adjust-down context"; + + leaf percent { + type types-sros:percent; + default "5"; + description "Minimum difference in percent between LSP bandwidth reservation and the maximum average data rate"; + } + + leaf bw { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Minimum difference in absolute bandwidth between LSP bandwidth reservation and max average data rate"; + } + + } // container adjust-down + + container adjust-up { + description "Enter the adjust-up context"; + + leaf percent { + type types-sros:percent; + default "5"; + description "Minimum difference in percent between LSP bandwidth reservation and the maximum average data rate"; + } + + leaf bw { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Minimum difference in absolute bandwidth between LSP bandwidth reservation and max average data rate"; + } + + } // container adjust-up + + container multipliers { + description "Enter the multipliers context"; + + leaf sample-multiplier { + type uint32 { + range "1..511"; + } + description "Multiplier for collection intervals in a sample interval"; + } + + leaf adjust-multiplier { + type uint32 { + range "1..16383"; + } + description "Number of collection intervals in the adjust interval"; + } + + } // container multipliers + + container overflow-limit { + presence "Configure overflow limit for auto-bandwidth for LSP."; + description "Enter the overflow-limit context"; + + leaf threshold { + type types-sros:percent; + default "0"; + description "Minimum difference in percent between the LSP bandwidth and the sampled data rate"; + } + + leaf bw { + type uint32 { + range "1..100000"; + } + units "megabps"; + description "Minimum difference in absolute bandwidth between the LSP bandwidth and the sampled data rate"; + } + + leaf number { + type uint32 { + range "1..10"; + } + mandatory true; + description "Number of overflow samples to trigger an overflow auto-bandwidth adjustment attempt"; + } + + } // container overflow-limit + + container underflow-limit { + presence "Configure underflow limit for auto-bandwidth for LSP."; + description "Enter the underflow-limit context"; + + leaf threshold { + type types-sros:percent; + default "0"; + description "Minimum difference in percent between the LSP bandwidth and the sampled data rate"; + } + + leaf bw { + type uint32 { + range "1..100000"; + } + units "megabps"; + description "Minimum difference in absolute bandwidth between the LSP bandwidth and the sampled data rate"; + } + + leaf number { + type uint32 { + range "1..10"; + } + mandatory true; + description "Number of overflow samples to trigger an overflow auto-bandwidth adjustment attempt"; + } + + } // container underflow-limit + + container use-last-adj-bw { + presence "Enable/disable use of last adjusted bandwidth for LSP."; + description "Enable/disable use of last adjusted bandwidth for LSP."; + + leaf secondary-retry-limit { + type types-mpls:retry-limit; + default "5"; + description + "Specify the max number of retry attempts that will be made + to signal the secondary path with the last adjusted bandwidth."; + } + + } // container use-last-adj-bw + + } // container auto-bandwidth + + container egress-statistics { + presence "Enable/disable LSP egress statistics."; + description "Enter the egress-statistics context"; + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy ID"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ingress statistics for LSP"; + } + + } // container egress-statistics + + container ingress-statistics { + presence "Enable/disable LSP ingress statistics."; + description "Enter the ingress-statistics context"; + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy ID"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ingress statistics for LSP"; + } + + } // container ingress-statistics + + container bfd { + description "Enter the bfd context"; + + leaf bfd-liveness { + type boolean; + default "false"; + description "Enable BFD"; + } + + leaf bfd-template { + type types-sros:named-item; + description "BFD template"; + } + + leaf lsp-ping-interval { + type union { + type uint32 { + range "60..300"; + } + type enumeration { + enum "none" { value 0; } + } + } + units "seconds"; + default "60"; + description "Interval for periodic LSP ping for BFD bootstrapping"; + } + + leaf failure-action { + type enumeration { + enum "none" { value 0; } + enum "down" { value 1; } + enum "failover" { value 2; } + } + default "none"; + description "Perform action when LSP BFD session fails"; + } + + } // container bfd + + list path-profile { + key "profile-id"; + max-elements 5; + description "Enter the path-profile context"; + + leaf profile-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..max"; + } + } + description "Profile ID for the specified LSP"; + } + + leaf path-group { + type uint32; + default "0"; + description "Profile ID for the specified LSP"; + } + + } // list path-profile + + list primary { + key "path-name"; + max-elements 1; + description "Enter the primary context"; + + leaf path-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Path name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of LSP path"; + } + + leaf adaptive { + type boolean; + description "Enable/disable make-before-break functionality."; + } + + leaf bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Amount of bandwidth to be reserved."; + } + + leaf hop-limit { + type uint32 { + range "2..255"; + } + description + "The maximum number of hops that an LSP will traverse + including the ingress and egress LSRs."; + } + + leaf record { + type boolean; + default "true"; + description "Enable/disable recording of all hops."; + } + + leaf record-label { + type boolean; + default "true"; + description "Enable/disable recording of labels at each node or instance."; + } + + leaf class-type { + type types-mpls:class-type; + description "Class-type"; + } + + leaf backup-class-type { + type types-mpls:class-type; + description "Class-type for the LSP or LSP path"; + } + + container priority { + description "Enter the priority context"; + + leaf setup-priority { + type types-mpls:priority; + default "7"; + description "Setup priority when insufficient bandwidth is available to set up LSP"; + } + + leaf hold-priority { + type types-mpls:priority; + default "0"; + description "Hold priority when insufficient bandwidth is available to set up LSP"; + } + + } // container priority + + container include-admin-group { + presence + "Configure administrative groups that should be included + when the LSP path is setup."; + description "Enter the include-admin-group context"; + + leaf-list group { + type types-sros:named-item; + min-elements 1; + max-elements 32; + description "Groups that are included when LSP path is setup"; + } + + } // container include-admin-group + + container exclude-admin-group { + presence + "Configure administrative groups that should be excluded + when the LSP path is setup."; + description "Enter the exclude-admin-group context"; + + leaf-list group { + type types-sros:named-item; + min-elements 1; + max-elements 32; + description "Groups to exclude when the LSP path is setup"; + } + + } // container exclude-admin-group + + container bfd { + description "Enter the bfd context"; + + leaf bfd-liveness { + type boolean; + default "false"; + description "Enable BFD"; + } + + leaf bfd-template { + type types-sros:named-item; + description "BFD template"; + } + + leaf lsp-ping-interval { + type union { + type uint32 { + range "60..300"; + } + type enumeration { + enum "none" { value 0; } + } + } + units "seconds"; + default "60"; + description "Interval for periodic LSP ping for BFD bootstrapping"; + } + + } // container bfd + + } // list primary + + list secondary { + key "path-name"; + max-elements 8; + description "Enter the secondary context"; + + leaf path-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Path name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of LSP path"; + } + + leaf adaptive { + type boolean; + description "Enable/disable make-before-break functionality."; + } + + leaf bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Amount of bandwidth to be reserved."; + } + + leaf hop-limit { + type uint32 { + range "2..255"; + } + description + "The maximum number of hops that an LSP will traverse + including the ingress and egress LSRs."; + } + + leaf record { + type boolean; + default "true"; + description "Enable/disable recording of all hops."; + } + + leaf record-label { + type boolean; + default "true"; + description "Enable/disable recording of labels at each node or instance."; + } + + leaf class-type { + type types-mpls:class-type; + description "Class-type"; + } + + leaf path-preference { + type int32 { + range "0..255"; + } + default "255"; + description "Path preference for the secondary standby path"; + } + + leaf srlg { + type boolean; + default "false"; + description "Use SRLG constraint in secondary path computation for an LSP at the head-end LER"; + } + + leaf standby { + type boolean; + default "false"; + description "Maintain secondary path LSP indefinitely in hot standby state"; + } + + container priority { + description "Enter the priority context"; + + leaf setup-priority { + type types-mpls:priority; + default "7"; + description "Setup priority when insufficient bandwidth is available to set up LSP"; + } + + leaf hold-priority { + type types-mpls:priority; + default "0"; + description "Hold priority when insufficient bandwidth is available to set up LSP"; + } + + } // container priority + + container include-admin-group { + presence + "Configure administrative groups that should be included + when the LSP path is setup."; + description "Enter the include-admin-group context"; + + leaf-list group { + type types-sros:named-item; + min-elements 1; + max-elements 32; + description "Groups that are included when LSP path is setup"; + } + + } // container include-admin-group + + container exclude-admin-group { + presence + "Configure administrative groups that should be excluded + when the LSP path is setup."; + description "Enter the exclude-admin-group context"; + + leaf-list group { + type types-sros:named-item; + min-elements 1; + max-elements 32; + description "Groups to exclude when the LSP path is setup"; + } + + } // container exclude-admin-group + + } // list secondary + + list primary-p2mp-instance { + key "instance-name"; + max-elements 1; + description "Enter the primary-p2mp-instance context"; + + leaf instance-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "The unique name which identifies this P2MP LSP for this virtual router. "; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of LSP path"; + } + + leaf adaptive { + type boolean; + description "Enable/disable make-before-break functionality."; + } + + leaf bandwidth { + type uint32 { + range "0..100000"; + } + units "megabps"; + default "0"; + description "Amount of bandwidth to be reserved."; + } + + leaf hop-limit { + type uint32 { + range "2..255"; + } + description + "The maximum number of hops that an LSP will traverse + including the ingress and egress LSRs."; + } + + leaf record { + type boolean; + default "true"; + description "Enable/disable recording of all hops."; + } + + leaf record-label { + type boolean; + default "true"; + description "Enable/disable recording of labels at each node or instance."; + } + + container include-admin-group { + presence + "Configure administrative groups that should be included + when the P2MP LSP is setup."; + description "Enter the include-admin-group context"; + + leaf-list group { + type types-sros:named-item; + min-elements 1; + max-elements 32; + description "Groups that are included when LSP path is setup"; + } + + } // container include-admin-group + + container exclude-admin-group { + presence + "Configure administrative groups that should be excluded + when the P2MP LSP is setup."; + description "Enter the exclude-admin-group context"; + + leaf-list group { + type types-sros:named-item; + min-elements 1; + max-elements 32; + description "Groups to exclude when the LSP path is setup"; + } + + } // container exclude-admin-group + + list s2l-path { + key "path-name to"; + max-elements 650; + description "Enter the s2l-path context"; + + leaf path-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "A label switch path (P2MP LSP) name."; + } + + leaf to { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-address; + } + description "The IP address of the destination address of the S2L sub LSP."; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administratively enable/disable the P2MP S2L sub LSP."; + } + + } // list s2l-path + + } // list primary-p2mp-instance + + } // list lsp + + list auto-lsp { + key "template-name"; + max-elements 500; + description "Enter the auto-lsp context"; + + leaf template-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name of the LSP template used to automatically create and signal multiple LSP instances"; + } + + choice auto-lsp-choice { + case one-hop { + + leaf one-hop { + type boolean; + default "false"; + description "Enable the automatic signaling of one-hop point-to-point LSPs"; + } + + } + case policy { + + leaf-list policy { + type types-sros:named-item-64; + max-elements 5; + ordered-by user; + description + "Specify policies to bind to this LSP template to enable automatic + creation of mesh point to point (P2P) LSPs."; + } + + } + } + } // list auto-lsp + + list static-lsp { + key "lsp-name"; + max-elements 1000; + description "Enter the static-lsp context"; + + leaf lsp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Labeled Switch path name"; + } + + leaf metric { + type uint32 { + range "1..16777215"; + } + description "MPLS static LSP metric to select an LSP"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the static LSP"; + } + + leaf to { + type types-sros:ipv4-unicast-address; + description "Destination IP address or the egress router for the LSP"; + } + + container push { + presence + "Configure label to be pushed on the label stack and + the next hop IP address."; + description "Enter the push context"; + + leaf out-label { + type union { + type uint32 { + range "16..1048575"; + } + type enumeration { + enum "implicit-null-label" { value 3; } + } + } + mandatory true; + description "Push specific label onto the top of the outgoing packet's label stack"; + } + + leaf next-hop { + type types-sros:ipv4-unicast-address; + mandatory true; + description "IP address for the next hop"; + } + + } // container push + + } // list static-lsp + + container forwarding-policies { + presence "Enable/disable Forwarding Policies for MPLS."; + description "Enter the forwarding-policies context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of MPLS forwarding policies"; + } + + leaf reserved-label-block { + type types-sros:named-item-64; + description "Reserved label block"; + } + + list forwarding-policy { + key "policy-name"; + max-elements 65536; + description "Enter the forwarding-policy context"; + + leaf policy-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Forwarding policy name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the forwarding policy"; + } + + leaf binding-label { + type types-sros:mpls-label-or-zero; + description "Binding label"; + } + + leaf endpoint { + type types-sros:ip-unicast-address; + description "Configure endpoint address."; + } + + leaf revert-timer { + type uint32 { + range "1..600"; + } + units "seconds"; + description "Revert timer"; + } + + leaf preference { + type uint32 { + range "1..255"; + } + default "255"; + description "Preference number"; + } + + leaf metric { + type uint32 { + range "1..16777215"; + } + description "Configure metric."; + } + + leaf tunnel-table-pref { + type uint32 { + range "1..255"; + } + default "255"; + description "Configure tunnel table preference."; + } + + list next-hop-group { + key "index"; + max-elements 32; + description "Enter the next-hop-group context"; + + leaf index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..32"; + } + } + description "Index for next hop group"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of next hop group"; + } + + leaf resolution-type { + type enumeration { + enum "direct" { value 1; } + enum "indirect" { value 2; } + } + sros-ext:immutable; + mandatory true; + description "Resolution type for next hop group"; + } + + leaf load-balancing-weight { + type uint32 { + range "1..max"; + } + description "Configure load balancing weight."; + } + + container primary-next-hop { + presence "Configure primary next-hop."; + description "Enter the primary-next-hop context"; + + leaf next-hop { + type types-sros:ip-unicast-address; + description "Next hop address"; + } + + list pushed-labels { + key "index"; + max-elements 10; + description "Enter the pushed-labels context"; + + leaf index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..10"; + } + } + description "Index for push-label."; + } + + leaf label { + type uint32 { + range "1..1048575"; + } + mandatory true; + description "Push label value."; + } + + } // list pushed-labels + + } // container primary-next-hop + + container backup-next-hop { + presence "Configure backup next-hop."; + description "Enter the backup-next-hop context"; + + leaf next-hop { + type types-sros:ip-unicast-address; + description "Next hop address"; + } + + list pushed-labels { + key "index"; + max-elements 10; + description "Enter the pushed-labels context"; + + leaf index { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..10"; + } + } + description "Index for push-label."; + } + + leaf label { + type uint32 { + range "1..1048575"; + } + mandatory true; + description "Push label value."; + } + + } // list pushed-labels + + } // container backup-next-hop + + } // list next-hop-group + + container ingress-statistics { + presence "Configure ingress-statistics."; + description "Enter the ingress-statistics context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of egress or ingress statistics"; + } + + } // container ingress-statistics + + } // list forwarding-policy + + } // container forwarding-policies + + container pce-init-lsp { + presence "Enable/disable support of PCE initiated LSPs"; + description "Enable/disable support of PCE initiated LSPs."; + + container sr-te { + presence "Enable/Disable support of PCE initiated SR-TE LSPs"; + description "Specifies if PCE initiated SR-TE LSPs are supported on the system."; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administratively enable or disable PCE initiated SR-TE LSPs."; + } + + } // container sr-te + + } // container pce-init-lsp + + container ingress-statistics { + description "Enter the ingress-statistics context"; + + list lsp { + key "sender lsp-name"; + description "Enter the lsp context"; + + leaf sender { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-unicast-address; + } + description "Sender address"; + } + + leaf lsp-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "Administrative name for Labeled Switch Path."; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy ID"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ingress statistics for LSP"; + } + + } // list lsp + + list p2mp-template-lsp { + key "sender rsvp-session-name"; + description "Enter the p2mp-template-lsp context"; + + leaf sender { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-unicast-address; + } + description "Sender address"; + } + + leaf rsvp-session-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "RSVP session name"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy ID"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ingress statistics for LSP"; + } + + leaf max-stats { + type uint32 { + range "1..8191"; + } + default "8191"; + description "Maximum number of statistic indices"; + } + + } // list p2mp-template-lsp + + list p2p-template-lsp { + key "sender rsvp-session-name"; + description "Enter the p2p-template-lsp context"; + + leaf sender { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-unicast-address; + } + description "Sender address"; + } + + leaf rsvp-session-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item-64; + } + description "RSVP session name"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy ID"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of ingress statistics for LSP"; + } + + leaf max-stats { + type uint32 { + range "1..8191"; + } + default "8191"; + description "Maximum number of statistic indices"; + } + + } // list p2p-template-lsp + + } // container ingress-statistics + + container aux-stats { + presence "Configure aux-stats."; + description "Enter the aux-stats context"; + + leaf sr { + type boolean; + default "false"; + description "Count Segment Routing (SR) traffic in the auxiliary MPLS statistics table"; + } + + } // container aux-stats + + } // container mpls + + container rsvp { + presence "Enables RSVP functionality."; + description "Enter the rsvp context"; + + leaf entropy-label-capability { + type boolean; + default "false"; + description "Allow receiving and processing of the entropy label and ELI on incoming packets of RSVP LSPs"; + } + + leaf graceful-shutdown { + type boolean; + default "false"; + description "Initiate a graceful shutdown of all RSVP interfaces on the node"; + } + + leaf implicit-null-label { + type boolean; + default "false"; + description "Signal the implicit null option for all RSVP LSPs"; + } + + leaf keep-multiplier { + type uint32 { + range "1..255"; + } + default "3"; + description "Value for the keep-multiplier to declare a reservation or neighbor as down"; + } + + leaf include-node-id-in-rro { + type boolean; + default "false"; + description "Include the node-id sub-object in the RRO (Record Route Object) on the RSVP instance"; + } + + leaf p2mp-merge-point-abort-timer { + type uint32 { + range "1..65535"; + } + units "seconds"; + description "Merge pointer timer for abort timer"; + } + + leaf p2p-merge-point-abort-timer { + type uint32 { + range "1..65535"; + } + units "seconds"; + description "Merge pointer timer for P2P paths"; + } + + leaf preemption-timer { + type uint32 { + range "0..1800"; + } + units "seconds"; + default "300"; + description "Preemption timer for the MPLS instance"; + } + + leaf rapid-retransmit-time { + type uint32 { + range "1..100"; + } + units "deciseconds"; + default "5"; + description "Rapid retransmission interval to reliably deliver RSVP messages"; + } + + leaf rapid-retry-limit { + type uint32 { + range "1..6"; + } + default "3"; + description "Rapid retry limit to reliably deliver RSVP messages"; + } + + leaf refresh-reduction-over-bypass { + type boolean; + default "false"; + description "Enable/disable refresh reduction capabilities over all bypass tunnels."; + } + + leaf refresh-time { + type uint32 { + range "1..65535"; + } + units "seconds"; + default "30"; + description "Interval between refresh messages"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of RSVP"; + } + + leaf-list te-down-threshold { + type types-rsvp:rsvp-te-threshold-level; + max-elements 16; + ordered-by user; + description "Value for the te-down-threshold"; + } + + leaf-list te-up-threshold { + type types-rsvp:rsvp-te-threshold-level; + max-elements 16; + ordered-by user; + description "Value for the te-up-threshold"; + } + + container graceful-restart { + description "Enter the graceful-restart context"; + + leaf max-recovery { + type uint32 { + range "1..1800"; + } + units "seconds"; + default "300"; + description "Maximum time to wait before a graceful helper recovers the session"; + } + + leaf max-restart { + type uint32 { + range "1..300"; + } + units "seconds"; + default "120"; + description "Maximum time that a graceful helper waits for session restart after the neighbor is considered down"; + } + + } // container graceful-restart + + container msg-pacing { + presence "Enable/disable RSVP message pacing."; + description "Enter the msg-pacing context"; + + leaf max-burst { + type uint32 { + range "100..1000"; + } + default "650"; + description "Maximum RSVP messages that are sent over a specified period when message pacing is enabled"; + } + + leaf period { + type uint32 { + range "100..1000"; + } + units "milliseconds"; + default "100"; + description "Time for RSVP message pacing"; + } + + } // container msg-pacing + + container te-threshold-update { + presence "Enables RSVP threshold based IGP TE functionality."; + description "Enter the te-threshold-update context"; + + leaf on-cac-failure { + type boolean; + default "false"; + description "CAC (Call Admission Control) failure-triggered IGP update"; + } + + leaf update-timer { + type uint32 { + range "1..300"; + } + units "seconds"; + description "Timer-based IGP updates"; + } + + } // container te-threshold-update + + container dbw-accounting { + presence "Enables Dark Bandwidth accounting."; + description "Enter the dbw-accounting context"; + + leaf dbw-multiplier { + type uint32 { + range "0..1000"; + } + units "percent"; + default "100"; + description "Dark Bandwidth multiplier"; + } + + leaf sample-interval { + type uint32 { + range "10..600"; + } + units "seconds"; + default "30"; + description "Dark Bandwidth sample interval"; + } + + leaf sample-multiplier { + type uint32 { + range "1..10"; + } + default "3"; + description "Dark Bandwidth sample multiplier"; + } + + container up-threshold { + description "Enter the up-threshold context"; + + leaf percent { + type types-sros:percent; + default "0"; + description "Minimum difference in percent between dark bandwidth and sampled data rate, to trigger IGP-TE update"; + } + + leaf bw { + type int32 { + range "0..1000000"; + } + units "megabps"; + description "Minimum absolute difference between dark bandwidth and sampled data rate to trigger IGP-TE update"; + } + + } // container up-threshold + + container down-threshold { + description "Enter the down-threshold context"; + + leaf percent { + type types-sros:percent; + default "0"; + description "Minimum difference in percent between dark bandwidth and sampled data rate, to trigger IGP-TE update"; + } + + leaf bw { + type int32 { + range "0..1000000"; + } + units "megabps"; + description "Minimum absolute difference between dark bandwidth and sampled data rate to trigger IGP-TE update"; + } + + } // container down-threshold + + } // container dbw-accounting + + container diffserv-te { + presence "Enables RSVP DiffServ TE functionality."; + description "Enter the diffserv-te context"; + + leaf admission-control-model { + type enumeration { + enum "mam" { value 1; } + enum "rdm" { value 2; } + } + mandatory true; + description "Parameters for the DiffServ TE node"; + } + + container class-type-bw { + description "Enter the class-type-bw context"; + + leaf ct0 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 0"; + } + + leaf ct1 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 1"; + } + + leaf ct2 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 2"; + } + + leaf ct3 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 3"; + } + + leaf ct4 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 4"; + } + + leaf ct5 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 5"; + } + + leaf ct6 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 6"; + } + + leaf ct7 { + type int32 { + range "0..100"; + } + default "0"; + description "Percentage of RSVP interface bandwidth for class type (CT) 7"; + } + + } // container class-type-bw + + list fc { + key "fc-name"; + description "Enter the fc context"; + + leaf fc-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:fc-name; + } + description "Forwarding class for this mapping"; + } + + leaf class-type { + type types-mpls:class-type; + mandatory true; + description "Diff-Serv Class Type (CT) for an LSP"; + } + + } // list fc + + list te-class { + key "te-class-number"; + description "Enter the te-class context"; + + leaf te-class-number { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "0..7"; + } + } + description "Unique value that identifies the TE class."; + } + + leaf class-type { + type types-mpls:class-type; + sros-ext:immutable; + mandatory true; + description "Class type (CT) associated with the TE class"; + } + + leaf priority { + type types-mpls:priority; + sros-ext:immutable; + mandatory true; + description "TE class priority"; + } + + } // list te-class + + } // container diffserv-te + + list interface { + key "interface-name"; + description "Enter the interface context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Index for router RSVP interface"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of RSVP on the interface"; + } + + leaf authentication-keychain { + type types-sros:named-item; + description "Configure TCP authentication keychain to use for the session."; + } + + leaf authentication-key { + type types-sros:encrypted-leaf { + length "1..51"; + } + description "Authentication or hash key string"; + } + + leaf bfd-liveness { + type boolean; + default "false"; + description "Enable BFD"; + } + + leaf graceful-restart-helper-mode { + type boolean; + default "false"; + description "Enable graceful restart helper for the RSVP interface"; + } + + leaf graceful-shutdown { + type boolean; + default "false"; + description "Initiate a graceful shutdown of RSVP interface"; + } + + leaf hello-interval { + type uint32 { + range "0..60"; + } + units "seconds"; + default "3"; + description "Time between RSVP Hello messages"; + } + + leaf subscription { + type uint32 { + range "0..1000"; + } + default "100"; + description "Percentage of the link bandwidth to use for reservation"; + } + + leaf dbw-multiplier { + type int32 { + range "0..1000"; + } + units "percent"; + description "Configure the Dark Bandwidth multiplier."; + } + + leaf implicit-null-label { + type boolean; + description "Signal the implicit null label value for all LSPs"; + } + + container class-type-bw { + presence "Enables RSVP interface class-type bw functionality."; + description "Enter the class-type-bw context"; + + leaf ct0 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 0"; + } + + leaf ct1 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 1"; + } + + leaf ct2 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 2"; + } + + leaf ct3 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 3"; + } + + leaf ct4 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 4"; + } + + leaf ct5 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 5"; + } + + leaf ct6 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 6"; + } + + leaf ct7 { + type int32 { + range "0..100"; + } + description "Percentage of link bandwidth for class type (CT) 7"; + } + + } // container class-type-bw + + container refresh-reduction { + presence "Enable/Disable refresh reduction."; + description "Enter the refresh-reduction context"; + + leaf reliable-delivery { + type boolean; + default "false"; + description "Reliable delivery of RSVP messages over the RSVP interface"; + } + + } // container refresh-reduction + + container dbw-up-threshold { + presence "Configure up threshold for Dark Bandwidth."; + description "Enter the dbw-up-threshold context"; + + leaf percent { + type int32 { + range "0..100"; + } + units "percent"; + description "Minimum difference in percent between dark bandwidth and sampled data rate, to trigger IGP-TE update"; + } + + leaf bw { + type int32 { + range "0..1000000"; + } + units "megabps"; + description "Minimum absolute difference between dark bandwidth and sampled data rate to trigger IGP-TE update"; + } + + } // container dbw-up-threshold + + container dbw-down-threshold { + presence "Configure down threshold for Dark Bandwidth."; + description "Enter the dbw-down-threshold context"; + + leaf percent { + type int32 { + range "0..100"; + } + units "percent"; + description "Minimum difference in percent between dark bandwidth and sampled data rate, to trigger IGP-TE update"; + } + + leaf bw { + type int32 { + range "0..1000000"; + } + units "megabps"; + description "Minimum absolute difference between dark bandwidth and sampled data rate to trigger IGP-TE update"; + } + + } // container dbw-down-threshold + + container te-down-threshold { + presence "Specifies down TE threshold levels."; + description "Enter the te-down-threshold context"; + + leaf-list value { + type types-rsvp:rsvp-te-threshold-level; + min-elements 1; + max-elements 16; + ordered-by user; + description "Specifies down TE threshold levels."; + } + + } // container te-down-threshold + + container te-up-threshold { + presence "Specifies up TE threshold levels."; + description "Enter the te-up-threshold context"; + + leaf-list value { + type types-rsvp:rsvp-te-threshold-level; + min-elements 1; + max-elements 16; + ordered-by user; + description "Specifies up TE threshold levels."; + } + + } // container te-up-threshold + + } // list interface + + } // container rsvp + + } // list router + + container service { + description "Enter the service context"; + + list vpls { + key "service-name"; + description "Enter the vpls context"; + + leaf service-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:service-name; + } + description "Name of the service"; + } + + leaf service-id { + type types-services:external-service-id; + sros-ext:immutable; + description "Unique service ID; cannot be used by any other service, regardless of service type"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf customer { + type types-services:customer-name; + sros-ext:immutable; + mandatory true; + description "Service customer ID"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the mirror destination service"; + } + + leaf vpn-id { + type types-services:vpn-id; + sros-ext:immutable; + description "VPN identifier for the service"; + } + + leaf service-mtu { + type int32 { + range "1..9194"; + } + default "1514"; + description "MTU size"; + } + + leaf etree { + type boolean; + sros-ext:immutable; + default "false"; + description "Use VPLS as an E-Tree VPLS"; + } + + leaf pbb-type { + type types-services:pbb-type; + sros-ext:immutable; + description "PBB VPLS type"; + } + + leaf mcast-ipv6-snooping-scope { + type enumeration { + enum "sg-based" { value 1; } + enum "mac-based" { value 2; } + } + default "mac-based"; + description "IPv6 multicast snooping scope"; + } + + leaf multicast-info-policy { + type types-sros:named-item; + description "Multicast information policy"; + } + + leaf shcv-policy-ipv4 { + type types-sros:external-named-item; + description "Subscriber host connectivity verification policy for IPv4"; + } + + leaf temp-flooding { + type int32 { + range "3..600"; + } + units "seconds"; + description "Temporary flooding"; + } + + container stp { + description "Enter the stp context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Enable/disable spanning tree protocol (STP)"; + } + + leaf forward-delay { + type int32 { + range "4..30"; + } + default "15"; + description "Configure forward-delay"; + } + + leaf hello-time { + type int32 { + range "1..10"; + } + default "2"; + description "Configure hello-time"; + } + + leaf hold-count { + type int32 { + range "1..20"; + } + default "6"; + description "Configure BPDU transmit hold count"; + } + + leaf maximum-age { + type int32 { + range "6..40"; + } + default "20"; + description "Configure maximum STP information age"; + } + + leaf mode { + type enumeration { + enum "rstp" { value 2; } + enum "comp-dot1w" { value 3; } + enum "dot1w" { value 4; } + } + default "rstp"; + description "Configure protocol version"; + } + + leaf priority { + type int32 { + range "0..65535"; + } + default "32768"; + description "Configure STP bridge priority"; + } + + } // container stp + + container fdb { + description "Enter the fdb context"; + + leaf discard-unknown { + type boolean; + default "false"; + description "Discard packets with unknown destination MAC addresses"; + } + + leaf mac-subnet-length { + type int32 { + range "24..48"; + } + default "48"; + description "MAC sub-net length."; + } + + leaf selective-learning { + type boolean; + default "false"; + description "Selective learning status."; + } + + container table { + description "Enter the table context"; + + leaf high-wmark { + type int32 { + range "0..100"; + } + default "95"; + description "High watermark for the FDB table"; + } + + leaf low-wmark { + type int32 { + range "0..100"; + } + default "90"; + description "Low watermark for the FDB table"; + } + + leaf size { + type int32 { + range "1..511999"; + } + default "250"; + description "Maximum MAC entries in the FDB"; + } + + } // container table + + container mac-learning { + description "Enter the mac-learning context"; + + leaf learning { + type boolean; + default "true"; + description "Enable learning of new MAC addresses"; + } + + leaf aging { + type boolean; + default "true"; + description "Enable aging of MAC addresses"; + } + + leaf local-age-time { + type int32 { + range "60..86400"; + } + default "300"; + description "Aging time for locally learned MAC addresses"; + } + + leaf remote-age-time { + type int32 { + range "60..86400"; + } + default "900"; + description "Aging time for locally learned MAC addresses"; + } + + } // container mac-learning + + container mac-move { + description "Enter the mac-move context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of MAC move"; + } + + } // container mac-move + + container static-mac { + description "Enter the static-mac context"; + + list mac { + key "mac-address"; + description "Enter the mac context"; + + leaf mac-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:mac-unicast-address-no-zero; + } + description "Static MAC address to SAP/SDP-binding or black-hole"; + } + + leaf monitor { + type enumeration { + enum "none" { value 0; } + enum "forward-status" { value 1; } + } + sros-ext:immutable; + default "none"; + description "Entity to be monitored to decide whether this entry can be installed in the FDB"; + } + + choice destination { + mandatory true; + case spoke-sdp { + + leaf spoke-sdp { + type types-services:sdp-bind-id; + sros-ext:immutable; + description "Spoke SDP bind associated with this MAC"; + } + + } + case mesh-sdp { + + leaf mesh-sdp { + type types-services:sdp-bind-id; + sros-ext:immutable; + description "Mesh SDP bind associated with this MAC"; + } + + } + case sap { + + leaf sap { + type types-sros:sap; + sros-ext:immutable; + description "SAP associated with this MAC"; + } + + } + case blackhole { + + leaf blackhole { + type empty; + sros-ext:immutable; + description "Create a static FDB entry for the MAC address to black-hole traffic"; + } + + } + case endpoint { + + leaf endpoint { + type types-sros:named-item; + sros-ext:immutable; + description "Endpoint associated with this MAC"; + } + + } + } + } // list mac + + } // container static-mac + + } // container fdb + + container mfib { + description "Enter the mfib context"; + + container table { + description "Enter the table context"; + + leaf high-wmark { + type int32 { + range "0..100"; + } + default "95"; + description "High watermark for the MFIB table"; + } + + leaf low-wmark { + type int32 { + range "0..100"; + } + default "90"; + description "Low watermark for the MFIB table"; + } + + leaf size { + type int32 { + range "1..40959"; + } + description "Maximum SG entries in the MFIB"; + } + + } // container table + + } // container mfib + + container mac-flush { + description "Enter the mac-flush context"; + + container tldp { + description "Enter the tldp context"; + + leaf propagate { + type boolean; + default "false"; + description "Propagate MAC flush frames from LDP peer to all mesh-SDP and Spoke-SDPs."; + } + + leaf send-on-failure { + type boolean; + default "false"; + description "Send MAC withdraw message on SAP/Spoke-SDP failure"; + } + + } // container tldp + + } // container mac-flush + + container vxlan { + description "Enter the vxlan context"; + + leaf source-vtep { + type types-sros:ip-unicast-address; + description "Vxlan source virtual tunnel endpoint information"; + } + + list instance { + key "vxlan-instance"; + description "Enter the instance context"; + + leaf vxlan-instance { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..2"; + } + } + default "1"; + description "VXLAN instance"; + } + + leaf vni { + type types-services:vxlan-vni; + sros-ext:immutable; + mandatory true; + description "VNI of the VXLAN"; + } + + leaf source-vtep-security { + type boolean; + default "false"; + description "Enable/disable source vtep security"; + } + + leaf rx-discard-on-ndf { + type enumeration { + enum "bm" { value 0; } + enum "bum" { value 1; } + enum "none" { value 2; } + } + default "bm"; + description "specifies the type of multicast traffic discarded on the receive side of when the vxlan instance is NDF"; + } + + container assisted-replication { + description "Enter the assisted-replication context"; + + choice role { + case leaf { + + container leaf { + presence "AR role as leaf."; + description "Enter the leaf context"; + + leaf acttime { + type uint32 { + range "1..255"; + } + units "seconds"; + description "Time for the leaf to wait before sending traffic to a new replicator"; + } + + } // container leaf + + } + case replicator { + + leaf replicator { + type empty; + description "AR role as replicator"; + } + + } + } + } // container assisted-replication + + container network { + description "Enter the network context"; + + container ingress { + description "Enter the ingress context"; + + container qos { + description "Enter the qos context"; + + container network { + description "Enter the network context"; + + leaf policy-name { + type types-qos:network-policy-name; + description "Ingress network policy name applied to this SDP binding"; + } + + container fp-redirect-group { + description "Enter the fp-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Forwarding-plane queue group policy for this SDP binding"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Instance of the forwarding-plane ingress Queue Group for this SDP binding"; + } + + } // container fp-redirect-group + + } // container network + + } // container qos + + } // container ingress + + } // container network + + list egress-vtep { + key "ip-address"; + description "Enter the egress-vtep context"; + + leaf ip-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-unicast-address; + } + description "configure egress vtep address for entry"; + } + + } // list egress-vtep + + container fdb { + description "Enter the fdb context"; + + leaf discard-unknown-source { + type boolean; + default "false"; + description "Enable/disable discarding of frames with unknown source"; + } + + leaf maximum-mac-addresses { + type types-services:max-mac-addr; + description "Maximum number of MAC entries in the FDB from this vxlan instance"; + } + + leaf protected-src-mac-violation-action { + type types-services:vxlan-protected-src-mac-violation-action; + description "Action when a relearn request for a protected MAC is received"; + } + + container mac-learning { + description "Enter the mac-learning context"; + + leaf learning { + type boolean; + default "false"; + description "Enable/disable learning of new MAC addresses"; + } + + leaf aging { + type boolean; + default "false"; + description "Enable/disable aging of MAC addresses"; + } + + } // container mac-learning + + } // container fdb + + container igmp-snooping { + description "igmp-snooping configuration for the VXLAN instance."; + + leaf mrouter-port { + type boolean; + default "false"; + description "Configure as a multicast router port."; + } + + } // container igmp-snooping + + container mld-snooping { + description "mld-snooping configuration for the VXLAN instance."; + + leaf mrouter-port { + type boolean; + default "false"; + description "Configure as a multicast router port."; + } + + } // container mld-snooping + + } // list instance + + } // container vxlan + + container proxy-arp { + presence "Enable proxy arp configuration information."; + description "Enter the proxy-arp context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the proxy"; + } + + leaf dynamic-populate { + type boolean; + default "false"; + description "Populate proxy ARP entries from snooped GARP/ARP/ND messages on SAPs/SDP-bindings"; + } + + leaf age-time { + type union { + type int32 { + range "60..86400"; + } + type enumeration { + enum "never" { value 0; } + } + } + units "seconds"; + default "never"; + description "Aging timer for proxy entries, where entries are flushed upon timer expiry"; + } + + leaf send-refresh { + type union { + type int32 { + range "120..86400"; + } + type enumeration { + enum "never" { value 0; } + } + } + default "never"; + description "Time at which to send a refresh message"; + } + + leaf table-size { + type int32 { + range "1..16383"; + } + default "250"; + description "Maximum number of learned and static entries allowed in the proxy table of this service"; + } + + container evpn { + description "Enter the evpn context"; + + leaf route-tag { + type int32 { + range "0|1..255"; + } + default "0"; + description "Route tag used on export policies to match MAC/IP routes generated by proxy-ARP or proxy-ND module"; + } + + container flood { + description "Enter the flood context"; + + leaf unknown-arp-req { + type boolean; + default "true"; + description "Flood ARP-requests (with source squelching) if there is no active proxy-ARP entry for requested IP"; + } + + leaf gratuitous-arp { + type boolean; + default "true"; + description "Flood GARP-requests/GARP-replies to the EVPN"; + } + + } // container flood + + } // container evpn + + container duplicate-detect { + description "Enter the duplicate-detect context"; + + leaf anti-spoof-mac { + type types-sros:mac-unicast-address-no-zero; + description "MAC address to replace the proxy-ARP/ND offending entry's MAC"; + } + + leaf window { + type int32 { + range "1..15"; + } + units "minutes"; + default "3"; + description "Time to monitor the MAC address in the anti-spoofing mechanism"; + } + + leaf num-moves { + type int32 { + range "3..10"; + } + default "5"; + description "Number of moves required to declare a duplicate entry"; + } + + leaf hold-down-time { + type union { + type uint32 { + range "2..60"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "minutes"; + default "9"; + description "Hold down time for a duplicate entry"; + } + + leaf static-blackhole { + type boolean; + default "false"; + description "Consider anti-spoof MAC as black-hole static MAC in FDB"; + } + + } // container duplicate-detect + + container static-arp { + description "Enter the static-arp context"; + + list ip-address { + key "ipv4-address"; + description "Enter the ip-address context"; + + leaf ipv4-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-unicast-address; + } + description "Proxy ARP IP address"; + } + + leaf mac { + type types-sros:mac-unicast-address-no-zero; + mandatory true; + description "Proxy ARP MAC address for static entry"; + } + + } // list ip-address + + } // container static-arp + + container dynamic-arp { + description "Enter the dynamic-arp context"; + + list ip-address { + key "ipv4-address"; + description "Enter the ip-address context"; + + leaf ipv4-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-unicast-address; + } + description "Proxy ARP IP address"; + } + + leaf mac-list { + type types-sros:named-item; + description "MAC list for the dynamic entry"; + } + + leaf resolve-retry-time { + type int32 { + range "1..60"; + } + units "minutes"; + default "5"; + description "Frequency at which the resolve messages are sent"; + } + + } // list ip-address + + } // container dynamic-arp + + } // container proxy-arp + + container proxy-nd { + presence "Enable proxy nd configuration information."; + description "Enter the proxy-nd context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the proxy"; + } + + leaf dynamic-populate { + type boolean; + default "false"; + description "Populate proxy ARP entries from snooped GARP/ARP/ND messages on SAPs/SDP-bindings"; + } + + leaf age-time { + type union { + type int32 { + range "60..86400"; + } + type enumeration { + enum "never" { value 0; } + } + } + units "seconds"; + default "never"; + description "Aging timer for proxy entries, where entries are flushed upon timer expiry"; + } + + leaf send-refresh { + type union { + type int32 { + range "120..86400"; + } + type enumeration { + enum "never" { value 0; } + } + } + default "never"; + description "Time at which to send a refresh message"; + } + + leaf table-size { + type int32 { + range "1..16383"; + } + default "250"; + description "Maximum number of learned and static entries allowed in the proxy table of this service"; + } + + container evpn { + description "Enter the evpn context"; + + leaf route-tag { + type int32 { + range "0|1..255"; + } + default "0"; + description "Route tag used on export policies to match MAC/IP routes generated by proxy-ARP or proxy-ND module"; + } + + leaf advertise-neighbor-type { + type enumeration { + enum "router" { value 1; } + enum "host" { value 2; } + } + default "router"; + description "Advertisement type of static or dynamic entries in the EVPN"; + } + + container flood { + description "Enter the flood context"; + + leaf unknown-neighbor-solicitation { + type boolean; + default "true"; + description "Flood unsolicited Neighbor Solicitation messages (with source squelching) into EVPN network"; + } + + leaf unknown-neighbor-advertise-router { + type boolean; + default "true"; + description "Flood router unsolicited Neighbor Advertisement (NA) replies to EVPN"; + } + + leaf unknown-neighbor-advertise-host { + type boolean; + default "true"; + description "Flood host unsolicited Neighbor Advertisement (NA) replies to EVPN"; + } + + } // container flood + + } // container evpn + + container duplicate-detect { + description "Enter the duplicate-detect context"; + + leaf anti-spoof-mac { + type types-sros:mac-unicast-address-no-zero; + description "MAC address to replace the proxy-ARP/ND offending entry's MAC"; + } + + leaf window { + type int32 { + range "1..15"; + } + units "minutes"; + default "3"; + description "Time to monitor the MAC address in the anti-spoofing mechanism"; + } + + leaf num-moves { + type int32 { + range "3..10"; + } + default "5"; + description "Number of moves required to declare a duplicate entry"; + } + + leaf hold-down-time { + type union { + type uint32 { + range "2..60"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "minutes"; + default "9"; + description "Hold down time for a duplicate entry"; + } + + leaf static-blackhole { + type boolean; + default "false"; + description "Consider anti-spoof MAC as black-hole static MAC in FDB"; + } + + } // container duplicate-detect + + container static-neighbor { + description "Enter the static-neighbor context"; + + list ip-address { + key "ipv6-address"; + description "Enter the ip-address context"; + + leaf ipv6-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-unicast-address; + } + description "Proxy ND IP address"; + } + + leaf mac { + type types-sros:mac-unicast-address-no-zero; + mandatory true; + description "Proxy ARP MAC address for static entry"; + } + + leaf type { + type enumeration { + enum "host" { value 0; } + enum "router" { value 1; } + } + default "router"; + description "Entry type"; + } + + } // list ip-address + + } // container static-neighbor + + container dynamic-neighbor { + description "Enter the dynamic-neighbor context"; + + list ip-address { + key "ipv6-address"; + description "Enter the ip-address context"; + + leaf ipv6-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-unicast-address; + } + description "Proxy ND IP address"; + } + + leaf mac-list { + type types-sros:named-item; + description "MAC list for the dynamic entry"; + } + + leaf resolve-retry-time { + type int32 { + range "1..60"; + } + units "minutes"; + default "5"; + description "Frequency at which the resolve messages are sent"; + } + + } // list ip-address + + } // container dynamic-neighbor + + } // container proxy-nd + + container routed-vpls { + presence "Enable to allow IP interface binding information."; + description "Enter the routed-vpls context"; + + leaf vxlan-ipv4-tep-ecmp { + type boolean; + default "false"; + description "Use ECMP on VXLAN IPv4 destinations for R-VPLS services"; + } + + container multicast { + description "Enter the multicast context"; + + container ipv4 { + description "Enter the ipv4 context"; + + leaf forward-to-ip-interface { + type boolean; + default "false"; + description "Forward IPv4 multicast from RVPLS to L3 interface"; + } + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "VPLS L3 interface as a multicast router port"; + } + + } // container igmp-snooping + + } // container ipv4 + + container ipv6 { + description "Enter the ipv6 context"; + + leaf forward-to-ip-interface { + type boolean; + default "false"; + description "Forward IPv6 multicast from RVPLS to L3 interface"; + } + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "VPLS L3 interface as a multicast router port"; + } + + } // container mld-snooping + + } // container ipv6 + + } // container multicast + + } // container routed-vpls + + container load-balancing { + description "Enter the load-balancing context"; + + leaf per-service-hashing { + type boolean; + default "false"; + description "Enable/disable per service hashing."; + } + + leaf spi-load-balancing { + type boolean; + default "false"; + description "Allow use of SPI (Security Parameter Index) in hashing for ESP/AH encrypted IPv4/IPv6 traffic"; + } + + leaf teid-load-balancing { + type boolean; + default "false"; + description "Include TEID in hashing algorithm for GTP-U/C encapsulated traffic"; + } + + } // container load-balancing + + container pbb { + description "Enter the pbb context"; + + leaf force-qtag-forwarding { + type boolean; + default "false"; + description "Enable 802.1q tag forwarding"; + } + + list backbone-vpls { + key "backbone-vpls-service-name"; + max-elements 1; + description "Enter the backbone-vpls context"; + + leaf backbone-vpls-service-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:service-name; + } + description "Backbone VPLS service"; + } + + leaf isid { + type types-services:isid; + sros-ext:immutable; + mandatory true; + description "Backbone VPLS ISID"; + } + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + list mrouter-destination { + key "mac-reference"; + description "Enter the mrouter-destination context"; + + leaf mac-reference { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Mac name reference"; + } + + } // list mrouter-destination + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + list mrouter-destination { + key "mac-reference"; + description "Enter the mrouter-destination context"; + + leaf mac-reference { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Mac name reference"; + } + + } // list mrouter-destination + + } // container mld-snooping + + list sap { + key "sap-id"; + description "Enter the sap context"; + + leaf sap-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:sap; + } + description "Backbone VPLS SAP"; + } + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + } // container mld-snooping + + } // list sap + + list spoke-sdp { + key "sdp-bind-id"; + description "Enter the spoke-sdp context"; + + leaf sdp-bind-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:sdp-bind-id; + } + description "Backbone VPLS SAP"; + } + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + } // container mld-snooping + + } // list spoke-sdp + + list mesh-sdp { + key "sdp-bind-id"; + description "Enter the mesh-sdp context"; + + leaf sdp-bind-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:sdp-bind-id; + } + description "Backbone VPLS SAP"; + } + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + } // container mld-snooping + + } // list mesh-sdp + + } // list backbone-vpls + + container i-vpls-mac-flush { + description "Enter the i-vpls-mac-flush context"; + + container tldp { + description "Enter the tldp context"; + + leaf send-on-bvpls-failure { + type boolean; + default "false"; + description "Send flush-all-from-me on b-vpls failure"; + } + + leaf propagate-from-bvpls { + type boolean; + default "false"; + description "Propagate mac-flush from b-vpls into local i-vpls"; + } + + container send-to-bvpls { + description "Enter the send-to-bvpls context"; + + leaf all-from-me { + type boolean; + default "false"; + description "Generate LDP MAC withdraw all from me message to b-VPLS"; + } + + leaf all-but-mine { + type boolean; + default "false"; + description "Generate LDP MAC withdraw message to b-VPLS"; + } + + } // container send-to-bvpls + + } // container tldp + + container bgp-evpn { + description "Enter the bgp-evpn context"; + + leaf send-to-bvpls { + type boolean; + default "false"; + description "Send b-VPLS EVPN flush"; + } + + } // container bgp-evpn + + } // container i-vpls-mac-flush + + container source-bmac { + description "Enter the source-bmac context"; + + leaf address { + type types-sros:mac-unicast-address-no-zero; + description "Backbone source MAC address used for PBB"; + } + + leaf use-es-bmac-lsb { + type boolean; + default "false"; + description "Use ethernet segment backbone MAC LSB"; + } + + leaf use-mclag-bmac-lsb { + type boolean; + default "false"; + description "Use MC LAG backbone MAC LSB"; + } + + } // container source-bmac + + container mac-notification { + description "Enter the mac-notification context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of MAC notification"; + } + + leaf count { + type uint32 { + range "1..10"; + } + description "MAC notification messages count"; + } + + leaf interval { + type uint32 { + range "1..100"; + } + units "deciseconds"; + description "Interval for MAC notification messages"; + } + + leaf renotify { + type union { + type uint32 { + range "240..840"; + } + type enumeration { + enum "none" { value 0; } + } + } + units "seconds"; + default "none"; + description "Re-notify interval for MAC-notification messages"; + } + + } // container mac-notification + + } // container pbb + + list bgp { + key "bgp-instance"; + description "Enter the bgp context"; + + leaf bgp-instance { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..2"; + } + } + description "BGP instance"; + } + + leaf route-distinguisher { + type types-services:vpn-route-distinguisher-or-auto-rd; + description "High-order 6 bytes that are used as string to compose VSI-ID for use in NLRI"; + } + + leaf-list vsi-import { + type types-sros:named-item-64; + max-elements 5; + ordered-by user; + description "VSI import policies"; + } + + leaf-list vsi-export { + type types-sros:named-item-64; + max-elements 5; + ordered-by user; + description "VSI export policies"; + } + + container route-target { + description "Enter the route-target context"; + + leaf export { + type types-services:route-target; + description "Extended community name for default import policy"; + } + + leaf import { + type types-services:route-target; + description "Extended community name for default import policy"; + } + + } // container route-target + + list pw-template-binding { + key "pw-template-name"; + max-elements 100; + description "Enter the pw-template-binding context"; + + leaf pw-template-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:pw-template-name; + } + description "PW template policy name"; + } + + leaf split-horizon-group { + type types-sros:named-item; + description "Split horizon group"; + } + + leaf bfd-template { + type types-sros:named-item; + description "BFD template name for PW-Template binding"; + } + + leaf bfd-liveness { + type boolean; + default "false"; + description "Enable BFD"; + } + + leaf-list import-rt { + type types-services:route-target; + max-elements 5; + description "Import route-target communities"; + } + + choice oper-group-association { + case oper-group { + + leaf oper-group { + type types-sros:named-item; + description "Operational group"; + } + + } + case monitor-oper-group { + + leaf monitor-oper-group { + type types-sros:named-item; + description "Oerational group to monitor"; + } + + } + } + } // list pw-template-binding + + } // list bgp + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of IGMP snooping"; + } + + leaf query-interval { + type types-sros:time-duration { + range "1..65535"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf robust-count { + type uint32 { + range "1..255"; + } + default "2"; + description "Robustness variable"; + } + + leaf report-source-address { + type types-sros:ipv4-address; + description "Source address used when generating IGMP reports."; + } + + leaf query-source-address { + type union { + type enumeration { + enum "system" { value 1; } + } + type types-sros:ipv4-address; + } + default "system"; + description "Source address for IGMP queries"; + } + + container mvr { + description "Enter the mvr context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of MVR"; + } + + leaf group-policy { + type types-sros:named-item; + description "Policy that applies MVR"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + } // container mvr + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of IGMP snooping"; + } + + leaf query-interval { + type types-sros:time-duration { + range "1..65535"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf robust-count { + type uint32 { + range "1..255"; + } + default "2"; + description "Robustness variable"; + } + + leaf report-source-address { + type types-sros:ipv6-address; + description "Source address used when generating MLD reports."; + } + + leaf query-source-address { + type union { + type enumeration { + enum "system" { value 1; } + } + type types-sros:ipv6-address; + } + default "system"; + description "Source address used when generating MLD queries."; + } + + container mvr { + description "Enter the mvr context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of MVR"; + } + + leaf group-policy { + type types-sros:named-item; + description "Policy that applies MVR"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + } // container mvr + + } // container mld-snooping + + container pim-snooping { + presence "Enable PIM on this service."; + description "Enter the pim-snooping context"; + + leaf hold-time { + type uint32 { + range "0..300"; + } + units "seconds"; + default "90"; + description "Duration that allows the PIM-snooping switch to snoop all the PIM states in the VPLS"; + } + + leaf-list group-policy { + type types-sros:display-string; + max-elements 5; + ordered-by user; + description "Group policy name"; + } + + container ipv4 { + description "Enter the ipv4 context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of snooping"; + } + + } // container ipv4 + + container ipv6 { + description "Enter the ipv6 context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of snooping"; + } + + } // container ipv6 + + } // container pim-snooping + + container bgp-ad { + presence "Enable BGP AD information."; + description "Enter the bgp-ad context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of BGP AD"; + } + + leaf vpls-id { + type types-services:vpls-id; + description "VPLS identifier as a 8-byte route distinguisher"; + } + + leaf vsi-id-prefix { + type types-sros:ipv4-address; + description "VSI prefix value"; + } + + } // container bgp-ad + + container bgp-evpn { + presence "Enable BGP EVPN information."; + description "Enter the bgp-evpn context"; + + leaf accept-ivpls-evpn-flush { + type boolean; + default "false"; + description "Accept non-zero ethernet-tag MAC routes and process for CMAC flushing"; + } + + leaf evi { + type types-services:evi; + description "EVPN ID"; + } + + leaf incl-mcast-orig-ip { + type types-sros:ipv4-unicast-address; + description "Originating IP address"; + } + + container routes { + description "Enter the routes context"; + + container mac-ip { + description "Enter the mac-ip context"; + + leaf advertise { + type boolean; + default "true"; + description "Status for the BGP-EVPN MAC/IP routes advertisement"; + } + + leaf cfm-mac { + type boolean; + default "false"; + description + "Enable/disable the advertisement of MEP, MIP, and VMEP + MAC addresses over the BGP EVPN."; + } + + leaf unknown-mac { + type boolean; + default "false"; + description + "Enable/disable the advertisement of MEP, MIP, and VMEP + MAC addresses over the BGP EVPN."; + } + + } // container mac-ip + + container ip-prefix { + description "Enter the ip-prefix context"; + + leaf advertise { + type boolean; + default "false"; + description "Status for the IP prefix routes advertisement"; + } + + leaf include-direct-interface-host { + type boolean; + default "false"; + description "BGP EVPN IP route advertisement"; + } + + } // container ip-prefix + + container incl-mcast { + description "Enter the incl-mcast context"; + + leaf advertise-ingress-replication { + type boolean; + default "true"; + description "BGP EVPN IMET-IR route advertisement"; + } + + } // container incl-mcast + + } // container routes + + container mac-duplication { + description "Enter the mac-duplication context"; + + leaf retry { + type union { + type uint32 { + range "2..60"; + } + type enumeration { + enum "never" { value 0; } + } + } + units "minutes"; + default "9"; + description "BGP EVPN MAC duplication retry"; + } + + leaf blackhole { + type boolean; + default "false"; + description "Enable black hole dup MAC configuration"; + } + + container detect { + description "Enter the detect context"; + + leaf num-moves { + type uint32 { + range "3..10"; + } + default "5"; + description "BGP EVPN MAC duplication detection number of moves"; + } + + leaf window { + type uint32 { + range "1..15"; + } + units "minutes"; + default "3"; + description "BGP EVPN MAC duplication detection window"; + } + + } // container detect + + } // container mac-duplication + + container isid-route-target { + description "Enter the isid-route-target context"; + + list range { + key "start"; + max-elements 8192; + description "Enter the range context"; + + leaf start { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:svc-isid-non-zero; + } + default "1"; + description "Starting value of the isid-range entry"; + } + + leaf end { + type types-sros:svc-isid-non-zero; + mandatory true; + description "Ending value of the isid-range entry"; + } + + leaf type { + type enumeration { + enum "auto" { value 1; } + enum "configured" { value 2; } + } + sros-ext:immutable; + default "auto"; + description "Method used to support the PBB-EVPN ISID-based route target advertisement"; + } + + leaf route-target { + type types-services:route-target; + sros-ext:immutable; + description "Route for the ISID range"; + } + + } // list range + + } // container isid-route-target + + list vxlan { + key "bgp-instance"; + description "Enter the vxlan context"; + + leaf bgp-instance { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..2"; + } + } + description "BGP instance"; + } + + leaf vxlan-instance { + type uint32 { + range "1..2"; + } + sros-ext:immutable; + mandatory true; + description "VXLAN instance"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of BGP EVPN VXLAN"; + } + + leaf send-tunnel-encap { + type boolean; + default "true"; + description "Enable/Disable sending Vxlan Encap."; + } + + leaf send-incl-mcast-ir-on-ndf { + type boolean; + default "true"; + description "Allow IMET-IR on NDF"; + } + + leaf default-route-tag { + type types-services:one-byte-value; + description "Default route tag to match against export policies: value as 0xXX."; + } + + leaf ecmp { + type types-services:ecmp-value; + default "1"; + description "Maximum ECMP routes information."; + } + + leaf mh-mode { + type enumeration { + enum "access" { value 0; } + enum "network" { value 1; } + } + default "access"; + description "Multi-homing mode"; + } + + container routes { + description "BGP-EVPN vxlan routes information"; + + container auto-disc { + description "BGP-EVPN vxlan routes auto-discovery information"; + + leaf advertise { + type boolean; + default "false"; + description "Route advertise on auto discovery"; + } + + } // container auto-disc + + } // container routes + + } // list vxlan + + list mpls { + key "bgp-instance"; + description "Enter the mpls context"; + + leaf bgp-instance { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type int32 { + range "1..2"; + } + } + description "BGP instance"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of BGP EVPN MPLS"; + } + + leaf force-vc-forwarding { + type types-services:bgp-evpn-force-vc-forwarding; + description "Forces vlan-vc-type forwarding in the data-path."; + } + + leaf control-word { + type boolean; + default "false"; + description "Enable/disable setting the CW bit in the label message."; + } + + leaf split-horizon-group { + type types-sros:named-item; + description "Split horizon group"; + } + + leaf ingress-replication-bum-label { + type boolean; + default "false"; + description "Use the same label as the one advertised for unicast traffic"; + } + + leaf ecmp { + type types-services:ecmp-value; + default "1"; + description "Maximum ECMP routes information"; + } + + leaf entropy-label { + type boolean; + default "false"; + description "Enable/disable use of entropy-label."; + } + + leaf default-route-tag { + type types-services:one-byte-value; + description "Default route tag to match against export policies: value as 0xXX."; + } + + container send-tunnel-encap { + description "Enter the send-tunnel-encap context"; + + leaf mpls { + type boolean; + default "true"; + description "Enable/disable MPLS encapsulation for this service."; + } + + leaf mpls-over-udp { + type boolean; + default "false"; + description "Enable/disable MPLS over UDP encapsulation for this service."; + } + + } // container send-tunnel-encap + + container auto-bind-tunnel { + description "Enter the auto-bind-tunnel context"; + + leaf resolution { + type types-services:resolve-status; + default "none"; + description "Resolution method for tunnel selection"; + } + + leaf enforce-strict-tunnel-tagging { + type boolean; + default "false"; + description "Enable/disable enforcement of strict tunnel tagging"; + } + + container resolution-filter { + description "Enter the resolution-filter context"; + + leaf bgp { + type boolean; + default "false"; + description "Set BGP type for auto bind tunnel"; + } + + leaf ldp { + type boolean; + default "false"; + description "Enable/disable setting LDP type for auto-bind-tunnel"; + } + + leaf rsvp { + type boolean; + default "false"; + description "Enable/disable setting RSVP-TE type for auto-bind-tunnel"; + } + + leaf sr-isis { + type boolean; + default "false"; + description "Enable/disable setting SR-ISIS type for auto-bind-tunnel"; + } + + leaf sr-ospf { + type boolean; + default "false"; + description "Segment Routing (SR) tunnel type programed by an OSPF instance in TTM"; + } + + leaf sr-te { + type boolean; + default "false"; + description "Enable/disable setting SR-TE type for auto-bind-tunnel"; + } + + leaf udp { + type boolean; + default "false"; + description "Set UDP type for auto-bind-tunnel"; + } + + leaf mpls-fwd-policy { + type boolean; + default "false"; + description "Enable/disable setting MPLS Forwarding Policy for auto-bind-tunnel"; + } + + leaf sr-policy { + type boolean; + default "false"; + description "Enable/disable setting SR Policy type for auto-bind-tunnel"; + } + + leaf rib-api { + type boolean; + default "false"; + description "Enable/disable setting RIB API type for auto-bind-tunnel"; + } + + } // container resolution-filter + + } // container auto-bind-tunnel + + container fdb { + description "Enter the fdb context"; + + leaf protected-src-mac-violation-action { + type types-services:vxlan-protected-src-mac-violation-action; + description "Action when a relearn request for a protected MAC is received"; + } + + } // container fdb + + } // list mpls + + } // container bgp-evpn + + container bgp-vpls { + presence "Enable BGP-VPLS for the service."; + description "Enter the bgp-vpls context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the service"; + } + + leaf maximum-ve-id { + type types-services:ve-id; + description "Maximum vpls-edge id for BGP-VPLS"; + } + + container ve { + description "Enter the ve context"; + + leaf name { + type types-sros:named-item; + description "Name of VPLS edge."; + } + + leaf id { + type types-services:ve-id; + description "VPLS edge identifier"; + } + + } // container ve + + } // container bgp-vpls + + list endpoint { + key "name"; + max-elements 10; + description "Enter the endpoint context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Service endpoint name"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf revert-time { + type types-services:revert-time; + default "immediate"; + description "Time to wait before reverting back to the primary spoke-sdp defined on this service endpoint"; + } + + leaf ignore-standby-signaling { + type boolean; + default "false"; + description "Ignore standby-bit received from TLDP peers when performing internal tasks"; + } + + leaf suppress-standby-signaling { + type boolean; + default "true"; + description "Do not send pseudowire standby bit to TLDP peer when specified spoke SDP is selected as standby"; + } + + leaf block-on-mesh-failure { + type boolean; + default "false"; + description + "Whether operational status of spoke-SDPs in the + endpoint will be affected by the operational status of + associated mesh SDPs in this service."; + } + + container fdb { + description "Enter the fdb context"; + + leaf mac-pinning { + type boolean; + default "false"; + description "Activate MAC address pinning on this endpoint"; + } + + leaf maximum-mac-addresses { + type types-services:max-mac-addr; + description "Maximum learned and static entries for this end point"; + } + + leaf auto-learn-mac-protect { + type boolean; + default "false"; + description "Populate automatically MAC protect list with MAC addresses learned on SDP with this endpoint"; + } + + leaf protected-src-mac-violation-action { + type types-services:sdp-protected-src-mac-violation-action; + description "Action when a relearn request for a protected MAC is received on the SDP"; + } + + } // container fdb + + } // list endpoint + + list split-horizon-group { + key "shg-name"; + description "Enter the split-horizon-group context"; + + leaf shg-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name for the service split-horizon-group"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf residential { + type boolean; + sros-ext:immutable; + default "false"; + description "Define as a residential split horizon group"; + } + + container fdb { + description "Enter the fdb context"; + + container saps { + description "Enter the saps context"; + + leaf auto-learn-mac-protect { + type boolean; + default "false"; + description "Populate automatically MAC protect list with MAC addresses learned on SDP with split horizon group"; + } + + leaf protected-src-mac-violation-action { + type types-services:sap-protected-src-mac-violation-action; + description "Action to take whenever a relearn request for a protected MAC is received"; + } + + leaf discard-unprotected-dest-mac { + type boolean; + default "false"; + description "Enable/disable unprotected dest MAC restriction"; + } + + } // container saps + + } // container fdb + + } // list split-horizon-group + + container eth-cfm { + description "Enter the eth-cfm context"; + + list mep { + key "md-admin-name ma-admin-name mep-id"; + description "Enter the mep context"; + + leaf md-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique domain name"; + } + + leaf ma-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique association name"; + } + + leaf mep-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:mep-id-type; + } + description "Maintenance association end point identifier"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the MEP"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf mac-address { + type types-sros:mac-unicast-address-no-zero; + description "MAC address for the MEP"; + } + + leaf install-mep { + type boolean; + default "false"; + description "Install MEP in the forwarding plane"; + } + + leaf low-priority-defect { + type types-eth-cfm:lowest-alarm-priority; + default "mac-rem-err-xcon"; + description "Lowest priority defect that is allowed to generate a fault alarm"; + } + + leaf ccm { + type boolean; + default "false"; + description "Generate CCM messages"; + } + + leaf ccm-ltm-priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of CCM and LTM messages transmitted by the MEP"; + } + + leaf ccm-padding-size { + type uint32 { + range "3..1500"; + } + description "Additional octets inserted into CCM PDU for data TLV padding"; + } + + leaf one-way-delay-threshold { + type uint32 { + range "0..600"; + } + units "seconds"; + default "3"; + description "Threshold for one way delay test"; + } + + container alarm-notification { + description "Enter the alarm-notification context"; + + leaf fng-alarm-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm"; + } + + leaf fng-reset-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm is reset"; + } + + } // container alarm-notification + + container eth-test { + presence "Enable/disable eth-test functionality on MEP."; + description "Enter the eth-test context"; + + leaf bit-error-threshold { + type uint32 { + range "0..11840"; + } + units "bit errors"; + default "1"; + description "Lowest priority defect threshold for the bit error trap to generate a fault alarm"; + } + + container test-pattern { + description "Enter the test-pattern context"; + + leaf pattern { + type enumeration { + enum "all-zeros" { value 0; } + enum "all-ones" { value 1; } + } + default "all-zeros"; + description "Test pattern for eth-test frames"; + } + + leaf crc-tlv { + type boolean; + default "false"; + description "Generate a CRC checksum"; + } + + } // container test-pattern + + } // container eth-test + + container grace { + description "Enter the grace context"; + + container eth-ed { + description "Enter the eth-ed context"; + + leaf max-rx-defect-window { + type uint32 { + range "1..86400"; + } + units "seconds"; + description "Value to compare to received peer value, lower is used as maximum ETH-ED expected defect window"; + } + + leaf priority { + type int32 { + range "0..7"; + } + description "Transmission priority for ETH-ED PDUs"; + } + + leaf rx-eth-ed { + type boolean; + default "true"; + description "Receive and process ETH-ED PDUs"; + } + + leaf tx-eth-ed { + type boolean; + default "false"; + description "Transmit ETH-ED PDUs"; + } + + } // container eth-ed + + container eth-vsm-grace { + description "Enter the eth-vsm-grace context"; + + leaf rx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the reception and processing of the Nokia ETH-CFM Grace PDU on the MEP"; + } + + leaf tx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the transmission of the Nokia ETH-CFM Grace PDU from the MEP"; + } + + } // container eth-vsm-grace + + } // container grace + + } // list mep + + } // container eth-cfm + + container mcr-default-gtw { + description "Enter the mcr-default-gtw context"; + + leaf ip { + type types-sros:ipv4-unicast-address; + description "Multi-chassis ring default gateway IP address"; + } + + leaf mac { + type yang:mac-address; + default "00:00:00:00:00:00"; + description "Multi-chassis ring default gateway MAC address"; + } + + } // container mcr-default-gtw + + list spoke-sdp { + key "sdp-bind-id"; + description "Enter the spoke-sdp context"; + + leaf sdp-bind-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:sdp-bind-id; + } + description + "SDP Binding identifier as <sdp-id>:<vc-id>. + sdp-id - [1..32767] + vc-id - [1..4294967295]."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of this Service SDP binding"; + } + + leaf vlan-vc-tag { + type types-services:vlan-vc-tag; + description "SDP bind VC tag"; + } + + leaf split-horizon-group { + type types-sros:named-item; + sros-ext:immutable; + description "Name of the split horizon group where the spoke SDP bind belongs to"; + } + + leaf multicast-source { + type boolean; + sros-ext:immutable; + default "false"; + description "Enable/disable multicast-source on the spoke SDP Bind."; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Allow agent to collect accounting statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Policy to collect accounting statistics"; + } + + leaf control-word { + type boolean; + default "false"; + description "Use the control word as preferred"; + } + + leaf force-vc-forwarding { + type enumeration { + enum "vlan" { value 1; } + enum "qinq-c-tag-c-tag" { value 2; } + enum "qinq-s-tag-c-tag" { value 3; } + } + description "VC forwarding status"; + } + + leaf etree-root-leaf-tag { + type boolean; + sros-ext:immutable; + default "false"; + description "E-tree root leaf tag status"; + } + + leaf etree-leaf { + type boolean; + sros-ext:immutable; + default "false"; + description "Enable etree leaf access-circuit status"; + } + + leaf bfd-template { + type types-sros:named-item; + description "BFD template associated with SDP binding"; + } + + leaf vc-type { + type types-services:vpls-sdp-bind-vc-type; + default "ether"; + description "Type of virtual circuit (VC) associated with the SDP binding; VPLS not supported"; + } + + leaf bpdu-translation { + type types-services:bpdu-translation; + description "Bpdu translation."; + } + + leaf ignore-standby-signaling { + type boolean; + default "false"; + description "Ignore standby-bit received from TLDP peers when performing internal tasks"; + } + + leaf block-on-mesh-failure { + type boolean; + default "false"; + description "Enable blocking after all configured SDPs or endpoints are in operationally down state"; + } + + choice label { + case entropy { + + leaf entropy-label { + type empty; + description "Whether the use of entropy-label is enabled or not."; + } + + } + case hash { + + container hash-label { + presence "Enable use of hash-label."; + description "Enter the hash-label context"; + + leaf signal-capability { + type empty; + description "To signal the hash label capability to the remote PE."; + } + + } // container hash-label + + } + } + choice oper-group-association { + case oper-group { + + leaf oper-group { + type types-sros:named-item; + description "Operational group identifier"; + } + + } + case monitor-oper-group { + + leaf monitor-oper-group { + type types-sros:named-item; + description "Operational group identifier that affect the state of this SDP bind"; + } + + } + } + container ingress { + description "Enter the ingress context"; + + leaf vc-label { + type types-services:ingress-vc-label; + description "Static MPLS VC label used by the far end device to send packets through this SDP"; + } + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter ID"; + } + + leaf ip { + type types-filter:filter-name; + description "IP filter ID"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container qos { + description "Enter the qos context"; + + container network { + description "Enter the network context"; + + leaf policy-name { + type types-qos:network-policy-name; + description "Ingress network policy name applied to this SDP binding"; + } + + container fp-redirect-group { + description "Enter the fp-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Forwarding-plane queue group policy for this SDP binding"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Instance of the forwarding-plane ingress Queue Group for this SDP binding"; + } + + } // container fp-redirect-group + + } // container network + + } // container qos + + } // container ingress + + container egress { + description "Enter the egress context"; + + leaf vc-label { + type types-services:egress-vc-label; + description "Static MPLS VC label that is used to send packets to the far end device through this SDP"; + } + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter ID"; + } + + leaf ip { + type types-filter:filter-name; + description "IP filter ID"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container qos { + description "Enter the qos context"; + + container network { + description "Enter the network context"; + + leaf policy-name { + type types-qos:network-policy-name; + description "Egress network policy name applied to this SDP binding"; + } + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Policy for port queue group for this SDP binding"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description + "Instance of the port egress Queue Group for this SDP + binding."; + } + + } // container port-redirect-group + + } // container network + + } // container qos + + container mfib-allowed-mda-destinations { + description "Enter the mfib-allowed-mda-destinations context"; + + list mda { + key "mda-id"; + description "Enter the mda context"; + + leaf mda-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-isa:slot-mda; + } + description "MFIB allowed MDA destination"; + } + + } // list mda + + } // container mfib-allowed-mda-destinations + + } // container egress + + container endpoint { + description "Enter the endpoint context"; + + leaf name { + type types-sros:named-item; + description "Name of endpoint to which this SDP bind is attached."; + } + + leaf precedence { + type types-services:sdp-precedence; + default "4"; + description "Precedence of this SDP bind when there are multiple SDP binds attached to one service endpoint"; + } + + } // container endpoint + + container cpu-protection { + description "Enter the cpu-protection context"; + + leaf policy-id { + type types-services:cpm-prot-policy-id; + default "255"; + description "CPM protection policy"; + } + + choice monitoring { + case mac { + + leaf mac-monitoring { + type empty; + description "Monitor MAC for CPU protection"; + } + + } + case cfm { + + container eth-cfm-monitoring { + presence "Enable ETH CFM monitoring configuration."; + description "Enter the eth-cfm-monitoring context"; + + leaf aggregate { + type empty; + description "Apply rate limit to the sum of the per peer packet rates"; + } + + leaf car { + type empty; + description "Eth-CFM packets to be ignored when enforcing overall rate"; + } + + } // container eth-cfm-monitoring + + } + } + } // container cpu-protection + + container pw-status { + description "Enter the pw-status context"; + + leaf signaling { + type boolean; + default "true"; + description "Whether this SDP binding supports pseudowire status signaling."; + } + + } // container pw-status + + container bfd-liveness { + presence "Enable BFD liveness information."; + description "Enter the bfd-liveness context"; + + leaf encap { + type types-services:bfd-encap; + default "ipv4"; + description "BFD encapsulation used on this SDP binding"; + } + + } // container bfd-liveness + + container i-vpls-mac-flush { + description "Enter the i-vpls-mac-flush context"; + + container bgp-evpn { + description "Enter the bgp-evpn context"; + + leaf send-to-bvpls { + type boolean; + default "true"; + description "Send B-VPLS EVPN flush"; + } + + } // container bgp-evpn + + } // container i-vpls-mac-flush + + container fdb { + description "Enter the fdb context"; + + leaf limit-mac-move { + type types-services:limit-mac-move; + default "blockable"; + description "MAC move"; + } + + leaf discard-unknown-source { + type boolean; + default "false"; + description "Discard packets with unknown destination MAC addresses"; + } + + leaf mac-pinning { + type boolean; + default "false"; + description "MAC address pinning in active status"; + } + + leaf maximum-mac-addresses { + type types-services:max-mac-addr; + description "Maximum MAC entries in the FDB from this SDP"; + } + + leaf auto-learn-mac-protect { + type boolean; + default "false"; + description "Populate automatically MAC protect list with source MAC addresses learned on SDP"; + } + + leaf protected-src-mac-violation-action { + type types-services:sdp-protected-src-mac-violation-action; + description "Action when a relearn request for a protected MAC is received on the SDP"; + } + + container mac-learning { + description "Enter the mac-learning context"; + + leaf learning { + type boolean; + default "true"; + description "Enable learning of new MAC addresses"; + } + + leaf aging { + type boolean; + default "true"; + description "Enable aging of MAC addresses"; + } + + } // container mac-learning + + } // container fdb + + container stp { + description "Enter the stp context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Enable/disable spanning-tree-protocol"; + } + + leaf auto-edge { + type boolean; + default "true"; + description "Enable/disable automatic detection of edge-port."; + } + + leaf edge-port { + type boolean; + default "false"; + description "Configure as edge-port."; + } + + leaf link-type { + type types-services:stp-link-type; + default "pt-pt"; + description "Configure STP link-type"; + } + + leaf path-cost { + type types-services:stp-path-cost; + default "10"; + description "Configure path-cost"; + } + + leaf priority { + type int32 { + range "0..255"; + } + default "128"; + description "Configure STP priority"; + } + + leaf root-guard { + type boolean; + default "false"; + description "Enable/disable STP root-guard"; + } + + leaf port-num { + type types-services:stp-port-num; + description "Configure virtual port number"; + } + + } // container stp + + container l2pt { + description "Enter the l2pt context"; + + container termination { + presence "Enable L2PT termination on managed VLANs"; + description "Enter the termination context"; + + container protocols { + description "Enter the protocols context"; + + leaf stp { + type boolean; + default "true"; + description "Enable/disable spanning tree protocols stp/mstp/pvst/rstp."; + } + + leaf cdp { + type boolean; + default "false"; + description "Enable Cisco discovery protocol"; + } + + leaf vtp { + type boolean; + default "false"; + description "Enable/disable virtual trunk protocol."; + } + + leaf dtp { + type boolean; + default "false"; + description "Enable dynamic trunking protocol"; + } + + leaf pagp { + type boolean; + default "false"; + description "Enable/disable port aggregation protocol."; + } + + leaf udld { + type boolean; + default "false"; + description "Enable/disable unidirectional link detection."; + } + + } // container protocols + + } // container termination + + } // container l2pt + + container dhcp { + description "Enter the dhcp context"; + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf snoop { + type boolean; + default "false"; + description "Allow DHCP snooping of DHCP messages on the SAP or SDP"; + } + + } // container dhcp + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IP router alert check option"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups allowed"; + } + + leaf query-interval { + type uint32 { + range "2..1024"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf query-response-interval { + type uint32 { + range "1..1023"; + } + units "seconds"; + default "10"; + description "Time to wait for a response to the host-query messages"; + } + + leaf query-last-member-interval { + type uint32 { + range "1..50"; + } + units "deciseconds"; + default "10"; + description "Time between group-specific query messages"; + } + + leaf fast-leave { + type boolean; + default "false"; + description "Allow IGMP fast leave processing"; + } + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + leaf robust-count { + type uint32 { + range "2..7"; + } + default "2"; + description "Number of retries to cope with message loss."; + } + + leaf send-queries { + type boolean; + default "false"; + description "Generate IGMP general queries"; + } + + leaf maximum-number-sources { + type uint32 { + range "1..1000"; + } + description "Maximum sources that are allowed per group"; + } + + leaf maximum-number-group-sources { + type uint32 { + range "1..32000"; + } + description "Maximum group source combinations"; + } + + leaf version { + type types-igmp:igmp-version; + default "3"; + description "IGMP protocol version"; + } + + container mcac { + description "Enter the mcac context"; + + leaf interface-policy { + type string { + length "1..32"; + } + description "Name for multicast CAC interface policy"; + } + + leaf policy { + type string { + length "1..32"; + } + description "Multicast CAC policy name"; + } + + container bandwidth { + description "Enter the bandwidth context"; + + leaf total { + type types-mcast-cac:bandwidth-limit; + description "Maximum allowed bandwidth."; + } + + leaf mandatory { + type types-mcast-cac:bandwidth-limit; + description "Pre-reserved bandwidth for all mandatory channels."; + } + + } // container bandwidth + + } // container mcac + + container static { + description "Enter the static context"; + + list group { + key "group-address"; + description "Enter the group context"; + + leaf group-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-multicast-address; + } + description "Group address of multicast channel"; + } + + choice source-or-starg { + mandatory true; + case source { + + list source { + key "source-address"; + description "Enter the source context"; + + leaf source-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-unicast-address; + } + description "Source address of multicast channel."; + } + + } // list source + + } + case starg { + + leaf starg { + type empty; + description "any source address (*,G)"; + } + + } + } + } // list group + + } // container static + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IP router alert check option"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups allowed"; + } + + leaf query-interval { + type uint32 { + range "2..1024"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf query-response-interval { + type uint32 { + range "1..1023"; + } + units "seconds"; + default "10"; + description "Time to wait for a response to the host-query messages"; + } + + leaf query-last-member-interval { + type uint32 { + range "1..50"; + } + units "deciseconds"; + default "10"; + description "Time between group-specific query messages"; + } + + leaf fast-leave { + type boolean; + default "false"; + description "Allow IGMP fast leave processing"; + } + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + leaf robust-count { + type uint32 { + range "2..7"; + } + default "2"; + description "Number of retries to cope with message loss."; + } + + leaf send-queries { + type boolean; + default "false"; + description "Generate IGMP general queries"; + } + + leaf version { + type types-igmp:mld-version; + default "2"; + description "MLD protocol version."; + } + + container static { + description "Enter the static context"; + + list group { + key "group-address"; + description "Enter the group context"; + + leaf group-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-multicast-address; + } + description "Group address of multicast channel"; + } + + choice source-or-starg { + mandatory true; + case source { + + list source { + key "source-address"; + description "Enter the source context"; + + leaf source-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-unicast-address; + } + description "Source address of multicast channel."; + } + + } // list source + + } + case starg { + + leaf starg { + type empty; + description "any source address (*,G)"; + } + + } + } + } // list group + + } // container static + + } // container mld-snooping + + container pim-snooping { + description "Enter the pim-snooping context"; + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups for this interface"; + } + + } // container pim-snooping + + container eth-cfm { + description "Enter the eth-cfm context"; + + leaf collect-lmm-stats { + type boolean; + default "false"; + description "Collect statistics for OAM-PM Loss Measurement Message (LMM) tests"; + } + + leaf-list squelch-ingress-levels { + type uint32 { + range "0..7"; + } + max-elements 8; + description "ETH-CFM PDUs to be silently discarded"; + } + + leaf vmep-filter { + type boolean; + default "false"; + description "Suppress eth-cfm PDUs based on level lower than or equal to configured Virtual MEP"; + } + + container collect-lmm-fc-stats { + description "Enter the collect-lmm-fc-stats context"; + + leaf-list fc { + type types-eth-cfm:fc-type; + max-elements 8; + description "Forwarding class name for which to create an individual profile-unaware counter"; + } + + leaf-list fc-in-profile { + type types-eth-cfm:fc-type; + max-elements 8; + description "Individual counters to create for the specified Forwarding Class"; + } + + } // container collect-lmm-fc-stats + + list mep { + key "md-admin-name ma-admin-name mep-id"; + description "Enter the mep context"; + + leaf md-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique domain name"; + } + + leaf ma-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique association name"; + } + + leaf mep-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:mep-id-type; + } + description "Maintenance association end point identifier"; + } + + leaf primary-vlan { + type boolean; + sros-ext:immutable; + default "false"; + description "MEP provisioned using MA primary VLAN ID"; + } + + leaf direction { + type types-eth-cfm:mp-direction; + sros-ext:immutable; + description "Direction the MEP faces"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the MEP"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf mac-address { + type types-sros:mac-unicast-address-no-zero; + description "MAC address for the MEP"; + } + + leaf install-mep { + type boolean; + default "false"; + description "Install MEP in the forwarding plane"; + } + + leaf low-priority-defect { + type types-eth-cfm:lowest-alarm-priority; + default "mac-rem-err-xcon"; + description "Lowest priority defect that is allowed to generate a fault alarm"; + } + + leaf fault-propagation { + type types-eth-cfm:fault-propagation-type; + description "Fault propagation for the MEP"; + } + + leaf ccm { + type boolean; + default "false"; + description "Generate CCM messages"; + } + + leaf ccm-ltm-priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of CCM and LTM messages transmitted by the MEP"; + } + + leaf ccm-padding-size { + type uint32 { + range "3..1500"; + } + description "Additional octets inserted into CCM PDU for data TLV padding"; + } + + leaf lbm-svc-act-responder { + type boolean; + default "false"; + description "Process service activation streams encapsulated in ETH-CFM request Loopback Message"; + } + + leaf one-way-delay-threshold { + type uint32 { + range "0..600"; + } + units "seconds"; + default "3"; + description "Threshold for one way delay test"; + } + + container alarm-notification { + description "Enter the alarm-notification context"; + + leaf fng-alarm-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "The Fault Notification Generation (FNG) alarm time."; + } + + leaf fng-reset-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm is reset"; + } + + } // container alarm-notification + + container ais { + presence + "The generation and reception of Alarm Indication Signal (AIS) + message parameters"; + description "Enter the ais context"; + + leaf-list client-meg-level { + type uint32 { + range "1..7"; + } + max-elements 7; + description "Client MEG level for AIS message generation"; + } + + leaf interface-support { + type boolean; + default "false"; + description "Allow generation of AIS PDUs based on the associated endpoint state"; + } + + leaf interval { + type uint32 { + range "1|60"; + } + units "seconds"; + default "1"; + description "Transmission interval for AIS messages"; + } + + leaf low-priority-defect { + type enumeration { + enum "all-def" { value 1; } + enum "mac-rem-err-xcon" { value 2; } + } + default "all-def"; + description + "The Lowest Priority Defect for the MEP AIS generation. + + When this object is 'all-def (1)', AIS frame generation will be + triggered for any defect in the CCM state machine. + When this object is 'mac-rem-err-xcon (2)', AIS frame generation will be + triggered for 'def-mac-staus' defect and any defect higher than + 'def-mac-status'."; + } + + leaf priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of AIS messages originated by the node"; + } + + } // container ais + + container csf { + presence "The reception of Client Signal Fail (CSF) message parameters"; + description "Enter the csf context"; + + leaf multiplier { + type decimal64 { + range "0.0|2.0..30.0"; + fraction-digits 1; + } + default "3.5"; + description "Receive period multiplier to time out CSF"; + } + + } // container csf + + container eth-test { + presence "Enable/disable eth-test functionality on MEP."; + description "Enter the eth-test context"; + + leaf bit-error-threshold { + type uint32 { + range "0..11840"; + } + units "bit errors"; + default "1"; + description "Lowest priority defect threshold for the bit error trap to generate a fault alarm"; + } + + container test-pattern { + description "Enter the test-pattern context"; + + leaf pattern { + type enumeration { + enum "all-zeros" { value 0; } + enum "all-ones" { value 1; } + } + default "all-zeros"; + description "Test pattern for eth-test frames"; + } + + leaf crc-tlv { + type boolean; + default "false"; + description "Generate a CRC checksum"; + } + + } // container test-pattern + + } // container eth-test + + container grace { + description "Enter the grace context"; + + container eth-ed { + description "Enter the eth-ed context"; + + leaf max-rx-defect-window { + type uint32 { + range "1..86400"; + } + units "seconds"; + description "Value to compare to received peer value, lower is used as maximum ETH-ED expected defect window"; + } + + leaf priority { + type int32 { + range "0..7"; + } + description "Transmission priority for ETH-ED PDUs"; + } + + leaf rx-eth-ed { + type boolean; + default "true"; + description "Receive and process ETH-ED PDUs"; + } + + leaf tx-eth-ed { + type boolean; + default "false"; + description "Transmit ETH-ED PDUs"; + } + + } // container eth-ed + + container eth-vsm-grace { + description "Enter the eth-vsm-grace context"; + + leaf rx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the reception and processing of the Nokia ETH-CFM Grace PDU on the MEP"; + } + + leaf tx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the transmission of the Nokia ETH-CFM Grace PDU from the MEP"; + } + + } // container eth-vsm-grace + + } // container grace + + } // list mep + + } // container eth-cfm + + } // list spoke-sdp + + list mesh-sdp { + key "sdp-bind-id"; + description "Enter the mesh-sdp context"; + + leaf sdp-bind-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:sdp-bind-id; + } + description + "SDP Binding identifier as <sdp-id>:<vc-id>. + sdp-id - [1..32767] + vc-id - [1..4294967295]."; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of this Service SDP binding"; + } + + leaf vlan-vc-tag { + type types-services:vlan-vc-tag; + description "SDP bind VC tag"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Allow agent to collect accounting statistics"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Policy to collect accounting statistics"; + } + + leaf control-word { + type boolean; + default "false"; + description "Use the control word as preferred"; + } + + leaf force-vc-forwarding { + type enumeration { + enum "vlan" { value 1; } + enum "qinq-c-tag-c-tag" { value 2; } + enum "qinq-s-tag-c-tag" { value 3; } + } + description "VC forwarding status"; + } + + leaf etree-root-leaf-tag { + type boolean; + sros-ext:immutable; + default "false"; + description "Status for E-tree root leaf tag"; + } + + leaf etree-leaf { + type boolean; + sros-ext:immutable; + default "false"; + description "Enable etree leaf access-circuit status"; + } + + leaf bfd-template { + type types-sros:named-item; + description "BFD template associated with SDP binding"; + } + + leaf vc-type { + type types-services:vpls-sdp-bind-vc-type; + default "ether"; + description "Type of virtual circuit (VC) associated with the SDP binding; VPLS not supported"; + } + + choice label { + case entropy { + + leaf entropy-label { + type empty; + description "Whether the use of entropy-label is enabled or not."; + } + + } + case hash { + + container hash-label { + presence "Enable use of hash-label."; + description "Enter the hash-label context"; + + leaf signal-capability { + type empty; + description "To signal the hash label capability to the remote PE."; + } + + } // container hash-label + + } + } + container ingress { + description "Enter the ingress context"; + + leaf vc-label { + type types-services:ingress-vc-label; + description "Static MPLS VC label used by the far end device to send packets through this SDP"; + } + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter ID"; + } + + leaf ip { + type types-filter:filter-name; + description "IP filter ID"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container qos { + description "Enter the qos context"; + + container network { + description "Enter the network context"; + + leaf policy-name { + type types-qos:network-policy-name; + description "Ingress network policy name applied to this SDP binding"; + } + + container fp-redirect-group { + description "Enter the fp-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Forwarding-plane queue group policy for this SDP binding"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Instance of the forwarding-plane ingress Queue Group for this SDP binding"; + } + + } // container fp-redirect-group + + } // container network + + } // container qos + + } // container ingress + + container egress { + description "Enter the egress context"; + + leaf vc-label { + type types-services:egress-vc-label; + description "Static MPLS VC label that is used to send packets to the far end device through this SDP"; + } + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter ID"; + } + + leaf ip { + type types-filter:filter-name; + description "IP filter ID"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container qos { + description "Enter the qos context"; + + container network { + description "Enter the network context"; + + leaf policy-name { + type types-qos:network-policy-name; + description "Egress network policy name applied to this SDP binding"; + } + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Policy for port queue group for this SDP binding"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description + "Instance of the port egress Queue Group for this SDP + binding."; + } + + } // container port-redirect-group + + } // container network + + } // container qos + + container mfib-allowed-mda-destinations { + description "Enter the mfib-allowed-mda-destinations context"; + + list mda { + key "mda-id"; + description "Enter the mda context"; + + leaf mda-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-isa:slot-mda; + } + description "MFIB allowed MDA destination"; + } + + } // list mda + + } // container mfib-allowed-mda-destinations + + } // container egress + + container cpu-protection { + description "Enter the cpu-protection context"; + + leaf policy-id { + type types-services:cpm-prot-policy-id; + default "255"; + description "CPM protection policy"; + } + + choice monitoring { + case mac { + + leaf mac-monitoring { + type empty; + description "Monitor MAC for CPU protection"; + } + + } + case cfm { + + container eth-cfm-monitoring { + presence "Enable ETH CFM monitoring configuration."; + description "Enter the eth-cfm-monitoring context"; + + leaf aggregate { + type empty; + description "Apply rate limit to the sum of the per peer packet rates"; + } + + leaf car { + type empty; + description "Eth-CFM packets to be ignored when enforcing overall rate"; + } + + } // container eth-cfm-monitoring + + } + } + } // container cpu-protection + + container bfd-liveness { + presence "Enable BFD liveness information."; + description "Enter the bfd-liveness context"; + + leaf encap { + type types-services:bfd-encap; + default "ipv4"; + description "BFD encapsulation used on this SDP binding"; + } + + } // container bfd-liveness + + container fdb { + description "Enter the fdb context"; + + leaf mac-pinning { + type boolean; + default "false"; + description "MAC address pinning in active status"; + } + + leaf auto-learn-mac-protect { + type boolean; + default "false"; + description "Enable/disable of automatic marking of MACs as protected"; + } + + leaf protected-src-mac-violation-action { + type types-services:sdp-protected-src-mac-violation-action; + description "Action to take whenever a relearn request for a protected MAC is received"; + } + + } // container fdb + + container dhcp { + description "Enter the dhcp context"; + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf snoop { + type boolean; + default "false"; + description "Allow DHCP snooping of DHCP messages on the SAP or SDP"; + } + + } // container dhcp + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IP router alert check option"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups allowed"; + } + + leaf query-interval { + type uint32 { + range "2..1024"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf query-response-interval { + type uint32 { + range "1..1023"; + } + units "seconds"; + default "10"; + description "Time to wait for a response to the host-query messages"; + } + + leaf query-last-member-interval { + type uint32 { + range "1..50"; + } + units "deciseconds"; + default "10"; + description "Time between group-specific query messages"; + } + + leaf fast-leave { + type boolean; + default "false"; + description "Allow IGMP fast leave processing"; + } + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + leaf robust-count { + type uint32 { + range "2..7"; + } + default "2"; + description "Number of retries to cope with message loss."; + } + + leaf send-queries { + type boolean; + default "false"; + description "Generate IGMP general queries"; + } + + leaf maximum-number-sources { + type uint32 { + range "1..1000"; + } + description "Maximum sources that are allowed per group"; + } + + leaf maximum-number-group-sources { + type uint32 { + range "1..32000"; + } + description "Maximum group source combinations"; + } + + leaf version { + type types-igmp:igmp-version; + default "3"; + description "IGMP protocol version"; + } + + container mcac { + description "Enter the mcac context"; + + leaf interface-policy { + type string { + length "1..32"; + } + description "Name for multicast CAC interface policy"; + } + + leaf policy { + type string { + length "1..32"; + } + description "Multicast CAC policy name"; + } + + container bandwidth { + description "Enter the bandwidth context"; + + leaf total { + type types-mcast-cac:bandwidth-limit; + description "Maximum allowed bandwidth."; + } + + leaf mandatory { + type types-mcast-cac:bandwidth-limit; + description "Pre-reserved bandwidth for all mandatory channels."; + } + + } // container bandwidth + + } // container mcac + + container static { + description "Enter the static context"; + + list group { + key "group-address"; + description "Enter the group context"; + + leaf group-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-multicast-address; + } + description "Group address of multicast channel"; + } + + choice source-or-starg { + mandatory true; + case source { + + list source { + key "source-address"; + description "Enter the source context"; + + leaf source-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-unicast-address; + } + description "Source address of multicast channel."; + } + + } // list source + + } + case starg { + + leaf starg { + type empty; + description "any source address (*,G)"; + } + + } + } + } // list group + + } // container static + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IP router alert check option"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups allowed"; + } + + leaf query-interval { + type uint32 { + range "2..1024"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf query-response-interval { + type uint32 { + range "1..1023"; + } + units "seconds"; + default "10"; + description "Time to wait for a response to the host-query messages"; + } + + leaf query-last-member-interval { + type uint32 { + range "1..50"; + } + units "deciseconds"; + default "10"; + description "Time between group-specific query messages"; + } + + leaf fast-leave { + type boolean; + default "false"; + description "Allow IGMP fast leave processing"; + } + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + leaf robust-count { + type uint32 { + range "2..7"; + } + default "2"; + description "Number of retries to cope with message loss."; + } + + leaf send-queries { + type boolean; + default "false"; + description "Generate IGMP general queries"; + } + + leaf version { + type types-igmp:mld-version; + default "2"; + description "MLD protocol version."; + } + + container static { + description "Enter the static context"; + + list group { + key "group-address"; + description "Enter the group context"; + + leaf group-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-multicast-address; + } + description "Group address of multicast channel"; + } + + choice source-or-starg { + mandatory true; + case source { + + list source { + key "source-address"; + description "Enter the source context"; + + leaf source-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-unicast-address; + } + description "Source address of multicast channel."; + } + + } // list source + + } + case starg { + + leaf starg { + type empty; + description "any source address (*,G)"; + } + + } + } + } // list group + + } // container static + + } // container mld-snooping + + container eth-cfm { + description "Enter the eth-cfm context"; + + leaf collect-lmm-stats { + type boolean; + default "false"; + description "Collect statistics for OAM-PM Loss Measurement Message (LMM) tests"; + } + + leaf-list squelch-ingress-levels { + type uint32 { + range "0..7"; + } + max-elements 8; + description "ETH-CFM PDUs to be silently discarded"; + } + + leaf vmep-filter { + type boolean; + default "false"; + description "Suppress eth-cfm PDUs based on level lower than or equal to configured Virtual MEP"; + } + + container collect-lmm-fc-stats { + description "Enter the collect-lmm-fc-stats context"; + + leaf-list fc { + type types-eth-cfm:fc-type; + max-elements 8; + description "Forwarding class name for which to create an individual profile-unaware counter"; + } + + leaf-list fc-in-profile { + type types-eth-cfm:fc-type; + max-elements 8; + description "Individual counters to create for the specified Forwarding Class"; + } + + } // container collect-lmm-fc-stats + + list mep { + key "md-admin-name ma-admin-name mep-id"; + description "Enter the mep context"; + + leaf md-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique domain name"; + } + + leaf ma-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique association name"; + } + + leaf mep-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:mep-id-type; + } + description "Maintenance association end point identifier"; + } + + leaf primary-vlan { + type boolean; + sros-ext:immutable; + default "false"; + description "MEP provisioned using MA primary VLAN ID"; + } + + leaf direction { + type types-eth-cfm:mp-direction; + sros-ext:immutable; + description "Direction the MEP faces"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the MEP"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf mac-address { + type types-sros:mac-unicast-address-no-zero; + description "MAC address for the MEP"; + } + + leaf install-mep { + type boolean; + default "false"; + description "Install MEP in the forwarding plane"; + } + + leaf low-priority-defect { + type types-eth-cfm:lowest-alarm-priority; + default "mac-rem-err-xcon"; + description "Lowest priority defect that is allowed to generate a fault alarm"; + } + + leaf fault-propagation { + type types-eth-cfm:fault-propagation-type; + description "Fault propagation for the MEP"; + } + + leaf ccm { + type boolean; + default "false"; + description "Generate CCM messages"; + } + + leaf ccm-ltm-priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of CCM and LTM messages transmitted by the MEP"; + } + + leaf ccm-padding-size { + type uint32 { + range "3..1500"; + } + description "Additional octets inserted into CCM PDU for data TLV padding"; + } + + leaf lbm-svc-act-responder { + type boolean; + default "false"; + description "Process service activation streams encapsulated in ETH-CFM request Loopback Message"; + } + + leaf one-way-delay-threshold { + type uint32 { + range "0..600"; + } + units "seconds"; + default "3"; + description "Threshold for one way delay test"; + } + + container alarm-notification { + description "Enter the alarm-notification context"; + + leaf fng-alarm-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm"; + } + + leaf fng-reset-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm is reset"; + } + + } // container alarm-notification + + container ais { + presence + "The generation and reception of Alarm Indication Signal (AIS) + message parameters"; + description "Enter the ais context"; + + leaf-list client-meg-level { + type uint32 { + range "1..7"; + } + max-elements 7; + description "Client MEG level for AIS message generation"; + } + + leaf interface-support { + type boolean; + default "false"; + description "Allow generation of AIS PDUs based on the associated endpoint state"; + } + + leaf interval { + type uint32 { + range "1|60"; + } + units "seconds"; + default "1"; + description "Transmission interval for AIS messages"; + } + + leaf low-priority-defect { + type enumeration { + enum "all-def" { value 1; } + enum "mac-rem-err-xcon" { value 2; } + } + default "all-def"; + description "Lowest priority defect for MEP AIS generation"; + } + + leaf priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of AIS messages originated by the node"; + } + + } // container ais + + container csf { + presence "The reception of Client Signal Fail (CSF) message parameters"; + description "Enter the csf context"; + + leaf multiplier { + type decimal64 { + range "0.0|2.0..30.0"; + fraction-digits 1; + } + default "3.5"; + description "Receive period multiplier to time out CSF"; + } + + } // container csf + + container eth-test { + presence "Enable/disable eth-test functionality on MEP."; + description "Enter the eth-test context"; + + leaf bit-error-threshold { + type uint32 { + range "0..11840"; + } + units "bit errors"; + default "1"; + description "Lowest priority defect threshold for the bit error trap to generate a fault alarm"; + } + + container test-pattern { + description "Enter the test-pattern context"; + + leaf pattern { + type enumeration { + enum "all-zeros" { value 0; } + enum "all-ones" { value 1; } + } + default "all-zeros"; + description "Test pattern for eth-test frames"; + } + + leaf crc-tlv { + type boolean; + default "false"; + description "Generate a CRC checksum"; + } + + } // container test-pattern + + } // container eth-test + + container grace { + description "Enter the grace context"; + + container eth-ed { + description "Enter the eth-ed context"; + + leaf max-rx-defect-window { + type uint32 { + range "1..86400"; + } + units "seconds"; + description "Value to compare to received peer value, lower is used as maximum ETH-ED expected defect window"; + } + + leaf priority { + type int32 { + range "0..7"; + } + description "Transmission priority for ETH-ED PDUs"; + } + + leaf rx-eth-ed { + type boolean; + default "true"; + description "Receive and process ETH-ED PDUs"; + } + + leaf tx-eth-ed { + type boolean; + default "false"; + description "Transmit ETH-ED PDUs"; + } + + } // container eth-ed + + container eth-vsm-grace { + description "Enter the eth-vsm-grace context"; + + leaf rx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the reception and processing of the Nokia ETH-CFM Grace PDU on the MEP"; + } + + leaf tx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the transmission of the Nokia ETH-CFM Grace PDU from the MEP"; + } + + } // container eth-vsm-grace + + } // container grace + + } // list mep + + } // container eth-cfm + + } // list mesh-sdp + + list bgp-mh-site { + key "site-name"; + description "Enter the bgp-mh-site context"; + + leaf site-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Name for the specific site"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the site"; + } + + leaf id { + type types-services:site-id; + description "ID for the site"; + } + + leaf boot-timer { + type types-services:site-boot-timer; + units "seconds"; + description "Time that system waits after node reboot and before it runs DF election algorithm"; + } + + leaf activation-timer { + type types-services:site-activation-timer; + units "seconds"; + description "Time that the local sites are in standby status, waiting for BGP updates"; + } + + leaf monitor-oper-group { + type types-sros:named-item; + description "Operational group to monitor"; + } + + leaf failed-threshold { + type types-services:failed-threshold; + default "all"; + description "Threshold for the site to be declared down"; + } + + leaf min-down-timer { + type types-services:site-min-down-timer; + units "seconds"; + description "Minimum downtime for BGP multi-homing site after transition from up to down"; + } + + choice site-object { + case spoke-sdp { + + leaf spoke-sdp { + type types-services:sdp-bind-id; + description "SDP to be associated with this site"; + } + + } + case sap { + + leaf sap { + type types-sros:sap; + description "SAP to be associated with this site"; + } + + } + case mesh-sdp { + + leaf mesh-sdp-binds { + type empty; + description "Specify if a mesh-sdp-binding is associated with this site"; + } + + } + case shg { + + leaf shg-name { + type types-sros:named-item; + description "Split horizon group to be associated with this site"; + } + + } + } + } // list bgp-mh-site + + list sap { + key "sap-id"; + description "Enter the sap context"; + + leaf sap-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:sap; + } + description "SAP identifier"; + } + + leaf description { + type types-sros:long-description; + description "Text description"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the SAP"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy"; + } + + leaf anti-spoof { + type types-services:anti-spoof-option; + description "Type of anti-spoof filtering"; + } + + leaf bandwidth { + type types-services:sap-bandwidth; + units "kilobps"; + description "SAP bandwidth"; + } + + leaf calling-station-id { + type types-sros:string-not-all-spaces { + length "1..64"; + } + description "Calling station ID"; + } + + leaf cflowd { + type boolean; + default "false"; + description "Enable Cflowd collection and analysis on this SAP"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect accounting statistics"; + } + + leaf dist-cpu-protection { + type types-sros:named-item; + description "Distributed CPU protection policy for SAP"; + } + + leaf host-admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of hosts"; + } + + leaf host-lockout-policy { + type types-sros:named-item; + description "Host lockout policy"; + } + + leaf multi-service-site { + type types-sros:named-item; + description "Multi service site name"; + } + + leaf split-horizon-group { + type types-sros:named-item; + sros-ext:immutable; + description "Split horizon group"; + } + + leaf multicast-source { + type boolean; + sros-ext:immutable; + default "false"; + description "Enable/disable multicast-source on the SAP."; + } + + leaf eth-ring { + type uint32 { + range "0..128"; + } + sros-ext:immutable; + description "Ethernet ring operation"; + } + + leaf etree-leaf { + type boolean; + sros-ext:immutable; + default "false"; + description "Enable etree leaf access-circuit status"; + } + + leaf arp-reply-agent { + type types-services:arp-reply-agent; + description "Enable arp-reply-agent function"; + } + + leaf bpdu-translation { + type types-services:bpdu-translation; + description "Bpdu translation on this SAP"; + } + + leaf process-cpm-traffic-on-sap-down { + type boolean; + default "false"; + description "Process CPM traffic on SAP down event"; + } + + leaf radius-auth-policy { + type types-sros:named-item; + description "RADIUS authentication policy"; + } + + leaf shcv-policy-ipv4 { + type types-sros:external-named-item; + description "Subscriber host connectivity verification policy for IPv4"; + } + + choice oper-group-association { + case oper-group { + + leaf oper-group { + type types-sros:named-item; + description "Operational group"; + } + + } + case monitor-oper-group { + + leaf monitor-oper-group { + type types-sros:named-item; + description "Monitor operational group"; + } + + } + } + container ingress { + description "Enter the ingress context"; + + container qos { + description "Enter the qos context"; + + leaf match-qinq-dot1p { + type enumeration { + enum "top" { value 2; } + enum "bottom" { value 3; } + } + description "Ingress match QinQ Dot1p"; + } + + container sap-ingress { + description "Enter the sap-ingress context"; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Policy identifier"; + } + + leaf queuing-type { + type types-services:services-sap-queuing-type; + description "Ingress queuing type"; + } + + container fp-redirect-group { + description "Enter the fp-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Forwarding-plane queue group policy"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Queue group instance"; + } + + } // container fp-redirect-group + + container overrides { + description "Enter the overrides context"; + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-queue-id; + } + description "Policer unique ID"; + } + + leaf cbs { + type union { + type uint32 { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobps"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "MBS"; + } + + leaf monitor-depth { + type boolean; + default "false"; + description "Monitor queue depth"; + } + + choice queue-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-services:sap-pir-rate-ovr; + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type types-services:sap-cir-rate-ovr; + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent-or-default-override; + description "Percentage reduction from the MBS for a queue drop tail"; + } + + } // container low + + } // container drop-tail + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight-override; + description "PIR parameter that overrides parent for queue group"; + } + + leaf cir-weight { + type types-qos:weight-override; + description "CIR parameter that overrides parent for queue group"; + } + + } // container parent + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id; + } + description "Policer unique ID"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "MBS"; + } + + leaf packet-byte-offset { + type types-qos:ingress-per-packet-offset-override; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + description "Mode of statistics collected by the policer"; + } + + choice policer-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + } // list policer + + } // container overrides + + } // container sap-ingress + + container policer-control-policy { + description "Enter the policer-control-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Policer control policy name"; + } + + container overrides { + presence "Apply a policer control policy override."; + description "Enter the overrides context"; + + container root { + description "Enter the root context"; + + leaf max-rate { + type types-services:sap-max-rate-ovr; + description "Maximum frame-based bandwidth limit"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-thresh-separation { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of separation buffer space"; + } + + list priority { + key "priority-level"; + description "Enter the priority context"; + + leaf priority-level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of cumulative buffer space allowed"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container root + + } // container overrides + + } // container policer-control-policy + + container scheduler-policy { + description "Enter the scheduler-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Scheduler policy name"; + } + + container overrides { + description "Enter the overrides context"; + + list scheduler { + key "scheduler-name"; + description "Enter the scheduler context"; + + leaf scheduler-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Scheduler override policy name"; + } + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-weight { + type types-qos:weight; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container parent + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + description "Specifies the administrative PIR"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "sum" { value -3; } + enum "max" { value -1; } + } + } + description "Specifies the administrative CIR"; + } + + } // container rate + + } // list scheduler + + } // container overrides + + } // container scheduler-policy + + } // container qos + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter identifier"; + } + + leaf ip { + type types-filter:filter-name; + description "IP filter identifier"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container qtag-manipulation { + description "Enter the qtag-manipulation context"; + + choice tags { + case push-dot1q-vlan { + + leaf push-dot1q-vlan { + type types-services:qtag-manipulation-info; + description "VLAN translation information"; + } + + } + } + } // container qtag-manipulation + + } // container ingress + + container egress { + description "Enter the egress context"; + + leaf dest-mac-rewrite { + type types-sros:mac-unicast-address-no-zero; + description "Destination MAC overwrite for unicast"; + } + + container qos { + description "Enter the qos context"; + + leaf qinq-mark-top-only { + type boolean; + default "false"; + description "Mark top Q-tags"; + } + + container sap-egress { + description "Enter the sap-egress context"; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Policy identifier"; + } + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Policy for port redirect queue group"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Instance of port queue group"; + } + + } // container port-redirect-group + + container overrides { + description "Enter the overrides context"; + + leaf hs-secondary-shaper { + type types-sros:named-item; + description "HS Secondary Shaper"; + } + + container hsmda-queues { + description "Enter the hsmda-queues context"; + + leaf secondary-shaper { + type types-sros:named-item; + description "Secondary shaper for the HSMDA queue"; + } + + leaf packet-byte-offset { + type types-services:egress-hsmda-queue-packet-byte-offset; + description "Packet byte offset for HSMDA queue"; + } + + leaf wrr-policy { + type types-sros:named-item; + description "WRR policy for the HSMDA queue"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress HSMDA queue ID"; + } + + leaf mbs { + type types-qos:hsmda-queue-burst-size-override; + units "bytes"; + description "Buffer space allowed for the queue"; + } + + leaf rate { + type types-qos:hsmda-queue-pir-rate-override; + description "Administrative PIR rate."; + } + + leaf slope-policy { + type types-sros:named-item; + description + "Name of the slope-policy which is used to override the + default slope-policy for the named buffer pool."; + } + + leaf wrr-weight { + type types-qos:hsmda-wrr-weight-override; + description "Weight value for the HSMDA queue"; + } + + } // list queue + + } // container hsmda-queues + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Policer unique ID"; + } + + leaf avg-frame-overhead { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description + "Encapsulation overhead, in centipercent, used to + translate packet-based rate to frame-based rate and vice versa."; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..14000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "Explicit shaping burst size of a queue."; + } + + leaf cbs { + type union { + type uint32 { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + description "MBS"; + } + + leaf monitor-depth { + type boolean; + default "false"; + description "Monitor queue depth"; + } + + leaf hs-wrr-weight { + type types-qos:hs-wrr-weight-override; + default "1"; + description "Weighted Round Robin (WRR) weight to parent with this queue into the scheduler"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight-override; + description "Scheduling class weight."; + } + + choice queue-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-services:sap-pir-rate-ovr; + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type types-services:sap-cir-rate-ovr; + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent-or-default-override; + description "Percentage reduction from the MBS for a queue drop tail"; + } + + } // container low + + } // container drop-tail + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight-override; + description "PIR parameter that overrides parent for queue group"; + } + + leaf cir-weight { + type types-qos:weight-override; + description "CIR parameter that overrides parent for queue group"; + } + + } // container parent + + container hs-wred-queue { + description "Enter the hs-wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Name of slope-policy."; + } + + } // container hs-wred-queue + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:sap-egress-policer-id; + } + description "Policer unique ID"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "MBS"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset-override; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf stat-mode { + type types-qos:egress-policer-stat-mode; + description "Mode of statistics collected by the policer"; + } + + choice policer-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + } // list policer + + list hs-wrr-group { + key "group-id"; + description "Enter the hs-wrr-group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hs-wrr-group-id; + } + description "HS WRR group identifier"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight-override; + description "Weight of scheduling class."; + } + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type union { + type uint32 { + range "1..2000000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "Administrative PIR."; + } + + } + case percent-rate { + + leaf percent-rate { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent."; + } + + } + } + } // list hs-wrr-group + + } // container overrides + + } // container sap-egress + + container policer-control-policy { + description "Enter the policer-control-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Policer control policy name"; + } + + container overrides { + presence "Apply a policer control policy override."; + description "Enter the overrides context"; + + container root { + description "Enter the root context"; + + leaf max-rate { + type types-services:sap-max-rate-ovr; + description "Maximum frame-based bandwidth limit"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-thresh-separation { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of separation buffer space"; + } + + list priority { + key "priority-level"; + description "Enter the priority context"; + + leaf priority-level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of cumulative buffer space allowed"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container root + + } // container overrides + + } // container policer-control-policy + + container scheduler-policy { + description "Enter the scheduler-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Scheduler policy name"; + } + + container overrides { + description "Enter the overrides context"; + + list scheduler { + key "scheduler-name"; + description "Enter the scheduler context"; + + leaf scheduler-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Scheduler override policy name"; + } + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-weight { + type types-qos:weight; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container parent + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + description "Specifies the administrative PIR"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "sum" { value -3; } + enum "max" { value -1; } + } + } + description "Specifies the administrative CIR"; + } + + } // container rate + + } // list scheduler + + } // container overrides + + } // container scheduler-policy + + container vlan-qos-policy { + description "Attach an egress vlan-qos-policy."; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Egress vlan-qos-policy name"; + } + + } // container vlan-qos-policy + + container egress-remark-policy { + description "Attach an egress-remark-policy."; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Egress-remark-policy name"; + } + + } // container egress-remark-policy + + } // container qos + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter identifier"; + } + + leaf ip { + type types-filter:filter-name; + description "IP filter identifier"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container agg-rate { + description "Enter the agg-rate context"; + + leaf limit-unused-bandwidth { + type boolean; + default "false"; + description "Enable aggregate rate overrun protection"; + } + + leaf rate { + type types-services:agg-rate-rate; + description "Maximum total rate of all egress queues in kbps."; + } + + leaf queue-frame-based-accounting { + type boolean; + default "false"; + description "Enable frame-based accounting on all policers and queues associated with context"; + } + + leaf cir { + type union { + type int32 { + range "0..100000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "0"; + description "Specifies the administrative CIR."; + } + + } // container agg-rate + + } // container egress + + container cpu-protection { + description "Enter the cpu-protection context"; + + leaf policy-id { + type types-services:cpm-prot-policy-id; + description "CPM protection policy"; + } + + choice monitoring { + case mac { + + leaf mac-monitoring { + type empty; + description "Monitor MAC for CPU protection"; + } + + } + case cfm { + + container eth-cfm-monitoring { + presence "Enable ETH CFM monitoring configuration."; + description "Enter the eth-cfm-monitoring context"; + + leaf aggregate { + type empty; + description "Apply rate limit to the sum of the per peer packet rates"; + } + + leaf car { + type empty; + description "Eth-CFM packets to be ignored when enforcing overall rate"; + } + + } // container eth-cfm-monitoring + + } + } + } // container cpu-protection + + container lag { + description "Enter the lag context"; + + leaf link-map-profile { + type types-services:link-map-profile-id; + description "LAG link map profile applied to a SAP or network interface"; + } + + container per-link-hash { + description "Configure per-link-hash information."; + + leaf class { + type types-services:sap-lag-per-link-hash-class; + default "1"; + description "Configure per-link-hash class."; + } + + leaf weight { + type types-services:sap-lag-per-link-hash-weight; + default "1"; + description "Configure per-link-hash weight."; + } + + } // container per-link-hash + + } // container lag + + container etree-root-leaf-tag { + presence "Enable E-tree root leaf tag status."; + description "Enter the etree-root-leaf-tag context"; + + leaf leaf { + type int32 { + range "1..4094"; + } + sros-ext:immutable; + mandatory true; + description "Leaf tag value"; + } + + } // container etree-root-leaf-tag + + container igmp-host-tracking { + description "Enter the igmp-host-tracking context"; + + leaf expiry-time { + type types-sros:time-duration { + range "1..65535"; + } + units "seconds"; + description "Time during which the system continues to track inactive hosts"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum number of multicast groups to be tracked"; + } + + leaf maximum-number-group-sources { + type uint32 { + range "1..32000"; + } + description "Maximum number of multicast groups to be tracked per group"; + } + + leaf maximum-number-sources { + type uint32 { + range "1..1000"; + } + description "Maximum number of multicast sources to be tracked"; + } + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IGMP router alert check option"; + } + + } // container igmp-host-tracking + + container igmp-snooping { + description "Enter the igmp-snooping context"; + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IP router alert check option"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups allowed"; + } + + leaf query-interval { + type uint32 { + range "2..1024"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf query-response-interval { + type uint32 { + range "1..1023"; + } + units "seconds"; + default "10"; + description "Time to wait for a response to the host-query messages"; + } + + leaf query-last-member-interval { + type uint32 { + range "1..50"; + } + units "deciseconds"; + default "10"; + description "Time between group-specific query messages"; + } + + leaf fast-leave { + type boolean; + default "false"; + description "Allow IGMP fast leave processing"; + } + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + leaf robust-count { + type uint32 { + range "2..7"; + } + default "2"; + description "Number of retries to cope with message loss."; + } + + leaf send-queries { + type boolean; + default "false"; + description "Generate IGMP general queries"; + } + + leaf maximum-number-sources { + type uint32 { + range "1..1000"; + } + description "Maximum sources that are allowed per group"; + } + + leaf maximum-number-group-sources { + type uint32 { + range "1..32000"; + } + description "Maximum group source combinations"; + } + + leaf version { + type types-igmp:igmp-version; + default "3"; + description "IGMP protocol version"; + } + + container mcac { + description "Enter the mcac context"; + + leaf interface-policy { + type string { + length "1..32"; + } + description "Name for multicast CAC interface policy"; + } + + leaf policy { + type string { + length "1..32"; + } + description "Multicast CAC policy name"; + } + + container mc-constraints { + description "Enter the mc-constraints context"; + + leaf use-lag-port-weight { + type boolean; + default "false"; + description "Use LAG port weight while calculating Multicast CAC constraints"; + } + + list level { + key "level-id"; + description "Enter the level context"; + + leaf level-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-mcast-cac:constraints-level; + } + description "Bandwidth level ID for a multicast CAC constraint"; + } + + leaf bandwidth { + type types-mcast-cac:bandwidth { + range "0..2147483647"; + } + mandatory true; + description "Bandwidth available for this level"; + } + + } // list level + + list number-down { + key "number-lag-port-down"; + description "Enter the number-down context"; + + leaf number-lag-port-down { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type uint32 { + range "1..64"; + } + } + description "Number of LAG ports down"; + } + + leaf level { + type types-mcast-cac:constraints-level; + mandatory true; + description "Level associated with the number of LAG ports that are down"; + } + + } // list number-down + + } // container mc-constraints + + container bandwidth { + description "Enter the bandwidth context"; + + leaf total { + type types-mcast-cac:bandwidth-limit; + description "Maximum allowed bandwidth."; + } + + leaf mandatory { + type types-mcast-cac:bandwidth-limit; + description "Pre-reserved bandwidth for all mandatory channels."; + } + + } // container bandwidth + + } // container mcac + + container mvr { + description "Enter the mvr context"; + + leaf from-vpls { + type types-services:service-name; + description "MVR VPLS from which the multicast channels are taken"; + } + + leaf to-sap { + type types-sros:sap; + description "Multicast channels copied to SAP"; + } + + } // container mvr + + container static { + description "Enter the static context"; + + list group { + key "group-address"; + description "Enter the group context"; + + leaf group-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-multicast-address; + } + description "Group address of multicast channel"; + } + + choice source-or-starg { + mandatory true; + case source { + + list source { + key "source-address"; + description "Enter the source context"; + + leaf source-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-unicast-address; + } + description "Source address of multicast channel."; + } + + } // list source + + } + case starg { + + leaf starg { + type empty; + description "any source address (*,G)"; + } + + } + } + } // list group + + } // container static + + } // container igmp-snooping + + container mld-snooping { + description "Enter the mld-snooping context"; + + leaf router-alert-check { + type boolean; + default "true"; + description "Enable IP router alert check option"; + } + + leaf import-policy { + type types-sros:named-item-64; + description "Import policy that filters IGMP packets"; + } + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups allowed"; + } + + leaf query-interval { + type uint32 { + range "2..1024"; + } + units "seconds"; + default "125"; + description "Time between two consecutive host-query messages"; + } + + leaf query-response-interval { + type uint32 { + range "1..1023"; + } + units "seconds"; + default "10"; + description "Time to wait for a response to the host-query messages"; + } + + leaf query-last-member-interval { + type uint32 { + range "1..50"; + } + units "deciseconds"; + default "10"; + description "Time between group-specific query messages"; + } + + leaf fast-leave { + type boolean; + default "false"; + description "Allow IGMP fast leave processing"; + } + + leaf mrouter-port { + type boolean; + default "false"; + description "Port as a multicast router port"; + } + + leaf robust-count { + type uint32 { + range "2..7"; + } + default "2"; + description "Number of retries to cope with message loss."; + } + + leaf send-queries { + type boolean; + default "false"; + description "Generate IGMP general queries"; + } + + leaf version { + type types-igmp:mld-version; + default "2"; + description "MLD protocol version."; + } + + container mvr { + description "Enter the mvr context"; + + leaf from-vpls { + type types-services:service-name; + description "MVR VPLS from which the multicast channels are taken"; + } + + leaf to-sap { + type types-sros:sap; + description "The SAP to which the multicast channels are copied"; + } + + } // container mvr + + container static { + description "Enter the static context"; + + list group { + key "group-address"; + description "Enter the group context"; + + leaf group-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-multicast-address; + } + description "Group address of multicast channel"; + } + + choice source-or-starg { + mandatory true; + case source { + + list source { + key "source-address"; + description "Enter the source context"; + + leaf source-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv6-unicast-address; + } + description "Source address of multicast channel."; + } + + } // list source + + } + case starg { + + leaf starg { + type empty; + description "any source address (*,G)"; + } + + } + } + } // list group + + } // container static + + } // container mld-snooping + + container pim-snooping { + description "Enter the pim-snooping context"; + + leaf maximum-number-groups { + type uint32 { + range "1..16000"; + } + description "Maximum groups for this interface"; + } + + } // container pim-snooping + + container stp { + description "Enter the stp context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Enable/disable spanning-tree-protocol"; + } + + leaf auto-edge { + type boolean; + default "true"; + description "Enable/disable automatic detection of edge-port."; + } + + leaf edge-port { + type boolean; + default "false"; + description "Configure as edge-port."; + } + + leaf link-type { + type types-services:stp-link-type; + default "pt-pt"; + description "Configure STP link-type"; + } + + leaf path-cost { + type types-services:stp-path-cost; + default "10"; + description "Configure path-cost"; + } + + leaf priority { + type int32 { + range "0..255"; + } + default "128"; + description "Configure STP priority"; + } + + leaf root-guard { + type boolean; + default "false"; + description "Enable/disable STP root-guard"; + } + + leaf port-num { + type types-services:stp-port-num; + description "Configure virtual port number"; + } + + } // container stp + + container l2pt { + description "Enter the l2pt context"; + + container termination { + presence "Enable L2PT termination on managed VLANs"; + description "Enter the termination context"; + + container protocols { + description "Enter the protocols context"; + + leaf stp { + type boolean; + default "true"; + description "Enable/disable spanning tree protocols stp/mstp/pvst/rstp."; + } + + leaf cdp { + type boolean; + default "false"; + description "Enable Cisco discovery protocol"; + } + + leaf vtp { + type boolean; + default "false"; + description "Enable/disable virtual trunk protocol."; + } + + leaf dtp { + type boolean; + default "false"; + description "Enable dynamic trunking protocol"; + } + + leaf pagp { + type boolean; + default "false"; + description "Enable/disable port aggregation protocol."; + } + + leaf udld { + type boolean; + default "false"; + description "Enable/disable unidirectional link detection."; + } + + } // container protocols + + } // container termination + + } // container l2pt + + container fdb { + description "Enter the fdb context"; + + leaf discard-unknown-source { + type boolean; + default "false"; + description "Discard frames with unknown source"; + } + + leaf limit-mac-move { + type types-services:limit-mac-move; + default "blockable"; + description "MAC move"; + } + + leaf mac-pinning { + type boolean; + default "false"; + description "Enable MAC address pinning on this SAP"; + } + + leaf maximum-mac-addresses { + type types-services:max-mac-addr; + description "Maximum number of MAC entries in the FDB"; + } + + leaf auto-learn-mac-protect { + type boolean; + default "false"; + description "Enable automatic update of MAC protect list"; + } + + leaf protected-src-mac-violation-action { + type types-services:sap-protected-src-mac-violation-action; + description "Action to take whenever a relearn request for a protected MAC is received"; + } + + leaf discard-unprotected-dest-mac { + type boolean; + default "false"; + description "Enable/disable unprotected dest MAC restriction"; + } + + container mac-learning { + description "Enter the mac-learning context"; + + leaf learning { + type boolean; + default "true"; + description "Enable learning of new MAC addresses"; + } + + leaf aging { + type boolean; + default "true"; + description "Enable aging of MAC addresses"; + } + + } // container mac-learning + + } // container fdb + + container l2tpv3-session { + presence "Enable L2TPv3 Session information."; + description "Enter the l2tpv3-session context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Adminstrative state of the entry."; + } + + leaf vc-id { + type types-services:vc-id; + description "VC identifier."; + } + + container pseudo-wire { + description "Enter the pseudo-wire context"; + + choice type { + case ethernet { + + leaf ethernet { + type empty; + description "Ethernet type."; + } + + } + case ethernet-vlan-id { + + leaf ethernet-vlan-id { + type int32 { + range "0..4095"; + } + description "Ethernet VLAN identifier."; + } + + } + } + } // container pseudo-wire + + container router { + description "Enter the router context"; + + leaf group { + type types-sros:named-item; + description "Tunnel group name."; + } + + leaf router-instance { + type types-sros:router-instance-base-vprn-loose; + description "Router instance hosting the l2tpv3 session."; + } + + } // container router + + } // container l2tpv3-session + + container i-vpls-mac-flush { + description "Enter the i-vpls-mac-flush context"; + + container bgp-evpn { + description "Enter the bgp-evpn context"; + + leaf send-to-bvpls { + type boolean; + default "true"; + description "Send B-VPLS EVPN flush"; + } + + } // container bgp-evpn + + } // container i-vpls-mac-flush + + container arp-host { + description "Enter the arp-host context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Enable/disable ARP hosts."; + } + + leaf host-limit { + type uint32 { + range "1..131071"; + } + default "1"; + description "Maximum number of ARP triggered hosts."; + } + + leaf min-auth-interval { + type types-sros:time-duration { + range "1..6000"; + } + units "minutes"; + default "15"; + description + "Minimal time that has to pass before incoming ARPs of an active + ARP host are re-authenticated."; + } + + } // container arp-host + + container dhcp { + description "Enter the dhcp context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of DHCP"; + } + + leaf description { + type types-sros:description; + description "Add/remove a text description for DHCP."; + } + + leaf snoop { + type boolean; + default "false"; + description "DHCP snooping."; + } + + container proxy-server { + description "Enter the proxy-server context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of DHCP proxy"; + } + + leaf emulated-server { + type types-sros:ipv4-unicast-address; + description "IP address used as the DHCP server address in the context of this service"; + } + + container lease-time { + description "Enter the lease-time context"; + + leaf value { + type types-sros:time-duration { + range "300..315446399"; + } + units "seconds"; + description "DHCP lease time"; + } + + leaf radius-override { + type boolean; + default "false"; + description "Use lease time information provided by RADIUS server"; + } + + } // container lease-time + + } // container proxy-server + + container option-82 { + description "Enter the option-82 context"; + + leaf action { + type enumeration { + enum "replace" { value 1; } + enum "drop" { value 2; } + enum "keep" { value 3; } + } + default "keep"; + description "What to do with DHCP option 82."; + } + + container circuit-id { + description "Enter the circuit-id context"; + + choice circuit-id { + default "ascii-tuple"; + case none { + + leaf none { + type empty; + description "Do not include the circuit-id."; + } + + } + case ascii-tuple { + + leaf ascii-tuple { + type empty; + description "Use ascii-tuple in the option."; + } + + } + case vlan-ascii-tuple { + + leaf vlan-ascii-tuple { + type empty; + description "Use vlan-ascii-tuple in the option."; + } + + } + case hex-string { + + leaf hex-string { + type types-sros:hex-string { + length "1..66"; + } + description "Use user-defined hexadecimal string in the option"; + } + + } + } + } // container circuit-id + + container remote-id { + description "Enter the remote-id context"; + + choice remote-id { + default "none"; + case none { + + leaf none { + type empty; + description "Do not include the remote-id."; + } + + } + case mac { + + leaf mac { + type empty; + description "Use MAC address in the option."; + } + + } + case ascii-string { + + leaf ascii-string { + type types-sros:string-not-all-spaces { + length "1..32"; + } + description "Use user-defined ASCII string in the option."; + } + + } + case hex-string { + + leaf hex-string { + type types-sros:hex-string { + length "1..66"; + } + description "Use user-defined hexadecimal string in the option."; + } + + } + } + } // container remote-id + + container vendor-specific-option { + description "Enter the vendor-specific-option context"; + + leaf system-id { + type boolean; + default "false"; + description "Send the system ID in the Nokia vendor specific suboption."; + } + + leaf client-mac-address { + type boolean; + default "false"; + description "Send the MAC address in the Nokia vendor specific suboption."; + } + + leaf service-id { + type boolean; + default "false"; + description "Send the service ID in the Nokia vendor specific suboption."; + } + + leaf sap-id { + type boolean; + default "false"; + description "Send the SAP ID in the Nokia vendor specific suboption."; + } + + leaf string { + type types-sros:string-not-all-spaces { + length "1..32"; + } + description "Send a user-defined string in the Nokia vendor specific suboption."; + } + + } // container vendor-specific-option + + } // container option-82 + + container lease-populate { + description "Enter the lease-populate context"; + + leaf max-leases { + type uint32 { + range "0..131071"; + } + default "0"; + description "Maximum number of DHCPv4 leases"; + } + + } // container lease-populate + + } // container dhcp + + container static-host { + description "Enter the static-host context"; + + list ipv4 { + key "ip mac"; + description "Enter the ipv4 context"; + + leaf ip { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-address; + } + description "IP address"; + } + + leaf mac { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:mac-unicast-address; + } + description "MAC address"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the static host"; + } + + leaf sub-profile { + type types-sros:external-named-item; + description "Sub-profile name"; + } + + leaf sla-profile { + type types-sros:external-named-item; + description "SLA profile name"; + } + + leaf ancp-string { + type types-submgt:ancp-string; + description "ANCP string"; + } + + leaf int-dest-id { + type types-submgt:int-dest-id; + description "Intermediate destination ID"; + } + + container subscriber-id { + description "Enter the subscriber-id context"; + + choice subscriber-id { + case string { + + leaf string { + type types-submgt:subscriber-id; + description "Subscriber identification"; + } + + } + case use-sap-id { + + leaf use-sap-id { + type empty; + description "Use the SAP id as subscriber ID"; + } + + } + } + } // container subscriber-id + + container shcv { + description "Enter the shcv context"; + + } // container shcv + + } // list ipv4 + + } // container static-host + + container sub-sla-mgmt { + description "Enter the sub-sla-mgmt context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of subscriber management on this SAP"; + } + + leaf sub-ident-policy { + type types-sros:external-named-item; + description "Subscriber identification policy used on this SAP"; + } + + leaf subscriber-limit { + type types-submgt:sap-subscriber-limit; + default "1"; + description "Maximum number of subscribers on this SAP"; + } + + leaf mac-da-hashing { + type boolean; + default "false"; + description "Use destination MAC address instead of subscriber ID to select egress LAG link"; + } + + container defaults { + description "Enter the defaults context"; + + leaf sub-profile { + type types-sros:external-named-item; + description "Default subscriber profile used for subscribers on this SAP"; + } + + leaf sla-profile { + type types-sros:external-named-item; + description "Default SLA profile for hosts on this SAP"; + } + + container subscriber-id { + description "Enter the subscriber-id context"; + + choice subscriber-id { + case auto-id { + + leaf auto-id { + type empty; + description "Use auto-generated subscriber identification string"; + } + + } + case sap-id { + + leaf sap-id { + type empty; + description "Use SAP ID as default subscriber identification string"; + } + + } + case string { + + leaf string { + type types-submgt:subscriber-id; + description "Subscriber ID policy name"; + } + + } + } + } // container subscriber-id + + container int-dest-id { + description "Enter the int-dest-id context"; + + choice int-dest-id { + case top-q-tag { + + leaf top-q-tag { + type empty; + description "Use the top Q-tag of this SAP"; + } + + } + case string { + + leaf string { + type types-submgt:int-dest-id; + description "Use the configured string"; + } + + } + } + } // container int-dest-id + + } // container defaults + + container single-sub-parameters { + description "Enter the single-sub-parameters context"; + + leaf profiled-traffic-only { + type boolean; + default "false"; + description "Include all traffic in subscriber profile"; + } + + container non-sub-traffic { + presence "true"; + description "Enter the non-sub-traffic context"; + + leaf sub-profile { + type types-sros:external-named-item; + mandatory true; + description "Subscriber IDprofile applied for all non-subscriber traffic"; + } + + leaf sla-profile { + type types-sros:external-named-item; + mandatory true; + description "SLA profile applicable for all non-subscriber traffic"; + } + + leaf subscriber-id { + type types-submgt:subscriber-id; + sros-ext:immutable; + description "Subscriber ID applied for all non-subscriber traffic"; + } + + } // container non-sub-traffic + + } // container single-sub-parameters + + } // container sub-sla-mgmt + + container eth-cfm { + description "Enter the eth-cfm context"; + + leaf collect-lmm-stats { + type boolean; + default "false"; + description "Collect statistics for OAM-PM Loss Measurement Message (LMM) tests"; + } + + leaf-list squelch-ingress-levels { + type uint32 { + range "0..7"; + } + max-elements 8; + description "ETH-CFM PDUs to be silently discarded"; + } + + leaf vmep-filter { + type boolean; + default "false"; + description "Suppress eth-cfm PDUs based on level lower than or equal to configured Virtual MEP"; + } + + container collect-lmm-fc-stats { + description "Enter the collect-lmm-fc-stats context"; + + leaf-list fc { + type types-eth-cfm:fc-type; + max-elements 8; + description "Forwarding class name for which to create an individual profile-unaware counter"; + } + + leaf-list fc-in-profile { + type types-eth-cfm:fc-type; + max-elements 8; + description "Individual counters to create for the specified Forwarding Class"; + } + + } // container collect-lmm-fc-stats + + list mep { + key "md-admin-name ma-admin-name mep-id"; + description "Enter the mep context"; + + leaf md-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique domain name"; + } + + leaf ma-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique association name"; + } + + leaf mep-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:mep-id-type; + } + description "Maintenance association end point identifier"; + } + + leaf primary-vlan { + type boolean; + sros-ext:immutable; + default "false"; + description "MEP provisioned using MA primary VLAN ID"; + } + + leaf direction { + type types-eth-cfm:mp-direction; + sros-ext:immutable; + description "Direction the MEP faces"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the MEP"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf mac-address { + type types-sros:mac-unicast-address-no-zero; + description "MAC address for the MEP"; + } + + leaf install-mep { + type boolean; + default "false"; + description "Install MEP in the forwarding plane"; + } + + leaf low-priority-defect { + type types-eth-cfm:lowest-alarm-priority; + default "mac-rem-err-xcon"; + description "Lowest priority defect that is allowed to generate a fault alarm"; + } + + leaf fault-propagation { + type types-eth-cfm:fault-propagation-type; + description "Fault propagation for the MEP"; + } + + leaf ccm { + type boolean; + default "false"; + description "Generate CCM messages"; + } + + leaf ccm-ltm-priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of CCM and LTM messages transmitted by the MEP"; + } + + leaf ccm-padding-size { + type uint32 { + range "3..1500"; + } + description "Additional octets inserted into CCM PDU for data TLV padding"; + } + + leaf lbm-svc-act-responder { + type boolean; + default "false"; + description "Process service activation streams encapsulated in ETH-CFM request Loopback Message"; + } + + leaf one-way-delay-threshold { + type uint32 { + range "0..600"; + } + units "seconds"; + default "3"; + description "Threshold for one way delay test"; + } + + container alarm-notification { + description "Enter the alarm-notification context"; + + leaf fng-alarm-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm"; + } + + leaf fng-reset-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm is reset"; + } + + } // container alarm-notification + + container ais { + presence + "The generation and reception of Alarm Indication Signal (AIS) + message parameters"; + description "Enter the ais context"; + + leaf-list client-meg-level { + type uint32 { + range "1..7"; + } + max-elements 7; + description "Client MEG level for AIS message generation"; + } + + leaf interface-support { + type boolean; + default "false"; + description "Allow generation of AIS PDUs based on the associated endpoint state"; + } + + leaf interval { + type uint32 { + range "1|60"; + } + units "seconds"; + default "1"; + description "Transmission interval for AIS messages"; + } + + leaf low-priority-defect { + type enumeration { + enum "all-def" { value 1; } + enum "mac-rem-err-xcon" { value 2; } + } + default "all-def"; + description "Lowest priority defect for MEP AIS generation"; + } + + leaf priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of AIS messages originated by the node"; + } + + } // container ais + + container csf { + presence "The reception of Client Signal Fail (CSF) message parameters"; + description "Enter the csf context"; + + leaf multiplier { + type decimal64 { + range "0.0|2.0..30.0"; + fraction-digits 1; + } + default "3.5"; + description "Receive period multiplier to time out CSF"; + } + + } // container csf + + container eth-test { + presence "Enable/disable eth-test functionality on MEP."; + description "Enter the eth-test context"; + + leaf bit-error-threshold { + type uint32 { + range "0..11840"; + } + units "bit errors"; + default "1"; + description "Lowest priority defect threshold for the bit error trap to generate a fault alarm"; + } + + container test-pattern { + description "Enter the test-pattern context"; + + leaf pattern { + type enumeration { + enum "all-zeros" { value 0; } + enum "all-ones" { value 1; } + } + default "all-zeros"; + description "Test pattern for eth-test frames"; + } + + leaf crc-tlv { + type boolean; + default "false"; + description "Generate a CRC checksum"; + } + + } // container test-pattern + + } // container eth-test + + container grace { + description "Enter the grace context"; + + container eth-ed { + description "Enter the eth-ed context"; + + leaf max-rx-defect-window { + type uint32 { + range "1..86400"; + } + units "seconds"; + description "Value to compare to received peer value, lower is used as maximum ETH-ED expected defect window"; + } + + leaf priority { + type int32 { + range "0..7"; + } + description "Transmission priority for ETH-ED PDUs"; + } + + leaf rx-eth-ed { + type boolean; + default "true"; + description "Receive and process ETH-ED PDUs"; + } + + leaf tx-eth-ed { + type boolean; + default "false"; + description "Transmit ETH-ED PDUs"; + } + + } // container eth-ed + + container eth-vsm-grace { + description "Enter the eth-vsm-grace context"; + + leaf rx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the reception and processing of the Nokia ETH-CFM Grace PDU on the MEP"; + } + + leaf tx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the transmission of the Nokia ETH-CFM Grace PDU from the MEP"; + } + + } // container eth-vsm-grace + + } // container grace + + } // list mep + + } // container eth-cfm + + container mc-ring { + presence "Prepare SAP for use in MC-ring"; + description "Enter the mc-ring context"; + + leaf ring-node { + type types-sros:named-item; + mandatory true; + description "Name for the ring node associated with this SAP"; + } + + } // container mc-ring + + } // list sap + + list capture-sap { + key "sap-id"; + description "Enter the capture-sap context"; + + leaf sap-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:sap; + } + description "SAP identifier"; + } + + leaf description { + type types-sros:long-description; + description "Text description"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the SAP"; + } + + leaf bandwidth { + type types-services:sap-bandwidth; + units "kilobps"; + description "SAP bandwidth"; + } + + leaf dist-cpu-protection { + type types-sros:named-item; + description "Distributed CPU protection policy for SAP"; + } + + leaf host-lockout-policy { + type types-sros:named-item; + description "Host lockout policy"; + } + + leaf radius-auth-policy { + type types-sros:named-item; + description "RADIUS authentication policy"; + } + + leaf nasreq-auth-policy { + type types-sros:named-item; + description "Diameter NASREQ application policy to use for authentication"; + } + + leaf allow-dot1q-msaps { + type boolean; + default "false"; + description "Create IEEE 802.1q Managed SAP's on an IEEE 802.1ad port"; + } + + leaf track-srrp { + type uint32 { + range "1..4294967295"; + } + description "SRRP instance that this capture SAP tracks"; + } + + container ingress { + description "Enter the ingress context"; + + container filter { + description "Enter the filter context"; + + leaf mac { + type types-filter:filter-name; + description "MAC filter identifier"; + } + + } // container filter + + } // container ingress + + container cpu-protection { + description "Enter the cpu-protection context"; + + leaf policy-id { + type types-services:cpm-prot-policy-id; + description "CPM protection policy"; + } + + choice monitoring { + case mac { + + leaf mac-monitoring { + type empty; + description "Monitor MAC for CPU protection"; + } + + } + } + } // container cpu-protection + + container trigger-packet { + description "Enter the trigger-packet context"; + + leaf arp { + type boolean; + default "false"; + description "ARP packet"; + } + + leaf data { + type boolean; + default "false"; + description "Data packet"; + } + + leaf dhcp { + type boolean; + default "false"; + description "DHCP packet"; + } + + leaf dhcp6 { + type boolean; + default "false"; + description "DHCP6 packet"; + } + + leaf pppoe { + type boolean; + default "false"; + description "PPPoE packet"; + } + + leaf rtr-solicit { + type boolean; + default "false"; + description "Router-solicit packet"; + } + + } // container trigger-packet + + container msap-defaults { + description "Enter the msap-defaults context"; + + leaf policy { + type types-sros:named-item; + description "MSAP policy"; + } + + leaf service-name { + type types-services:service-name; + description "Service name"; + } + + leaf group-interface { + type types-sros:interface-name; + description "Group interface"; + } + + } // container msap-defaults + + container ipoe-session { + description "Enter the ipoe-session context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of IPoE session"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf ipoe-session-policy { + type types-sros:named-item; + description "IPoE Session policy to be used for new sessions"; + } + + leaf user-db { + type types-sros:named-item; + description "Local user database that is used to (pre-)authenticate new sessions"; + } + + } // container ipoe-session + + container dhcp { + description "Enter the dhcp context"; + + leaf python-policy { + type types-sros:named-item; + description "Python policy"; + } + + leaf user-db { + type types-sros:named-item; + description "Local user database"; + } + + } // container dhcp + + container dhcp6 { + description "Enter the dhcp6 context"; + + leaf python-policy { + type types-sros:named-item; + description "Python policy"; + } + + leaf user-db { + type types-sros:named-item; + description "Local user database"; + } + + } // container dhcp6 + + container pppoe { + description "Enter the pppoe context"; + + leaf policy { + type types-sros:named-item; + description "PPP policy"; + } + + leaf python-policy { + type types-sros:named-item; + description "Python policy"; + } + + leaf user-db { + type types-sros:named-item; + description "Local user database"; + } + + } // container pppoe + + container router-solicit { + description "Enter the router-solicit context"; + + leaf user-db { + type types-sros:named-item; + description "Local user database"; + } + + } // container router-solicit + + } // list capture-sap + + list interface { + key "interface-name"; + description "Enter the interface context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Router interface name"; + } + + leaf description { + type types-sros:very-long-description; + description "Text description"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the interface"; + } + + leaf mac { + type types-sros:mac-unicast-address; + description "MAC address for the interface"; + } + + container hold-time { + description "Enter the hold-time context"; + + container ipv4 { + description "Enter the ipv4 context"; + + container up { + description "Enter the up context"; + + leaf seconds { + type types-router:hold-time-seconds; + units "seconds"; + description "Up hold time for the IP interface"; + } + + } // container up + + container down { + description "Enter the down context"; + + leaf seconds { + type types-router:hold-time-seconds; + units "seconds"; + description "Down hold time for the IP interface"; + } + + leaf init-only { + type boolean; + default "false"; + description "Apply down delay only when interface is configured or after reboot"; + } + + } // container down + + } // container ipv4 + + } // container hold-time + + container ipv4 { + description "Enter the ipv4 context"; + + container primary { + presence "Primary IPv4 address for this router interface."; + description "Enter the primary context"; + + leaf address { + type types-sros:ipv4-address; + mandatory true; + description "IPv4 address for a VPLS interface"; + } + + leaf prefix-length { + type uint32 { + range "0..32"; + } + mandatory true; + description "IPv4 address prefix length"; + } + + } // container primary + + container neighbor-discovery { + description "Enter the neighbor-discovery context"; + + leaf timeout { + type uint32 { + range "0..65535"; + } + units "seconds"; + default "14400"; + description "ARP timeout value to determine how long an ARP entry remains in the ARP cache"; + } + + list static-neighbor { + key "ipv4-address"; + description "Enter the static-neighbor context"; + + leaf ipv4-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-address; + } + description "IPv4 address corresponding to the media-dependent physical address"; + } + + leaf mac-address { + type yang:mac-address; + mandatory true; + description "Media-dependent physical address"; + } + + } // list static-neighbor + + } // container neighbor-discovery + + } // container ipv4 + + } // list interface + + container igmp-host-tracking { + description "Enter the igmp-host-tracking context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of IGMP host tracking"; + } + + leaf expiry-time { + type types-sros:time-duration { + range "1..65535"; + } + units "seconds"; + default "260"; + description "Time during which the system continues to track inactive hosts"; + } + + } // container igmp-host-tracking + + container wlan-gw { + description "Enter the wlan-gw context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of WLAN-GW"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf sap-template { + type types-sros:named-item; + description "Template used when creating internal SAPs towards ISAs"; + } + + } // container wlan-gw + + container gsmp { + description "Enter the gsmp context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of GSMP"; + } + + list group { + key "name"; + max-elements 1024; + description "Enter the group context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "GSMP neighbor group name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the GSMP group"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf keepalive { + type types-sros:time-duration { + range "1..25"; + } + units "seconds"; + default "10"; + description "Keepalive value for the GSMP connections in this group"; + } + + leaf hold-multiplier { + type uint32 { + range "1..100"; + } + default "3"; + description "Hold-multiplier for the GSMP connections in this group"; + } + + leaf persistency { + type boolean; + default "false"; + description "Store DSL line information when the GSMP connection terminates"; + } + + leaf idle-filter { + type boolean; + default "false"; + description "Filter ANCP messages from IDLE DSL lines"; + } + + container ancp { + description "Enter the ancp context"; + + leaf dynamic-topology-discovery { + type boolean; + default "true"; + description "Enable the ANCP dynamic topology discovery capability"; + } + + leaf oam { + type boolean; + default "false"; + description "Enable GSMP ANCP OAM capability at startup of GSMP connection"; + } + + } // container ancp + + list neighbor { + key "remote-address"; + description "Enter the neighbor context"; + + leaf remote-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-unicast-address; + } + description "GSMP neighbor remote IP address"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the GSMP neighbor"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf local-address { + type types-sros:ipv4-unicast-address; + description "Restrict connections to this local address only within the service running ANCP"; + } + + container priority-marking { + description "Enter the priority-marking context"; + + choice priority-marking { + case dscp { + + leaf dscp { + type types-qos:dscp-name; + description "DSCP that is used while remarking the in profile packets"; + } + + } + case prec { + + leaf prec { + type types-qos:precedence-value; + description "Precedence priority marking"; + } + + } + } + } // container priority-marking + + } // list neighbor + + } // list group + + } // container gsmp + + } // list vpls + + list vprn { + key "service-name"; + description "Enter the vprn context"; + + leaf service-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-services:service-name; + } + description "Name of the service"; + } + + container aggregates { + description "Enter the aggregates context"; + + list aggregate { + key "ip-prefix"; + description "Enter the aggregate context"; + + leaf ip-prefix { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-unicast-prefix; + } + description "IP address prefix to match for aggregation"; + } + + leaf as-set { + type boolean; + default "false"; + description "Allow aggregate route as an AS-SET option"; + } + + leaf-list community { + type types-sros:community; + max-elements 12; + ordered-by user; + description "Community name that is added to aggregate route"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf summary-only { + type boolean; + default "false"; + description "Advertise only the aggregate route and not the specific routes that make up the aggregate"; + } + + leaf local-preference { + type int64 { + range "0..4294967295"; + } + description "Default local preference if aggregate route is exported and advertised to BGP peers"; + } + + choice next-hop { + case blackhole { + + container blackhole { + presence "blackhole"; + description "Enter the blackhole context"; + + leaf generate-icmp { + type boolean; + default "false"; + description "Send ICMP unreachable messages when packets match an aggregate route with black-hole next-hop"; + } + + } // container blackhole + + } + case indirect { + + leaf indirect { + type types-sros:ip-unicast-address; + sros-ext:immutable; + description "Address of indirect next hop"; + } + + } + } + container aggregator { + description "Enter the aggregator context"; + + leaf as-number { + type uint32 { + range "1..max"; + } + description "Aggregator Autonomous System Number (ASN)"; + } + + leaf address { + type types-sros:ipv4-unicast-address; + description "Aggregator IP address"; + } + + } // container aggregator + + } // list aggregate + + } // container aggregates + + container bgp { + presence "Enable BGP for VPRN services"; + description "Enter the bgp context"; + + list group { + key "group-name"; + description "Enter the group context"; + + leaf group-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "BGP peer group"; + } + + list prefix-limit { + key "family"; + description "Enter the prefix-limit context"; + + leaf family { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type enumeration { + enum "ipv4" { value 1; } + enum "ipv6" { value 3; } + enum "mcast-ipv4" { value 4; } + enum "flow-ipv4" { value 10; } + enum "flow-ipv6" { value 14; } + enum "mcast-ipv6" { value 16; } + enum "label-ipv4" { value 17; } + } + } + description "Address family to which the limit applies"; + } + + leaf maximum { + type uint32 { + range "1..4294967295"; + } + mandatory true; + description "Specifies the maximum number of routes that can be learned from this peer."; + } + + leaf log-only { + type boolean; + default "false"; + description "Send warning message if specified threshold or limit is reached, without disabling BGP peer session"; + } + + leaf threshold { + type uint32 { + range "1..100"; + } + default "90"; + description "Threshold value that triggers a warning message"; + } + + leaf idle-timeout { + type int32 { + range "1..1024"; + } + description "Time that BGP peering remains idle before reconnecting to peers"; + } + + leaf post-import { + type boolean; + default "false"; + description "Apply prefix limit only to number of routes accepted by import policies"; + } + + } // list prefix-limit + + } // list group + + list neighbor { + key "ip-address"; + description "Enter the neighbor context"; + + leaf ip-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-address-with-zone; + } + description "IP address that the neighbor uses to communicate with BGP peers"; + } + + list prefix-limit { + key "family"; + description "Enter the prefix-limit context"; + + leaf family { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type enumeration { + enum "ipv4" { value 1; } + enum "ipv6" { value 3; } + enum "mcast-ipv4" { value 4; } + enum "flow-ipv4" { value 10; } + enum "flow-ipv6" { value 14; } + enum "mcast-ipv6" { value 16; } + enum "label-ipv4" { value 17; } + } + } + description "Address family to which the limit applies"; + } + + leaf maximum { + type uint32 { + range "1..4294967295"; + } + mandatory true; + description "Specifies the maximum number of routes that can be learned from this peer."; + } + + leaf log-only { + type boolean; + default "false"; + description "Send warning message if specified threshold or limit is reached, without disabling BGP peer session"; + } + + leaf threshold { + type uint32 { + range "1..100"; + } + default "90"; + description "Threshold value that triggers a warning message"; + } + + leaf idle-timeout { + type int32 { + range "1..1024"; + } + description "Time that BGP peering remains idle before reconnecting to peers"; + } + + leaf post-import { + type boolean; + default "false"; + description "Apply prefix limit only to number of routes accepted by import policies"; + } + + } // list prefix-limit + + } // list neighbor + + } // container bgp + + list interface { + key "interface-name"; + description "Enter the interface context"; + + leaf interface-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "Name of the interface"; + } + + list sap { + key "sap-id"; + max-elements 1; + description "Enter the sap context"; + + leaf sap-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:sap; + } + description "SAP identifier"; + } + + leaf description { + type types-sros:long-description; + description "Text description"; + } + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of the SAP"; + } + + leaf accounting-policy { + type types-log:log-policy-id; + description "Accounting policy"; + } + + leaf anti-spoof { + type types-services:anti-spoof-option; + description "Anti-spoof filtering"; + } + + leaf bandwidth { + type types-services:sap-bandwidth; + units "kilobps"; + description "SAP bandwidth"; + } + + leaf calling-station-id { + type types-sros:string-not-all-spaces { + length "1..64"; + } + description "Calling station ID"; + } + + leaf collect-stats { + type boolean; + default "false"; + description "Collect accounting statistics"; + } + + leaf dist-cpu-protection { + type types-sros:named-item; + description "Distributed CPU protection policy for SAP"; + } + + leaf host-admin-state { + type types-sros:admin-state; + default "enable"; + description "Enable/disable administrative state of hosts"; + } + + leaf host-lockout-policy { + type types-sros:named-item; + description "Host lockout policy"; + } + + leaf multi-service-site { + type types-sros:named-item; + description "Multi service site name"; + } + + container ingress { + description "Enter the ingress context"; + + leaf queue-group-redirect-list { + type types-sros:named-item; + description "Queue group redirect list"; + } + + container qos { + description "Enter the qos context"; + + leaf match-qinq-dot1p { + type enumeration { + enum "top" { value 2; } + enum "bottom" { value 3; } + } + description "Ingress match QinQ Dot1p"; + } + + container sap-ingress { + description "Enter the sap-ingress context"; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Policy identifier"; + } + + leaf queuing-type { + type types-services:services-sap-queuing-type; + description "Ingress queuing type"; + } + + container fp-redirect-group { + description "Enter the fp-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Forwarding-plane queue group policy"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Queue group instance"; + } + + } // container fp-redirect-group + + container overrides { + description "Enter the overrides context"; + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-queue-id; + } + description "Policer unique ID"; + } + + leaf cbs { + type union { + type uint32 { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobps"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "MBS"; + } + + leaf monitor-depth { + type boolean; + default "false"; + description "Monitor queue depth"; + } + + choice queue-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-services:sap-pir-rate-ovr; + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type types-services:sap-cir-rate-ovr; + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent-or-default-override; + description "Percentage reduction from the MBS for a queue drop tail"; + } + + } // container low + + } // container drop-tail + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight-override; + description "PIR parameter that overrides parent for queue group"; + } + + leaf cir-weight { + type types-qos:weight-override; + description "CIR parameter that overrides parent for queue group"; + } + + } // container parent + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:ingress-policer-id; + } + description "Policer unique ID"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "MBS"; + } + + leaf packet-byte-offset { + type types-qos:ingress-per-packet-offset-override; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf stat-mode { + type types-qos:ingress-policer-stat-mode; + description "Mode of statistics collected by the policer"; + } + + choice policer-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + } // list policer + + } // container overrides + + } // container sap-ingress + + container policer-control-policy { + description "Enter the policer-control-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Policer control policy name"; + } + + container overrides { + presence "Apply a policer control policy override."; + description "Enter the overrides context"; + + container root { + description "Enter the root context"; + + leaf max-rate { + type types-services:sap-max-rate-ovr; + description "Maximum frame-based bandwidth limit"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-thresh-separation { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of separation buffer space"; + } + + list priority { + key "priority-level"; + description "Enter the priority context"; + + leaf priority-level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of cumulative buffer space allowed"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container root + + } // container overrides + + } // container policer-control-policy + + container scheduler-policy { + description "Enter the scheduler-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Scheduler policy name"; + } + + container overrides { + description "Enter the overrides context"; + + list scheduler { + key "scheduler-name"; + description "Enter the scheduler context"; + + leaf scheduler-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Scheduler override policy name"; + } + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-weight { + type types-qos:weight; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container parent + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + description "Specifies the administrative PIR"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "sum" { value -3; } + enum "max" { value -1; } + } + } + description "Specifies the administrative CIR"; + } + + } // container rate + + } // list scheduler + + } // container overrides + + } // container scheduler-policy + + } // container qos + + container filter { + description "Enter the filter context"; + + leaf ip { + type types-filter:filter-name; + description "IP filter ID"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + } // container ingress + + container egress { + description "Enter the egress context"; + + leaf queue-group-redirect-list { + type types-sros:named-item; + description "Queue group redirect list"; + } + + container qos { + description "Enter the qos context"; + + leaf qinq-mark-top-only { + type boolean; + default "false"; + description "Mark top Q-tags"; + } + + container sap-egress { + description "Enter the sap-egress context"; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Policy identifier"; + } + + container port-redirect-group { + description "Enter the port-redirect-group context"; + + leaf group-name { + type types-sros:named-item; + description "Policy for port redirect queue group"; + } + + leaf instance { + type types-services:qos-qgrp-instance-id; + description "Instance of port queue group"; + } + + } // container port-redirect-group + + container overrides { + description "Enter the overrides context"; + + leaf hs-secondary-shaper { + type types-sros:named-item; + description "HS Secondary Shaper"; + } + + container hsmda-queues { + description "Enter the hsmda-queues context"; + + leaf secondary-shaper { + type types-sros:named-item; + description "Secondary shaper for the HSMDA queue"; + } + + leaf packet-byte-offset { + type types-services:egress-hsmda-queue-packet-byte-offset; + description "Packet byte offset for HSMDA queue"; + } + + leaf wrr-policy { + type types-sros:named-item; + description "WRR policy for the HSMDA queue"; + } + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Egress HSMDA queue ID"; + } + + leaf mbs { + type types-qos:hsmda-queue-burst-size-override; + units "bytes"; + description "Buffer space allowed for the queue"; + } + + leaf rate { + type types-qos:hsmda-queue-pir-rate-override; + description "Administrative PIR rate."; + } + + leaf slope-policy { + type types-sros:named-item; + description + "Name of the slope-policy which is used to override the + default slope-policy for the named buffer pool."; + } + + leaf wrr-weight { + type types-qos:hsmda-wrr-weight-override; + description "Weight value for the HSMDA queue"; + } + + } // list queue + + } // container hsmda-queues + + list queue { + key "queue-id"; + description "Enter the queue context"; + + leaf queue-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:egress-queue-id; + } + description "Policer unique ID"; + } + + leaf avg-frame-overhead { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description + "Encapsulation overhead, in centipercent, used to + translate packet-based rate to frame-based rate and vice versa."; + } + + leaf burst-limit { + type union { + type types-qos:bytes { + range "1..14000000"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "Explicit shaping burst size of a queue."; + } + + leaf cbs { + type union { + type uint32 { + range "0..1048576"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "kilobytes"; + description "MBS"; + } + + leaf monitor-depth { + type boolean; + default "false"; + description "Monitor queue depth"; + } + + leaf hs-wrr-weight { + type types-qos:hs-wrr-weight-override; + default "1"; + description "Weighted Round Robin (WRR) weight to parent with this queue into the scheduler"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight-override; + description "Scheduling class weight."; + } + + choice queue-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type types-services:sap-pir-rate-ovr; + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type types-services:sap-cir-rate-ovr; + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + container adaptation-rule { + description "Enter the adaptation-rule context"; + + leaf pir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational PIR value"; + } + + leaf cir { + type types-qos:adaptation-rule-override; + description "Constraint used when deriving the operational CIR value"; + } + + } // container adaptation-rule + + container drop-tail { + description "Enter the drop-tail context"; + + container low { + description "Enter the low context"; + + leaf percent-reduction-from-mbs { + type types-qos:burst-percent-or-default-override; + description "Percentage reduction from the MBS for a queue drop tail"; + } + + } // container low + + } // container drop-tail + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight-override; + description "PIR parameter that overrides parent for queue group"; + } + + leaf cir-weight { + type types-qos:weight-override; + description "CIR parameter that overrides parent for queue group"; + } + + } // container parent + + container hs-wred-queue { + description "Enter the hs-wred-queue context"; + + leaf policy { + type types-sros:named-item; + description "Name of slope-policy."; + } + + } // container hs-wred-queue + + } // list queue + + list policer { + key "policer-id"; + description "Enter the policer context"; + + leaf policer-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:sap-egress-policer-id; + } + description "Policer unique ID"; + } + + leaf cbs { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "CBS"; + } + + leaf mbs { + type union { + type types-qos:bytes { + range "0..1073741824"; + } + type enumeration { + enum "auto" { value -1; } + } + } + description "MBS"; + } + + leaf packet-byte-offset { + type types-qos:egress-per-packet-offset-override; + description "Size of each packet, handled by the policer, to be modified"; + } + + leaf stat-mode { + type types-qos:egress-policer-stat-mode; + description "Mode of statistics collected by the policer"; + } + + choice policer-override-rate { + case rate { + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "PIR rate"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "CIR rate"; + } + + } // container rate + + } + case percent-rate { + + container percent-rate { + description "Enter the percent-rate context"; + + leaf pir { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "PIR percent rate"; + } + + leaf cir { + type decimal64 { + range "0.00..100.00"; + fraction-digits 2; + } + description "CIR percent rate"; + } + + } // container percent-rate + + } + } + } // list policer + + list hs-wrr-group { + key "group-id"; + description "Enter the hs-wrr-group context"; + + leaf group-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hs-wrr-group-id; + } + description "HS WRR group identifier"; + } + + leaf hs-class-weight { + type types-qos:hs-class-weight-override; + description "Weight of scheduling class."; + } + + choice rate-or-percent-rate { + case rate { + + leaf rate { + type union { + type uint32 { + range "1..2000000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + description "Administrative PIR."; + } + + } + case percent-rate { + + leaf percent-rate { + type decimal64 { + range "0.01..100.00"; + fraction-digits 2; + } + description "Administrative PIR percent."; + } + + } + } + } // list hs-wrr-group + + } // container overrides + + } // container sap-egress + + container policer-control-policy { + description "Enter the policer-control-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Policer control policy name"; + } + + container overrides { + presence "Apply a policer control policy override."; + description "Enter the overrides context"; + + container root { + description "Enter the root context"; + + leaf max-rate { + type types-services:sap-max-rate-ovr; + description "Maximum frame-based bandwidth limit"; + } + + container priority-mbs-thresholds { + description "Enter the priority-mbs-thresholds context"; + + leaf min-thresh-separation { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of separation buffer space"; + } + + list priority { + key "priority-level"; + description "Enter the priority context"; + + leaf priority-level { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-qos:hierarchy-level; + } + description "Priority level"; + } + + leaf mbs-contribution { + type union { + type types-qos:bytes { + range "0..16777216"; + } + type enumeration { + enum "auto" { value -1; } + } + } + units "bytes"; + description "Minimum amount of cumulative buffer space allowed"; + } + + } // list priority + + } // container priority-mbs-thresholds + + } // container root + + } // container overrides + + } // container policer-control-policy + + container scheduler-policy { + description "Enter the scheduler-policy context"; + + leaf policy-name { + type types-sros:named-item; + description "Scheduler policy name"; + } + + container overrides { + description "Enter the overrides context"; + + list scheduler { + key "scheduler-name"; + description "Enter the scheduler context"; + + leaf scheduler-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "Scheduler override policy name"; + } + + container parent { + description "Enter the parent context"; + + leaf weight { + type types-qos:weight; + description "Weight to be used by the scheduler for feeding this queue"; + } + + leaf cir-weight { + type types-qos:weight; + description "Weight that is used by the scheduler until the committed rate for feeding this queue"; + } + + } // container parent + + container rate { + description "Enter the rate context"; + + leaf pir { + type union { + type int64 { + range "1..6400000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + description "Specifies the administrative PIR"; + } + + leaf cir { + type union { + type int64 { + range "0..6400000000"; + } + type enumeration { + enum "sum" { value -3; } + enum "max" { value -1; } + } + } + description "Specifies the administrative CIR"; + } + + } // container rate + + } // list scheduler + + } // container overrides + + } // container scheduler-policy + + container vlan-qos-policy { + description "Attach an egress vlan-qos-policy."; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Egress vlan-qos-policy name"; + } + + } // container vlan-qos-policy + + container egress-remark-policy { + description "Attach an egress-remark-policy."; + + leaf policy-name { + type types-qos:qos-policy-name; + description "Egress-remark-policy name"; + } + + } // container egress-remark-policy + + } // container qos + + container filter { + description "Enter the filter context"; + + leaf ip { + type types-filter:filter-name; + description "MAC filter ID"; + } + + leaf ipv6 { + type types-filter:filter-name; + description "IPv6 filter identifier"; + } + + } // container filter + + container agg-rate { + description "Enter the agg-rate context"; + + leaf limit-unused-bandwidth { + type boolean; + default "false"; + description "Enable aggregate rate overrun protection"; + } + + leaf rate { + type types-services:agg-rate-rate; + description "Maximum total rate of all egress queues in kbps."; + } + + leaf queue-frame-based-accounting { + type boolean; + default "false"; + description "Enable frame-based accounting on all policers and queues associated with context"; + } + + leaf cir { + type union { + type int32 { + range "0..100000000"; + } + type enumeration { + enum "max" { value -1; } + } + } + units "kilobps"; + default "0"; + description "Specifies the administrative CIR."; + } + + } // container agg-rate + + } // container egress + + container cpu-protection { + description "Enter the cpu-protection context"; + + leaf policy-id { + type types-services:cpm-prot-policy-id; + description "CPM protection policy"; + } + + choice monitoring { + case mac { + + leaf mac-monitoring { + type empty; + description "Monitor MAC for CPU protection"; + } + + } + case cfm { + + container eth-cfm-monitoring { + presence "Enable ETH CFM monitoring configuration."; + description "Enter the eth-cfm-monitoring context"; + + leaf aggregate { + type empty; + description "Apply rate limit to the sum of the per peer packet rates"; + } + + leaf car { + type empty; + description "Eth-CFM packets to be ignored when enforcing overall rate"; + } + + } // container eth-cfm-monitoring + + } + case ip { + + leaf ip-src-monitoring { + type empty; + description "Enable IP source monitoring for CPU protection"; + } + + } + } + } // container cpu-protection + + container lag { + description "Enter the lag context"; + + leaf link-map-profile { + type types-services:link-map-profile-id; + description "LAG link map profile applied to a SAP or network interface"; + } + + container per-link-hash { + description "Configure per-link-hash information."; + + leaf class { + type types-services:sap-lag-per-link-hash-class; + default "1"; + description "Configure per-link-hash class."; + } + + leaf weight { + type types-services:sap-lag-per-link-hash-weight; + default "1"; + description "Configure per-link-hash weight."; + } + + } // container per-link-hash + + } // container lag + + container fwd-wholesale { + description "Enter the fwd-wholesale context"; + + leaf pppoe-service { + type types-services:service-name; + description "PPPoE service name"; + } + + } // container fwd-wholesale + + container eth-cfm { + description "Enter the eth-cfm context"; + + leaf collect-lmm-stats { + type boolean; + default "false"; + description + "Enable/disable the collection of statistics for OAM-PM + Loss Measurement Message (LMM) tests "; + } + + leaf-list squelch-ingress-levels { + type uint32 { + range "0..7"; + } + max-elements 8; + description "ETH-CFM PDUs to be silently discarded"; + } + + container collect-lmm-fc-stats { + description "Enter the collect-lmm-fc-stats context"; + + leaf-list fc { + type types-eth-cfm:fc-type; + max-elements 8; + description "Forwarding class name for which to create an individual profile-unaware counter"; + } + + leaf-list fc-in-profile { + type types-eth-cfm:fc-type; + max-elements 8; + description "Individual counters to create for the specified Forwarding Class"; + } + + } // container collect-lmm-fc-stats + + list mep { + key "md-admin-name ma-admin-name mep-id"; + description "Enter the mep context"; + + leaf md-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique domain name"; + } + + leaf ma-admin-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:admin-name; + } + description "Unique association name"; + } + + leaf mep-id { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-eth-cfm:mep-id-type; + } + description "Maintenance association end point identifier"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the MEP"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf install-mep { + type boolean; + default "false"; + description "Install MEP in the forwarding plane"; + } + + leaf low-priority-defect { + type types-eth-cfm:lowest-alarm-priority; + default "mac-rem-err-xcon"; + description "Lowest priority defect that is allowed to generate a fault alarm"; + } + + leaf fault-propagation { + type types-eth-cfm:fault-propagation-type; + description "Fault propagation for the MEP"; + } + + leaf ccm { + type boolean; + default "false"; + description "Generate CCM messages"; + } + + leaf ccm-ltm-priority { + type types-eth-cfm:frame-priority; + default "7"; + description "Priority of CCM and LTM messages transmitted by the MEP"; + } + + leaf ccm-padding-size { + type uint32 { + range "3..1500"; + } + description "Additional octets inserted into CCM PDU for data TLV padding"; + } + + leaf one-way-delay-threshold { + type uint32 { + range "0..600"; + } + units "seconds"; + default "3"; + description "Threshold for one way delay test"; + } + + leaf ais { + type boolean; + default "false"; + description "Generate AIS frames from the Maintenance Entity Group (MEG)."; + } + + container alarm-notification { + description "Enter the alarm-notification context"; + + leaf fng-alarm-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm"; + } + + leaf fng-reset-time { + type int32 { + range "250|500|1000"; + } + units "centiseconds"; + description "Time to expire before a Fault Notification Generation (FNG) alarm is reset"; + } + + } // container alarm-notification + + container csf { + presence "The reception of Client Signal Fail (CSF) message parameters"; + description "Enter the csf context"; + + leaf multiplier { + type decimal64 { + range "0.0|2.0..30.0"; + fraction-digits 1; + } + default "3.5"; + description "Receive period multiplier to time out CSF"; + } + + } // container csf + + container eth-test { + presence "Enable/disable eth-test functionality on MEP."; + description "Enter the eth-test context"; + + leaf bit-error-threshold { + type uint32 { + range "0..11840"; + } + units "bit errors"; + default "1"; + description "Lowest priority defect threshold for the bit error trap to generate a fault alarm"; + } + + container test-pattern { + description "Enter the test-pattern context"; + + leaf pattern { + type enumeration { + enum "all-zeros" { value 0; } + enum "all-ones" { value 1; } + } + default "all-zeros"; + description "Test pattern for eth-test frames"; + } + + leaf crc-tlv { + type boolean; + default "false"; + description "Generate a CRC checksum"; + } + + } // container test-pattern + + } // container eth-test + + container grace { + description "Enter the grace context"; + + container eth-ed { + description "Enter the eth-ed context"; + + leaf max-rx-defect-window { + type uint32 { + range "1..86400"; + } + units "seconds"; + description "Value to compare to received peer value, lower is used as maximum ETH-ED expected defect window"; + } + + leaf priority { + type int32 { + range "0..7"; + } + description "Transmission priority for ETH-ED PDUs"; + } + + leaf rx-eth-ed { + type boolean; + default "true"; + description "Receive and process ETH-ED PDUs"; + } + + leaf tx-eth-ed { + type boolean; + default "false"; + description "Transmit ETH-ED PDUs"; + } + + } // container eth-ed + + container eth-vsm-grace { + description "Enter the eth-vsm-grace context"; + + leaf rx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the reception and processing of the Nokia ETH-CFM Grace PDU on the MEP"; + } + + leaf tx-eth-vsm-grace { + type boolean; + default "true"; + description "Allow the transmission of the Nokia ETH-CFM Grace PDU from the MEP"; + } + + } // container eth-vsm-grace + + } // container grace + + } // list mep + + } // container eth-cfm + + list ip-tunnel { + key "tunnel-name"; + max-elements 1; + description "Enter the ip-tunnel context"; + + leaf tunnel-name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:interface-name; + } + description "IP tunnel name"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the tunnel"; + } + + leaf description { + type types-sros:description; + description "Text description"; + } + + leaf clear-df-bit { + type boolean; + default "false"; + description "Clear the Do-not-Fragment bit"; + } + + leaf delivery-service { + type types-services:service-name; + description "Delivery service name"; + } + + leaf dscp { + type types-qos:dscp-name; + description "Differentiated Services Code Point (DSCP) name"; + } + + leaf encapsulated-ip-mtu { + type uint32 { + range "512..9000"; + } + units "bytes"; + description "Encapsulated IP MTU of this tunnel"; + } + + leaf ip-mtu { + type uint32 { + range "512..9000"; + } + units "bytes"; + description "IP MTU of this tunnel"; + } + + leaf public-tcp-mss-adjust { + type union { + type uint32 { + range "512..9000"; + } + type enumeration { + enum "auto" { value 0; } + } + } + units "bytes"; + description "TCP maximum segment size (MSS) on private network"; + } + + leaf private-tcp-mss-adjust { + type int32 { + range "512..9000"; + } + units "bytes"; + description "TCP maximum segment size (MSS) on private network"; + } + + leaf reassembly { + type union { + type int32 { + range "1..5000"; + } + type enumeration { + enum "use-tunnel-group-setting" { value -1; } + enum "none" { value 0; } + } + } + units "milliseconds"; + default "use-tunnel-group-setting"; + description "Reassembly wait time"; + } + + leaf remote-ip-address { + type types-sros:ip-address; + description "Remote IP address of this tunnel"; + } + + leaf backup-remote-ip-address { + type types-sros:ip-address; + description "Backup remote IP address that is applied to this tunnel"; + } + + leaf local-ip-address { + type types-sros:ip-address; + description "Local IP address of this tunnel"; + } + + container icmp6-generation { + description "Enter the icmp6-generation context"; + + container packet-too-big { + description "Enter the packet-too-big context"; + + leaf admin-state { + type types-sros:admin-state; + default "enable"; + description "Administrative state of packet-too-big messages"; + } + + leaf number { + type uint32 { + range "10..1000"; + } + default "100"; + description "Number of packet-too-big ICMPv6 messages issued in a specified time frame"; + } + + leaf seconds { + type uint32 { + range "1..60"; + } + units "seconds"; + default "10"; + description "Time frame to limit the number of packet-too-big ICMPv6 messages"; + } + + } // container packet-too-big + + } // container icmp6-generation + + container gre-header { + description "Enter the gre-header context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the GRE header in the tunnel"; + } + + container key { + description "Enter the key context"; + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the keys in the GRE header"; + } + + leaf send { + type uint32; + default "0"; + description "Send key of a GRE header"; + } + + leaf receive { + type uint32; + default "0"; + description "Receive key of a GRE header"; + } + + } // container key + + } // container gre-header + + list dest-ip { + key "dest-ip-address"; + description "Enter the dest-ip context"; + + leaf dest-ip-address { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ip-address; + } + description "Destination IP address of the tunnel"; + } + + } // list dest-ip + + } // list ip-tunnel + + list ipsec-gateway { + key "name"; + max-elements 1; + description "Enter the ipsec-gateway context"; + + leaf name { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:named-item; + } + description "IPsec gateway name."; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the IPsec gateway."; + } + + leaf default-tunnel-template { + type types-ipsec:tunnel-template-id; + description "The IPsec tunnel template ID."; + } + + leaf ike-policy { + type types-ipsec:ike-policy-id; + description "IKE policy ID."; + } + + leaf pre-shared-key { + type types-sros:encrypted-leaf { + length "1..115"; + } + description + "The pre-shared key used for authentication by two + peers forming the tunnel for the IPSec gateway."; + } + + container default-secure-service { + presence "The default security service used by this IPsec gateway."; + description "Enter the default-secure-service context"; + + leaf service-name { + type types-services:service-name; + description "The name of the default security service used by this IPsec gateway."; + } + + leaf interface { + type types-sros:interface-name; + description "The name of the default interface used by this IPsec gateway."; + } + + } // container default-secure-service + + container local { + description "Enter the local context"; + + leaf gateway-address { + type types-sros:ip-address; + description "The IPsec gateway address."; + } + + container id { + description "Enter the id context"; + + choice id { + default "auto"; + case auto { + + leaf auto { + type empty; + description + "System picks a local ID automatically based on auth-method configured + in ike-policy."; + } + + } + case ipv4 { + + leaf ipv4 { + type types-sros:ipv4-unicast-address; + description "The IPv4 Local ID."; + } + + } + case ipv6 { + + leaf ipv6 { + type types-sros:ipv6-unicast-address; + description "The IPv6 Local ID."; + } + + } + case fqdn { + + leaf fqdn { + type types-sros:fully-qualified-domain-name; + description "The Fully Qualified Domain Name (FQDN) Local ID."; + } + + } + } + } // container id + + } // container local + + container max-history-key-records { + description "Enter the max-history-key-records context"; + + leaf ike { + type uint32 { + range "1..3"; + } + description "The maximum number of historical IKE keys which can be recorded by the system."; + } + + leaf esp { + type uint32 { + range "1..48"; + } + description "The maximum number of historical ESP keys which can be recorded by the system."; + } + + } // container max-history-key-records + + } // list ipsec-gateway + + container static-host { + description "Enter the static-host context"; + + list ipv4 { + key "ip mac"; + description "Enter the ipv4 context"; + + leaf ip { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:ipv4-address; + } + description "IP address"; + } + + leaf mac { + type union { + type string { + length "1..64"; + pattern "<.*>" { + error-message "Config Groups Regex Pattern"; + } + } + type types-sros:mac-unicast-address; + } + description "MAC address"; + } + + leaf admin-state { + type types-sros:admin-state; + default "disable"; + description "Administrative state of the static host"; + } + + leaf sub-profile { + type types-sros:external-named-item; + description "Sub-profile name"; + } + + leaf sla-profile { + type types-sros:external-named-item; + description "SLA profile name"; + } + + leaf ancp-string { + type types-submgt:ancp-string; + description "ANCP string"; + } + + leaf int-dest-id { + type types-submgt:int-dest-id; + description "Intermediate destination ID"; + } + + container subscriber-id { + description "Enter the subscriber-id context"; + + choice subscriber-id { + case string { + + leaf string { + type types-submgt:subscriber-id; + description "Subscriber identification"; + } + + } + case use-sap-id { + + leaf use-sap-id { + type empty; + description "Use the SAP id as subscriber ID"; + } + + } + } + } // container subscriber-id + + } // list ipv4 + + } // container static-host + + } // list sap + + } // list interface + + } // list vprn + + } // container service + + } // list group + + } // container groups + + } // grouping conf-groups + +} |