mirror of
https://github.com/Telecominfraproject/oopt-gnpy-api.git
synced 2025-10-29 01:02:18 +00:00
34df7f5fc1
Signed-off-by: EstherLerouzic <esther.lerouzic@orange.com> Change-Id: I44c9c96c58fabb79e2b569f7b404036b475b4fde
633 lines
15 KiB
YANG
633 lines
15 KiB
YANG
module gnpy-path-computation {
|
|
yang-version 1.1;
|
|
namespace "gnpy:gnpy-path-computation";
|
|
|
|
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 "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";
|
|
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 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 5;
|
|
}
|
|
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;
|
|
}
|
|
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 lowest_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{
|
|
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{
|
|
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 no-path-type {
|
|
description
|
|
"base for blocking reasons";
|
|
}
|
|
|
|
identity NO_PATH {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity NO_PATH_WITH_CONSTRAINT {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity NO_FEASIBLE_BAUDRATE_WITH_SPACING {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity NO_COMPUTED_SNR {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity MODE_NOT_FEASIBLE {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity NO_FEASIBLE_MODE {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity NO_SPECTRUM {
|
|
base no-path-type;
|
|
}
|
|
|
|
identity NOT_ENOUGH_RESERVED_SPECTRUM {
|
|
base no-path-type;
|
|
}
|
|
|
|
|
|
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 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 {
|
|
description "Label hop type";
|
|
config false;
|
|
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 {
|
|
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 {
|
|
leaf metric-type {
|
|
type identityref {
|
|
base path-metric-type;
|
|
}
|
|
}
|
|
leaf accumulative-value {
|
|
type union {
|
|
type decimal64 {
|
|
fraction-digits 1;
|
|
}
|
|
type decimal64 {
|
|
fraction-digits 2;
|
|
}
|
|
type decimal64 {
|
|
fraction-digits 6;
|
|
}
|
|
type string;
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping response-path-property {
|
|
list path-metric {
|
|
uses accumulated-metric-object;
|
|
}
|
|
list z-a-path-metric {
|
|
uses accumulated-metric-object;
|
|
}
|
|
}
|
|
|
|
grouping response-path-route-object {
|
|
list path-route-objects {
|
|
container path-route-object {
|
|
uses explicit-route-hop ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
grouping response {
|
|
list response {
|
|
config false;
|
|
key response-id;
|
|
leaf response-id {
|
|
type string;
|
|
mandatory true;
|
|
description "Each path computation response is uniquely identified by the response-id number.";
|
|
}
|
|
container path-properties {
|
|
uses response-path-property;
|
|
uses response-path-route-object;
|
|
}
|
|
container no-path {
|
|
leaf no-path {
|
|
type identityref {
|
|
base no-path-type;
|
|
}
|
|
}
|
|
container path-properties {
|
|
uses response-path-property;
|
|
uses response-path-route-object;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
container services {
|
|
uses service;
|
|
}
|
|
|
|
container responses {
|
|
uses response;
|
|
}
|
|
}
|