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

public interface BgpData
extends org.opendaylight.yangtools.yang.binding.DataRoot

This YANG module defines the generic configuration data for BGP, which is across all of the vendor implementations of the protocol. It is intended that the module will be extended by vendors to define vendor-specific BGP configuration parameters and policies, for example route maps or route Terms and Acronyms BGP (bgp): Border Gateway Protocol IP (ip): Internet IPv4 (ipv4):Internet Protocol Version 4 IPv6 (ipv6): Internet Protocol Version MED(med): Multi Exit Discriminator IGP (igp): Interior Gateway Protocol MTU (mtu) Maximum Transmission Unit

This class represents the following YANG schema fragment defined in module bgp

 module bgp {
   namespace urn:cisco:params:xml:ns:yang:bgp;
   prefix bgp;
   import ietf-inet-types {
     prefix inet;
     revision-date 2013-07-15;
   }
   import ietf-yang-types {
     prefix yang;
   }
   revision 2013-07-15 {
   }
   typedef prefix-list-ref {
     type leafref {
       path /prefix-lists/prefix-list/prefix-list-name;
     }
   }
   typedef neigbour-ref {
     type leafref {
       path /bgp-neighbors/bgp-neighbor/as-number;
     }
   }
   typedef bgp-peer-admin-status {
     type enumeration {
       enum unknown;
       enum up;
       enum down;
     }
   }
   typedef actions-enum {
     type enumeration {
       enum permit;
       enum deny;
     }
   }
   grouping ACTIONS {
     leaf action {
       type actions-enum;
     }
   }
   grouping slow-peer-config {
     container detection {
       leaf enable {
         type boolean;
         default true;
       }
       leaf threshold {
         type uint16 {
           range 120..3600;
         }
       }
     }
     leaf split-update-group {
       type enumeration {
         enum dynamic;
         enum static;
       }
     }
   }
   grouping update-group-management {
     leaf split-as-override {
       type boolean;
     }
   }
   grouping neighbour-base-af-config {
     leaf active {
       type boolean;
       default false;
     }
     leaf advertisement-interval {
       type uint32;
     }
     leaf allowas-in {
       type boolean;
       default false;
     }
     leaf maximum-prefix {
       type uint32;
     }
     leaf next-hop-self {
       type boolean;
       default true;
     }
     leaf next-hop-unchanged {
       type boolean;
       default true;
     }
     container remove-private-as {
       leaf remove-private-as-number {
         type boolean;
       }
       leaf replace-with-local-as {
         type boolean;
       }
     }
     leaf route-reflector-client {
       type boolean;
       default false;
     }
     leaf send-community {
       type enumeration {
         enum both;
         enum extended;
         enum standard;
       }
       default standard;
     }
     uses slow-peer-config;
     leaf soo {
       type string;
     }
     leaf weight {
       type uint16;
     }
   }
   grouping neighbour-common-af-config {
     uses neighbour-base-af-config;
     leaf prefix-list {
       type prefix-list-ref;
     }
     leaf soft-reconfiguration {
       type boolean;
     }
   }
   grouping neighbour-cast-af-config {
     uses neighbour-common-af-config;
     leaf propagate-dmzlink-bw {
       type boolean;
     }
     container default-originate {
       leaf enable {
         type boolean;
         default false;
       }
     }
   }
   grouping neighbour-ip-multicast-af-config {
     uses neighbour-cast-af-config;
     leaf route-server-client-context {
       type string;
     }
   }
   grouping neighbour-ip-unicast-af-config {
     uses neighbour-ip-multicast-af-config;
   }
   grouping bgp-af-config {
     leaf additional-paths {
       type enumeration {
         enum all;
         enum best-n;
         enum group-best;
       }
     }
     leaf advertise-best-external {
       type boolean;
     }
     container aggregate-timer {
       leaf enable {
         type boolean;
         default true;
       }
       leaf threshold {
         type uint16 {
           range 6..60;
         }
       }
     }
     container bestpath {
       choice bestpath-selection {
         case as-path {
           leaf ignore-as-path {
             type boolean;
             default false;
           }
         }
         case compare-routerid {
           leaf ignore-routerid {
             type boolean;
             default false;
           }
         }
         case cost-community {
           leaf ignore-cost-community {
             type boolean;
             default false;
           }
         }
         case igp-metric {
           leaf ignore-igp-metric {
             type boolean;
             default false;
           }
         }
         case mad-confed {
           leaf enable {
             type boolean;
             default false;
           }
           leaf missing-as-worst {
             type boolean;
             default false;
           }
         }
       }
     }
     leaf dampening {
       type boolean;
       default false;
     }
     leaf propagate-dmzlink-bw {
       type boolean;
     }
     leaf redistribute-internal {
       type boolean;
     }
     leaf scan-time {
       type uint8 {
         range 5..60;
       }
     }
     uses slow-peer-config;
     leaf soft-reconfig-backup {
       type boolean;
     }
   }
   grouping bgp-af-vpn-config {
     uses bgp-af-config;
     uses update-group-management;
   }
   grouping bgp-af-mvpn-config {
     leaf scan-time {
       type uint8 {
         range 5..60;
       }
     }
     uses slow-peer-config;
     leaf soft-reconfig-backup {
       type boolean;
     }
     leaf propagate-dmzlink-bw {
       type boolean;
     }
     leaf rr-group {
       type string;
     }
     uses update-group-management;
   }
   grouping redistribute {
     choice protocol {
       case bgp {
         leaf enable-bgp {
           type boolean;
         }
       }
       case ospf {
         leaf enable-ospf {
           type boolean;
         }
       }
       case isis {
         leaf enable-isis {
           type boolean;
         }
       }
       case connected {
         leaf enable-connected {
           type boolean;
         }
       }
       case eigrp {
         leaf enable-eigrp {
           type boolean;
         }
       }
       case mobile {
         leaf enable-mobile {
           type boolean;
         }
       }
       case static {
         leaf enable-static {
           type boolean;
         }
       }
       case rip {
         leaf enable-rip {
           type boolean;
         }
       }
     }
   }
   grouping router-af-config {
     leaf aggregate-address {
       type inet:ip-address;
     }
     leaf distance {
       type uint8 {
         range 1..255;
       }
     }
     leaf network {
       type inet:ip-address;
     }
     uses redistribute;
   }
   grouping maximum-paths {
     leaf number-of-path {
       type uint8 {
         range 1..32;
       }
     }
     leaf ibgp-number-of-path {
       type uint8 {
         range 1..32;
       }
     }
   }
   container bgp-router {
     leaf local-as-number {
       type uint32;
     }
     leaf local-as-identifier {
       type inet:ip-address;
     }
     container rpki-config {
       container cache-server-config {
         choice server {
           case ip-address {
             leaf ip-address {
               type inet:ip-address;
             }
           }
           case host-name {
             leaf ip-host-address {
               type inet:host;
             }
           }
         }
         choice transport {
           case tcp {
             leaf tcp-port {
               type uint32;
             }
           }
           case ssh {
             leaf ssh-port {
               type uint32;
             }
           }
         }
         leaf user-name {
           type string;
         }
         leaf password {
           type string;
         }
         leaf preference-value {
           type uint8 {
             range 1..10;
           }
         }
         leaf purge-time {
           type uint16 {
             range 30..360;
           }
         }
         choice refresh-time {
           case disable {
             leaf refresh-time-disable {
               type boolean;
             }
           }
           case set-time {
             leaf refresh-interval {
               type uint16 {
                 range 15..3600;
               }
             }
           }
         }
         choice responce-time {
           case disable {
             leaf responce-time-disable {
               type boolean;
             }
           }
           case set-time {
             leaf responce-interval {
               type uint16 {
                 range 15..3600;
               }
             }
           }
         }
       }
       container validation-config {
         leaf enable {
           type boolean;
           default true;
         }
         leaf enable-ibgp {
           type boolean;
         }
         choice validation-time {
           case validation-off {
             leaf disable {
               type boolean;
             }
           }
           case set-time {
             leaf prefix-validation-time {
               type uint16 {
                 range 5..60;
               }
             }
           }
         }
       }
       container bestpath-computation {
         leaf enable {
           type boolean;
         }
         leaf allow-invalid {
           type boolean;
         }
       }
     }
     container af-configuration {
       container ipv4 {
         container mdt {
           container bgp {
             leaf dampening {
               type boolean;
               default false;
             }
             leaf scan-time {
               type uint8 {
                 range 5..60;
               }
             }
             uses slow-peer-config;
             leaf soft-reconfig-backup {
               type boolean;
             }
             leaf propagate-dmzlink-bw {
               type boolean;
             }
           }
         }
         container multicast {
           container bgp {
             uses bgp-af-config;
           }
           leaf auto-summary {
             type boolean;
           }
           uses router-af-config;
           leaf default-metric {
             type uint32;
           }
         }
         container unicast {
           container bgp {
             uses bgp-af-config;
             leaf always-compare-med {
               type boolean;
               default false;
             }
             leaf enforce-first-as {
               type boolean;
               default true;
             }
             leaf fast-external-fallover {
               type boolean;
               default true;
             }
             leaf suppress-inactive {
               type boolean;
             }
             leaf asnotation {
               type enumeration {
                 enum asplain;
                 enum dot;
               }
             }
             leaf enable-client-to-client-reflection {
               type boolean;
               default true;
             }
             leaf cluster-id {
               type string;
             }
             container confederation {
               leaf identifier {
                 type string;
               }
               list peers {
                 key as-name;
                 leaf as-name {
                   type string;
                 }
               }
             }
             container consistency-checker {
               leaf enable {
                 type boolean;
               }
               leaf interval {
                 type uint16 {
                   range 5..1440;
                 }
               }
               choice inconsistency-action {
                 case error-message {
                   leaf generate-error-message-only {
                     type boolean;
                   }
                 }
                 case autorepair {
                   leaf perform-autorepair {
                     type boolean;
                   }
                 }
               }
             }
             leaf deterministic-med {
               type boolean;
             }
             container graceful-restart {
               leaf enable {
                 type boolean;
               }
               leaf restart-time {
                 type uint16 {
                   range 1..3600;
                 }
                 default 120;
               }
               leaf stalepath-time {
                 type uint16 {
                   range 5..3600;
                 }
                 default 360;
               }
             }
             container listener-congfig {
               leaf enable {
                 type boolean;
               }
               leaf limit {
                 type uint16 {
                   range 1..5000;
                 }
                 default 100;
               }
               leaf range {
                 type uint16 {
                   range 0..32;
                 }
               }
               leaf peer-group {
                 type string;
               }
             }
             leaf log-neighbor-changes {
               type boolean;
             }
             leaf max-as-limit {
               type uint16 {
                 range 1..254;
               }
             }
             container router-id {
               leaf enable {
                 type boolean;
               }
               choice config-type {
                 case static {
                   leaf ip-address {
                     type boolean;
                   }
                 }
                 case auto-config {
                   leaf enable-auto-config {
                     type boolean;
                   }
                 }
               }
             }
             container transport {
               leaf enable-path-mtu-discovery {
                 type boolean;
                 default true;
               }
             }
           }
           leaf auto-summary {
             type boolean;
           }
           uses router-af-config;
           uses maximum-paths;
           leaf synchronization {
             type boolean;
           }
         }
         container mvpn {
           container bgp {
             uses bgp-af-mvpn-config;
           }
           leaf auto-summary {
             type boolean;
           }
         }
       }
       container ipv6 {
         container multicast {
           container bgp {
             uses bgp-af-config;
           }
           uses router-af-config;
         }
         container unicast {
           container bgp {
             uses bgp-af-config;
           }
           uses router-af-config;
           leaf default-metric {
             type uint32;
           }
           uses maximum-paths;
           leaf synchronization {
             type boolean;
           }
         }
         container mvpn {
           container bgp {
             uses bgp-af-mvpn-config;
           }
         }
       }
       container l2vpn {
         container vpls {
           container bgp {
             leaf scan-time {
               type uint8 {
                 range 5..60;
               }
             }
             uses slow-peer-config;
           }
         }
       }
       container nsap {
         container unicast {
           container bgp {
             container aggregate-timer {
               leaf enable {
                 type boolean;
                 default true;
               }
               leaf threshold {
                 type uint16 {
                   range 6..60;
                 }
               }
             }
             leaf dampening {
               type boolean;
               default false;
             }
             leaf propagate-dmzlink-bw {
               type boolean;
             }
             leaf redistribute-internal {
               type boolean;
             }
             leaf scan-time {
               type uint8 {
                 range 5..60;
               }
             }
             uses slow-peer-config;
             leaf soft-reconfig-backup {
               type boolean;
             }
           }
           leaf default-metric {
             type uint32;
           }
           uses maximum-paths;
           leaf network {
             type inet:ip-address;
           }
           uses redistribute;
           leaf synchronization {
             type boolean;
           }
         }
       }
     }
     container rtfilter {
       container unicast {
         container bgp {
           uses slow-peer-config;
         }
         uses maximum-paths;
       }
     }
     container vpnv4 {
       container unicast {
         container bgp {
           uses bgp-af-vpn-config;
         }
         uses maximum-paths;
       }
       container multicast {
         container bgp {
           uses bgp-af-vpn-config;
         }
         uses maximum-paths;
       }
     }
     container vpnv6 {
       container unicast {
         container bgp {
           uses bgp-af-vpn-config;
         }
       }
     }
   }
   container bgp-neighbors {
     list bgp-neighbor {
       key as-number;
       leaf as-number {
         type uint32;
       }
       choice peer-address-type {
         case ip-address {
           leaf ip-address {
             type inet:ip-address;
           }
         }
         case prefix {
           leaf prefix {
             type inet:ip-prefix;
           }
         }
         case host {
           leaf ip-host-address {
             type inet:host;
           }
         }
       }
       leaf prefix-list {
         type prefix-list-ref;
       }
       leaf default-action {
         type actions-enum;
       }
       container af-specific-config {
         container ipv4 {
           container mdt {
             uses neighbour-common-af-config;
           }
           container unicast {
             uses neighbour-ip-unicast-af-config;
           }
           container multicast {
             uses neighbour-ip-multicast-af-config;
           }
           container mvpn {
             uses neighbour-cast-af-config;
           }
         }
         container ipv6 {
           container unicast {
             uses neighbour-ip-unicast-af-config;
           }
           container multicast {
             uses neighbour-ip-multicast-af-config;
           }
           container mvpn {
             uses neighbour-common-af-config;
           }
         }
         container l2vpn {
           container evpn {
             uses neighbour-common-af-config;
           }
           container vpls {
             uses neighbour-common-af-config;
           }
         }
         container nsap {
           container unicast {
             uses neighbour-base-af-config;
             leaf prefix-list {
               type prefix-list-ref;
             }
           }
         }
         container rtfilter {
           container unicast {
             uses neighbour-base-af-config;
             leaf soft-reconfiguration {
               type boolean;
             }
           }
         }
         container vpnv4 {
           container unicast {
             uses neighbour-cast-af-config;
           }
           container multicast {
             uses neighbour-cast-af-config;
           }
         }
         container vpnv6 {
           container unicast {
             uses neighbour-cast-af-config;
           }
           container multicast {
             uses neighbour-cast-af-config;
           }
         }
       }
       container bgp-neighbor-state {
         leaf adminStatus {
           type bgp-peer-admin-status;
         }
         leaf in-lastupdatetime {
           type yang:timestamp;
         }
       }
       container bgp-neighbor-statistics {
         leaf nr-in-updates {
           type uint32;
         }
         leaf nr-out-updates {
           type uint32;
         }
       }
     }
   }
   container prefix-lists {
     list prefix-list {
       key prefix-list-name;
       leaf prefix-list-name {
         type string;
       }
       container prefixes {
         list prefix {
           key seq-nr;
           leaf seq-nr {
             type uint16;
           }
           container prefix-filter {
             choice ip-address-group {
               case ip-address {
                 leaf ip-address {
                   type inet:ip-address;
                 }
               }
               case prefix {
                 leaf prefix {
                   type inet:ip-prefix;
                 }
               }
               case host {
                 leaf ip-host-address {
                   type inet:host;
                 }
               }
               case ip-range {
                 leaf lower {
                   type inet:ip-address;
                 }
                 leaf upper {
                   type inet:ip-address;
                 }
               }
             }
             leaf action {
               type actions-enum;
             }
             container statistics {
               leaf prefix-hit-count {
                 type uint32;
                 config false;
               }
             }
           }
         }
       }
     }
   }
 }

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`@Nullable BgpNeighbors`	`getBgpNeighbors()`	The top level container for the list of neighbours of the BGP router.
`@Nullable BgpRouter`	`getBgpRouter()`	This is a top-level container for the BGP router.
`@Nullable PrefixLists`	`getPrefixLists()`	Contains all prefix lists defined on a router.

- Method Detail
  - getBgpRouter
```
@Nullable BgpRouter getBgpRouter()
```
    This is a top-level container for the BGP router.
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.BgpRouter bgpRouter, or null if not present
  - getBgpNeighbors
```
@Nullable BgpNeighbors getBgpNeighbors()
```
    The top level container for the list of neighbours of the BGP router.
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.BgpNeighbors bgpNeighbors, or null if not present
  - getPrefixLists
```
@Nullable PrefixLists getPrefixLists()
```
    Contains all prefix lists defined on a router.
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.PrefixLists prefixLists, or null if not present

Interface BgpData

Method Summary

Method Detail

getBgpRouter

getBgpNeighbors

getPrefixLists