[email protected] Maven / Gradle / Ivy
module openconfig-bgp {
yang-version "1.1";
// namespace
namespace "http://openconfig.net/yang/bgp";
prefix "bgp";
// import some basic inet types
import ietf-inet-types { prefix inet; }
import openconfig-bgp-multiprotocol { prefix bgp-mp; }
import openconfig-routing-policy { prefix rpol; }
import openconfig-bgp-types { prefix bgp-types; }
import openconfig-bgp-operational { prefix bgp-op; }
import openconfig-extensions { prefix oc-ext; }
// meta
organization
"OpenConfig working group";
contact
"OpenConfig working group
[email protected]";
description
"This module describes a YANG model for BGP protocol
configuration.It is a limited subset of all of the configuration
parameters available in the variety of vendor implementations,
hence it is expected that it would be augmented with vendor-
specific configuration data as needed. Additional modules or
submodules to handle other aspects of BGP configuration,
including policy, VRFs, VPNs, and additional address families
are also expected.
This model supports the following BGP configuration level
hierarchy:
BGP
|
+-> [ global BGP configuration ]
+-> AFI / SAFI global
+-> peer group
+-> [ peer group config ]
+-> AFI / SAFI [ per-AFI overrides ]
+-> neighbor
+-> [ neighbor config ]
+-> [ optional pointer to peer-group ]
+-> AFI / SAFI [ per-AFI overrides ]";
oc-ext:openconfig-version "1.1.0";
revision "2015-10-09" {
description
"Initial OpenConfig public release";
reference "1.1.0";
}
revision "2015-05-15" {
description
"Refactored BGP module";
reference "Pre-release";
}
grouping bgp-global_config {
description
"Global configuration options for the BGP router.";
leaf as {
type inet:as-number;
mandatory "true";
description
"Local autonomous system number of the router. Uses
the 32-bit as-number type from the model in RFC 6991.";
}
leaf router-id {
type inet:ipv4-address;
description
"Router id of the router, expressed as an
32-bit value, IPv4 address.";
}
}
grouping bgp-default-route-distance_config {
description
"Configuration options relating to the administrative distance
(or preference) assigned to routes received from different
sources (external, internal, and local).";
leaf external-route-distance {
type uint8 {
range "1..255";
}
description
"Administrative distance for routes learned from external
BGP (eBGP).";
}
leaf internal-route-distance {
type uint8 {
range "1..255";
}
description
"Administrative distance for routes learned from internal
BGP (iBGP).";
}
}
grouping bgp-confederation_config {
description
"Configuration options specifying parameters when the local
router is within an autonomous system which is part of a BGP
confederation.";
leaf enabled {
type boolean;
description
"When this leaf is set to true it indicates that
the local-AS is part of a BGP confederation";
}
leaf identifier {
type inet:as-number;
description
"Confederation identifier for the autonomous system.";
}
leaf-list member-as {
type inet:as-number;
description
"Remote autonomous systems that are to be treated
as part of the local confederation.";
}
}
grouping bgp-neighbor_config {
description
"Neighbor level configuration items.";
leaf peer-as {
type inet:as-number;
description
"AS number of the peer.";
}
leaf local-as {
type inet:as-number;
description
"The local autonomous system number that is to be used
when establishing sessions with the remote peer or peer
group, if this differs from the global BGP router
autonomous system number.";
}
leaf peer-type {
type bgp-types:peer-type;
description
"Explicitly designate the peer or peer group as internal
(iBGP) or external (eBGP).";
}
leaf auth-password {
type string;
description
"Configures an MD5 authentication password for use with
neighboring devices.";
}
leaf remove-private-as {
// could also make this a container with a flag to enable
// remove-private and separate option. here, option implies
// remove-private is enabled.
type bgp-types:remove-private-as-option;
description
"Remove private AS numbers from updates sent to peers.";
}
leaf route-flap-damping {
type boolean;
default false;
description
"Enable route flap damping.";
}
leaf send-community {
type bgp-types:community-type;
default "NONE";
description
"Specify which types of community should be sent to the
neighbor or group. The default is to not send the
community attribute";
}
leaf description {
type string;
description
"An optional textual description (intended primarily for use
with a peer or group";
}
}
grouping bgp-neighbor-timers_config {
description
"Config parameters related to timers associated with the BGP
peer";
leaf connect-retry {
type decimal64 {
fraction-digits 2;
}
default 30;
description
"Time interval in seconds between attempts to establish a
session with the peer.";
}
leaf hold-time {
type decimal64 {
fraction-digits 2;
}
default 90;
description
"Time interval in seconds that a BGP session will be
considered active in the absence of keepalive or other
messages from the peer. The hold-time is typically
set to 3x the keepalive-interval.";
reference
"RFC 4271 - A Border Gateway Protocol 4, Sec. 10";
}
leaf keepalive-interval {
type decimal64 {
fraction-digits 2;
}
default 30;
description
"Time interval in seconds between transmission of keepalive
messages to the neighbor. Typically set to 1/3 the
hold-time.";
}
leaf minimum-advertisement-interval {
type decimal64 {
fraction-digits 2;
}
default 30;
description
"Minimum time which must elapse between subsequent UPDATE
messages relating to a common set of NLRI being transmitted
to a peer. This timer is referred to as
MinRouteAdvertisementIntervalTimer by RFC 4721 and serves to
reduce the number of UPDATE messages transmitted when a
particular set of NLRI exhibit instability.";
reference
"RFC 4271 - A Border Gateway Protocol 4, Sec 9.2.1.1";
}
}
grouping bgp-neighbor-transport_config {
description
"Configuration parameters relating to the transport protocol
used by the BGP session to the peer";
leaf tcp-mss {
type uint16;
description
"Sets the max segment size for BGP TCP sessions.";
}
leaf mtu-discovery {
type boolean;
default false;
description
"Turns path mtu discovery for BGP TCP sessions on (true)
or off (false)";
}
leaf passive-mode {
type boolean;
default false;
description
"Wait for peers to issue requests to open a BGP session,
rather than initiating sessions from the local router.";
}
leaf local-address {
type union {
type inet:ip-address;
type string;
}
//TODO: the string should be converted to a leafref type
//to point to an interface when YANG 1.1 is available with
//leafrefs in union types.
description
"Set the local IP (either IPv4 or IPv6) address to use
for the session when sending BGP update messages. This
may be expressed as either an IP address or reference
to the name of an interface.";
}
}
grouping bgp-neighbor-error-handling_config {
description
"Configuration parameters relating to enhanced error handling
behaviours for BGP";
leaf treat-as-withdraw {
type boolean;
default "false";
description
"Specify whether erroneous UPDATE messages for which the
NLRI can be extracted are treated as though the NLRI is
withdrawn - avoiding session reset";
reference "https://tools.ietf.org/html/rfc7606";
}
}
grouping bgp-neighbor-logging-options_config {
description
"Configuration parameters specifying the logging behaviour for
BGP sessions to the peer";
leaf log-neighbor-state-changes {
type boolean;
default "true";
description
"Configure logging of peer state changes. Default is
to enable logging of peer state changes.";
}
}
grouping bgp-neighbor-multihop_config {
description
"Configuration parameters specifying the multihop behaviour for
BGP sessions to the peer";
leaf enabled {
type boolean;
default "false";
description
"When enabled the referenced group or neighbors are permitted
to be indirectly connected - including cases where the TTL
can be decremented between the BGP peers";
}
leaf multihop-ttl {
type uint8;
description
"Time-to-live value to use when packets are sent to the
referenced group or neighbors and ebgp-multihop is enabled";
}
}
grouping bgp-neighbor-route-reflector_config {
description
"Configuration parameters determining whether the behaviour of
the local system when acting as a route-reflector";
leaf route-reflector-cluster-id {
type bgp-types:rr-cluster-id-type;
description
"route-reflector cluster id to use when local router is
configured as a route reflector. Commonly set at the group
level, but allows a different cluster
id to be set for each neighbor.";
}
leaf route-reflector-client {
type boolean;
default "false";
description
"Configure the neighbor as a route reflector client.";
}
}
grouping bgp-neighbor-as-path-options_config {
description
"Configuration parameters allowing manipulation of the AS_PATH
attribute";
leaf allow-own-as {
type uint8;
default 0;
description
"Specify the number of occurrences of the local BGP speaker's
AS that can occur within the AS_PATH before it is rejected.";
}
leaf replace-peer-as {
type boolean;
default "false";
description
"Replace occurrences of the peer's AS in the AS_PATH
with the local autonomous system number";
}
}
grouping bgp-neighbor-add-paths_config {
description
"Configuration parameters specfying whether the local system
will send or receive multiple paths using ADD_PATHS";
leaf receive {
type boolean;
default false;
description
"Enable ability to receive multiple path advertisements
for an NLRI from the neighbor or group";
}
leaf send-max {
type uint8;
description
"The maximum number of paths to advertise to neighbors
for a single NLRI";
}
}
grouping bgp-neighbor-peer-group_config {
description
"Configuration parameters indicating whether the specified peer
is to be considered as part of a peer-group - and therefore
inherit its configuration";
leaf peer-group {
type leafref {
path "/bgp:bgp/bgp:peer-groups/bgp:peer-group/bgp:peer-group-name";
require-instance true;
}
description
"The peer-group with which this neighbor is associated";
}
}
grouping bgp-graceful-restart {
description
"Configures BGP graceful restart, which is a negotiated
option that indicates that a BGP speaker is able to retain
forwarding state when a BGP session restarts";
reference "RFC 4724: Graceful Restart Mechanism for BGP";
container graceful-restart {
description
"Parameters relating the graceful restart mechanism for BGP";
container config {
description
"Configuration parameters relating to graceful-restart";
uses bgp-neighbor-graceful-restart_config;
}
container state {
config false;
description
"State information associated with graceful-restart";
uses bgp-neighbor-graceful-restart_config;
}
}
}
grouping bgp-neighbor-graceful-restart_config {
description
"Configuration parameters relating to BGP graceful restart.";
leaf enabled {
type boolean;
description
"Enable or disable the graceful-restart capability.";
}
leaf restart-time {
type uint16 {
range 0..4096;
}
description
"Estimated time (in seconds) for the local BGP speaker to
restart a session. This value is advertise in the graceful
restart BGP capability. This is a 12-bit value, referred to
as Restart Time in RFC4724. Per RFC4724, the suggested
default value is <= the hold-time value.";
}
leaf stale-routes-time {
type decimal64 {
fraction-digits 2;
}
description
"An upper-bound on the time thate stale routes will be
retained by a router after a session is restarted. If an
End-of-RIB (EOR) marker is received prior to this timer
expiring stale-routes will be flushed upon its receipt - if
no EOR is received, then when this timer expires stale paths
will be purged. This timer is referred to as the
Selection_Deferral_Timer in RFC4724";
}
leaf helper-only {
type boolean;
description
"Enable graceful-restart in helper mode only. When this
leaf is set, the local system does not retain forwarding
its own state during a restart, but supports procedures
for the receiving speaker, as defined in RFC4724.";
}
}
// ************************************************************
// * configuration context containers *
// ************************************************************
grouping bgp-global-base {
description
"Global configuration parameters for the BGP router";
container config {
description
"Configuration parameters relating to the global BGP router";
uses bgp-global_config;
/*
Presence is added as a workaround for BUG-6069 and it lacks
of presence meaning therefore is left empty.
*/
presence "";
}
container state {
config false;
description
"State information relating to the global BGP router";
uses bgp-global_config;
uses bgp-op:bgp-global_state;
}
uses bgp-mp:bgp-route-selection-options;
container default-route-distance {
description
"Administrative distance (or preference) assigned to
routes received from different sources
(external, internal, and local).";
container config {
description
"Configuration parameters relating to the default route
distance";
uses bgp-default-route-distance_config;
}
container state {
config false;
description
"State information relating to the default route distance";
uses bgp-default-route-distance_config;
}
}
container confederation {
description
"Parameters indicating whether the local system acts as part
of a BGP confederation";
container config {
description
"Configuration parameters relating to BGP confederations";
uses bgp-confederation_config;
}
container state {
config false;
description
"State information relating to the BGP confederations";
uses bgp-confederation_config;
}
}
uses bgp-mp:bgp-use-multiple-paths;
uses bgp-graceful-restart;
container afi-safis {
description
"Address family specific configuration";
uses bgp-mp:bgp-common-afi-safi-list;
}
}
grouping bgp-neighbors {
description
"BGP neighbors configured on the local system";
list neighbor {
key "neighbor-address";
description
"List of BGP neighbors configured on the local system,
uniquely identified by peer IPv[46] address";
leaf neighbor-address {
// FIXME: BUG-4625: DTO generation cannot handle this case in Binding Spec v1
// type leafref {
// path "../config/neighbor-address";
// }
type inet:ip-address;
description
"Reference to the address of the BGP neighbor used as
a key in the neighbor list";
}
uses bgp-neighbor-group;
}
}
grouping bgp-peer-group {
description
"BGP peer-groups configured on the local system";
list peer-group {
key "peer-group-name";
description
"List of BGP peer-groups configured on the local system -
uniquely identified by peer-group name";
leaf peer-group-name {
// FIXME: BUG-4625: DTO generation cannot handle this case in Binding Spec v1
// type leafref {
// path "../config/peer-group-name";
// }
type string;
description
"Reference to the name of the BGP peer-group used as a
key in the peer-group list";
}
uses bgp-neighbor-group;
}
}
grouping bgp-neighbor-group {
description
"Parameters related to a BGP neighbor or group";
container config {
description
"Configuration parameters relating to the BGP neighbor or
group";
uses bgp-neighbor_config;
}
container state {
config false;
description
"State information relating to the BGP neighbor or group";
uses bgp-neighbor_config;
}
container timers {
description
"Timers related to a BGP neighbor or group";
container config {
description
"Configuration parameters relating to timers used for the
BGP neighbor or group";
uses bgp-neighbor-timers_config;
}
container state {
config false;
description
"State information relating to the timers used for the BGP
neighbor or group";
uses bgp-neighbor-timers_config;
}
}
container transport {
description
"Transport session parameters for the BGP neighbor or group";
container config {
description
"Configuration parameters relating to the transport
session(s) used for the BGP neighbor or group";
uses bgp-neighbor-transport_config;
}
container state {
config false;
description
"State information relating to the transport session(s)
used for the BGP neighbor or group";
uses bgp-neighbor-transport_config;
}
}
container error-handling {
description
"Error handling parameters used for the BGP neighbor or
group";
container config {
description
"Configuration parameters enabling or modifying the
behavior or enhanced error handling mechanisms for the BGP
neighbor or group";
uses bgp-neighbor-error-handling_config;
}
container state {
config false;
description
"State information relating to enhanced error handling
mechanisms for the BGP neighbor or group";
uses bgp-neighbor-error-handling_config;
}
}
container logging-options {
description
"Logging options for events related to the BGP neighbor or
group";
container config {
description
"Configuration parameters enabling or modifying logging
for events relating to the BGP neighbor or group";
uses bgp-neighbor-logging-options_config;
}
container state {
config false;
description
"State information relating to logging for the BGP neighbor
or group";
uses bgp-neighbor-logging-options_config;
}
}
container ebgp-multihop {
description
"eBGP multi-hop parameters for the BGP neighbor or group";
container config {
description
"Configuration parameters relating to eBGP multihop for the
BGP neighbor or group";
uses bgp-neighbor-multihop_config;
}
container state {
config false;
description
"State information for eBGP multihop, for the BGP neighbor
or group";
uses bgp-neighbor-multihop_config;
}
}
container route-reflector {
description
"Route reflector parameters for the BGP neighbor or group";
container config {
description
"Configuraton parameters relating to route reflection
for the BGP neighbor or group";
uses bgp-neighbor-route-reflector_config;
}
container state {
config false;
description
"State information relating to route reflection for the
BGP neighbor or group";
uses bgp-neighbor-route-reflector_config;
}
}
container as-path-options {
description
"AS_PATH manipulation parameters for the BGP neighbor or
group";
container config {
description
"Configuration parameters relating to AS_PATH manipulation
for the BGP peer or group";
uses bgp-neighbor-as-path-options_config;
}
container state {
config false;
description
"State information relating to the AS_PATH manipulation
mechanisms for the BGP peer or group";
uses bgp-neighbor-as-path-options_config;
}
}
container add-paths {
description
"Parameters relating to the advertisement and receipt of
multiple paths for a single NLRI (add-paths)";
container config {
description
"Configuration parameters relating to ADD_PATHS";
uses bgp-neighbor-add-paths_config;
}
container state {
config false;
description
"State information associated with ADD_PATHS";
uses bgp-neighbor-add-paths_config;
}
}
container afi-safis {
description
"Per-address-family configuration parameters associated with
the neighbor or group";
uses bgp-mp:bgp-common-afi-safi-list;
}
uses bgp-graceful-restart;
uses rpol:apply-policy-group;
}
grouping bgp-neighbor-neighbor-address_config {
description
"Configuration options relating to the BGP neighbor address";
leaf neighbor-address {
type inet:ip-address;
description
"Address of the BGP peer, either in IPv4 or IPv6";
}
}
grouping bgp-peer-group-peer-group-name_config {
description
"Configuration options relating to the BGP peer-group name";
leaf peer-group-name {
type string;
description
"Name of the BGP peer-group";
}
}
// add peer-group pointer only for the neighbor list
augment /bgp/neighbors/neighbor/config {
description
"Augmentation to allow association of a neighbor with a
peer-group";
uses bgp-neighbor-peer-group_config;
}
augment /bgp/neighbors/neighbor/state {
description
"Augmentation to reflect the association of a neighbor with a
peer-group";
uses bgp-neighbor-peer-group_config;
}
augment /bgp/peer-groups/peer-group {
description
"Augmentation to add multipath configuration to a peer-group";
uses bgp-mp:bgp-use-multiple-paths;
}
augment /bgp/neighbors/neighbor {
description
"Augmentation to add the multipath configuration to a
neighbor";
uses bgp-mp:bgp-use-multiple-paths-neighbor;
}
augment /bgp/peer-groups/peer-group/afi-safis/afi-safi {
description
"Augmentation to add multipath configuration to a peer-group
on a per-AFI-SAFI basis";
uses bgp-mp:bgp-use-multiple-paths;
}
augment /bgp/neighbors/neighbor/afi-safis/afi-safi {
description
"Augmentation to add multipath configuration to a neighbor
on a per-AFI-SAFI basis";
uses bgp-mp:bgp-use-multiple-paths-neighbor;
}
augment /bgp/global/afi-safis/afi-safi {
description
"Augmentation to add global instance specific AFI-SAFI
configuration information";
uses bgp-mp:bgp-global-afi-safi;
uses bgp-mp:bgp-use-multiple-paths;
}
augment /bgp/peer-groups/peer-group/afi-safis/afi-safi {
description
"Augmentation that adds peer-group instance specific
AFI-SAFI configuration information";
uses bgp-mp:bgp-group-afi-safi;
}
augment /bgp/neighbors/neighbor/config {
description
"Augmentation adding the neighbor address to the
neighbor configuration container";
uses bgp-neighbor-neighbor-address_config;
}
augment /bgp/neighbors/neighbor/state {
description
"Augmentation adding the neighbor address to the
neighbor state container";
uses bgp-neighbor-neighbor-address_config;
}
augment /bgp/peer-groups/peer-group/config {
description
"Augmentation adding the peer-group name to the
peer-group configuration container";
uses bgp-peer-group-peer-group-name_config;
}
augment /bgp/peer-groups/peer-group/state {
description
"Augmentation adding the peer-group name to the
peer-group state container";
uses bgp-peer-group-peer-group-name_config;
}
// ************************************************************
// * Augmentations to add state *
// * (rjs: cleaner to have these in the base module to avoid *
// needing to specify which module - e.g. augment of *
// /bgp:bgp/bgp:neighbors/bgp:neighbor...) *
// ************************************************************
augment /bgp/neighbors/neighbor/state {
description
"Augmentation to add operational state related to a particular
BGP neighbor";
uses bgp-op:bgp-neighbor_state;
}
augment /bgp/neighbors/bgp:neighbor/state {
description
"Augmentation to add operational state related to a particular
BGP neighbor";
container messages {
description
"Counters for BGP messages sent and received from the
neighbor";
container sent {
description
"Counters relating to BGP messages sent to the neighbor";
uses bgp-op:bgp-neighbor-message-counters-sent_state;
}
container received {
description
"Counters for BGP messages received from the neighbor";
uses bgp-op:bgp-neighbor-message-counters-received_state;
}
}
container queues {
description
"Counters related to queued messages associated with the
BGP neighbor";
uses bgp-op:bgp-neighbor-queue-counters_state;
}
}
augment /bgp:bgp/bgp:neighbors/neighbor/timers/state {
description
"Augmentation to add the operational state of timers associated
with the BGP neighbor";
uses bgp-op:bgp-neighbor-timers_state;
}
augment /bgp/neighbors/neighbor/transport/state {
description
"Augmentation to add the operational state of the transport
session associated with the BGP neighbor";
uses bgp-op:bgp-neighbor-transport_state;
}
augment /bgp/neighbors/neighbor/error-handling/state {
description
"Augmentation to add the operational state of the error
handling associated with the BGP neighbor";
uses bgp-op:bgp-neighbor-error-handling_state;
}
augment /bgp/neighbors/neighbor/graceful-restart/state {
description
"Augmentation to add the operational state of graceful-restart
associated with a BGP neighbor";
uses bgp-op:bgp-afi-safi-graceful-restart_state;
}
augment /bgp/peer-groups/peer-group/state {
description
"Augmentation to add the operational state and counters
relating to a BGP peer-group";
uses bgp-op:bgp-peer-group_state;
}
augment /bgp/global/afi-safis/afi-safi/state {
description
"Augmentation to add operational state and counters
on a per-AFI-SAFI basis to the global BGP router";
uses bgp-op:bgp-global-afi-safi_state;
}
augment /bgp/neighbors/neighbor/afi-safis/afi-safi/state {
description
"Augmentation to add per-AFI-SAFI operational state
and counters to the BGP neighbor";
uses bgp-op:bgp-neighbor-afi-safi_state;
}
augment "/bgp/neighbors/neighbor/afi-safis/afi-safi/" +
"graceful-restart/state" {
description
"Augmentation to add per-AFI-SAFI operational state for BGP
graceful-restart";
uses bgp-op:bgp-neighbor-afi-safi-graceful-restart_state;
}
grouping bgp-top {
description
"Top-level grouping for the BGP model data";
container bgp {
presence "Container for BGP protocol hierarchy";
description
"Top-level configuration and state for the BGP router";
container global {
description
"Global configuration for the BGP router";
uses bgp-global-base;
uses rpol:apply-policy-group;
}
container neighbors {
description
"Configuration for BGP neighbors";
uses bgp-neighbors;
}
container peer-groups {
description
"Configuration for BGP peer-groups";
uses bgp-peer-group;
}
}
}
// ************************************************************
// * module structure containers *
// ************************************************************
uses bgp-top;
}