module ietf-network-topology-state {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-network-topology-state";
prefix lnk-s;
import ietf-network-state {
prefix nd-s;
}
import ietf-network-topology {
prefix lnk;
}
organization
"IETF I2RS (Interface to the Routing System) Working Group";
contact
"WG Web:
WG List:
WG Chair: Susan Hares
WG Chair: Russ White
Editor: Alexander Clemm
Editor: Jan Medved
Editor: Robert Varga
Editor: Nitin Bahadur
Editor: Hariharan Ananthakrishnan
Editor: Xufeng Liu
";
description
"This module defines a common base model for network topology
state, representing topology that is either learned, or topology
that results from applying topology that has been configured per
the ietf-network-topology model, mirroring the corresponding
data nodes in this model. It augments the base network state
model with links to connect nodes, as well as termination
points to terminate links on nodes.
The model mirrors ietf-network-topology, but contains only
read-only state data. The model is not needed when the
underlying implementation infrastructure supports the Network
Management Datastore Architecture (NMDA).
Copyright (c) 2017 IETF Trust and the persons identified as
authors of the code. All rights reserved.
Redistribution and use in source and binary forms, with or
without modification, is permitted pursuant to, and subject
to the license terms contained in, the Simplified BSD License
set forth in Section 4.c of the IETF Trust's Legal Provisions
Relating to IETF Documents
(http://trustee.ietf.org/license-info).
This version of this YANG module is part of
draft-ietf-i2rs-yang-network-topo-14;
see the RFC itself for full legal notices.
NOTE TO RFC EDITOR: Please replace above reference to
draft-ietf-i2rs-yang-network-topo-14 with RFC
number when published (i.e. RFC xxxx).";
revision 2017-06-30 {
description
"Initial revision.
NOTE TO RFC EDITOR: Please replace the following reference
to draft-ietf-i2rs-yang-network-topo-14 with
RFC number when published (i.e. RFC xxxx).";
reference
"draft-ietf-i2rs-yang-network-topo-14";
}
grouping link-ref {
description
"References a link in a specific network.";
leaf link-ref {
type leafref {
path "/nd-s:networks/nd-s:network[nd-s:network-id=current()"+
"/../network-ref]/lnk-s:link/lnk-s:link-id";
require-instance false;
}
description
"A type for an absolute reference a link instance.
(This type should not be used for relative references.
In such a case, a relative path should be used instead.)";
}
uses nd-s:network-ref;
}
grouping tp-ref {
description
"References a termination point in a specific node.";
leaf tp-ref {
type leafref {
path "/nd-s:networks/nd-s:network[nd-s:network-id=current()"+
"/../network-ref]/nd-s:node[nd-s:node-id=current()/../"+
"node-ref]/lnk-s:termination-point/lnk-s:tp-id";
require-instance false;
}
description
"A type for an absolute reference to a termination point.
(This type should not be used for relative references.
In such a case, a relative path should be used instead.)";
}
uses nd-s:node-ref;
}
augment "/nd-s:networks/nd-s:network" {
description
"Add links to the network model.";
list link {
key "link-id";
description
"A network link connects a local (source) node and
a remote (destination) node via a set of
the respective node's termination points.
It is possible to have several links between the same
source and destination nodes. Likewise, a link could
potentially be re-homed between termination points.
Therefore, in order to ensure that we would always know
to distinguish between links, every link is identified by
a dedicated link identifier. Note that a link models a
point-to-point link, not a multipoint link.";
container source {
description
"This container holds the logical source of a particular
link.";
leaf source-node {
type leafref {
path "../../../nd-s:node/nd-s:node-id";
require-instance false;
}
description
"Source node identifier, must be in same topology.";
}
leaf source-tp {
type leafref {
path "../../../nd-s:node[nd-s:node-id=current()/../"+
"source-node]/termination-point/tp-id";
require-instance false;
}
description
"Termination point within source node that terminates
the link.";
}
}
container destination {
description
"This container holds the logical destination of a
particular link.";
leaf dest-node {
type leafref {
path "../../../nd-s:node/nd-s:node-id";
require-instance false;
}
description
"Destination node identifier, must be in the same
network.";
}
leaf dest-tp {
type leafref {
path "../../../nd-s:node[nd-s:node-id=current()/../"+
"dest-node]/termination-point/tp-id";
require-instance false;
}
description
"Termination point within destination node that
terminates the link.";
}
}
leaf link-id {
type lnk:link-id;
description
"The identifier of a link in the topology.
A link is specific to a topology to which it belongs.";
}
list supporting-link {
key "network-ref link-ref";
description
"Identifies the link, or links, that this link
is dependent on.";
leaf network-ref {
type leafref {
path "../../../nd-s:supporting-network/nd-s:network-ref";
require-instance false;
}
description
"This leaf identifies in which underlay topology
the supporting link is present.";
}
leaf link-ref {
type leafref {
path "/nd-s:networks/nd-s:network[nd-s:network-id="+
"current()/../network-ref]/link/link-id";
require-instance false;
}
description
"This leaf identifies a link which is a part
of this link's underlay. Reference loops in which
a link identifies itself as its underlay, either
directly or transitively, are not allowed.";
}
}
}
}
augment "/nd-s:networks/nd-s:network/nd-s:node" {
description
"Augment termination points which terminate links.
Termination points can ultimately be mapped to interfaces.";
list termination-point {
key "tp-id";
description
"A termination point can terminate a link.
Depending on the type of topology, a termination point
could, for example, refer to a port or an interface.";
leaf tp-id {
type lnk:tp-id;
description
"Termination point identifier.";
}
list supporting-termination-point {
key "network-ref node-ref tp-ref";
description
"This list identifies any termination points that
the termination point is dependent on, or maps onto.
Those termination points will themselves be contained
in a supporting node.
This dependency information can be inferred from
the dependencies between links. For this reason,
this item is not separately configurable. Hence no
corresponding constraint needs to be articulated.
The corresponding information is simply provided by the
implementing system.";
leaf network-ref {
type leafref {
path "../../../nd-s:supporting-node/nd-s:network-ref";
require-instance false;
}
description
"This leaf identifies in which topology the
supporting termination point is present.";
}
leaf node-ref {
type leafref {
path "../../../nd-s:supporting-node/nd-s:node-ref";
require-instance false;
}
description
"This leaf identifies in which node the supporting
termination point is present.";
}
leaf tp-ref {
type leafref {
path "/nd-s:networks/nd-s:network[nd-s:network-id="+
"current()/../network-ref]/nd-s:node[nd-s:node-id="+
"current()/../node-ref]/termination-point/tp-id";
require-instance false;
}
description
"Reference to the underlay node, must be in a
different topology";
}
}
}
}
}