opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/controller-models/controller-network.yang

   1 module controller-network {
   2         yang-version 1;
   3         namespace "urn:opendaylight:controller:network";
   4         prefix "topos";
   5
   6         import ietf-inet-types { prefix "inet"; }
   7
   8         revision 2013-05-20 {
   9            description "Initial demo";
  10         }
  11
  12
  13
  14
  15         typedef topology-id {
  16                 type string;
  17         }
  18
  19         typedef node-id {
  20                 type string;
  21         }
  22
  23         typedef link-id {
  24                 type string;
  25         }
  26
  27         typedef tp-id {
  28                 type string;
  29                 description "identifier for termination points on a port";
  30         }
  31
  32         typedef tp-ref {
  33                 type leafref {
  34                         path "/network/topologies/topology/nodes/node/termination-points/termination-point/tp-id";
  35                 }
  36         }
  37         typedef topology-ref {
  38                 type leafref {
  39                         path "/network/topologies/topology/topology-id";
  40                 }
  41                 description "This type is used for leafs that reference topology identifier instance.";
  42                 // currently not used
  43         }
  44
  45         typedef node-ref {
  46                 type leafref {
  47                         path "/network/topologies/topology/nodes/node/node-id";
  48                 }
  49                 description "This type is used for leafs that reference a node instance.";
  50         }
  51
  52         typedef link-ref {
  53                 type leafref {
  54                         path "/network/topologies/topology/links/link/link-id";
  55                 }
  56                 description "This type is used for leafs that reference a link instance.";
  57                 // currently not used
  58         }
  59
  60         typedef network-element-ref {
  61                 type leafref {
  62                         path "/network/network-elements/network-element/element-id";
  63                 }
  64         }
  65
  66
  67         typedef element-id {
  68                 type string;
  69         }
  70
  71         container network {
  72                 container topologies {
  73                         list topology {
  74                                 description "
  75                                         This is the model of abstract topology which contains only Network
  76                                         Nodes and Network Links. Each topology MUST be identified by
  77                                         unique topology-id for reason that the store could contain many
  78                                         topologies.
  79                                 ";
  80                                 key "topology-id";
  81                                 leaf topology-id {
  82                                         type topology-id;
  83                                         description "
  84                                                 It is presumed that datastore will contain many topologies. To
  85                                                 distinguish between topologies it is vital to have UNIQUE
  86                                                 topology identifier.
  87                                         ";
  88                                 }
  89
  90                                 container types {
  91                                         description "
  92                                                 The container for definition of topology types.
  93                                                 The augmenting modules should add empty optional leaf
  94                                                 to this container to signalize topology type.
  95                                         ";
  96                                 }
  97
  98                                 container nodes {
  99                                         list node {
 100                                                 description "The list of network nodes defined for topology.";
 101
 102                                                 key "node-id";
 103                                                 leaf node-id {
 104                                                         type node-id;
 105                                                         description "The Topology identifier of network-node.";
 106                                                 }
 107
 108                                                 leaf supporting-ne {
 109                                                         type network-element-ref;
 110                                                 }
 111
 112                                                 container termination-points {
 113                                                         list termination-point {
 114                                                                 key "tp-id";
 115                                                                 leaf tp-id {
 116                                                                         type tp-id;
 117                                                                 }
 118                                                         }
 119                                                 }
 120                                         }
 121                                 }
 122
 123                                 container links {
 124                                         list link {
 125                                                 description "
 126                                                         The Network Link which is defined by Local (Source) and
 127                                                         Remote (Destination) Network Nodes. Every link MUST be
 128                                                         defined either by identifier and his local and remote
 129                                                         Network Nodes (in real applications it is common that many
 130                                                         links are originated from one node and end up in same
 131                                                         remote node). To ensure that we would always know to
 132                                                         distinguish between links, every link SHOULD have
 133                                                         identifier.
 134                                                 ";
 135                                                 key "link-id";
 136
 137                                                 leaf link-id {
 138                                                         type link-id;
 139                                                 }
 140                                                 container source {
 141                                                         leaf source-node {
 142                                                                 type node-ref;
 143                                                                 description "Source node identifier.";
 144                                                         }
 145                                                         leaf source-tp {
 146                                                                 type tp-ref;
 147                                                         }
 148                                                 }
 149                                                 container destination {
 150                                                         leaf dest-node {
 151                                                                 type node-ref;
 152                                                                 description "Destination node identifier.";
 153                                                         }
 154                                                         leaf dest-tp {
 155                                                                 type tp-ref;
 156                                                         }
 157                                                 }
 158                                         }
 159                                 }
 160                         }
 161                 }
 162                 container network-elements {
 163                         config true;
 164                         list network-element {
 165                                 key "element-id";
 166                                 leaf element-id {
 167                                         type element-id;
 168                                 }
 169                         }
 170                 }
 171         }
 172 }