[mdsal.git] / code-generator / maven-sal-api-gen-plugin / src / test / resources / wadl-gen / controller-network.yang

/*
 * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
module controller-network {
        yang-version 1;
        namespace "urn:opendaylight:controller:network";
        prefix "topos";
        
        import ietf-inet-types { prefix "inet"; }
        
        revision 2013-05-20 {
           description "Initial demo";
        }
        

        
        
        typedef topology-id {
                type string;
        }

        typedef node-id {
                type string;
        }

        typedef link-id {
                type string;
        }

        typedef tp-id {
                type string;
                description "identifier for termination points on a port";
        }

        typedef tp-ref {
                type leafref {
                        path "/network/topologies/topology/nodes/node/termination-points/termination-point/tp-id";
                }
        }
        typedef topology-ref {
                type leafref {
                        path "/network/topologies/topology/topology-id";
                }
                description "This type is used for leafs that reference topology identifier instance.";
                // currently not used
        }

        typedef node-ref {
                type leafref {
                        path "/network/topologies/topology/nodes/node/node-id";
                }
                description "This type is used for leafs that reference a node instance.";
        }

        typedef link-ref {
                type leafref {
                        path "/network/topologies/topology/links/link/link-id";
                }
                description "This type is used for leafs that reference a link instance.";
                // currently not used
        }
        
        typedef network-element-ref {
                type leafref {
                        path "/network/network-elements/network-element/element-id";
                }
        }


        typedef element-id {
                type string;
        }
        
        container network {
                container topologies {
                        list topology {
                                description "
                                        This is the model of abstract topology which contains only Network
                                        Nodes and Network Links. Each topology MUST be identified by
                                        unique topology-id for reason that the store could contain many
                                        topologies.
                                ";
                                key "topology-id";
                                leaf topology-id {
                                        type topology-id; 
                                        description "
                                                It is presumed that datastore will contain many topologies. To
                                                distinguish between topologies it is vital to have UNIQUE
                                                topology identifier.
                                        ";
                                }

                                container types {
                                        description "
                                                The container for definition of topology types.
                                                The augmenting modules should add empty optional leaf 
                                                to this container to signalize topology type.
                                        ";
                                }

                                container nodes {
                                        list node {
                                                description "The list of network nodes defined for topology.";

                                                key "node-id";
                                                leaf node-id {
                                                        type node-id;
                                                        description "The Topology identifier of network-node.";
                                                }

                                                leaf supporting-ne {
                                                        type network-element-ref;
                                                }
                                                
                                                container termination-points {
                                                        list termination-point {
                                                                key "tp-id";
                                                                leaf tp-id {
                                                                        type tp-id;
                                                                }
                                                        }
                                                }
                                        }
                                }
                
                                container links {
                                        list link {
                                                description "
                                                        The Network Link which is defined by Local (Source) and
                                                        Remote (Destination) Network Nodes. Every link MUST be
                                                        defined either by identifier and his local and remote
                                                        Network Nodes (in real applications it is common that many
                                                        links are originated from one node and end up in same
                                                        remote node). To ensure that we would always know to
                                                        distinguish between links, every link SHOULD have
                                                        identifier.
                                                ";
                                                key "link-id";
                
                                                leaf link-id {
                                                        type link-id;
                                                }
                                                container source { 
                                                        leaf source-node {
                                                                type node-ref;
                                                                description "Source node identifier.";
                                                        }
                                                        leaf source-tp {
                                                                type tp-ref;
                                                        }
                                                }
                                                container destination { 
                                                        leaf dest-node {
                                                                type node-ref;
                                                                description "Destination node identifier.";
                                                        }
                                                        leaf dest-tp {
                                                                type tp-ref;
                                                        }
                                                }
                                        }
                                }
                        }
                }
                container network-elements {
                        config true;
                        list network-element {
                                key "element-id";
                                leaf element-id {
                                        type element-id;
                                }
                        }
                }
        }
        
        rpc activate-software-image {
         input {
             leaf image-name {
                 type string;
             }
         }
         output {
             leaf status {
                 type string;
             }
         }
     }
     
     rpc rock-the-house {
         input {
             leaf zip-code {
                 type string;
             }
         }
     }
}