Package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109

Interface PcepTypesData

All Superinterfaces:

org.opendaylight.yangtools.yang.binding.DataRoot

@Generated("mdsal-binding-generator")
public interface PcepTypesData
extends org.opendaylight.yangtools.yang.binding.DataRoot

This module contains the base data model of a PCEP message. It rolls up the definitions contained in RFC5440, RFC7896, RFC5520 and RFC8306, RFC5886. Copyright (c)2013 Cisco Systems, Inc. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html

This class represents the following YANG schema fragment defined in module pcep-types

 module pcep-types {
   yang-version 1;
   namespace urn:opendaylight:params:xml:ns:yang:pcep:types;
   prefix pcep-t;
   import ieee754 {
     prefix ieee754;
     revision-date 2013-08-19;
   }
   import ietf-inet-types {
     prefix inet;
     revision-date 2013-07-15;
   }
   import network-concepts {
     prefix netc;
     revision-date 2013-11-25;
   }
   import rsvp {
     prefix rsvp;
     revision-date 2015-08-20;
   }
   import iana {
     prefix iana;
     revision-date 2013-08-16;
   }
   revision 2018-11-09 {
   }
   revision 2013-10-05 {
   }
   typedef protocol-version {
     type uint8 {
       range 1..7;
     }
   }
   typedef request-id {
     type uint32 {
       range 1..max;
     }
   }
   typedef of-id {
     type uint16;
   }
   grouping vendor-information {
     leaf enterprise-number {
       type iana:enterprise-number;
     }
     choice enterprise-specific-information;
   }
   grouping tlv {
   }
   grouping no-path-vector-tlv {
     uses tlv;
     leaf flags {
       type bits {
         bit p2mp-unreachable {
           position 24;
         }
         bit no-gco-solution {
           position 25;
         }
         bit no-gco-migration {
           position 26;
         }
         bit path-key {
           position 27;
         }
         bit chain-unavailable {
           position 28;
         }
         bit unknown-source {
           position 29;
         }
         bit unknown-destination {
           position 30;
         }
         bit pce-unavailable {
           position 31;
         }
       }
     }
   }
   grouping overload-duration-tlv {
     container overload-duration {
       uses tlv;
       leaf duration {
         type uint32;
         units seconds;
       }
     }
   }
   grouping req-missing-tlv {
     container req-missing {
       uses tlv;
       leaf request-id {
         type request-id;
       }
     }
   }
   grouping of-list-tlv {
     container of-list {
       uses tlv;
       leaf-list codes {
         type of-id;
       }
     }
   }
   grouping order-tlv {
     container order {
       uses tlv;
       leaf delete {
         type uint32;
       }
       leaf setup {
         type uint32;
       }
     }
   }
   grouping vs-tlv {
     container vs-tlv {
       status obsolete;
       uses tlv;
       leaf enterprise-number {
         type iana:enterprise-number;
       }
       choice vendor-payload;
     }
   }
   grouping path-setup-type-tlv {
     container path-setup-type {
       uses tlv;
       leaf pst {
         type uint8;
         default 0;
       }
     }
   }
   grouping object-header {
     leaf processing-rule {
       type boolean;
       default false;
     }
     leaf ignore {
       type boolean;
       default false;
     }
   }
   grouping object {
     uses object-header;
   }
   grouping vendor-information-tlvs {
     list vendor-information-tlv {
       uses tlv;
       uses vendor-information;
     }
   }
   grouping vendor-information-objects {
     list vendor-information-object {
       uses object;
       uses vendor-information;
     }
   }
   grouping open-object {
     container open {
       uses object;
       container tlvs {
         uses of-list-tlv;
         uses vendor-information-tlvs;
       }
       leaf version {
         type protocol-version;
         default 1;
       }
       leaf keepalive {
         type uint8 {
           range 0..255;
         }
       }
       leaf dead-timer {
         type uint8 {
           range 0..255;
         }
       }
       leaf session-id {
         type uint8;
       }
     }
   }
   grouping rp-object {
     container rp {
       uses object;
       container tlvs {
         uses order-tlv;
         uses vendor-information-tlvs;
         uses path-setup-type-tlv;
       }
       leaf priority {
         type uint8 {
           range 1..7;
         }
       }
       leaf request-id {
         type request-id;
       }
       leaf reoptimization {
         type boolean;
         default false;
       }
       leaf bi-directional {
         type boolean;
         default false;
       }
       leaf loose {
         type boolean;
         default false;
       }
       leaf path-key {
         type boolean;
         default false;
       }
       leaf fragmentation {
         type boolean;
         default false;
       }
       leaf p2mp {
         type boolean;
         default false;
       }
       leaf ero-compression {
         type boolean;
         default false;
       }
       leaf supply-of {
         type boolean;
         default false;
       }
       leaf order {
         type boolean;
         default false;
       }
       leaf make-before-break {
         type boolean;
         default false;
       }
     }
   }
   grouping no-path-object {
     uses object;
     leaf nature-of-issue {
       type uint8;
     }
     leaf unsatisfied-constraints {
       when "nature-of-issue = 0" {
       }
       type boolean;
       default false;
     }
   }
   typedef p2mp-leaves {
     type enumeration {
       enum new-leaves-to-add {
         value 1;
       }
       enum old-leaves-to-remove {
         value 2;
       }
       enum old-leaves-path-modified-reoptimized {
         value 3;
       }
       enum old-leaves-path-unchanged {
         value 4;
       }
     }
   }
   grouping p2mp-leaves-leaf {
     leaf p2mp-leaves {
       type p2mp-leaves;
     }
   }
   grouping endpoints-ipv4-source {
     leaf source-ipv4-address {
       type inet:ipv4-address-no-zone;
     }
   }
   grouping endpoints-ipv6-source {
     leaf source-ipv6-address {
       type inet:ipv6-address-no-zone;
     }
   }
   grouping ipv6-destinations {
     leaf-list destination-ipv6-address {
       type inet:ipv6-address-no-zone;
       min-elements 1;
     }
   }
   grouping ipv4-destinations {
     leaf-list destination-ipv4-address {
       type inet:ipv4-address-no-zone;
       min-elements 1;
     }
   }
   grouping endpoints {
     choice address-family {
       case ipv4-case {
         container ipv4 {
           uses endpoints-ipv4-source;
           leaf destination-ipv4-address {
             type inet:ipv4-address-no-zone;
           }
         }
       }
       case ipv6-case {
         container ipv6 {
           uses endpoints-ipv6-source;
           leaf destination-ipv6-address {
             type inet:ipv6-address-no-zone;
           }
         }
       }
       case p2mp-ipv4-case {
         container p2mp-ipv4 {
           uses p2mp-leaves-leaf;
           uses endpoints-ipv4-source;
           uses ipv4-destinations;
         }
       }
       case p2mp-ipv6-case {
         container p2mp-ipv6 {
           uses p2mp-leaves-leaf;
           uses endpoints-ipv6-source;
           uses ipv6-destinations;
         }
       }
     }
   }
   grouping endpoints-object {
     container endpoints-obj {
       uses object;
       uses endpoints;
     }
   }
   grouping bnc {
     uses object;
     list subobject {
       leaf loose {
         type boolean;
       }
       uses rsvp:ip-prefix-subobject;
       ordered-by user;
     }
   }
   grouping branch-node-object {
     container branch-node-list {
       uses bnc;
     }
   }
   grouping non-branch-node-object {
     container non-branch-node-list {
       uses bnc;
     }
   }
   grouping bnc-object {
     choice branch-node-type {
       case branch-node-case {
         uses branch-node-object;
       }
       case non-branch-node-case {
         uses non-branch-node-object;
       }
     }
   }
   grouping unreach-destination-object {
     container unreach-destination-obj {
       uses object;
       choice destination {
         case ipv4-destination-case {
           uses ipv4-destinations;
         }
         case ipv6-destination-case {
           uses ipv6-destinations;
         }
       }
     }
   }
   grouping bandwidth {
     leaf bandwidth {
       type netc:bandwidth;
     }
   }
   grouping bandwidth-object {
     container bandwidth {
       uses object;
       uses bandwidth;
     }
   }
   grouping reoptimization-bandwidth-object {
     container reoptimization-bandwidth {
       uses object;
       uses bandwidth;
     }
   }
   grouping metric-object {
     container metric {
       uses object;
       leaf metric-type {
         type uint8;
       }
       leaf bound {
         type boolean;
         default false;
       }
       leaf computed {
         type boolean;
         default false;
       }
       leaf value {
         type ieee754:float32;
       }
     }
   }
   grouping exclude-route-object {
     container xro {
       uses object;
       leaf flags {
         type bits {
           bit fail {
             position 31;
           }
         }
       }
       list subobject {
         uses rsvp:exclude-route-subobjects;
         ordered-by user;
       }
     }
   }
   grouping explicit-route-object {
     container ero {
       uses object;
       list subobject {
         leaf loose {
           type boolean;
         }
         uses rsvp:explicit-route-subobjects;
         ordered-by user;
       }
     }
   }
   grouping secondary-explicit-route-object {
     container sero {
       uses object;
       list subobject {
         leaf loose {
           type boolean;
         }
         uses rsvp:secondary-explicit-route-subobjects;
         ordered-by user;
       }
     }
   }
   grouping include-route-object {
     container iro {
       uses object;
       list subobject {
         leaf loose {
           type boolean;
         }
         uses rsvp:explicit-route-subobjects;
         ordered-by user;
       }
     }
   }
   grouping reported-route-object {
     container rro {
       uses object;
       list subobject {
         uses rsvp:record-route-subobjects;
         ordered-by user;
       }
     }
   }
   grouping secondary-reported-route-object {
     container srro {
       uses object;
       list subobject {
         uses rsvp:secondary-record-route-subobjects;
         ordered-by user;
       }
     }
   }
   grouping lspa-object {
     container lspa {
       uses object;
       uses rsvp:tunnel-attributes;
       container tlvs {
         uses vendor-information-tlvs;
       }
     }
   }
   grouping svec-object {
     container svec {
       uses object;
       leaf link-diverse {
         type boolean;
         default false;
       }
       leaf node-diverse {
         type boolean;
         default false;
       }
       leaf srlg-diverse {
         type boolean;
         default false;
       }
       leaf partial-path-diverse {
         type boolean;
         default false;
       }
       leaf link-direction-diverse {
         type boolean;
         default false;
       }
       leaf-list requests-ids {
         type request-id;
       }
     }
   }
   grouping notification-object {
     container c-notification {
       uses object;
       container tlvs {
         when "../type = 2 and ../value = 1";
         uses overload-duration-tlv;
         uses vendor-information-tlvs;
       }
       leaf type {
         type uint8;
       }
       leaf value {
         type uint8;
       }
     }
   }
   grouping pcep-error-object {
     container error-object {
       uses object;
       container tlvs {
         when "../type = 7";
         uses req-missing-tlv;
         uses vendor-information-tlvs;
       }
       leaf type {
         type uint8;
       }
       leaf value {
         type uint8;
       }
     }
   }
   grouping load-balancing-object {
     container load-balancing {
       uses object;
       leaf max-lsp {
         type uint8;
       }
       leaf min-bandwidth {
         type netc:bandwidth;
       }
     }
   }
   grouping close-object {
     container c-close {
       uses object;
       leaf reason {
         type uint8;
       }
       container tlvs {
         uses vendor-information-tlvs;
       }
     }
   }
   grouping path-key-object {
     container path-key {
       uses object;
       list path-keys {
         min-elements 1;
         leaf loose {
           type boolean;
           default false;
         }
         uses rsvp:path-key-subobject;
         ordered-by user;
       }
     }
   }
   grouping of-object {
     container of {
       uses object;
       leaf code {
         type of-id;
       }
       container tlvs {
         uses vendor-information-tlvs;
       }
     }
   }
   grouping monitoring-object {
     container monitoring {
       uses object;
       leaf flags {
         type bits {
           bit incomplete {
             position 19;
           }
           bit overload {
             position 20;
           }
           bit processing-time {
             position 21;
           }
           bit general {
             position 22;
           }
           bit liveness {
             position 23;
           }
         }
       }
       leaf monitoring-id {
         type uint32;
       }
       container tlvs {
         uses vendor-information-tlvs;
       }
     }
   }
   grouping pcc-id-req-object {
     container pcc-id-req {
       uses object;
       leaf ip-address {
         type inet:ip-address-no-zone;
       }
     }
   }
   grouping pce-id-object {
     container pce-id {
       uses object;
       leaf ip-address {
         type inet:ip-address-no-zone;
       }
     }
   }
   grouping proc-time-object {
     container proc-time {
       uses object;
       leaf estimated {
         type boolean;
       }
       leaf current-proc-time {
         type uint32;
       }
       leaf min-proc-time {
         type uint32;
       }
       leaf max-proc-time {
         type uint32;
       }
       leaf average-proc-time {
         type uint32;
       }
       leaf variance-proc-time {
         type uint32;
       }
     }
   }
   grouping overload-object {
     container overload {
       uses object;
       leaf duration {
         type uint16;
       }
     }
   }
   typedef class-type {
     type uint8 {
       range 1..7;
     }
   }
   grouping classtype-object {
     container class-type {
       uses object;
       leaf class-type {
         type class-type;
       }
     }
   }
   grouping gc-object {
     container gc {
       uses object;
       leaf max-hop {
         type uint8;
       }
       leaf max-utilization {
         type uint8 {
           range 0..100;
         }
         units percent;
       }
       leaf min-utilization {
         type uint8 {
           range 0..100;
         }
         units percent;
       }
       leaf over-booking-factor {
         type uint8 {
           range 0..100;
         }
         units percent;
       }
       container tlvs {
         uses vendor-information-tlvs;
       }
     }
   }
   grouping message {
   }
   grouping message-header {
     leaf version {
       type protocol-version;
       default 1;
     }
   }
   grouping open-message {
     uses message;
     container open-message {
       uses message-header;
       uses open-object;
     }
   }
   grouping keepalive-message {
     uses message;
     container keepalive-message {
       uses message-header;
     }
   }
   grouping lsp-attributes {
     uses lspa-object;
     uses bandwidth-object;
     uses reoptimization-bandwidth-object;
     list metrics {
       uses metric-object;
     }
     uses include-route-object;
     uses reported-route-object;
     uses exclude-route-object;
     uses of-object;
     uses classtype-object;
   }
   grouping pcreq-message {
     uses message;
     container pcreq-message {
       uses message-header;
       list requests {
         uses rp-object;
         container path-key-expansion {
           when "rp/path-key = true";
           uses path-key-object;
         }
         container segment-computation {
           when "rp/path-key = false";
           container p2p {
             when "../rp/p2mp = false";
             uses endpoints-object;
             container reported-route {
               uses reported-route-object;
               uses reoptimization-bandwidth-object;
             }
             uses vendor-information-objects;
             uses load-balancing-object;
             uses lsp-attributes;
           }
           container p2mp {
             when "../rp/p2mp = true";
             list endpoint-rro-pair {
               uses endpoints-object;
               list rros {
                 choice route-object {
                   case reported-route-object-case {
                     uses reported-route-object;
                   }
                   case secondary-reported-route-object-case {
                     uses secondary-reported-route-object;
                   }
                 }
               }
               uses reoptimization-bandwidth-object;
               min-elements 1;
             }
             uses of-object;
             uses lspa-object;
             uses bandwidth-object;
             list metric {
               uses metric-object;
             }
             choice iro-bnc-choice {
               case iro-case {
                 uses include-route-object;
               }
               case bnc-case {
                 uses bnc-object;
               }
             }
             uses load-balancing-object;
           }
         }
         uses vendor-information-objects;
       }
       list svec {
         uses svec-object;
         uses of-object;
         uses gc-object;
         uses exclude-route-object;
         list metric {
           uses metric-object;
         }
         uses vendor-information-objects;
       }
       container monitoring-request {
         uses monitoring;
         list pce-id-list {
           uses pce-id-object;
         }
       }
     }
   }
   grouping path-definition {
     uses explicit-route-object;
     uses lsp-attributes;
   }
   grouping monitoring {
     uses monitoring-object;
     uses pcc-id-req-object;
   }
   grouping monitoring-metrics {
     list metric-pce {
       uses pce-id-object;
       uses proc-time-object;
       uses overload-object;
     }
   }
   grouping monitoring-response {
     uses monitoring;
     choice monitoring-metrics-list {
       case specific-metrics-list {
         list specific-metrics {
           uses rp-object;
           uses monitoring-metrics;
         }
       }
       case general-metrics-list {
         uses monitoring-metrics;
       }
     }
   }
   grouping pcmonrep-message {
     uses message;
     container pcmonrep-message {
       uses monitoring-response;
     }
   }
   grouping pcrep-message {
     uses message;
     container pcrep-message {
       uses message-header;
       list replies {
         uses rp-object;
         uses vendor-information-objects;
         uses monitoring;
         uses monitoring-metrics;
         choice result {
           case success-case {
             container success {
               list paths {
                 uses path-definition;
               }
               uses vendor-information-objects;
             }
           }
           case failure-case {
             container no-path {
               uses no-path-object;
               container tlvs {
                 uses vendor-information-tlvs;
                 container no-path-vector {
                   uses no-path-vector-tlv;
                 }
               }
             }
             uses lsp-attributes;
           }
         }
       }
     }
   }
   grouping pcntf-message {
     uses message;
     container pcntf-message {
       uses message-header;
       list notifications {
         list rps {
           uses rp-object;
         }
         list notifications {
           uses notification-object;
         }
       }
     }
   }
   grouping pcerr-message {
     uses message;
     container pcerr-message {
       uses message-header;
       list errors {
         uses pcep-error-object;
       }
       choice error-type {
         case request-case {
           container request {
             list rps {
               uses rp-object;
             }
           }
         }
         case session-case {
           container session {
             uses open-object;
           }
         }
       }
     }
   }
   grouping close-message {
     uses message;
     container c-close-message {
       uses message-header;
       uses close-object;
     }
   }
   grouping start-tls-message {
     uses message;
     container start-tls-message {
       uses message-header;
     }
   }
 }