mirror of https://github.com/FRRouting/frr.git
1173 lines
31 KiB
YANG
1173 lines
31 KiB
YANG
submodule frr-bgp-common {
|
|
yang-version 1.1;
|
|
|
|
belongs-to frr-bgp {
|
|
prefix "bgp";
|
|
}
|
|
|
|
import ietf-bgp-types {
|
|
prefix bt;
|
|
}
|
|
|
|
import ietf-inet-types {
|
|
prefix inet;
|
|
}
|
|
|
|
import frr-bgp-types {
|
|
prefix frr-bt;
|
|
}
|
|
|
|
import frr-route-map {
|
|
prefix frr-route-map;
|
|
}
|
|
|
|
import frr-route-types {
|
|
prefix frr-rt-type;
|
|
}
|
|
|
|
import frr-vrf {
|
|
prefix frr-vrf;
|
|
}
|
|
|
|
import ietf-routing-types {
|
|
prefix rt-types;
|
|
}
|
|
|
|
import frr-interface {
|
|
prefix frr-interface;
|
|
}
|
|
|
|
organization
|
|
"FRRouting";
|
|
contact
|
|
"FRR Users List: <mailto:frog@lists.frrouting.org> FRR Development
|
|
List: <mailto:dev@lists.frrouting.org>";
|
|
description
|
|
"This submodule contains general data definitions for use in BGP.
|
|
|
|
Copyright 2020 FRRouting
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.";
|
|
|
|
revision 2019-12-03 {
|
|
description
|
|
"Initial revision.";
|
|
}
|
|
|
|
grouping rmap-policy-import {
|
|
leaf rmap-import {
|
|
type frr-route-map:route-map-ref;
|
|
}
|
|
}
|
|
|
|
grouping rmap-policy-export {
|
|
leaf rmap-export {
|
|
type frr-route-map:route-map-ref;
|
|
}
|
|
}
|
|
|
|
grouping unsuppress-map-policy-import {
|
|
leaf unsuppress-map-import {
|
|
type frr-route-map:route-map-ref;
|
|
}
|
|
}
|
|
|
|
grouping unsuppress-map-policy-export {
|
|
leaf unsuppress-map-export {
|
|
type frr-route-map:route-map-ref;
|
|
}
|
|
}
|
|
|
|
grouping plist-policy-import {
|
|
leaf plist-import {
|
|
type frr-bt:plist-ref;
|
|
}
|
|
}
|
|
|
|
grouping plist-policy-export {
|
|
leaf plist-export {
|
|
type frr-bt:plist-ref;
|
|
}
|
|
}
|
|
|
|
grouping access-list-policy-import {
|
|
leaf access-list-import {
|
|
type frr-bt:access-list-ref;
|
|
}
|
|
}
|
|
|
|
grouping access-list-policy-export {
|
|
leaf access-list-export {
|
|
type frr-bt:access-list-ref;
|
|
}
|
|
}
|
|
|
|
grouping as-path-filter-list-policy-import {
|
|
leaf as-path-filter-list-import {
|
|
type frr-bt:as-path-filter-ref;
|
|
}
|
|
}
|
|
|
|
grouping as-path-filter-list-policy-export {
|
|
leaf as-path-filter-list-export {
|
|
type frr-bt:as-path-filter-ref;
|
|
}
|
|
}
|
|
|
|
grouping route-selection-options {
|
|
description
|
|
"Configuration relating to route selection options.";
|
|
container route-selection-options {
|
|
description
|
|
"Parameters relating to options for route selection.";
|
|
leaf always-compare-med {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Compare multi-exit discriminator (MED) value from
|
|
different ASes when selecting the best route. The
|
|
default behaviour is to only compare MEDs for paths
|
|
received from the same AS.";
|
|
}
|
|
|
|
leaf deterministic-med {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Compare multi-exit discriminator (MED) value from
|
|
Same ASes when selecting the best route.";
|
|
}
|
|
|
|
leaf confed-med {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Compare multi-exit discriminator (MED) value from
|
|
different Sub ASes when selecting the best route.";
|
|
}
|
|
|
|
leaf missing-as-worst-med {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Missing multi-exit discriminator (MED) value is
|
|
considered as value of infinity, making the path
|
|
least desirable when selecting the best route.";
|
|
}
|
|
|
|
leaf aspath-confed {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Compare path lengths including confederation sets
|
|
and sequences in selecting a route.";
|
|
}
|
|
|
|
leaf ignore-as-path-length {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Ignore the AS path length when selecting the best path.
|
|
The default is to use the AS path length and prefer paths
|
|
with shorter length.";
|
|
}
|
|
|
|
leaf external-compare-router-id {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When comparing similar routes received from external BGP
|
|
peers, use the router-id as a criterion to select the
|
|
active path.";
|
|
}
|
|
|
|
leaf allow-multiple-as {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Allow multi-path to use paths from different neighbouring
|
|
ASes. The default is to only consider multiple paths
|
|
from the same neighbouring AS.";
|
|
}
|
|
|
|
leaf multi-path-as-set {
|
|
when "../allow-multiple-as = 'true'";
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Multi-path with AS-SET, When set to 'true' it adds AS set
|
|
information for aggregate routes, When set to 'false' it
|
|
prevents AS set generation.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping med-config {
|
|
description
|
|
"Configuration relating to MED.";
|
|
container med-config {
|
|
leaf enable-med-admin {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Flag to enable receiving of MED metric attribute
|
|
in routing updates.";
|
|
}
|
|
leaf max-med-admin {
|
|
type uint32 {
|
|
range "0..4294967295";
|
|
}
|
|
default "4294967294";
|
|
description
|
|
"Tells the router to announce routes with this MED value
|
|
This MED value is applicable for indefinite time.";
|
|
}
|
|
|
|
leaf max-med-onstart-up-time {
|
|
type uint32 {
|
|
range "5..86400";
|
|
}
|
|
units "seconds";
|
|
description
|
|
"Tells the router to announce routes with MED value,
|
|
This MED value is applicable for this duration during
|
|
start-up.";
|
|
}
|
|
|
|
leaf max-med-onstart-up-value {
|
|
type uint32 {
|
|
range "0..4294967295";
|
|
}
|
|
default "4294967294";
|
|
description
|
|
"Tells the router to announce routes with this MED value
|
|
This MED value is applicable for start-up time.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping route-reflector-config {
|
|
description
|
|
"Grouping used to include route reflector
|
|
configuration for BGP global.";
|
|
container route-reflector {
|
|
description
|
|
"Route reflector parameters for the BGP global.";
|
|
leaf route-reflector-cluster-id {
|
|
type bt: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.";
|
|
reference
|
|
"RFC 4456: BGP Route Reflection: An Alternative to
|
|
Full Mesh.";
|
|
}
|
|
|
|
leaf no-client-reflect {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true', this disables route redistribution
|
|
by the Route Reflector. It is set 'true' when the client is
|
|
fully meshed to prevent sending of redundant route
|
|
advertisements.";
|
|
reference
|
|
"TODO: Add reference when IETF writes a draft describing
|
|
this.";
|
|
}
|
|
|
|
leaf allow-outbound-policy {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true', this allow RR to modify the attributes of the
|
|
reflected IBGP routes as per the out route-map. It is set 'false'
|
|
RR will not modify the attributes of the reflected IBGP routes as
|
|
per the out route-map rules.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping global-bgp-config {
|
|
leaf instance-type-view {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' BGP instance type is view.
|
|
When set to 'false' BGP instance type is regular.";
|
|
}
|
|
|
|
leaf ebgp-multihop-connected-route-check {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' it will disable checking if nexthop is connected
|
|
on EBGP sessions. When set to 'false' it will enable checking if
|
|
nexthop is connected on EBGP sessions.";
|
|
}
|
|
|
|
leaf fast-external-failover {
|
|
type boolean;
|
|
default "true";
|
|
description
|
|
"It's an interface tracking mechanism. When set to 'true' don't
|
|
immediately reset session if a link to a directly connected
|
|
external peer goes down. When set to 'false' it will immediately
|
|
reset session if a link to a directly connected external peer goes down.";
|
|
}
|
|
|
|
leaf local-pref {
|
|
type uint32;
|
|
default "100";
|
|
description
|
|
"BGP local preference attribute sent to internal peers to
|
|
indicate the degree of preference for externally learned
|
|
routes. The route with the highest local preference
|
|
value is preferred.";
|
|
reference
|
|
"RFC 4271.";
|
|
}
|
|
|
|
leaf default-shutdown {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Apply administrative shutdown to newly configured peers.";
|
|
}
|
|
|
|
leaf suppress-duplicates {
|
|
type boolean;
|
|
default "true";
|
|
description
|
|
"Suppress duplicate updates if the route actually not changed.";
|
|
}
|
|
|
|
leaf ebgp-requires-policy {
|
|
type boolean;
|
|
default "true";
|
|
description
|
|
"When set to 'true' BGP speaker requires in and out policy
|
|
for EBGP peers (RFC8212).";
|
|
}
|
|
|
|
leaf show-hostname {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' BGP show hostname in certain command outputs.";
|
|
}
|
|
|
|
leaf show-nexthop-hostname {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' BGP show hostname for nexthop in certain
|
|
command outputs.";
|
|
}
|
|
}
|
|
|
|
grouping global-neighbor-config {
|
|
container global-neighbor-config {
|
|
leaf dynamic-neighbors-limit {
|
|
type uint32 {
|
|
range "1..65535";
|
|
}
|
|
description
|
|
"Maximum number of BGP Dynamic Neighbors that can be created.";
|
|
}
|
|
|
|
leaf log-neighbor-changes {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' BGP will start logging neighbor up/down and reset reason.
|
|
When set to 'false' BGP will stop logging neighbor up/down and reset reason.";
|
|
}
|
|
|
|
container packet-quanta-config {
|
|
leaf wpkt-quanta {
|
|
type uint32 {
|
|
range "1..64";
|
|
}
|
|
default "64";
|
|
description
|
|
"How many packets to write to peer socket per run.";
|
|
}
|
|
|
|
leaf rpkt-quanta {
|
|
type uint32 {
|
|
range "1..10";
|
|
}
|
|
default "10";
|
|
description
|
|
"How many packets to read from peer socket per I/O cycle.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping global-update-group-config {
|
|
container global-update-group-config {
|
|
leaf subgroup-pkt-queue-size {
|
|
type uint32 {
|
|
range "20..100";
|
|
}
|
|
default "40";
|
|
description
|
|
"Subgroup packet queue size.";
|
|
}
|
|
|
|
leaf coalesce-time {
|
|
type uint32 {
|
|
range "0..4294967295";
|
|
}
|
|
units "milliseconds";
|
|
default "1000";
|
|
description
|
|
"Configures the Subgroup coalesce timer.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping global-network-config {
|
|
leaf import-check {
|
|
type boolean;
|
|
default "true";
|
|
description
|
|
"When set to 'true' bgp creates entries for network statements
|
|
if a matching prefix exists in the rib. When set to 'false' bgp
|
|
creates entries for networks that the router cannot reach.
|
|
|
|
In FRR versions < 7.4 this used to default to 'false' this is an
|
|
incompatible backward change";
|
|
}
|
|
}
|
|
|
|
grouping neighbor-timers {
|
|
leaf hold-time {
|
|
type uint16 {
|
|
range "0 | 3..65535";
|
|
}
|
|
units "seconds";
|
|
default "180";
|
|
description
|
|
"Time interval (in seconds) for the HoldTimer established
|
|
with the peer. When read as operational data (ro), the
|
|
value of this object is calculated by this BGP speaker,
|
|
using the smaller of the values in hold-time that was
|
|
configured (rw) in the running datastore and the Hold Time
|
|
received in the OPEN message.
|
|
|
|
This value must be at least three seconds
|
|
if it is not zero (0).
|
|
|
|
If the Hold Timer has not been established
|
|
with the peer this object MUST have a value
|
|
of zero (0).
|
|
|
|
If the configured value of hold-time object was
|
|
a value of (0), then when read this object MUST have a
|
|
value of (0) also.";
|
|
reference
|
|
"RFC 4271";
|
|
}
|
|
|
|
leaf keepalive {
|
|
type uint16 {
|
|
range "0..65535";
|
|
}
|
|
units "seconds";
|
|
default "60";
|
|
description
|
|
"When used as a configuration (rw) value, this Time interval
|
|
(in seconds) for the KeepAlive timer configured for this BGP
|
|
speaker with this peer. The value of this object will only
|
|
determine the KEEPALIVE messages' frequency relative to
|
|
the value specified in configured value for hold-time.
|
|
|
|
If the value of this object is zero (0), no periodical
|
|
KEEPALIVE messages are sent to the peer after the BGP
|
|
connection has been established. The suggested value for
|
|
this timer is 30 seconds.;
|
|
|
|
The actual time interval for the KEEPALIVE messages is
|
|
indicated by operational value of keepalive. That value
|
|
of this object is calculated by this BGP speaker such that,
|
|
when compared with hold-time, it has the same proportion
|
|
that keepalive has, compared with hold-time. A
|
|
reasonable maximum value for this timer would be one third
|
|
of that of hold-time.";
|
|
reference
|
|
"RFC 4271";
|
|
}
|
|
}
|
|
|
|
grouping global-config-timers {
|
|
container global-config-timers {
|
|
leaf rmap-delay-time {
|
|
type uint16 {
|
|
range "0..600";
|
|
}
|
|
units "seconds";
|
|
default "5";
|
|
description
|
|
"Time to wait before processing route-map changes.";
|
|
}
|
|
|
|
leaf update-delay-time {
|
|
type uint16 {
|
|
range "0..3600";
|
|
}
|
|
units "seconds";
|
|
description
|
|
"Time to force initial delay for best-path and updates.";
|
|
}
|
|
|
|
leaf establish-wait-time {
|
|
type uint16 {
|
|
range "1..3600";
|
|
}
|
|
units "seconds";
|
|
description
|
|
"Time to force initial delay for updates.";
|
|
}
|
|
|
|
leaf connect-retry-interval {
|
|
type uint16 {
|
|
range "1..max";
|
|
}
|
|
units "seconds";
|
|
default "120";
|
|
description
|
|
"Time interval (in seconds) for the ConnectRetryTimer. The
|
|
suggested value for this timer is 120 seconds.";
|
|
reference
|
|
"RFC 4271, This is the value used
|
|
to initialize the 'ConnectRetryTimer'.";
|
|
}
|
|
|
|
uses neighbor-timers;
|
|
}
|
|
}
|
|
|
|
grouping graceful-restart-config {
|
|
description
|
|
"Configuration parameters relating to BGP graceful restart.";
|
|
choice mode {
|
|
case graceful-restart-mode {
|
|
leaf enabled {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Enable or disable the graceful-restart capability. When set to 'true'
|
|
it will enable graceful restart and helper both globally. When set
|
|
to 'false' it will enable the default behaviour global helper mode.";
|
|
}
|
|
}
|
|
|
|
case graceful-restart-disable-mode {
|
|
leaf graceful-restart-disable {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' it will disable graceful restart and helper both
|
|
globally. when set to 'false' it will enable the default behaviour
|
|
global helper mode.";
|
|
}
|
|
}
|
|
}
|
|
|
|
leaf preserve-fw-entry {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Sets F-bit indication that fib is preserved while doing Graceful Restart.
|
|
When set to 'true' Zebra would preserve the FIB entry on the restarting
|
|
node.";
|
|
}
|
|
|
|
leaf restart-time {
|
|
type uint16 {
|
|
range "1..3600";
|
|
}
|
|
units "seconds";
|
|
default "120";
|
|
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. This timer is
|
|
applicable for helper node.";
|
|
reference
|
|
"RFC 4724: Graceful Restart Mechanism for BGP.";
|
|
}
|
|
|
|
leaf stale-routes-time {
|
|
type uint16 {
|
|
range "1..3600";
|
|
}
|
|
units "seconds";
|
|
default "360";
|
|
description
|
|
"An upper-bound on the time that 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 applicable for restarting node.";
|
|
reference
|
|
"RFC 4724: Graceful Restart Mechanism for BGP.";
|
|
}
|
|
|
|
leaf selection-deferral-time {
|
|
type uint16 {
|
|
range "0..3600";
|
|
}
|
|
units "seconds";
|
|
default "360";
|
|
description
|
|
"An upper-bound on the time that restarting router defers
|
|
the route selection process after restart.";
|
|
reference
|
|
"RFC 4724: Graceful Restart Mechanism for BGP.";
|
|
}
|
|
|
|
leaf rib-stale-time {
|
|
type uint16 {
|
|
range "1..3600";
|
|
}
|
|
units "seconds";
|
|
default "500";
|
|
description
|
|
"An upper-bound on the time that helper router holds the
|
|
stale routes in Zebra, When this timer gets expired Zebra
|
|
removes the stale routes.";
|
|
}
|
|
}
|
|
|
|
grouping global-group-use-multiple-paths {
|
|
description
|
|
"Common grouping used for both global and groups which provides
|
|
configuration parameters relating to use of multiple paths.";
|
|
container use-multiple-paths {
|
|
description
|
|
"Parameters related to the use of multiple paths for the
|
|
same NLRI.";
|
|
container ebgp {
|
|
description
|
|
"Multi-Path parameters for EBGP.";
|
|
leaf maximum-paths {
|
|
type uint16;
|
|
default "64";
|
|
description
|
|
"Maximum number of parallel paths to consider when using
|
|
BGP multi-path. The default is use a single path.";
|
|
}
|
|
}
|
|
|
|
container ibgp {
|
|
description
|
|
"Multi-Path parameters for IBGP.";
|
|
leaf maximum-paths {
|
|
type uint16;
|
|
default "64";
|
|
description
|
|
"Maximum number of parallel paths to consider when using
|
|
IBGP multi-path. The default is to use a single path.";
|
|
}
|
|
|
|
leaf cluster-length-list {
|
|
when "../maximum-paths != 0";
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' route with the shortest cluster-list
|
|
length is used. The cluster-list reflects the IBGP
|
|
reflection path the route has taken. It's the part
|
|
of route selection algo.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping global-redistribute {
|
|
description
|
|
"List of route redistribution per AFI.";
|
|
list redistribution-list {
|
|
key "route-type route-instance";
|
|
leaf route-type {
|
|
type frr-rt-type:frr-route-types;
|
|
description
|
|
"Protocol route type.";
|
|
}
|
|
|
|
leaf route-instance {
|
|
type uint16 {
|
|
range "0..65535";
|
|
}
|
|
description
|
|
"Protocol Instance.";
|
|
}
|
|
|
|
leaf metric {
|
|
type uint32 {
|
|
range "0..4294967295";
|
|
}
|
|
description
|
|
"Metric for redistributed routes.";
|
|
}
|
|
|
|
leaf rmap-policy-import {
|
|
type frr-route-map:route-map-ref;
|
|
description
|
|
"Route-map to be applied for redistributed routes into the bgp.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping mp-afi-safi-network-config {
|
|
leaf label-index {
|
|
type rt-types:mpls-label;
|
|
description
|
|
"Label index to associate with the prefix.";
|
|
}
|
|
|
|
leaf rmap-policy-export {
|
|
type frr-route-map:route-map-ref;
|
|
description
|
|
"Route-map to modify the attributes for Routes going out
|
|
via BGP updates.";
|
|
}
|
|
}
|
|
|
|
grouping mp-afi-safi-agg-route-config {
|
|
leaf as-set {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' AS set path information is generated
|
|
for aggregate address. When set to 'false' AS set path
|
|
information is not generated.";
|
|
}
|
|
|
|
leaf summary-only {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' it advertise only the aggregate route
|
|
and suppress the advertisement of all the component routes.
|
|
When set to 'false' all more-specific routes summarized
|
|
by the aggregate route are advertised.";
|
|
}
|
|
|
|
leaf rmap-policy-export {
|
|
type frr-route-map:route-map-ref;
|
|
description
|
|
"Apply route map to aggregate network.";
|
|
}
|
|
|
|
leaf origin {
|
|
type enumeration {
|
|
enum "igp" {
|
|
value 0;
|
|
description
|
|
"Local IGP.";
|
|
}
|
|
enum "egp" {
|
|
value 1;
|
|
description
|
|
"Remote EGP.";
|
|
}
|
|
enum "incomplete" {
|
|
value 2;
|
|
description
|
|
"Unknown heritage.";
|
|
}
|
|
enum "unspecified" {
|
|
value 255;
|
|
description
|
|
"Unspecified.";
|
|
}
|
|
}
|
|
default "unspecified";
|
|
description
|
|
"BGP origin type.";
|
|
}
|
|
|
|
leaf match-med {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"When set to 'true' aggregate-route matches only
|
|
med.";
|
|
}
|
|
|
|
leaf suppress-map {
|
|
type string;
|
|
description
|
|
"Suppress more specific routes specified in route-map.";
|
|
}
|
|
}
|
|
|
|
grouping admin-distance {
|
|
container admin-distance {
|
|
description
|
|
"Administrative distance (or preference) assigned to
|
|
routes received from different sources
|
|
(external, internal, and local).";
|
|
leaf external {
|
|
type uint8 {
|
|
range "1..255";
|
|
}
|
|
default "20";
|
|
description
|
|
"Administrative distance for routes learned from
|
|
external BGP (EBGP).";
|
|
}
|
|
|
|
leaf internal {
|
|
type uint8 {
|
|
range "1..255";
|
|
}
|
|
default "200";
|
|
description
|
|
"Administrative distance for routes learned from
|
|
internal BGP (IBGP).";
|
|
}
|
|
|
|
leaf local {
|
|
type uint8 {
|
|
range "1..255";
|
|
}
|
|
default "200";
|
|
description
|
|
"Administrative distance for routes learned from
|
|
local.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping distance-per-route-config {
|
|
leaf distance {
|
|
type uint8 {
|
|
range "1..255";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Administrative distance for route.";
|
|
}
|
|
|
|
leaf access-list-policy-export {
|
|
type frr-bt:access-list-ref;
|
|
description
|
|
"Access-list policy applied on routes going from BGP to Zebra.";
|
|
}
|
|
}
|
|
|
|
grouping route-flap-dampening {
|
|
container route-flap-dampening {
|
|
description
|
|
"Dampening feature";
|
|
leaf enable {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Enable route flap dampening.";
|
|
}
|
|
|
|
leaf reach-decay {
|
|
when "../enable = 'true'";
|
|
type uint8 {
|
|
range "1..45";
|
|
}
|
|
units "seconds";
|
|
default "15";
|
|
description
|
|
"This value specifies the time desired for the instability
|
|
metric value to reach one-half of its current value when
|
|
the route is reachable. This half-life value determines
|
|
the rate at which the metric value is decayed. A smaller
|
|
half-life value makes a suppressed route reusable sooner
|
|
than a larger value. The accumulated penalty will be reduced
|
|
to half after this duration.";
|
|
}
|
|
|
|
leaf reuse-above {
|
|
when "../enable = 'true'";
|
|
type uint16 {
|
|
range "1..20000";
|
|
}
|
|
default "750";
|
|
description
|
|
"This is the value of the instability metric at which a
|
|
suppressed route becomes unsuppressed if it is reachable
|
|
but currently suppressed. The value assigned to
|
|
reuse-below must be less than suppress-above.";
|
|
}
|
|
|
|
leaf suppress-above {
|
|
when "../enable = 'true'";
|
|
type uint16 {
|
|
range "1..20000";
|
|
}
|
|
default "2000";
|
|
description
|
|
"This is the value of the instability metric at which
|
|
route suppression takes place. A route is not installed
|
|
in the forwarding information base (FIB), or announced
|
|
even if it is reachable during the period that it is
|
|
suppressed.";
|
|
}
|
|
|
|
leaf unreach-decay {
|
|
when "../enable = 'true'";
|
|
type uint8 {
|
|
range "1..255";
|
|
}
|
|
units "seconds";
|
|
default "60";
|
|
description
|
|
"This value acts the same as reach-decay except that it
|
|
specifies the rate at which the instability metric is
|
|
decayed when a route is unreachable. It should have a
|
|
value greater than or equal to reach-decay.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping flow-spec-config {
|
|
container flow-spec-config {
|
|
description
|
|
"Flow spec feature.";
|
|
leaf interface {
|
|
type frr-interface:interface-ref {
|
|
require-instance false;
|
|
}
|
|
description
|
|
"The local interface.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping global-graceful-shutdown {
|
|
description
|
|
"Structural grouping used to include graceful-shutdown
|
|
configuration for both BGP neighbors and peer groups.";
|
|
container graceful-shutdown {
|
|
description
|
|
"BGP Graceful shutdown feature.";
|
|
leaf enable {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Enable graceful-shutdown feature.";
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping global-filter-config {
|
|
description
|
|
"Structural grouping used to include filter
|
|
configuration for BGP RIB table.";
|
|
container filter-config {
|
|
description
|
|
"BGP table to RIB route download filter.";
|
|
uses rmap-policy-export;
|
|
}
|
|
}
|
|
|
|
grouping route-distinguisher-params {
|
|
description
|
|
"Route distinguisher value as per RFC4364.";
|
|
leaf rd {
|
|
type rt-types:route-distinguisher;
|
|
description
|
|
"Route distinguisher value as per RFC4364.";
|
|
}
|
|
}
|
|
|
|
grouping vpn-label-params {
|
|
description
|
|
"Label value for VRF.";
|
|
choice label-allocation-mode {
|
|
case manual {
|
|
leaf label {
|
|
type rt-types:mpls-label;
|
|
description
|
|
"Label index to associate with the prefix.";
|
|
}
|
|
}
|
|
|
|
case auto {
|
|
leaf label-auto {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Automatically assign a label.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping vpn-nexthop-params {
|
|
description
|
|
"Specify next hop to use for VRF advertised prefixes.";
|
|
leaf nexthop {
|
|
type inet:ip-address;
|
|
description
|
|
"Nexthop IP address.";
|
|
}
|
|
}
|
|
|
|
grouping rt-list {
|
|
description
|
|
"Route Target list";
|
|
leaf-list import-rt-list {
|
|
type rt-types:route-target;
|
|
description
|
|
"For routes leaked from vpn to current address-family: match any.";
|
|
}
|
|
|
|
leaf-list export-rt-list {
|
|
type rt-types:route-target;
|
|
description
|
|
"For routes leaked from current address-family to vpn: set.";
|
|
}
|
|
}
|
|
|
|
grouping vpn-route-target-params {
|
|
description
|
|
"Route Target value.";
|
|
leaf redirect-rt {
|
|
type rt-types:route-target;
|
|
description
|
|
"Flow-spec redirect type route target.";
|
|
}
|
|
|
|
choice rt-direction {
|
|
case import-export {
|
|
uses rt-list;
|
|
}
|
|
|
|
case both {
|
|
leaf-list rt-list {
|
|
type rt-types:route-target;
|
|
description
|
|
"Both import: match any and export: set.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping vpn-import-params {
|
|
description
|
|
"VPN route leaking parameters.";
|
|
leaf import-vpn {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Import routes from default instance VPN RIB.";
|
|
}
|
|
|
|
leaf export-vpn {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Export routes to default instance VPN RIB.";
|
|
}
|
|
|
|
list import-vrf-list {
|
|
key "vrf";
|
|
description
|
|
"List of VRFs to import routes from.";
|
|
leaf vrf {
|
|
type frr-vrf:vrf-ref {
|
|
require-instance false;
|
|
}
|
|
description
|
|
"Routing instance.";
|
|
}
|
|
}
|
|
|
|
uses rmap-policy-import;
|
|
|
|
uses rmap-policy-export;
|
|
}
|
|
|
|
grouping global-afi-safi-vpn-config {
|
|
container vpn-config {
|
|
leaf rd {
|
|
type string;
|
|
description
|
|
"Route distinguisher value as per RFC4364.";
|
|
}
|
|
|
|
uses vpn-label-params;
|
|
|
|
uses vpn-nexthop-params;
|
|
|
|
uses vpn-import-params;
|
|
|
|
uses vpn-route-target-params;
|
|
}
|
|
}
|
|
|
|
grouping global-afi-safi-vpn-network-config {
|
|
list network-config {
|
|
key "rd";
|
|
description
|
|
"A list of rd.";
|
|
uses route-distinguisher-params;
|
|
|
|
list prefix-list {
|
|
key "prefix";
|
|
description
|
|
"A list of prefix.";
|
|
leaf prefix {
|
|
type inet:ip-prefix;
|
|
description
|
|
"IP destination prefix.";
|
|
}
|
|
|
|
leaf label-index {
|
|
type uint32;
|
|
mandatory true;
|
|
description
|
|
"Label index to associate with the prefix.";
|
|
}
|
|
|
|
leaf rmap-policy-export {
|
|
type frr-route-map:route-map-ref;
|
|
description
|
|
"Route-map to modify the attributes for Routes going out
|
|
via BGP updates.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|