sonic-bgp-global.yang

module sonic-bgp-global {
    namespace "http://github.com/Azure/sonic-bgp-global";
    prefix sbgpg;
    yang-version 1.1;

    import sonic-vrf {
        prefix svrf;
    }

    import ietf-inet-types {
        prefix inet;
    }

    import sonic-bgp-common {
        prefix sbc;
    }

    import sonic-route-map {
        prefix srmap;
    }

    import sonic-extension {
        prefix sonic-ext;
    }

    import sonic-types {
        prefix cmn;
    }

    organization
        "SONiC";

    contact
        "SONiC";

    description
        "SONIC BGP Global YANG";

    revision 2021-02-26 {
        description
            "Initial revision.";
    }

    container sonic-bgp-global {
        container BGP_GLOBALS {
            list BGP_GLOBALS_LIST {
                key "vrf_name";

                leaf vrf_name {
                    type union {
                        type string {
                            pattern "default";
                        }
                        type leafref {
                            path "/svrf:sonic-vrf/svrf:VRF/svrf:VRF_LIST/svrf:vrf_name";
                        }
                    }
                    description "VRF name";
                }

                leaf router_id {
                    type inet:ipv4-address;
                    description "Router identifier";
                }

                leaf local_asn {
                    type uint32 {
                        range "1..4294967295";
                    }
                    description "local AS number";
                }

                leaf always_compare_med {
                    type boolean;
                    description "Allow comparing MED from different neighbors";
                }

                leaf load_balance_mp_relax {
                    type boolean;
                    description "Allow load sharing across routes that have different AS paths (but same length)";
                }

                leaf graceful_restart_enable {
                    type boolean;
                    description "Enable graceful restart";
                }

                leaf gr_preserve_fw_state {
                    type boolean;
                    description
                        "Set F-bit indication that FIB is preserved while doing Graceful Restart.";
                }

                leaf gr_restart_time {
                    type uint16 {
                        range "1..3600";
                    }
                    description "Set the time to wait to delete stale routes before a BGP open message is received";
                }

                leaf gr_stale_routes_time {
                    type uint16 {
                        range "1..3600";
                    }
                    description "Set the max time to hold onto restarting peer's stale paths";
                }

                leaf external_compare_router_id {
                    type boolean;
                    description "Compare router-id for identical EBGP paths";
                }

                leaf ignore_as_path_length {
                    type boolean;
                    description "Ignore as-path length in selecting a route";
                }

                leaf log_nbr_state_changes {
                    type boolean;
                    description "Log neighbor up/down and reset reason";
                }

                leaf rr_cluster_id {
                    type string;
                    description "Route-Reflector Cluster-id";
                }

                leaf rr_allow_out_policy {
                    type boolean;
                    description "Allow modifications made by out route-map";
                }

                leaf disable_ebgp_connected_rt_check {
                    type boolean;
                    description "Disable checking if nexthop is connected on ebgp sessions";
                }

                leaf fast_external_failover {
                    type boolean;
                    description "Immediately reset session if a link to a directly connected external peer goes down";
                }

                leaf network_import_check {
                    type boolean;
                    description "Check BGP network route exists in IGP";
                }

                leaf graceful_shutdown {
                    type boolean;
                    description "Enable graceful shutdown";
                }

                leaf rr_clnt_to_clnt_reflection {
                    type boolean;
                    description
                        "Enable client to client route reflection.";
                }

                leaf max_dynamic_neighbors {
                    type uint16 {
                        range 1..5000;
                    }
                    description
                        "Maximum number of BGP dynamic neighbors that can be created.";
                }

                leaf read_quanta {
                    type uint8 {
                        range 1..10;
                    }
                    description
                        "This indicates how many packets to read from peer socket per I/O cycle";
                }

                leaf write_quanta {
                    type uint8 {
                        range 1..10;
                    }
                    description
                        "This indicates how many packets to write to peer socket per run";
                }

                leaf coalesce_time {
                    type uint32;
                    description
                        "Subgroup coalesce timer value in milli-sec";
                }

                leaf route_map_process_delay {
                    type uint16 {
                        range 0..600;
                    }
                    description
                        "0 disables the timer, no route updates happen when route-maps change";
                }

                leaf deterministic_med {
                    type boolean;
                    description
                        "Pick the best-MED path among paths advertised from the neighboring AS.";
                }

                leaf med_confed {
                    type boolean;
                    description
                        "Compare MED among confederation paths when set to true.";
                }

                leaf med_missing_as_worst {
                    type boolean;
                    description
                        "Treat missing MED as the least preferred one when set to true.";
                }

                leaf compare_confed_as_path {
                    type boolean;
                    description
                        "Compare path lengths including confederation sets & sequences in selecting a route";
                }

                leaf as_path_mp_as_set {
                    type boolean;
                    description
                        "Generate an AS_SET.";
                }

                leaf default_ipv4_unicast {
                    type boolean;
                    description
                        "Activate ipv4-unicast for a peer by default";
                }

                leaf default_local_preference {
                    type uint32;
                    description
                        "Configure default local preference value.";
                }

                leaf default_show_hostname {
                    type boolean;
                    description
                        "Show hostname in BGP dumps.";
                }

                leaf default_shutdown {
                    type boolean;
                    description
                        "Apply administrative shutdown to newly configured peers.";
                }

                leaf default_subgroup_pkt_queue_max {
                    type uint8 {
                        range 20..100;
                    }
                    description
                        "Configure subgroup packet queue max.";
                }

                leaf max_med_time {
                    type uint32{
                        range 5..86400;
                    }
                    description
                        "Time (seconds) period for max-med";
                }

                leaf max_med_val {
                    type uint32;
                    description
                        "Max MED value to be used";
                }

                leaf max_med_admin {
                    type boolean;
                    description
                        "Enable Max MED admin status.";
                }

                leaf max_med_admin_val {
                    type uint32;
                    description
                        "Administrative Max MED value to be used";
                }


                leaf max_delay {
                    type uint16 {
                        range 0..3600;
                    }
                    description
                        "Maximum delay for best path calculation.";
                }

                leaf establish_wait {
                    type uint16 {
                        range 0..3600;
                    }
                    sonic-ext:custom-validation ValidateMaxDelayAndEstWait;
                    description
                        "Maximum delay for updates.";
                }

                leaf confed_id {
                    type uint32 {
                        range "1..4294967295";
                    }
                    description
                        "Set routing domain confederation AS.";
                }

                leaf-list confed_peers {
                    type uint32 {
                        range "1..4294967295";
                    }
                    description
                        "Peer ASs in BGP confederation";
                }

                leaf keepalive {
                    type uint16;
                    description "Keepalive interval";
                }

                leaf holdtime {
                    type uint16;
                    description "Hold time";
                }
            }
        }

        container BGP_GLOBALS_AF {
            list BGP_GLOBALS_AF_LIST {
                key "vrf_name afi_safi";

                leaf vrf_name {
                    type leafref {
                        path "../../../BGP_GLOBALS/BGP_GLOBALS_LIST/vrf_name";
                    }
                    description "Vrf name";
                }

                leaf afi_safi {
                    type string;
                    description "Address family name and subsequent address family name";
                }

                leaf max_ebgp_paths {
                    type uint16 {
                        range "1..256";
                    }
                    description "Maximum eBGP paths";
                    default 1;
                }

                leaf max_ibgp_paths {
                    type uint16 {
                        range "1..256";
                    }
                    description "Maximum iBGP paths";
                    default 1;
                }

                leaf import_vrf {
                    type union {
                        type string {
                            pattern "default";
                        }
                        type leafref {
                            path "../../../BGP_GLOBALS/BGP_GLOBALS_LIST/vrf_name";
                        }
                    }
                    must "current() != current()/../vrf_name" {
                        error-message "Import VRF should be different than self!";
                    }
                    description "Import routes from particular VRF";
                }

                leaf import_vrf_route_map {
                    type leafref {
                        path "/srmap:sonic-route-map/srmap:ROUTE_MAP_SET/srmap:ROUTE_MAP_SET_LIST/srmap:name";
                    }
                    description "Import routes from VRF with route filter";
                }

                leaf route_download_filter {
                    type leafref {
                        path "/srmap:sonic-route-map/srmap:ROUTE_MAP_SET/srmap:ROUTE_MAP_SET_LIST/srmap:name";
                    }
                    description "Route download filter";
                }

                leaf ebgp_route_distance {
                    type uint8 {
                        range "1..255";
                    }
                    description "Distance for routes external to the AS";
                }

                leaf ibgp_route_distance {
                    type uint8 {
                        range "1..255";
                    }
                    description "Distance for routes internal to the AS";
                }

                leaf local_route_distance {
                    type uint8 {
                        range "1..255";
                    }
                    description "Distance for local routes";
                }

                leaf ibgp_equal_cluster_length {
                    type boolean;
                    description
                        "Match the cluster length.";
                }

                leaf route_flap_dampen {
                    must "current()/../afi_safi = 'ipv4_unicast'" { error-message "Route flap dampening is supported only for IPv4 address family!"; }
                    type boolean;
                    description "Enable route-flap dampening";
                }

                leaf route_flap_dampen_half_life {
                    must "current()/../afi_safi = 'ipv4_unicast'" { error-message "Route flap dampening is supported only for IPv4 address family!"; }
                    type uint8 {
                        range "1..45";
                    }
                    description "Half-life time for the penalty";
                }

                leaf route_flap_dampen_reuse_threshold {
                    must "current()/../afi_safi = 'ipv4_unicast'" { error-message "Route flap dampening is supported only for IPv4 address family!"; }
                    type uint16 {
                        range "1..20000";
                    }
                    description "Value to start reusing a route";
                }

                leaf route_flap_dampen_suppress_threshold {
                    must "current()/../afi_safi = 'ipv4_unicast'" { error-message "Route flap dampening is supported only for IPv4 address family!"; }
                    type uint16 {
                        range "1..20000";
                    }
                    description "Value to start suppressing a route";
                }

                leaf route_flap_dampen_max_suppress {
                    must "current()/../afi_safi = 'ipv4_unicast'" { error-message "Route flap dampening is supported only for IPv4 address family!"; }
                    type uint8 {
                        range "1..255";
                    }
                    description "Maximum duration to suppress a stable route";
                }
            }
        }

        container BGP_GLOBALS_AF_AGGREGATE_ADDR {
            list BGP_GLOBALS_AF_AGGREGATE_ADDR_LIST {
                key "vrf_name afi_safi ip_prefix";

                leaf vrf_name {
                    type leafref {
                        path "../../../BGP_GLOBALS/BGP_GLOBALS_LIST/vrf_name";
                    }
                    description "VRF name";
                }

                leaf afi_safi {
                    type string;
                    description "Address family name and subsequent address family name";
                }

                leaf ip_prefix {
                    type inet:ip-prefix;
                    description "Aggregate address";
                }

                leaf as_set {
                    type boolean;
                    description "Generate AS set path information";
                }

                leaf summary_only {
                    type boolean;
                    description "Filter more specific routes from updates";
                }

                leaf policy {
                    type leafref {
                        path "/srmap:sonic-route-map/srmap:ROUTE_MAP_SET/srmap:ROUTE_MAP_SET_LIST/srmap:name";
                    }
                    description "Apply route map to aggregate network";
                }
            }
        }

        container BGP_GLOBALS_AF_NETWORK {
            list BGP_GLOBALS_AF_NETWORK_LIST {
                key "vrf_name afi_safi ip_prefix";

                leaf vrf_name {
                    type leafref {
                        path "../../../BGP_GLOBALS/BGP_GLOBALS_LIST/vrf_name";
                    }
                    description "VRF name";
                }

                leaf afi_safi {
                    type string;
                    description "Address family name and subsequent address family name";
                }

                leaf ip_prefix {
                    type inet:ip-prefix;
                    description "Network address";
                }

                leaf policy {
                    type leafref {
                        path "/srmap:sonic-route-map/srmap:ROUTE_MAP_SET/srmap:ROUTE_MAP_SET_LIST/srmap:name";
                    }
                    description "Route-map to modify the attributes";
                }

                leaf backdoor {
                    type boolean;
                    sonic-ext:custom-validation ValidateAfisafiForBackdoor;
                    description "Indicates the backdoor route";
                }
            }
        }
    }
}