module gnpy-path-computation-simplified {
  yang-version 1;
  namespace "gnpy:path";
  prefix gnpypc;

  import ietf-inet-types {
    prefix inet;
  }

  organization
    "Telecom Infra Project OOPT PSE Working Group";
  contact
    "WG Web:   <https://github.com/Telecominfraproject/oopt-gnpy>
     contact:  <mailto:ahmed.triki@orange.com>
     contact:  <mailto:esther.lerouzic@orange.com>
    ";
  description
    "YANG model for gnpy path computation simplified for transportPCE";

  revision 2020-09-09 {
    description
      "remove key from route-object-include-exclude";
  }
  revision 2020-02-02 {
    description
      "second draft with detailed blocking reasons";
    reference
      "YANG model for path computation with gnpy inputs";
  }

  identity SNR-bandwidth {
    base path-metric-type;
    description
      "A metric that records SNR in signal bandwidth";
  }

  identity OSNR-bandwidth {
    base path-metric-type;
    description
      "A metric that records OSNR in signal bandwidth";
  }

  identity SNR-0.1nm {
    base path-metric-type;
    description
      "A metric that records SNR in 0.1nm";
  }

  identity OSNR-0.1nm {
    base path-metric-type;
    description
      "A metric that records OSNR in 0.1nm";
  }

  identity reference_power {
    base path-metric-type;
    description
      "to be revised";
  }

  identity path_bandwidth {
    base path-metric-type;
    description
      "to be revised";
  }

  identity path-metric-type {
    description
      "Base identity for path metric type";
  }

  identity route-usage-type {
    description
      "Base identity for route usage";
  }

  identity route-include-ero {
    base route-usage-type;
    description
      "Include ERO from route";
  }

  identity route-exclude-ero {
    base route-usage-type;
    description
      "Exclude ERO from route";
  }

  identity route-exclude-srlg {
    base route-usage-type;
    description
      "Exclude SRLG from route";
  }

  typedef te-hop-type {
    type enumeration {
      enum LOOSE {
        description
          "loose hop in an explicit path";
      }
      enum STRICT {
        description
          "strict hop in an explicit path";
      }
    }
    description
      "enumerated type for specifying loose or strict
       paths";
    reference
      "RFC3209: section-4.3.2";
  }

  typedef te-path-disjointness {
    type bits {
      bit node {
        position 0;
        description
          "Node disjoint.";
      }
      bit link {
        position 1;
        description
          "Link disjoint.";
      }
      bit srlg {
        position 2;
        description
          "SRLG (Shared Risk Link Group) disjoint.";
      }
    }
    description
      "Type of the resource disjointness for a TE tunnel path.";
    reference
      "RFC4872: RSVP-TE Extensions in Support of End-to-End
       Generalized Multi-Protocol Label Switching (GMPLS)
       Recovery";
  } // te-path-disjointness

  typedef te-node-id {
    type inet:ip-address;
    description
      "An identifier for a node in a topology.
       The identifier is represented as 32-bit unsigned integer in
       the dotted-quad notation.
       This attribute is mapped to Router ID in
       RFC3630, RFC5329, RFC5305, and RFC6119.";
  }

  typedef te-tp-id {
    type union {
      type uint32; // Unnumbered
      type inet:ip-address; // IPv4 or IPv6 address
    }
    description
      "An identifier for a TE link endpoint on a node.
       This attribute is mapped to local or remote link identifier in
       RFC3630 and RFC5305.";
  }

  typedef accumulated-metric-type {
    type union {
      type uint64;
      type decimal64 {
        fraction-digits 2;
      }
    }
    description
      "type useable for accumulative-value";
  }

  grouping effective-freq-slot {
    /* content copied from ietf-flexi-grid-media-channel, because only M and N are needed
       from the initial grouping.
     */
    description
      "The effective frequency slot is an attribute
       of a media channel and, being a frequency slot, it is
       described by its nominal central frequency and slot
       width";
    reference
      "rfc7698";
    leaf N {
      type int32;
      description
        "Is used to determine the Nominal Central
         Frequency. The set of nominal central frequencies
         can be built using the following expression:
           f = 193.1 THz + n x 0.00625 THz,
         where 193.1 THz is ITU-T ''anchor frequency'' for
         transmission over the C band, n is a positive or
         negative integer including 0.";
      reference
        "rfc7698";
    }
    leaf M {
      type int32;
      description
        "Is used to determine the slot width. A slot width
         is constrained to be M x SWG (that is, M x 12.5 GHz),
         where M is an integer greater than or equal to 1.";
      reference
        "rfc7698";
    }
  }

