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));