All Superinterfaces:: org.opendaylight.yangtools.yang.binding.DataRoot

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

This module contains the base data model of a BGP message. It rolls up the definitions contained in RFC4271 and RFC7752. 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 bgp-linkstate

 module bgp-linkstate {
   yang-version 1;
   namespace urn:opendaylight:params:xml:ns:yang:bgp-linkstate;
   prefix bgp-ls;
   import ietf-inet-types {
     prefix inet;
     revision-date 2013-07-15;
   }
   import ietf-routing-types {
     prefix rt-types;
   }
   import bgp-message {
     prefix bgp-msg;
     revision-date 2020-01-20;
   }
   import bgp-multiprotocol {
     prefix bgp-mp;
     revision-date 2018-03-29;
   }
   import bgp-rib {
     prefix bgp-rib;
     revision-date 2018-03-29;
   }
   import bgp-types {
     prefix bgp-t;
     revision-date 2020-01-20;
   }
   import network-concepts {
     prefix netc;
     revision-date 2013-11-25;
   }
   import rsvp {
     prefix rsvp;
     revision-date 2015-08-20;
   }
   import bgp-segment-routing {
     prefix bgp-sr;
     revision-date 2020-01-20;
   }
   import bgp-epe {
     prefix bgp-epe;
     revision-date 2020-01-20;
   }
   import bmp-monitor {
     prefix bmp-mon;
     revision-date 2020-01-20;
   }
   revision 2020-01-20 {
   }
   revision 2018-03-29 {
   }
   revision 2017-12-07 {
   }
   revision 2015-02-10 {
   }
   revision 2013-11-25 {
   }
   revision 2013-09-18 {
   }
   identity linkstate-address-family {
     base address-family;
   }
   identity linkstate-subsequent-address-family {
     base subsequent-address-family;
   }
   typedef nlri-type {
     type enumeration {
       enum node {
         value 1;
       }
       enum link {
         value 2;
       }
       enum ipv4-prefix {
         value 3;
       }
       enum ipv6-prefix {
         value 4;
       }
       enum ipv4-te-lsp {
         status deprecated;
         value 5;
       }
       enum ipv6-te-lsp {
         status deprecated;
         value 6;
       }
     }
   }
   typedef protocol-id {
     type enumeration {
       enum isis-level1 {
         value 1;
       }
       enum isis-level2 {
         value 2;
       }
       enum ospf {
         value 3;
       }
       enum direct {
         value 4;
       }
       enum static {
         value 5;
       }
       enum ospf-v3 {
         value 6;
       }
       enum bgp-epe {
         value 7;
       }
       enum rsvp-te {
         status deprecated;
         value 8;
       }
       enum segment-routing {
         status deprecated;
         value 9;
       }
     }
   }
   typedef ospf-route-type {
     type enumeration {
       enum intra-area {
         value 1;
       }
       enum inter-area {
         value 2;
       }
       enum external1 {
         value 3;
       }
       enum external2 {
         value 4;
       }
       enum nssa1 {
         value 5;
       }
       enum nssa2 {
         value 6;
       }
     }
   }
   typedef identifier {
     type uint64;
   }
   typedef domain-identifier {
     type uint32;
   }
   typedef area-identifier {
     type uint32;
   }
   typedef ipv4-interface-identifier {
     type inet:ipv4-address-no-zone;
   }
   typedef ipv6-interface-identifier {
     type inet:ipv6-address-no-zone;
   }
   typedef ospf-interface-identifier {
     type uint32;
   }
   typedef topology-identifier {
     type uint16 {
       range 0..4095;
     }
   }
   grouping isis-router-identifier {
     leaf iso-system-id {
       type netc:iso-system-identifier;
     }
   }
   grouping isis-lan-identifier {
     container is-is-router-identifier {
       uses isis-router-identifier;
     }
     leaf psn {
       type uint8 {
         range 1..255;
       }
     }
   }
   grouping ospf-router-identifier {
     leaf ospf-router-id {
       type uint32;
     }
   }
   grouping ospf-v2-lan-identifier {
     uses ospf-router-identifier;
     leaf ipv4-address {
       type ipv4-interface-identifier;
     }
   }
   grouping ospf-v3-lan-identifier {
     uses ospf-router-identifier;
     leaf lan-interface {
       type ospf-interface-identifier;
     }
   }
   grouping node-identifier {
     leaf as-number {
       type inet:as-number;
     }
     leaf area-id {
       type area-identifier;
     }
     leaf domain-id {
       type domain-identifier;
     }
     choice c-router-identifier {
       case isis-node-case {
         container isis-node {
           uses isis-router-identifier;
         }
       }
       case isis-pseudonode-case {
         container isis-pseudonode {
           uses isis-lan-identifier;
         }
       }
       case ospf-node-case {
         container ospf-node {
           uses ospf-router-identifier;
         }
       }
       case ospf-pseudonode-case {
         container ospf-pseudonode {
           uses ospf-v3-lan-identifier;
         }
       }
     }
   }
   grouping link-lr-identifiers {
     leaf link-local-identifier {
       type uint32;
     }
     leaf link-remote-identifier {
       type uint32;
     }
   }
   grouping prefix-identifiers {
     leaf multi-topology-id {
       type topology-identifier;
     }
     leaf ospf-route-type {
       when "../../protocol-id[ .='ospf' or .='ospf-v3' ]";
       type ospf-route-type;
     }
     leaf ip-reachability-information {
       type inet:ip-prefix;
     }
   }
   grouping link-identifier {
     uses link-lr-identifiers;
     leaf ipv4-interface-address {
       type ipv4-interface-identifier;
     }
     leaf ipv6-interface-address {
       type ipv6-interface-identifier;
     }
     leaf ipv4-neighbor-address {
       type ipv4-interface-identifier;
     }
     leaf ipv6-neighbor-address {
       type ipv6-interface-identifier;
     }
     leaf multi-topology-id {
       type topology-identifier;
     }
   }
   grouping linkstate {
     uses bgp-t:route-distinguisher-grouping {
       refine route-distinguisher {
         mandatory false;
       }
     }
     leaf protocol-id {
       type protocol-id;
     }
     leaf identifier {
       type identifier;
     }
     choice object-type {
       case node-case {
         container node-descriptors {
           uses node-identifier;
         }
       }
       case link-case {
         container local-node-descriptors {
           uses node-identifier;
           uses bgp-epe:epe-node-descriptors;
         }
         container remote-node-descriptors {
           uses node-identifier;
           uses bgp-epe:epe-node-descriptors;
         }
         container link-descriptors {
           uses link-identifier;
         }
       }
       case prefix-case {
         container advertising-node-descriptors {
           uses node-identifier;
         }
         container prefix-descriptors {
           uses prefix-identifiers;
         }
       }
       case te-lsp-case {
         choice address-family {
           case ipv4-case {
             leaf ipv4-tunnel-sender-address {
               type inet:ipv4-address-no-zone;
             }
             leaf ipv4-tunnel-endpoint-address {
               type inet:ipv4-address-no-zone;
             }
           }
           case ipv6-case {
             leaf ipv6-tunnel-sender-address {
               type inet:ipv6-address-no-zone;
             }
             leaf ipv6-tunnel-endpoint-address {
               type inet:ipv6-address-no-zone;
             }
           }
         }
         leaf tunnel-id {
           type rsvp:tunnel-id;
         }
         leaf lsp-id {
           type rsvp:lsp-id;
         }
       }
     }
   }
   grouping linkstate-destination {
     list c-linkstate-destination {
       uses linkstate;
       uses bgp-msg:path-id-grouping;
     }
   }
   augment /bgp-msg:update/bgp-msg:attributes/bgp-mp:mp-reach-nlri/bgp-mp:advertized-routes/bgp-mp:destination-type {
     case destination-linkstate-case {
       container destination-linkstate {
         uses linkstate-destination;
       }
     }
   }
   augment /bgp-msg:update/bgp-msg:attributes/bgp-mp:mp-unreach-nlri/bgp-mp:withdrawn-routes/bgp-mp:destination-type {
     case destination-linkstate-case {
       container destination-linkstate {
         uses linkstate-destination;
       }
     }
   }
   typedef node-flag-bits {
     type bits {
       bit overload {
         position 0;
       }
       bit attached {
         position 1;
       }
       bit external {
         position 2;
       }
       bit abr {
         position 3;
       }
       bit router {
         position 4;
       }
       bit v6 {
         position 5;
       }
     }
   }
   typedef isis-area-identifier {
     type binary {
       length 1..20;
     }
   }
   typedef ipv4-router-identifier {
     type inet:ipv4-address-no-zone;
   }
   typedef ipv6-router-identifier {
     type inet:ipv6-address-no-zone;
   }
   grouping node-state {
     leaf-list topology-identifier {
       type topology-identifier;
     }
     leaf node-flags {
       type node-flag-bits;
     }
     leaf-list isis-area-id {
       type isis-area-identifier;
     }
     leaf dynamic-hostname {
       type string;
     }
     leaf ipv4-router-id {
       type ipv4-router-identifier;
     }
     leaf ipv6-router-id {
       type ipv6-router-identifier;
     }
     container sr-capabilities {
       uses bgp-sr:sr-capabilities-tlv;
     }
     container sr-algorithm {
       uses bgp-sr:sr-algorithms-tlv;
     }
   }
   typedef link-protection-type {
     type enumeration {
       enum extra-traffic {
         value 1;
       }
       enum unprotected {
         value 2;
       }
       enum shared {
         value 4;
       }
       enum dedicated-1to1 {
         value 8;
       }
       enum dedicated-1plus1 {
         value 16;
       }
       enum enhanced {
         value 32;
       }
     }
   }
   typedef mpls-protocol-mask {
     type bits {
       bit ldp {
         position 0;
       }
       bit rsvpte {
         position 1;
       }
     }
   }
   typedef administrative-group {
     type uint32;
   }
   grouping unreserved-bandwidth {
     leaf priority {
       type uint8 {
         range 0..7;
       }
     }
     leaf bandwidth {
       type netc:bandwidth;
     }
   }
   typedef delay {
     type rt-types:uint24;
     units microseconds;
   }
   typedef loss {
     type rt-types:uint24;
     units percent;
   }
   grouping linkstate-attribute {
     leaf local-ipv4-router-id {
       type ipv4-router-identifier;
     }
     leaf local-ipv6-router-id {
       type ipv6-router-identifier;
     }
     leaf remote-ipv4-router-id {
       type ipv4-router-identifier;
     }
     leaf remote-ipv6-router-id {
       type ipv6-router-identifier;
     }
     leaf mpls-protocol {
       type mpls-protocol-mask;
     }
     leaf te-metric {
       type netc:te-metric;
     }
     leaf metric {
       type netc:metric;
     }
     leaf-list shared-risk-link-groups {
       type rsvp:srlg-id;
     }
     leaf link-name {
       type string;
     }
     leaf max-link-bandwidth {
       type netc:bandwidth;
     }
     leaf max-reservable-bandwidth {
       type netc:bandwidth;
     }
     list unreserved-bandwidth {
       key priority;
       uses unreserved-bandwidth;
     }
     leaf link-protection {
       type link-protection-type;
     }
     leaf admin-group {
       type administrative-group;
     }
     list sr-adj-ids {
       uses bgp-sr:adj-sid-tlv;
     }
     list sr-lan-adj-ids {
       uses bgp-sr:lan-adj-sid-tlv;
     }
     container peer-node-sid {
       uses bgp-sr:epe-adj-sid-tlv;
     }
     container peer-adj-sid {
       uses bgp-sr:epe-adj-sid-tlv;
     }
     list peer-set-sids {
       uses bgp-sr:epe-adj-sid-tlv;
     }
     leaf link-delay {
       type delay;
     }
     container link-min-max-delay {
       leaf min-delay {
         type delay;
       }
       leaf max-delay {
         type delay;
       }
     }
     leaf delay-variation {
       type delay;
     }
     leaf link-loss {
       type loss;
     }
     leaf residual-bandwidth {
       type netc:bandwidth;
     }
     leaf available-bandwidth {
       type netc:bandwidth;
     }
     leaf utilized-bandwidth {
       type netc:bandwidth;
     }
   }
   typedef route-tag {
     type binary {
       length 4;
     }
   }
   typedef extended-route-tag {
     type binary {
       length 8;
     }
   }
   grouping igp-bits {
     leaf up-down {
       status deprecated;
       type bits {
         bit up-down {
           position 0;
         }
       }
     }
     leaf is-is-up-down {
       type boolean;
     }
     leaf ospf-no-unicast {
       type boolean;
     }
     leaf ospf-local-address {
       type boolean;
     }
     leaf ospf-propagate-nssa {
       type boolean;
     }
   }
   grouping prefix-state {
     container igp-bits {
       uses igp-bits;
     }
     leaf-list route-tags {
       type route-tag;
     }
     leaf-list extended-tags {
       type extended-route-tag;
     }
     leaf prefix-metric {
       type netc:igp-metric;
     }
     leaf ospf-forwarding-address {
       type inet:ip-address-no-zone;
     }
     container sr-prefix {
       uses bgp-sr:prefix-sid-tlv;
     }
     container ipv6-sr-prefix {
       uses bgp-sr:ipv6-prefix-sid-tlv;
     }
     container sr-range {
       uses bgp-sr:range-tlv;
     }
     list sr-binding-sid-labels {
       uses bgp-sr:binding-sid-tlv;
     }
   }
   grouping linkstate-path-attribute {
     choice link-state-attribute {
       case node-attributes-case {
         container node-attributes {
           uses node-state;
         }
       }
       case link-attributes-case {
         container link-attributes {
           uses linkstate-attribute;
         }
       }
       case prefix-attributes-case {
         container prefix-attributes {
           uses prefix-state;
         }
       }
       case te-lsp-attributes-case {
         status deprecated;
         container te-lsp-attributes {
           uses rsvp:tspec-object;
           uses rsvp:flow-spec-object;
           uses rsvp:session-attribute-object;
           uses rsvp:explicit-route-object;
           uses rsvp:secondary-explicit-route-object;
           uses rsvp:record-route-object;
           uses rsvp:secondary-record-route-object;
           uses rsvp:fast-reroute-object;
           uses rsvp:detour-object;
           uses rsvp:exclude-route-object;
           uses rsvp:lsp-attributes-object;
           uses rsvp:lsp-required-attributes-object;
           uses rsvp:protection-object;
           uses rsvp:association-object;
           uses rsvp:primary-path-route-object;
           uses rsvp:admin-status-object;
           uses rsvp:bandwidth-object;
           uses rsvp:metric-object;
         }
       }
     }
   }
   grouping linkstate-routes {
     container linkstate-routes {
       list linkstate-route {
         key "route-key path-id";
         uses linkstate;
         uses bgp-rib:route {
           augment attributes {
             uses linkstate-path-attribute;
           }
         }
       }
     }
   }
   augment /bgp-msg:update/bgp-msg:attributes {
     uses linkstate-path-attribute;
   }
   augment /bgp-rib:application-rib/bgp-rib:tables/bgp-rib:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
   augment /bgp-rib:bgp-rib/bgp-rib:rib/bgp-rib:loc-rib/bgp-rib:tables/bgp-rib:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
   augment /bgp-rib:bgp-rib/bgp-rib:rib/bgp-rib:peer/bgp-rib:adj-rib-in/bgp-rib:tables/bgp-rib:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
   augment /bgp-rib:bgp-rib/bgp-rib:rib/bgp-rib:peer/bgp-rib:effective-rib-in/bgp-rib:tables/bgp-rib:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
   augment /bgp-rib:bgp-rib/bgp-rib:rib/bgp-rib:peer/bgp-rib:adj-rib-out/bgp-rib:tables/bgp-rib:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
   augment /bmp-mon:bmp-monitor/bmp-mon:monitor/bmp-mon:router/bmp-mon:peer/bmp-mon:pre-policy-rib/bmp-mon:tables/bmp-mon:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
   augment /bmp-mon:bmp-monitor/bmp-mon:monitor/bmp-mon:router/bmp-mon:peer/bmp-mon:post-policy-rib/bmp-mon:tables/bmp-mon:routes {
     case linkstate-routes-case {
       uses linkstate-routes;
     }
   }
 }

Interface BgpLinkstateData