Intermediate representation

The intermediate representation is the output of the a converter, it is backend specific and is built as a tree structure made from python builtins values.

A tree is a acyclic, directional graph with an element called root.

The root of our tree is stored in the first element of a tuple, along with the root’s direct sons as a list:

tree = (root, direct_sons)

As an example here we present the tree (‘spam’, [‘eggs’, ‘snakes’])

As a son may be a carrier of a value so we store it in a dictionary instead of adding a leaf with another level of recursion.

As an example here we present the tree (‘spam’, [ { ‘eggs’: 2 }, { ‘snakes’ : { ‘loved’ : ‘python’ }}]):

This tree could be tranlated to a configuration file for AirOS that looks like this:

spam.eggs=2
spam.snakes.loved=python

So our tree representation is based on the simple assumption that a leaf is a dictionary without nested values and nested values in a dictionary creates a father-son relationship.

Instead when the configuration requires that the son values must be prefixed from a number, e.g. vlan.1.devname=eth0 we store a list of dictionaries.

(
     'spam',
     [
         {
             'eggs' : 2,
         },
         {
             'snakes' : {
                 'loved' : [
                     {
                         'python2' : True,
                     },
                     {
                         'python3' : True,
                     },
                     {
                         'ipython' : True,
                     }
                  ],
              },
         }
     ]
)

And the resulting tree is:

And the configuration is:

spam.eggs=2
spam.snakes.loved.1.python2=true
spam.snakes.loved.2.python3=true
spam.snakes.loved.2.ipython=true

The process by which we can go from the intermediate representation from the output configuration is called flattening, you can find more in the next section.

Flattening

To avoid at all cost a recursive logic in the template we flatten the intermediate representation to something that has a namespace a key and a value.

The objective is to go from a python NetJSON configuration dictionary that we get from loading a NetJSON to the AirOS configuration.

An input NetJSON configuration dictionary is just a python dictionary, e.g.:

#python
{
     'interfaces' : [
         {
             'name' : 'eth0.1',
             'type' : 'ethernet',
             'comment' : 'management vlan'
             'comment' : 'management'
         },
         {
             'name' : 'eth0.2',
             'type' : 'ethernet',
             'comment' : 'traffic'
         }
     ]
}

And this must be converted to an appropiate AirOS configuration which looks like this:

vlan.1.comment=management
vlan.1.devname=eth0
vlan.1.id=1
vlan.1.status=enabled
vlan.2.comment=management
vlan.2.devname=eth0
vlan.2.id=2
vlan.2.status=enabled
vlan.status=enabled

To do this we must convert the NetJSON configuration dictionary into something that resembles the target text, the output configuration.

(
     # namespace
     'vlan',
     #options
     [
         {
             # key : value
             '1.devname' : 'eth0',
             '1.id' : '1'
             '1.status' : 'enabled',
             '1.comment' : 'management'
         },
         {
             '2.devname' : 'eth0',
             '2.id' : '2'
             '2.status' : 'enabled',
             '2.comment' : 'traffic'
         }
     ]
)

And to do that we get rid of the multiple indentation levels by flattening the tree structure.

The tree associated with the previous NetJSON example is this:

And by exploring depth first we get to read a line of the configuration at a time.

E.g. following the blue line from the vlan root to the first leaf we have the configuration vlan.1.devname=eth0