// vi: set smarttab et sw=4 tabstop=4:
module odl-bgp-rib-impl-cfg {
    yang-version 1;
    namespace "urn:opendaylight:params:xml:ns:yang:controller:bgp:rib:impl";
    prefix "bgprib-impl";

    import bgp-multiprotocol { prefix bgp-mp; revision-date 2013-09-19; }
    import bgp-rib { prefix rib; revision-date 2013-09-25; }
    import bgp-types { prefix bgp-t; revision-date 2013-09-19; }
    import odl-bgp-rib-cfg { prefix bgprib; revision-date 2013-07-01; }
    import odl-bgp-parser-spi-cfg { prefix bgpspi; revision-date 2013-11-15; }
    import odl-bgp-rib-spi-cfg { prefix ribspi; revision-date 2013-11-15; }
    import ietf-inet-types { prefix inet; revision-date 2010-09-24; }
    import opendaylight-md-sal-binding {prefix mdsb; revision-date 2013-10-28; }
    import opendaylight-md-sal-dom {prefix sal; revision-date 2013-10-28; }
    import netty { prefix netty; revision-date 2013-11-19; }
    import config { prefix config; revision-date 2013-04-05; }
    import odl-tcpmd5-cfg { prefix tcpmd5; revision-date 2014-04-27; }
    import odl-tcpmd5-netty-cfg { prefix tcpmd5n; revision-date 2014-04-27; }
    import rpc-context { prefix rpcx; revision-date 2013-06-17; }
    import odl-bgp-openconfig-spi-cfg { prefix bgp-oc-spi; revision-date 2015-09-25; }
    import odl-bgp-path-selection-mode { prefix bps; revision-date 2016-03-01;}

    organization "Cisco Systems, Inc.";

    contact "Robert Varga <rovarga@cisco.com>";

    description
        "This module contains the base YANG definitions for
         BGP listener implementation.

        Copyright (c)2013 Cisco Systems, Inc. All rights reserved.;

        This program and the accompanying materials are made available
        under the terms of the Eclipse Public License v1.0 which
        accompanies this distribution, and is available at
        http://www.eclipse.org/legal/epl-v10.html";

    revision "2016-03-30" {
        description
            "Updated to simplify reconnection strategy.";
    }
    revision "2013-04-09" {
        description
            "Initial revision";
    }

    identity base-bgp-parser {
        base config:module-type;
        config:java-name-prefix BaseBGPParser;
        config:provided-service bgpspi:extension;
    }

    augment "/config:modules/config:module/config:configuration" {
        case base-bgp-parser {
            when "/config:modules/config:module/config:type = 'base-bgp-parser'";
        }
    }

    identity bgp-dispatcher {
        description
            "Service representing a BGP Dispatcher.";

        base "config:service-type";
        config:java-class "org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher";
    }

    identity bgp-dispatcher-impl {
        base config:module-type;
        config:provided-service bgp-dispatcher;
        config:java-name-prefix BGPDispatcherImpl;
    }

    augment "/config:modules/config:module/config:configuration" {
        case bgp-dispatcher-impl {
            when "/config:modules/config:module/config:type = 'bgp-dispatcher-impl'";

            container bgp-extensions {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgpspi:consumer-extensions;
                    }
                }
            }

