YANG parser and composer
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.

README.md

yang-js

YANG parser and evaluator

Super light-weight and fast. Produces adaptive JS objects bound by YANG schema expressions according to RFC 6020 specifications. Composes dynamic YANG schema expressions by analyzing arbitrary JS objects.

NPM Version NPM Downloads

Yang = require 'yang-js'
schema = """
  container foo {
    leaf a { type string; }
    leaf b { type uint8; }
	list bar {
	  key "b1";
	  leaf b1 { type uint16; }
	  container blob;
    }
  }
  """
model = (Yang schema) {
  foo:
    a: 'apple'
    b: 10
	bar: [
	  { b1: 100 }
	]
}

Installation

$ npm install yang-js

For development/testing, clone from repo and initialize:

$ git clone https://github.com/corenova/yang-js
$ cd yang-js
$ npm install

When using with the web browser, you can generate a minified version from the repo:

$ npm run build:web

It will produce dist/yang.min.js that can then be used directly inside the web browser.

Features

  • Robust parsing
  • Focus on high performance
  • Extensive test coverage
  • Flexible control logic binding
  • Powerful XPATH expressions
  • Isomorphic runtime
  • Adaptive validations
  • Dynamic schema generation
  • Granular event subscriptions

Please note that yang-js is not a code-stub generator based on YANG schema input. It directly embeds YANG schema compliance into ordinary JS objects as well as generates YANG schema(s) from ordinary JS objects.

Quick Start

Here's a quick example for using this module in coffeescript:

Yang = require 'yang-js'
schema = """
  container foo {
    leaf a { type string; }
    leaf b { type uint8; }
  }
  """
model = Yang.parse(schema).eval {
  foo:
    a: 'apple'
    b: 10
}

The example above uses the explict long-hand version of using this module, which uses the parse method to generate the Yang expression and immediately perform an eval using the Yang expression for the passed-in JS data object.

Since the above is a common usage pattern sequence, this module also provides a cast-style short-hand version as follows:

model = (Yang schema) {
  foo:
    a: 'apple'
    b: 10
}

It is functionally equivalent to the explicit version but provides cleaner syntactic expression regarding how the data object is being cast with the Yang expression to get back a new schema-driven object.

Once you have the model instance, you can directly interact with its properties and see the schema enforcement and validations in action.

As the above example illustrates, the yang-js module takes a free-form approach when dealing with YANG schema statements. You can use any YANG statement as the top of the expression and parse it to return a corresponding YANG expression instance. However, only YANG expressions that represent a data node element will eval to generate a new Property instance. Also, only module schemas will eval to generate a new Model instance.

Reference Guides

Bundled YANG Modules

Please refer to Working with Multiple Schemas section of the Getting Started Guide for usage examples.

API

Below are the list of methods provided by the yang-js module. You can click on each method entry for detailed info on usage.

Main module

The following operations are available from require('yang-js').

Please note that when you load the main module, it will attempt to automatically register .yang extension into require.extensions.

Yang instance

The Yang instance is created from parse/compose operations from the main module.

Property instance

The Property instances are created during Yang.eval operation and are bound to every node element defined by the underlying Yang schema expression.

Please refer to Property for a list of all available properties on this instance.

Model instance

The Model instance is created from Yang.eval operation for YANG module schema and aggregates Property instances.

This instance also inherits all Property methods and properties.

Please refer to Model for a list of all available properties on this instance.

Examples

Jukebox is a simple example YANG module extracted from RFC 6020. This example implementation is included in this repository's example folder and exercised as part of the test suite. It demonstrates use of the register and import facilities for loading the YANG schema file and binding various control logic behavior.

Promise is a resource reservation module implemented for OPNFV. This example implementation is hosted in a separate GitHub repository opnfv/promise and utilizes yang-js for the complete implementation. It demonstrates use of multiple YANG data models in modeling complex systems. Please be sure to check it out to learn more about advanced usage of yang-js.

Tests

To run the test suite, first install the dependencies, then run npm test:

$ npm install
$ npm test

Also refer to Compliance Report for the latest RFC 6020 YANG specification compliance. There's also active effort to support the latest YANG 1.1 draft specifications. You can take a look at the mocha test suite in the test directory for compliance coverage unit-tests and other examples.

License

Apache 2.0

This software is brought to you by Corenova Technologies. We'd love to hear your feedback. Please feel free to reach me at peter@corenova.com anytime with questions, suggestions, etc.