skyquake/plugins/composer/src/schemas/yang/confd2model.js

   1 /*
   2  *
   3  *   Copyright 2016 RIFT.IO Inc
   4  *
   5  *   Licensed under the Apache License, Version 2.0 (the "License");
   6  *   you may not use this file except in compliance with the License.
   7  *   You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *   Unless required by applicable law or agreed to in writing, software
  12  *   distributed under the License is distributed on an "AS IS" BASIS,
  13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *   See the License for the specific language governing permissions and
  15  *   limitations under the License.
  16  *
  17  */
  18
  19 'use strict';
  20
  21 // the models to be transformed into the output DSL JSON meta file
  22 var yang = [require('./json-nsd.json'), require('./json-vnfd.json')];
  23
  24 var _ = require('lodash');
  25 var inet = require('./ietf-inet-types.yang.json');
  26
  27 var utils = {
  28         resolvePath(obj, path) {
  29                 // supports a.b, a[1] and foo[bar], etc.
  30                 // where obj is ['nope', 'yes', {a: {b: 1}, foo: 2}]
  31                 // then [1] returns 'yes'; [2].a.b returns 1; [2].a[foo] returns 2;
  32                 path = path.split(/[\.\[\]]/).filter(d => d);
  33                 return path.reduce((r, p) => {
  34                         if (r) {
  35                                 return r[p];
  36                         }
  37                 }, obj);
  38         },
  39         assignPathValue(obj, path, value) {
  40                 path = path.split(/[\.\[\]]/).filter(d => d);
  41                 // enable look-ahead to determine if type is array or object
  42                 const pathCopy = path.slice();
  43                 // last item in path used to assign value on the resolved object
  44                 const name = path.pop();
  45                 const resolvedObj = path.reduce((r, p, i) => {
  46                         if (typeof(r[p]) !== 'object') {
  47                                 // look-ahead to see if next path item is a number
  48                                 const isArray = !isNaN(parseInt(pathCopy[i + 1], 10));
  49                                 r[p] = isArray ? [] : {}
  50                         }
  51                         return r[p];
  52                 }, obj);
  53                 resolvedObj[name] = value;
  54         }
  55 };
  56
  57 var isType = d => /^(leaf|leaf-list|list|container|choice|case|uses)$/.test(d);
  58
  59 function deriveCardinalityFromProperty(property, typeName) {
  60         if (String(property.mandatory) === 'true') {
  61                 return '1';
  62         }
  63         let min = 0, max = Infinity;
  64         if (property.hasOwnProperty('min-elements')) {
  65                 min = parseInt(property['min-elements'], 10) || 0;
  66         }
  67         if (property.hasOwnProperty('max-elements')) {
  68                 max = parseInt(property['max-elements'], 10) || Infinity;
  69         } else {
  70                 if (!/^(list|leaf-list)$/.test(typeName)) {
  71                         max = '1';
  72                 }
  73         }
  74         if (min > max) {
  75                 return String(min);
  76         }
  77         if (min === max) {
  78                 return String(min);
  79         }
  80         return String(min) + '..' + (max === Infinity ? 'N' : max);
  81 }
  82
  83 function cleanWhitespace(text) {
  84         if (typeof text === 'string') {
  85                 return text.replace(/\s+/g, ' ');
  86         }
  87         return text;
  88 }
  89
  90 function buildProperties(typeData, typeName) {
  91         var properties = [];
  92         Object.keys(typeData).forEach(name => {
  93                 var property = typeData[name];
  94                 var listKey = typeName === 'list' ? String(property.key).split(/\s/).filter(k => k && k !== 'undefined') : false;
  95                 var meta = {
  96                         name: name,
  97                         type: typeName,
  98                         description: cleanWhitespace(property.description),
  99                         cardinality: deriveCardinalityFromProperty(property, typeName),
 100                         'data-type': property.type,
 101                         properties: Object.keys(property).filter(isType).reduce((r, childType) => {
 102                                 return r.concat(buildProperties(property[childType], childType));
 103                         }, [])
 104                 };
 105                 if (listKey) {
 106                         meta.key = listKey;
 107                 }
 108                 properties.push(meta);
 109         });
 110         return properties;
 111 }
 112
 113 function lookupUses(uses, yang) {
 114         function doLookup(lookupTypeName) {
 115                 var key;
 116                 // warn: hardcoded prefix support for mano-types - other prefixes will be ignored
 117                 if (/^manotypes:/.test(lookupTypeName)) {
 118                         var moduleName = lookupTypeName.split(':')[1];
 119                         key = ['dependencies.mano-types.module.mano-types.grouping', moduleName].join('.');
 120                 } else {
 121                         var name = yang.name.replace(/^rw-/, '');
 122                         key = ['dependencies', name, 'module', name, 'grouping', lookupTypeName].join('.');
 123                 }
 124                 return utils.resolvePath(yang, key);
 125         }
 126         if (typeof uses === 'object') {
 127                 return Object.keys(uses).reduce((result, key) => {
 128                         var found = doLookup(key);
 129                         Object.keys(found).filter(isType).forEach(type => {
 130                                 var property = result[type] || (result[type] = {});
 131                                 Object.assign(property, found[type]);
 132                         });
 133                         return result;
 134                 }, {});
 135         } else if (typeof uses === 'string') {
 136                 return doLookup(uses);
 137         }
 138         return {};
 139 }
 140
 141 function lookupTypedef(property, yang) {
 142         var key;
 143         var lookupTypeName = property.type;
 144         // warn: hardcoded prefix support - other prefixes will be ignored
 145         if (/^manotypes:/.test(lookupTypeName)) {
 146                 var lookupName = lookupTypeName.split(':')[1];
 147                 key = ['dependencies.mano-types.module.mano-types.typedef', lookupName].join('.');
 148         } else if (/^inet:/.test(lookupTypeName)) {
 149                 var lookupName = lookupTypeName.split(':')[1];
 150                 yang = inet;
 151                 key = ['schema.module.ietf-inet-types.typedef', lookupName].join('.');
 152         }
 153         if (key) {
 154                 return utils.resolvePath(yang, key);
 155         }
 156 }
 157
 158 function resolveUses(property, yang) {
 159         var childData = property.uses;
 160         var resolved = lookupUses(childData, yang);
 161         //console.log('uses', childData, 'found', resolved);
 162         Object.keys(resolved).forEach(type => {
 163                 var parentTypes = property[type] || (property[type] = {});
 164                 // copy types into the parent types bucket
 165                 Object.assign(parentTypes, resolveReferences(yang, resolved[type]));
 166         });
 167         delete property.uses;
 168 }
 169
 170 function resolveTypedef(property, yang) {
 171         if (/:/.test(property.type)) {
 172                 var found = lookupTypedef(property, yang);
 173                 if (found) {
 174                         Object.assign(property, found);
 175                 }
 176         }
 177 }
 178
 179 function resolveReferences(yang, data) {
 180         var dataClone = _.cloneDeep(data);
 181         function doResolve(typeData) {
 182                 Object.keys(typeData).forEach(name => {
 183                         var property = typeData[name];
 184                         resolveTypedef(property, yang);
 185                         Object.keys(property).filter(isType).forEach(childType => {
 186                                 if (childType === 'uses') {
 187                                         resolveUses(property, yang);
 188                                 } else {
 189                                         doResolve(property[childType]);
 190                                 }
 191                         });
 192                 });
 193         }
 194         doResolve(dataClone);
 195         return dataClone;
 196 }
 197
 198 function module(yang) {
 199         let module;
 200         var name = yang.name.replace(/^rw-/, '');
 201         if (!name) {
 202                 throw 'no name given in json yang';
 203         }
 204         const path = ['container', name + '-catalog'].join('.');
 205         module = utils.resolvePath(yang, path);
 206
 207         if (!module) {
 208                 module = utils.resolvePath(yang, ['schema', 'module', name, path].join('.'));
 209         }
 210         if (!module) {
 211                 module = utils.resolvePath(yang, ['dependencies', name, 'module', name, path].join('.'));
 212         }
 213         if (!module) {
 214                 throw 'cannot find the module' + name;
 215         }
 216
 217         // module/agument/nsd:nsd-catalog/nsd:nsd/meta
 218         const augLeafPath = ['schema.module', 'rw-' + name, 'augment', '/' + name + ':' + name + '-catalog/' + name + ':' + name, 'leaf'];
 219         const meta = utils.resolvePath(yang, augLeafPath.concat('meta').join('.'));
 220
 221         const putLeafPath = ['dependencies', name, 'module', name, path, 'list', name, 'leaf'];
 222
 223         if (meta) {
 224                 utils.assignPathValue(yang, putLeafPath.concat(['meta']).join('.'), meta);
 225         }
 226
 227         // module/agument/nsd:nsd-catalog/nsd:nsd/logo
 228         const logo = utils.resolvePath(yang, augLeafPath.concat('logo').join('.'));
 229         if (logo) {
 230                 utils.assignPathValue(yang, putLeafPath.concat(['logo']).join('.'), logo);
 231         }
 232         var data = module.list;
 233
 234         return {name: name, data: resolveReferences(yang, data)};
 235
 236 }
 237
 238 function reduceModule(result, module) {
 239         result[module.name] = buildProperties(module.data, 'list')[0];
 240         return result;
 241 }
 242
 243 var result = yang.map(module).reduce(reduceModule, {});
 244
 245 console.log(JSON.stringify(result, null, 5));