            container boss-group {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity netty:netty-threadgroup;
                    }
                }
            }

            container worker-group {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity netty:netty-threadgroup;
                    }
                }
            }

            container md5-channel-factory {
                uses config:service-ref {
                    refine type {
                        mandatory false;
                        config:required-identity tcpmd5n:md5-channel-factory;
                    }
                }
            }

            container md5-server-channel-factory {
                uses config:service-ref {
                    refine type {
                        mandatory false;
                        config:required-identity tcpmd5n:md5-server-channel-factory;
                    }
                }
            }
        }
    }

    identity base-bgp-rib {
        base config:module-type;
        config:provided-service ribspi:extension;
        config:java-name-prefix BaseBGPRIB;
    }

    augment "/config:modules/config:module/config:configuration" {
        case base-bgp-rib {
            when "/config:modules/config:module/config:type = 'base-bgp-rib'";
        }
    }

    identity rib-instance {
        description
            "Service representing a RIB instance";

        base "config:service-type";
        config:java-class "org.opendaylight.protocol.bgp.rib.impl.spi.RIB";
    }

    identity bgp-peer-registry {
        description
            "Registry of BGP peers. Every new BGP in/out connection looks for peers to handle bgp messages in this registry";

        base "config:service-type";
        config:java-class "org.opendaylight.protocol.bgp.rib.impl.spi.BGPPeerRegistry";
    }

    identity strict-bgp-peer-registry {
        description
            "Registry of BGP peers that allows only one connection per 2 peers. Uses IP address for Peer identification and BGP Ids to resolve duplicate connections";

        config:provided-service bgp-peer-registry;
        base config:module-type;
        config:java-name-prefix StrictBgpPeerRegistry;
    }


    augment "/config:modules/config:module/config:configuration" {
        case strict-bgp-peer-registry {
            when "/config:modules/config:module/config:type = 'strict-bgp-peer-registry'";
        }
    }

    identity bgp-peer {
        description
            "BGP peer instance.";

        base config:module-type;
        config:java-name-prefix BGPPeer;
    }

    identity bgp-peer-acceptor {
        description
            "BGP peer acceptor that handles incoming bgp connections. Uses BGP peer registry to accept or decline incoming connections";

        base config:module-type;
        config:java-name-prefix BGPPeerAcceptor;
    }

    augment "/config:modules/config:module/config:configuration" {
        case bgp-peer-acceptor {
            when "/config:modules/config:module/config:type = 'bgp-peer-acceptor'";

            leaf binding-address {
                description "IP address to bind to";
                type inet:ip-address;
                default "0.0.0.0";
            }

            leaf binding-port {
                description "Port to bind to";
                type inet:port-number;
                default "179";
            }

            container accepting-bgp-dispatcher {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-dispatcher;
                    }
                }
            }

            container accepting-peer-registry {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-peer-registry;
                    }
                }
            }
        }
    }

    identity bgp-application-peer {
        description
            "Application peer handler which handles translation from custom RIB into local RIB";

        base config:module-type;
        config:java-name-prefix BGPApplicationPeer;
    }

    augment "/config:modules/config:module/config:configuration" {
        case bgp-application-peer {
            when "/config:modules/config:module/config:type = 'bgp-application-peer'";

            container data-broker {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity sal:dom-async-data-broker;
                    }
                }
            }

            container target-rib {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity rib-instance;
                    }
                }
            }

            container peer-registry {
                description "BGP peer registry where current instance of BGP peer will be registered.";
                uses config:service-ref {
                    refine type {
                        // FIXME backwards compatibility. If not configured, GLOBAL instance is used
                        mandatory false;
                        config:required-identity bgp-peer-registry;
                    }
                }
            }

            leaf application-rib-id {
                type rib:application-rib-id;
                mandatory true;
            }

            leaf bgp-peer-id {
                type inet:ipv4-address;
                mandatory true;
            }
        }
    }

    identity bgp-table-type {
        description
            "Service representing a AFI/SAFI pair";

        base "config:service-type";
        config:java-class "org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType";
    }

    identity add-path {
        base "config:service-type";
        config:java-class "org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.mp.capabilities.add.path.capability.AddressFamilies";
    }

    identity add-path-impl {
        config:provided-service add-path;
        base config:module-type;
        config:java-name-prefix AddPathImpl;
    }

    identity bgp-table-type-impl {
        description
            "Simple provider for bgp-table-type.";

        config:provided-service bgp-table-type;
        base config:module-type;
        config:java-name-prefix BGPTableTypeImpl;
    }

    augment "/config:modules/config:module/config:configuration" {
        case bgp-table-type-impl {
            when "/config:modules/config:module/config:type = 'bgp-table-type-impl'";

            leaf afi {
                type identityref {
                    base bgp-t:address-family;
                }
                mandatory true;
            }
            leaf safi {
                type identityref {
                    base bgp-t:subsequent-address-family;
                }
                mandatory true;
            }
        }
    }

    augment "/config:modules/config:module/config:configuration" {
        case add-path-impl {
            when "/config:modules/config:module/config:type = 'add-path-impl'";
            container address-family {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-table-type;
                    }
                }
            }
            leaf send-receive {
                type bgp-mp:send-receive;
                mandatory true;
            }
        }
    }

    augment "/config:modules/config:module/config:configuration" {
        case bgp-peer {
            when "/config:modules/config:module/config:type = 'bgp-peer'";

            leaf host {
                description "Remote host IP address";
                type inet:ip-address;
                mandatory true;
            }

            leaf port {
                description "Remote host port";
                type inet:port-number;
                default 179;
            }

            leaf holdtimer {
                type int16;
                default 180;
            }

            leaf retrytimer {
                type int16;
                default 10;
            }

            leaf peer-role {
                type rib:peer-role;
                default ibgp;
            }

            leaf initiate-connection {
                description "If true, connection will be initiated right away from current device.
                    If not, the peer will only be registered to peer registry and available for incomming bgp connections.";
                type boolean;
                default true;
            }

            list advertized-table {
                key "type name";
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-table-type;
                    }
                }
            }

            list add-path {
                key "type name";
                uses config:service-ref {
                    refine type {
                        config:required-identity add-path;
                    }
                }
            }

            leaf route-refresh {
                type boolean;
                default "true";
            }

            leaf remote-as {
                description
                    "Expected remote AS number. If not present, it is assumed
                    to be the same as our local AS number.";
                type uint32;
            }

            leaf password {
                type tcpmd5:rfc2385-key;
                description "RFC2385 shared secret";
            }

            container rib {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity rib-instance;
                    }
                }
            }

            container peer-registry {
                description "BGP peer registry where current instance of BGP peer will be registered.";
                uses config:service-ref {
                    refine type {
                        // FIXME backwards compatibility. If not configured, GLOBAL instance is used
                        mandatory false;
                        config:required-identity bgp-peer-registry;
                    }
                }
            }
        }
    }

    grouping message-state {
        leaf count {
            description "Total number of BGP messages.";
            type uint32;
            default 0;
        }

        leaf timestamp {
            description "The BGP message timestamp (seconds).";
            type uint32;
            default 0;
        }
    }

    grouping message-stats {
        container received {
            description "The received BGP messages statistics.";
            uses message-state;
        }

        container sent {
            description "The sent BGP messages statistics.";
            uses message-state;
        }
    }

    grouping error {
        leaf code {
            description "The BGP error code.";
            type uint8;
            default 0;
        }

        leaf sub-code {
            description "The BGP error sub-code.";
            type uint8;
            default 0;
        }
    }

    grouping afi-safi {
        leaf afi {
            description "Address Family Identifier.";
            type string;
            default "";
        }
        leaf safi {
            description "Subsequent Address Family Identifier.";
            type string;
            default "";
        }
    }

    grouping preferences {
        leaf bgp-id {
            description "The BGP Identifier.";
            type string;
            default "";
        }

        leaf address {
            description "The IP address of BGP connection.";
            type string;
            default "";
        }

        leaf port {
            description "The port for connection between the BGP peers.";
            type uint16;
            default 0;
        }

        leaf as {
            description "Autonomous system number.";
            type uint32;
            default 0;
        }

        leaf holdtime {
            description "Time interval (in seconds) for HoldTimer proposed by the peer.";
            type uint16;
            default 0;
        }

        leaf four-octet-as-capability {
            description "The BGP peer 4 byte AS numbers support capability.";
            type boolean;
            default "false";
        }

        leaf bgp-extended-message-capability {
            description "The bgp extended message support capability.";
            type boolean;
            default "false";
        }

        leaf gr-capability {
            description "BGP graceful restart support capability.";
            type boolean;
            default "false";
        }

        leaf add-path-capability {
            type boolean;
            default "false";
        }

        leaf route-refresh-capability {
            reference "https://tools.ietf.org/html/rfc2918";
            type boolean;
            default "false";
        }

        list advertized-table-types {
            description "The BGP Table-type capabilities advertized by the BGP peer.";
            uses afi-safi;
        }

        list advertised-add-path-table-types {
            description "The BGP Table-type capabilities advertized by the BGP peer.";
            uses afi-safi;
            leaf send-receive {
                description "Send Receive Add Path Configuration.";
                type string;
                default "";
            }
        }
    }

    identity peer-rpc;

    augment "/config:modules/config:module/config:state" {
        case bgp-peer {
            when "/config:modules/config:module/config:type = 'bgp-peer'";

            rpcx:rpc-context-instance "peer-rpc";

            container bgp-peer-state {
                list route-table {

                    leaf table-type {
                        description "The table name - composed of AFI and SAFI.";
                        type string;
                    }

                    leaf routes-count {
                        description "The total number of routes in table.";
                        type uint32;
                        default 0;
                    }
                }

                leaf session-established-count {
                    description "The total number of time the BGP session was transitioned to Up state.";
                    type uint32;
                    default 0;
                }
            }

            container bgp-session-state {

                leaf session-state {
                    description "The BGP peer connection state.";
                    type string;
                }

                leaf session-duration {
                    description "The session duration (time formated d:HH:mm:ss).";
                    type string;
                }

                leaf holdtime-current {
                    description "Time interval (in seconds) for HoldTimer established with the peer.";
                    type uint16;
                    default 0;
                }

                leaf keepalive-current {
                    description "Time interval (in seconds) for KeepAlive established with the peer.";
                    type uint16;
                    default 0;
                }

                container speaker-preferences {
                    description "The BGP speaker preferences, to which this BGP peer is connected.";
                    uses preferences;
                }

                container peer-preferences {
                    description "The BGP peer preferences.";
                    uses preferences;
                }

                container messages-stats {
                    description "The BGP messages statistics.";
                    container total-msgs {
                        description "The statistics for all received/sent BGP messages.";
                        uses message-stats;
                    }

                    container keep-alive-msgs {
                        description "The statistics for received/sent BGP Keep-Alive messages.";
                        uses message-stats;
                    }

                    container update-msgs {
                        description "The statistics for received/sent BGP Update messages.";
                        uses message-stats;
                    }

                    container route-refresh-msgs {
                        description "The statistics for received/sent BGP Route Refresh messages.";
                        uses message-stats;
                    }

                    container error-msgs {
                        container error-received {
                            description "The received BGP Error (notification) messages statistics.";
                            uses message-state;
                            uses error;
                        }

                        container error-sent {
                            description "The sent BGP Error (notification) messages statistics.";
                            uses message-state;
                            uses error;
                        }
                    }
                }
            }
        }
    }

    rpc reset-session {
        description "Restart the session between BGP peers";
        input {
            uses rpcx:rpc-context-ref {
                refine context-instance {
                    rpcx:rpc-context-instance peer-rpc;
                }
            }
        }
     }

     rpc reset-stats {
        description "Reset the BGP peer statistics.";
        input {
            uses rpcx:rpc-context-ref {
                refine context-instance {
                    rpcx:rpc-context-instance peer-rpc;
                }
            }
        }
     }

    identity bgp-path-selection-mode {
        description
            "Service representing an address family + path selection mode.";

        base "config:service-type";
        config:java-class "org.opendaylight.protocol.bgp.rib.impl.spi.BGPBestPathSelection";
    }

    identity bgp-psm-impl {
        base config:module-type;
        config:provided-service bgp-path-selection-mode;
        config:java-name-prefix BGPPSMImpl;
    }

    augment "/config:modules/config:module/config:configuration" {
        case bgp-psm-impl {
            when "/config:modules/config:module/config:type = 'bgp-psm-impl'";
            container path-address-family {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-table-type;
                    }
                }
            }
            container path-selection-mode {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bps:path-selection-mode-factory;
                    }
                }
            }
        }
    }

    identity rib-impl {
        base config:module-type;
        config:provided-service bgprib:rib;
        config:provided-service rib-instance;
        config:java-name-prefix RIBImpl;
    }

    augment "/config:modules/config:module/config:configuration" {
        case rib-impl {
            when "/config:modules/config:module/config:type = 'rib-impl'";

            container extensions {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity ribspi:consumer-extensions;
                    }
                }
            }

            container bgp-dispatcher {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-dispatcher;
                    }
                }
            }

            container data-provider {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity mdsb:binding-async-data-broker;
                    }
                }
            }

            container codec-tree-factory {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity mdsb:binding-codec-tree-factory;
                    }
                }
            }

            container dom-data-provider {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity sal:dom-async-data-broker;
                    }
                }
            }

            container openconfig-provider {
                uses config:service-ref {
                    refine type {
                        mandatory false;
                        config:required-identity bgp-oc-spi:bgp-openconfig-provider;
                    }
                }
            }

            leaf local-as {
                description "Our local AS number. Needed by best selection path attribute.";
                type uint32;
                mandatory true;
            }

            leaf bgp-rib-id {
                description "Our local BGP identifier. Needed by best selection path attribute.";
                mandatory true;
                type inet:ipv4-address;
            }

            list local-table {
                uses config:service-ref {
                    refine type {
                        mandatory true;
                        config:required-identity bgp-table-type;
                    }
                }
            }

            leaf rib-id {
                description "Identifier of this RIB in local data store.";
                type rib:rib-id;
                mandatory true;
            }

            leaf cluster-id {
                description "IBGP identifier. Needed by route reflection.";
                reference "https://tools.ietf.org/html/rfc4456#section-7";
                type inet:ipv4-address;
            }

            list path-selection-mode {
                uses config:service-ref {
                    refine type {
                        config:required-identity bgp-path-selection-mode;
                    }
                }
            }
        }
    }
}