module gnpy-path-computation-simplified {
  yang-version 1.1;
  namespace "gnpy:path";

  prefix "gnpypc";

    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 -
    The license used for all the yang files of GNPy is BSD 3-Clause License

    BSD 3-Clause License

    Copyright (c) 2018, Telecom Infra Project
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this
      list of conditions and the following disclaimer.

    * 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.

    * Neither the name of the copyright holder nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

    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 2022-06-15 {
    description
      "change fraction digits from 2 to 6 for accumulative-value leaf, from 5 to 6 for output-power leaf";
    reference
      "YANG model for api input for path computation with gnpy";
  }

  revision 2022-02-21 {
    description
      "draft for GNPy4TPCE preversion - non official version relevant for v2.4 GNPy file format";
    reference
      "YANG model for api input for path computation with gnpy";
  }

  revision 2020-10-22 {
    description
      "draft for experimental/2020-candi";
    reference
      "YANG model for path computation with gnpy inputs";
  }

  revision 2019-01-03 {
    description
      "first draft for GNPy4TPCE preversion - non official version relevant for v1.2 GNPy file format";
    reference
      "YANG model for api input for path computation with gnpy";
  }

  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 uint32;
              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 {
        mandatory true;
        type decimal64 {
          fraction-digits 1;
        }
        units Hz;
        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 int32;
        description "Nb of channel to take into account for the full load case.
        ";

      }
      leaf output-power{
        type decimal64 {
          fraction-digits 6;
        }
        units W;
        description "optical power setting to be used for the propagation";

      }
      leaf path_bandwidth{
        type decimal64 {
          fraction-digits 5;
        }
        mandatory true;
        units bit/s;
        description "Capacity required";
      }
  }

  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";
  }

  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 "not used yet. hop output (input??) power";
          }
        }
      }
    }

  }

  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 accumulated-metric-type {
      type union {
        type uint64;
        type decimal64 {
          fraction-digits 2;
        }
      }
      description
          "type useable for accumulative-value";
  }

  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.";
        }
        key "index";
        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 {
          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";
          }
          description
            "Numbered and Unnumbered link/node explicit route
            subobject";
        }
      }
      case label {
        container label-hop {
          description "Label hop type";
          uses effective-freq-slot;
        }
        description
          "The Label ERO subobject";
      }
      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 {
      uses gnpy-specific-parameters ;
      description
        "A requested bandwidth to use for path computation";
    }
  }

  grouping end-points {
    description
      "Common grouping to define the TE tunnel end-points";

    leaf source {
      type string;
      description "TE tunnel source address.";
    }
    leaf destination {
      type string;
      description "P2P tunnel destination address";
    }
    leaf src-tp-id {
      type string;
      description "TE tunnel source termination point identifier.";
    }
    leaf dst-tp-id {
      type string;
      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 string;
        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 string;
          description "This list reports the set of M path computation requests that must be synchronized.";
        }
      }
    }
  }

  grouping path-metric {
    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 6;
      }
      description "TE path metric accumulative value";
    }
  }
  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;
        uses path-metric;
      }
      list z-a-path-metric {
        key metric-type;
        uses path-metric;
      }
      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 {
    uses generic-path-properties;
    description "Path computation output information";
  }

// 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";
      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 ;
      description "if path computation cannot identify a path,
        rpc returns no path.";
    }
  }

   grouping service {
     list path-request {
       key "request-id";
       description "request-list";
       leaf request-id {
         type string;
         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 string;
         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 {
           uses path-info;
           description "Path computation service.";
         }
       }
     }
   }


  container result {
    uses gnpypc:result;
    description
      "Describe the response object to gnpy";
  }
}