gnpy-api 0.0.0__py3-none-any.whl

gnpyapi/yang/gnpy-path-computation-simplified@2020-10-22.yang

@@ -0,0 +1,559 @@
+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 for - 2020 - candi preversion";
+
+  revision "2020-10-22" {
+    description 
+      "draft for experimental/2020-candi";
+    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 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 5;
+        }
+        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 2;
+      }
+      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.";
+         }
+       }
+     }
+   }
+}