oopt-gnpy/gnpy/yang/gnpy-path-computation@2025-01-20.yang

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

  prefix "gnpypc";

  import gnpy-api {
    prefix "gapi";
    revision-date 2025-06-13;
  }

  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 - 2020 - candi preversion";

  revision "2025-01-20" {
    description 
      "Add tx_power";
    reference 
      "YANG model for path computation with gnpy inputs";
  }

  revision "2022-12-01" {
    description 
      "draft for detecon - GNPy API";
    reference 
      "YANG model for path computation with gnpy inputs";
  }

  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 union {
                type int32;
                type empty;
              }
              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 union {
                type uint32;
                type empty;
              }
              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 transceiver type (to be read from equipment library";

      }
      leaf trx_mode {
        type union {
          type string;
          type empty;
        }
        description "name of the transceiver mode (to be read from equipment library";
      }
      list effective-freq-slot {
        key "N";
        description
          "Definition of a list of frequency slots using n and m values (ITU T G694.1)";
        uses effective-freq-slot ;
      }
      leaf spacing {
        type decimal64 {
          fraction-digits 2;
        }
        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 union {
          type int32;
          type empty;
        }
        description "Nb of channel to take into account for the full load case.
        ";

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

      }
      leaf tx_power{
        type union {
          type decimal64 {
            fraction-digits 5;
          }
          type empty;
        }
        units W;
        description "optical power out of transceiver";

      }
      leaf path_bandwidth{
        type decimal64 {
          fraction-digits 1;
        }
        units bit/s;
        mandatory true;
        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 lowest_SNR-0.1nm {
    base path-metric-type;
    description
      "A metric that records the lowest SNR in 0.1nm in spectrum";
  }

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

  identity PDL_penalty {
    base path-metric-type;
    description
      "A metric that records the PDL penalty.";
  }

  identity PMD_penalty {
    base path-metric-type;
    description
      "A metric that records the PMD penalty.";
  }

  identity CD_penalty {
    base path-metric-type;
    description
      "A metric that records the CD penalty.";
  }

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

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

  grouping transponder{
    description
      "Transponder type and mode used in the hop.";
    leaf transponder-type {
      type string ;
      description
        "transceiver type.";
    }
      leaf transponder-mode {
      type string ;
      description
        "transceiver mode.";
    }
  }

  grouping hop-attribute{
    description
      "This grouping defines the hop attribute parameters for request or response";
    choice hop-type{
      description
        "Hop may be a regenerator or a terminal.";
      case tsp {
        container transponder {
          description
            "Transponder hop in the path. (at source and at destination)";
          uses transponder ;
        }
      }
      case regen {
        container regenerator{
          description
            "Regenerator hop in the path.";
          uses transponder ;
        }
      }
    }

  }

  identity no-path-type {
    description
    "base for blocking reasons";
  }

  identity NO_PATH {
    base no-path-type;
    description
      "Cause of feasibility failure: no path could be computed.";

  }

  identity NO_PATH_WITH_CONSTRAINT {
    base no-path-type;
    description
      "Cause of feasibility failure: no path can meet the includec
      node constraint.";

  }

  identity NO_FEASIBLE_BAUDRATE_WITH_SPACING {
    base no-path-type;
    description
      "Cause of feasibility failure: no mode can fit in the
      requested spectrum.";
  }

  identity NO_COMPUTED_SNR {
    base no-path-type;
    description
      "Cause of feasibility failure: requests SNR performance
      could not be computed";
  }

  identity MODE_NOT_FEASIBLE {
    base no-path-type;
    description
      "Cause of feasibility failure: requested mode does not provide
      enough performance for this path.";

  }

  identity NO_FEASIBLE_MODE {
    base no-path-type;
    description
      "Cause of feasibility failure: no mode of this transceiver
      can achieve enough performance for the path.";

  }

  identity NO_SPECTRUM {
    base no-path-type;
    description
      "Cause of feasibility failure: requests requires more spectrum
      than the actual available spectrum on the path.";
  }

  identity NOT_ENOUGH_RESERVED_SPECTRUM {
    base no-path-type;
    description
      "Cause of feasibility failure: signal requires more spectrum
      than the one defined in the request.";
  }


  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 {
        key "index";
        config false;
        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 subobject-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 {
        list label-hop {
          key "N";
          config false;
          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 service {
    description
      "reusable grouping for path computation requests.";

    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 accumulated-metric-object {
    description
      "Reusable grouping for performance metrics.";
    leaf metric-type {
      type identityref {
        base path-metric-type;
      }
      description
        "Metric type.";
    }
    leaf accumulative-value {
      type union {
        type decimal64 {
          fraction-digits 8;
        }
        type decimal64 {
          fraction-digits 2;
        }
        type decimal64 {
          fraction-digits 1;
        }
        type string;
        type empty;
      }        
      description
        "Accumulative value.";
    }
  }

  grouping response-path-property {
    description
      "Reusable grouping for responses of a path computation request.";
    list path-metric {
      key metric-type;
      description
        "List of accumulated metrics at the end of the path.";
      uses accumulated-metric-object;
    }
    list z-a-path-metric {
      key metric-type;
      description
        "List of accumulated metrics at the end of the path.";
      uses accumulated-metric-object;
    }
  }

  grouping response-path-route-object {
    description
      "Definition of the explicit path of one response";
    list path-route-objects {
      config false;
      description
        "List of the explicit path hops.";
      container path-route-object {
        description
          "Definition of the hop.";
        uses explicit-route-hop ;
      }
    }
  }

  grouping response {
    description
      "Reusable grouping for path computation response.";
    list response {
      key response-id;
      description
        "List of responses for the path-computation request.";
      leaf response-id {
         type string;
         mandatory true;
         description "Each path computation response is uniquely identified by the response-id number.";
      }
      container path-properties {
        description
          "Definition of the content of the successful response";
        uses response-path-property;
        uses response-path-route-object;
      }
      container no-path {
        description
          "Definition of the content of the response when feasibility is not achieved.";
        leaf no-path {
          type identityref {
            base no-path-type;
          }
          description
            "Detailed reason for feasibility failure.";
        }
        container path-properties {
          description
            "Definition of the content of the failed response";
          uses response-path-property;
          uses response-path-route-object;
        }
      }
    }
   }

  grouping path-computation {
    description
      "Reusable grouping that defined data for requests or for
      responses of a path-computation";
    container services {
      description
        "Definition of path-computation requests.";
      uses service;
    }

    container responses {
      description
        "Definition of path-computation responses.";
      uses response;
    }
  }

  container services {
    description
      "Definition of path-computation requests.";
    uses service;
  }

  container responses {
    description
      "Definition of path-computation responses.";
    uses response;
  }

  augment "/gapi:api" {
    description "Add the gnpy-path-computation imput in the API request.";
    uses path-computation;
  }
}