YANG

YANG is a powerful and versatile data modeling language that was designed from the requirements of network operators for an easy to use and robust mechanism for provisioning devices and services across networks. It was originally designed at the Internet Engineering Task Force (IETF) and has been so successful that it has been adopted as the standard for modeling design in many other standards bodies such as the Metro Ethernet Forum, OpenDaylight, OpenConfig, and others. The number of YANG modules being implemented for interfaces, devices, and service is exploding.

The YANG RFC 6020 has many very readable examples.

*  = partially supported

YANG Example of reusable groups

grouping target {
         leaf address {
             type inet:ip-address;
             description "Target IP address";
         }
         leaf port {
             type inet:port-number;
             description "Target port number";
         }
     }

     container peer {
         container destination {
             uses target;
         }
     }

NETCONF XML Example for the above

     <peer>
       <destination>
         <address>192.0.2.1</address>
         <port>830</port>
       </destination>
     </peer>

YANG Example of must and error-message

container interface {
         leaf ifType {
             type enumeration {
                 enum ethernet;
                 enum atm;
             }
         }
         leaf ifMTU {
             type uint32;
         }
         must "ifType != 'ethernet' or " +
              "(ifType = 'ethernet' and ifMTU = 1500)" {
             error-message "An ethernet MTU must be 1500";
         }
         must "ifType != 'atm' or " +
              "(ifType = 'atm' and ifMTU <= 17966 and ifMTU >= 64)" {
             error-message "An atm MTU must be  64 .. 17966";
         }
     }

YANG Example of <edit-config> operations

Given the following container definition:

     container system {
         description "Contains various system parameters";
         container services {
             description "Configure externally available services";
             container "ssh" {
                 presence "Enables SSH";
                 description "SSH service specific configuration";
                 // more leafs, containers and stuff here...
             }
         }
     }

A corresponding XML instance example:

     <system>
       <services>
         <ssh/>
       </services>
     </system>

Since the <ssh> element is present, ssh is enabled.

To delete a container with an <edit-config>:

     <rpc message-id="101"
          xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"
          xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0">
       <edit-config>
         <target>
           <running/>
         </target>
         <config>
           <system xmlns="http://example.com/schema/config">
             <services>
               <ssh nc:operation="delete"/>
             </services>
           </system>
         </config>
       </edit-config>
     </rpc>

• YANG is the data modeling language for NETCONF
• designed to be human readable and easy to understand
• composed of hierarchical schema encoded in XML that can closely resemble an implementation’s native data structures
• organizes the semantics and data representation
• augments inserts nodes into an existing hierarchy so they can augment existing YANG modules, e.g. a standard module where the implementation provides additional vendor specific data/service
• deviations over-ride nodes in an existing hierarchy so they can deviate from existing YANG modules, e.g. a standard module where the implementation cannot provide the data/service for a particular node
• “if”, “when”, and “choice” constructs
• contains a rich set of standard types and can create derived types and unions of types
• grouping allows collections of nodes to be reused
• “rpc” statement defines methods, input and output parameters
• provides notifications
• robust development is supported with versioning and with modularity. Modules can include sub-modules, which in turn can include yet more sub-modules

YumaWorks’ YumaPro SDK implements the YANG standard fully, including optional requirements.

Key features of YumaPro’s YANG implementation:

• YumaPro is a 100% “native YANG” implementation – YANG modules are used directly by all the tools to control all aspects of NETCONF protocol usage
• all YumaPro programs use the same centralized YANG language parser
• keeps current with evolving standard’s features
• YumaPro programs support concurrent usage of different revisions of the same module or sub-module
• translation of existing investment in SNMP MIB data into YANG with freely available smidump tool