module org-openroadm-routing {
  namespace "http://org/openroadm/routing";
  prefix org-openroadm-routing;

  import ietf-yang-types {
    prefix yang;
    revision-date 2013-07-15;
  }
  import org-openroadm-device {
    prefix org-openroadm-device;
    revision-date 2020-05-29;
  }

  organization
    "Open ROADM MSA";
  contact
    "OpenROADM.org";
  description
    "This model defines Yang model for routing.

     This model reuses data items defined in the IETF YANG model for
     interfaces described by RFC 8022.

     Some attributes which are not required in Open ROADM MSA are removed.
     Yang file included are changed to fit into Open ROADM MSA yang structure.

     IETF code is subject to the following copyright and license:
     Copyright (c) IETF Trust and the persons identified as authors of
     the code.
     All rights reserved.

     Redistribution and use in source and binary forms, with or without
     modification, is permitted pursuant to, and subject to the license
     terms contained in, the Simplified BSD License set forth in
     Section 4.c of the IETF Trust's Legal Provisions Relating
     to IETF Documents (http://trustee.ietf.org/license-info).";

  revision 2020-05-29 {
    description
      "Version 7.1.0";
  }
  revision 2020-03-27 {
    description
      "Version 7.0.0";
  }
  revision 2019-11-29 {
    description
      "Version 6.1.0";
  }
  revision 2019-09-27 {
    description
      "Version 6.0.0";
  }
  revision 2019-05-31 {
    description
      "Version 5.1.0";
  }
  revision 2019-03-29 {
    description
      "Version 5.0.0";
  }
  revision 2015-05-25 {
    description
      "Initial revision.";
    reference
      "RFC XXXX: A YANG Data Model for Routing Management";
  }

  feature multiple-ribs {
    description
      "This feature indicates that the server supports user-defined
       RIBs.

       Servers that do not advertise this feature SHOULD provide
       exactly one system-controlled RIB per routing-instance and
       supported address family and make them also the default RIBs.
       These RIBs then appear as entries of the list
       /routing-state/routing-instance/ribs/rib.";
  }

  feature router-id {
    description
      "This feature indicates that the server supports configuration
       of an explicit 32-bit router ID that is used by some routing
       protocols.

       Servers that do not advertise this feature set a router ID
       algorithmically, usually to one of configured IPv4 addresses.
       However, this algorithm is implementation-specific.";
  }

  identity address-family {
    description
      "Base identity from which identities describing address
       families are derived.";
  }

  identity ipv4 {
    base address-family;
    description
      "This identity represents IPv4 address family.";
  }

  identity ipv6 {
    base address-family;
    description
      "This identity represents IPv6 address family.";
  }

  identity routing-instance {
    description
      "Base identity from which identities describing routing
       instance types are derived.";
  }

  identity default-routing-instance {
    base routing-instance;
    description
      "This identity represents either a default routing instance, or
       the only routing instance on systems that do not support
       multiple instances.";
  }

  identity vrf-routing-instance {
    base routing-instance;
    description
      "This identity represents a VRF routing instance. The type is
       distinct from the default-routing-instance. There may be
       multiple vrf-routing-interfaces.";
  }

  identity routing-protocol {
    description
      "Base identity from which routing protocol identities are
       derived.";
  }

  identity direct {
    base routing-protocol;
    description
      "Routing pseudo-protocol that provides routes to directly
       connected networks.";
  }

  identity static {
    base routing-protocol;
    description
      "Static routing pseudo-protocol.";
  }

  typedef routing-instance-ref {
    type leafref {
      path "/org-openroadm-device:org-openroadm-device/org-openroadm-routing:routing/org-openroadm-routing:routing-instance/org-openroadm-routing:name";
    }
    description
      "This type is used for leafs that reference a routing instance
       configuration.";
  }

  typedef routing-instance-state-ref {
    type leafref {
      path "/org-openroadm-device:org-openroadm-device/org-openroadm-routing:routing-state/org-openroadm-routing:routing-instance/org-openroadm-routing:name";
    }
    description
      "This type is used for leafs that reference state data of a
       routing instance.";
  }

  typedef route-preference {
    type uint32;
    description
      "This type is used for route preferences.";
  }

  grouping address-family-group {
    description
      "This grouping provides a leaf identifying an address
       family.";
    leaf address-family {
      type identityref {
        base address-family;
      }
      mandatory true;
      description
        "Address family.";
    }
  }

  grouping router-id {
    description
      "This grouping provides router ID.";
    leaf router-id {
      type yang:dotted-quad;
      description
        "A 32-bit number in the form of a dotted quad that is used by
         some routing protocols identifying a router.";
      reference
        "RFC 2328: OSPF Version 2.";
    }
  }

  grouping special-next-hop-group {
    description
      "This grouping provides a leaf with an enumeration of special
       next-hops.";
    leaf special-next-hop {
      type enumeration {
        enum blackhole {
          description
            "Silently discard the packet.";
        }
        enum unreachable {
          description
            "Discard the packet and notify the sender with an error
             message indicating that the destination host is
             unreachable.";
        }
        enum prohibit {
          description
            "Discard the packet and notify the sender with an error
             message indicating that the communication is
             administratively prohibited.";
        }
        enum receive {
          description
            "The packet will be received by the local system.";
        }
      }
      description
        "Special next-hop options.";
    }
  }

  grouping next-hop-content {
    description
      "Generic parameters of next-hops in static routes.";
    choice next-hop-options {
      mandatory true;
      description
        "Options for next-hops in static routes.

         It is expected that other cases will be added through
         augments from other modules, e.g., for Equal-Cost Multipath
         routing (ECMP).";
      case simple-next-hop {
        description
          "Simple next-hop is specified as an outgoing interface,
           next-hop address or both.

           Address-family-specific modules are expected to provide
           'next-hop-address' leaf via augmentation.";
        leaf outgoing-interface {
          type leafref {
            path "/org-openroadm-device:org-openroadm-device/org-openroadm-routing:routing/org-openroadm-routing:routing-instance/org-openroadm-routing:interfaces/org-openroadm-routing:interface";
          }
          description
            "Name of the outgoing interface.";
        }
      }
      case special-next-hop {
        uses special-next-hop-group;
      }
    }
  }

  grouping route-metadata {
    description
      "Common route metadata.";
    leaf source-protocol {
      type identityref {
        base routing-protocol;
      }
      mandatory true;
      description
        "Type of the routing protocol from which the route
         originated.";
    }
    leaf active {
      type empty;
      description
        "Presence of this leaf indicates that the route is preferred
         among all routes in the same RIB that have the same
         destination prefix.";
    }
    leaf last-updated {
      type yang:date-and-time;
      description
        "Time stamp of the last modification of the route. If the
         route was never modified, it is the time when the route was
         inserted into the RIB.";
    }
  }

  grouping routing-grp {
    container routing {
      description
        "Configuration parameters for the routing subsystem.";
      list routing-instance {
        key "name";
        description
          "Configuration of a routing instance.";
        leaf name {
          type string;
          description
            "The name of the routing instance.

             For system-controlled entries, the value of this leaf must
             be the same as the name of the corresponding entry in
             state data.

             For user-controlled entries, an arbitrary name can be
             used.";
        }
        leaf type {
          type identityref {
            base routing-instance;
          }
          default "org-openroadm-routing:default-routing-instance";
          description
            "The type of the routing instance.";
        }
        leaf enabled {
          type boolean;
          default "true";
          description
            "Enable/disable the routing instance.

             If this parameter is false, the parent routing instance is
             disabled and does not appear in state data, despite any
             other configuration that might be present.";
        }
        uses router-id {
          if-feature "router-id";
          description
            "Configuration of the global router ID. Routing protocols
             that use router ID can use this parameter or override it
             with another value.";
        }
        leaf description {
          type string;
          description
            "Textual description of the routing instance.";
        }
        container interfaces {
          description
            "Assignment of the routing instance's interfaces.";
          leaf-list interface {
            type org-openroadm-device:interface-ref;
            description
              "The name of a configured network layer interface to be
               assigned to the routing-instance.";
          }
        }
        container routing-protocols {
          description
            "Configuration of routing protocol instances.";
          list routing-protocol {
            key "type name";
            description
              "Each entry contains configuration of a routing protocol
               instance.";
            leaf type {
              type identityref {
                base routing-protocol;
              }
              description
                "Type of the routing protocol - an identity derived
                 from the 'routing-protocol' base identity.";
            }
            leaf name {
              type string;
              description
                "An arbitrary name of the routing protocol instance.";
            }
            leaf description {
              type string;
              description
                "Textual description of the routing protocol
                 instance.";
            }
            container static-routes {
              when "../type='org-openroadm-routing:static'" {
                description
                  "This container is only valid for the 'static'
                   routing protocol.";
              }
              description
                "Configuration of the 'static' pseudo-protocol.

                 Address-family-specific modules augment this node with
                 their lists of routes.";
            }
          }
        }
        container ribs {
          description
            "Configuration of RIBs.";
          list rib {
            key "name";
            description
              "Each entry contains configuration for a RIB identified
               by the 'name' key.

               Entries having the same key as a system-controlled entry
               of the list /routing-state/routing-instance/ribs/rib are
               used for configuring parameters of that entry. Other
               entries define additional user-controlled RIBs.";
            leaf name {
              type string;
              description
                "The name of the RIB.

                 For system-controlled entries, the value of this leaf
                 must be the same as the name of the corresponding
                 entry in state data.

                 For user-controlled entries, an arbitrary name can be
                 used.";
            }
            uses address-family-group {
              description
                "Address family of the RIB.

                 It is mandatory for user-controlled RIBs. For
                 system-controlled RIBs it can be omitted, otherwise it
                 must match the address family of the corresponding
                 state entry.";
              refine "address-family" {
                mandatory false;
              }
            }
            leaf description {
              type string;
              description
                "Textual description of the RIB.";
            }
          }
        }
      }
    }
  }

  augment "/org-openroadm-device:org-openroadm-device" {
    uses routing-grp;
  }

  grouping routing-state-grp {
    container routing-state {
      config false;
      description
        "State data of the routing subsystem.";
      list routing-instance {
        key "name";
        description
          "Each list entry is a container for state data of a routing
           instance.

           An implementation MUST support routing instance(s) of the
           type 'rt:default-routing-instance', and MAY support other
           types. An implementation MAY restrict the number of routing
           instances of each supported type.

           An implementation SHOULD create at least one
           system-controlled instance, and MAY allow the clients to
           create user-controlled routing instances in
           configuration.";
        leaf name {
          type string;
          description
            "The name of the routing instance.

             For system-controlled instances the name is persistent,
             i.e., it SHOULD NOT change across reboots.";
        }
        leaf type {
          type identityref {
            base routing-instance;
          }
          description
            "The routing instance type.";
        }
        uses router-id {
          description
            "Global router ID.

             It may be either configured or assigned algorithmically by
             the implementation.";
        }
        container routing-protocols {
          description
            "Container for the list of routing protocol instances.";
          list routing-protocol {
            key "type name";
            description
              "State data of a routing protocol instance.

               An implementation MUST provide exactly one
               system-controlled instance of the type 'direct'. Other
               instances MAY be created by configuration.";
            leaf type {
              type identityref {
                base routing-protocol;
              }
              description
                "Type of the routing protocol.";
            }
            leaf name {
              type string;
              description
                "The name of the routing protocol instance.

                 For system-controlled instances this name is
                 persistent, i.e., it SHOULD NOT change across
                 reboots.";
            }
          }
        }
        container ribs {
          description
            "Container for RIBs.";
          list rib {
            key "name";
            min-elements 1;
            description
              "Each entry represents a RIB identified by the 'name'
               key. All routes in a RIB MUST belong to the same address
               family.

               For each routing instance, an implementation SHOULD
               provide one system-controlled default RIB for each
               supported address family.";
            leaf name {
              type string;
              description
                "The name of the RIB.";
            }
            uses address-family-group;
            leaf default-rib {
              if-feature "multiple-ribs";
              type boolean;
              default "true";
              description
                "This flag has the value of 'true' if and only if the
                 RIB is the default RIB for the given address family.

                 A default RIB always receives direct routes. By
                 default it also receives routes from all routing
                 protocols.";
            }
            container routes {
              description
                "Current content of the RIB.";
            }
          }
        }
      }
    }
  }

  augment "/org-openroadm-device:org-openroadm-device" {
    uses routing-state-grp;
  }
}