  grouping gnpy-specific-parameters {
    description
      "This grouping defines the gnpy specific parameters for requests.";
    leaf technology {
      type string;
      default "flexi-grid";
      description
        "Data plane technology type.";
    }
    leaf trx_type {
      type string;
      mandatory true;
      description
        "name of the transponder type (to be read from equipment library";
    }
    leaf trx_mode {
      type string;
      description
        "name of the transponder mode (to be read from equipment library";
    }
    list effective-freq-slot {
      key "N";
      uses effective-freq-slot;
    }
    leaf spacing {
      type decimal64 {
        fraction-digits 1;
      }
      units "Hz";
      mandatory true;
      description
        "It is the spacing between channels assuming full load with
         same channels as the requested one. multiple of 12.5 GHz";
    }
    leaf max-nb-of-channel {
      type uint32;
      description
        "Nb of channel to take into account for the full load case.\n";
    }
    leaf output-power {
      type decimal64 {
        fraction-digits 5;
      }
      units "W";
      description
        "optical power setting to be used for the propagation";
    }
    leaf path_bandwidth {
      type decimal64 {
        fraction-digits 5;
      }
      units "bit/s";
      mandatory true;
      description
        "Capacity required";
    }
  }

  grouping transponder {
    leaf transponder-type {
      type string;
      description
        "transponder type.";
    }
    leaf transponder-mode {
      type string;
      description
        "transponder mode.";
    }
  }

  grouping hop-attribute {
    description
      "This grouping defines the hop attribute parameters for request or response";
    choice hop-type {
      case tsp {
        container transponder {
          uses transponder;
        }
      }
      case regen {
        container regenerator {
          leaf regenerator-id {
            type string;
          }
          uses transponder;
        }
      }
      case pow {
        container optical-power {
          leaf optical-power {
            type decimal64 {
              fraction-digits 5;
            }
            units "W";
            description
              "hop output (input??) power";
          }
        }
      }
    }
  }

  grouping path-route-objects {
    description
      "List of EROs to be included or excluded when performing
       the path computation.";
    container explicit-route-objects {
      description
        "Container for the route object list";
      list route-object-include-exclude {
        description
          "List of explicit route objects to include or
           exclude in path computation";
        leaf explicit-route-usage {
          type identityref {
            base route-usage-type;
          }
          description
            "Explicit-route usage.";
        }
        uses explicit-route-hop;
      }
    }
  }

  grouping generic-path-disjointness {
    description
      "Path disjointness grouping";
    leaf disjointness {
      type te-path-disjointness;
      description
        "The type of resource disjointness.
         Under primary path, disjointness level applies to
         all secondary LSPs. Under secondary, disjointness
         level overrides the one under primary";
    }
  }

  grouping common-path-constraints-attributes {
    description
      "Common path constraints configuration grouping";
    uses common-constraints_config;
  }

  grouping generic-path-constraints {
    description
      "Global named path constraints configuration
       grouping";
    container path-constraints {
      description
        "TE named path constraints container";
      uses common-path-constraints-attributes;
    }
  }

  grouping explicit-route-hop {
    description
      "The explicit route subobject grouping";
    leaf index {
      type uint32;
      description
        "ERO subobject index";
    }
    choice type {
      description
        "The explicit route subobject type";
      case num-unnum-hop {
        container num-unnum-hop {
          description
            "Numbered and Unnumbered link/node explicit route
             subobject";
          leaf node-id {
            //type te-node-id;
            type string;
            description
              "The identifier of a node in the TE topology.";
          }
          leaf link-tp-id {
            //type te-tp-id;
            type string;
            description
              "TE link termination point identifier. The combination
               of TE link ID and the TE node ID is used to identify an
               unnumbered TE link.";
          }
          leaf hop-type {
            type te-hop-type;
            description
              "strict or loose hop";
          }
        }
      }
      case label {
        description
          "The Label ERO subobject";
        container label-hop {
          description
            "Label hop type";
          uses effective-freq-slot;
        }
      }
      case hop-attribute {
        uses gnpypc:hop-attribute;
      }
    }
  }

