Page tree
Skip to end of metadata
Go to start of metadata

One of the core values of CORD is the abstractions (models) it defines for services and service composition, including the set of foundational models (e.g., instances, networks, slices, controllers) used to assemble services. The project aims to rigorously define and leverage these models.  It has three main objectives.

  • Define Rigorous Models – It is widely accepted that data models will play a central role in managing network and cloud services, along with significant consensus around YANG as a standard modeling language. As much attention as YANG gets, however, it is just a language for specifying models. There has been surprisingly little work done to define a comprehensive set of service models. At the same time, a rich set of models have been defined for CORD. They are implemented in Django, iteratively refined based on operational experience, and sufficiently complete to build fully functioning systems. The first objective is to rigorously model CORD in YANG, and to publish these models as one “manifestation” of CORD. Our hope is that these models, which can be viewed as collectively defining the CORD architecture, will complement the impact the CORD reference implementation has on the state-of-the-art. Our intent is to both refine and extend our current models over time, and whenever appropriate, work with the broader community to define/adopt standard models.

  • Build a Service Emulation Environment – The collection of YANG-based models for CORD is “executable” in the sense that they can be loaded into a runtime system and evaluated. Doing this by itself—that is, without being linked to any physical resources—provides an emulation environment that can be used to develop, debug, and validate service models.  In this respect, the emulator is similar to the front-end configuration available in the current reference implementation. The second objective is to make this emulation environment available to the CORD community, providing yet another tool in support of creating agile services. Over time, parts (or possibly all) of this emulator might be operationalized by incorporating it into the reference implementation, but we see value for an emulator in-and-of itself.

  • Simplify Service On-Boarding – Today on-boarding a service into CORD requires the service developer to write a set of Python routines. Some of these routines could be auto-generated from a single specification file. The third objective is to do exactly this using YANG specifications for CORD services. Our intent is not to replace the current implementation of CORD with a YANG-based version (the internals will continue to be implemented in Python/Django, and this will be true for the foreseeable future), but it is instead much more modest—to accept YANG service specifications and translate these specifications into a form that can be imported into the current implementation. Over time, parts (or possibly all) of CORD might be based on a purely YANG-based engine.

This project has been in bootstrap mode for the last three months. We currently have a first draft of some CORD models expressed in YANG, a CORD model emulator, and documentation describing how to both write models and run them in the emulator. They are currently available on GitHub at https://github.com/opencord/composer. We plan to start focusing on four medium-term tasks:

  1. Continue to analyze existing Django-based models for various CORD services, and create their YANG-based counterparts.

  2. Augment the emulator with custom views that provide a web-based GUI for service models.

  3. Clean up the existing Django-based models (for both the XOS core and CORD services) based on our experience creating their YANG counterparts.

  4. Build tools to translate YANG service models onto the underlying Django representation, with the goal of providing service developers with an alternative means of on-boarding services.

There are two observations about the project’s long-term trajectory. First, we envision this effort will dovetail with efforts going on in other communities, most notably OPNFV (application modeling), OpenConfig (service configuration), and ONF (Information Models). We expect to work jointly with these communities to define standard models, leveraging our operational experience with the CORD reference implementation.

Second, while the YANG models are based on their Django counterparts in the operational version of CORD, there is currently no mechanism to enforce that the YANG and Django model definitions remain in sync. We plan to incrementally improve the operational system based on this modeling work (and likewise, to incrementally improve the YANG models based on operational experience), but there is a risk that these two representations of the models will drift. It will be important to ensure that our modeling effort stay in sync with the reference implementation of CORD.

Project Specifics

Contacts: Peter Lee (peter@corenova.com), Larry Peterson (llp@onlab.us)

Resources: Peter Lee (Corenova), Sapan Bhatia (ON.Lab)

Committers/Reviewers: Lee, Bhatia, Peterson, Matteo Scandolo, Scott Baker

Collaborations: OPNFV Promise, OPNFV Models, Others TBD


  • No labels