  grouping common-constraints_config {
    description
      "Common constraints grouping that can be set on
       a constraint set or directly on the tunnel";
    container te-bandwidth {
      description
        "A requested bandwidth to use for path computation";
      uses gnpy-specific-parameters;
    }
  }

  grouping end-points {
    description
      "Common grouping to define the TE tunnel end-points";
    leaf source {
      type inet:ip-address;
      description
        "TE tunnel source address.";
    }
    leaf destination {
      type inet:ip-address;
      description
        "P2P tunnel destination address";
    }
    leaf src-tp-id {
      type binary;
      description
        "TE tunnel source termination point identifier.";
    }
    leaf dst-tp-id {
      type binary;
      description
        "TE tunnel destination termination point
         identifier.";
    }
  }

  grouping synchronization-info {
    description
      "Information for sync";
    list synchronization {
      key "synchronization-id";
      description
        "sync list";
      leaf synchronization-id {
        type uint32;
        description
          "index";
      }
      container svec {
        description
          "Synchronization VECtor";
        leaf relaxable {
          type boolean;
          default "true";
          description
            "If this leaf is true, path computation process is free
             to ignore svec content.
             otherwise it must take into account this svec.";
        }
        uses generic-path-disjointness;
        leaf-list request-id-number {
          type uint32;
          description
            "This list reports the set of M path computation requests that must be synchronized.";
        }
      }
    }
  }

  grouping generic-path-properties {
    description
      "TE generic path properties grouping";
    container path-properties {
      config false;
      description
        "The TE path properties";
      list path-metric {
        key "metric-type";
        description
          "TE path metric type";
        leaf metric-type {
          type identityref {
            base path-metric-type;
          }
          description
            "TE path metric type";
        }
        leaf accumulative-value {
          type decimal64 {
            fraction-digits 2;
          }
          description
            "TE path metric accumulative value";
        }
      }
      //      container path-route-objects {
      //        description
      //          "Container for the list of route objects either returned by
      //           the computation engine or actually used by an LSP";
      //        list path-route-object {
      //          key index;
      //          description
      //            "List of route objects either returned by the computation
      //             engine or actually used by an LSP";
      //          uses explicit-route-hop;
      //        }
      //      }
      list path-route-objects {
        description
          "Container for the list of route objects either returned by
           the computation engine or actually used by an LSP";
        container path-route-object {
          description
            "List of route objects either returned by the computation
             engine or actually used by an LSP";
          uses explicit-route-hop;
        }
      }
    }
  }

  grouping path-info {
    description
      "Path computation output information";
    uses generic-path-properties;
  }

  // adding some blocking reasons and info on path in case of blocking

  grouping no-path-info {
    description
      "no-path-info";
    container no-path {
      presence "Response without path information, due to failure
                performing the path computation";
      description
        "if path computation cannot identify a path,
         rpc returns no path.";
      leaf no-path {
        type string;
        mandatory true;
        description
          "returned blocking reasons:
            NO_PATH
            NO_COMPUTED_SNR
            NO_FEASIBLE_BAUDRATE_WITH_SPACING
            NO_PATH_WITH_CONSTRAINT
            NO_FEASIBLE_MODE
            MODE_NOT_FEASIBLE
            NO_SPECTRUM
          ";
      }
      uses generic-path-properties;
    }
  }

  /* TODO : correct the following with good trees:
   *  te:tunnels-rpc/te:input/te:tunnel-info
   *  te:tunnels-rpc/te:output/te:result
   */

  grouping service {
    list path-request {
      key "request-id";
      description
        "request-list";
      leaf request-id {
        type uint32;
        mandatory true;
        description
          "Each path computation request is uniquely identified by the request-id-number.";
      }
      leaf bidirectional {
        type boolean;
        mandatory true;
        description
          "Specify the bidirectionality of the path";
      }
      uses end-points;
      uses path-route-objects;
      uses generic-path-constraints;
    }
    uses synchronization-info;
  }

  grouping result {
    list response {
      key "response-id";
      config false;
      description
        "response";
      leaf response-id {
        type uint32;
        description
          "The list key that has to reuse request-id-number.";
      }
      choice response-type {
        config false;
        description
          "response-type";
        case no-path-case {
          uses no-path-info;
        }
        case path-case {
          description
            "Path computation service.";
          uses path-info;
        }
      }
    }
  }

  container result {
    description
      "Describe the service file to connect to gnpy";
    uses result;
  }
}