skyquake/plugins/composer/src/src/libraries/model/DescriptorModelFactory.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  * Created by onvelocity on 11/23/15.
  20  */
  21
  22 'use strict';
  23
  24 import _isEmpty from 'lodash/isEmpty'
  25 import _cloneDeep from 'lodash/cloneDeep'
  26 import d3 from 'd3'
  27 import UID from './../UniqueId'
  28 import guid from '../guid'
  29 import Position from './../graph/Position'
  30 import ColorGroups from '../ColorGroups'
  31 import DescriptorModel from './DescriptorModel'
  32 import DescriptorModelMetaFactory from './DescriptorModelMetaFactory'
  33 import DescriptorModelMetaProperty from './DescriptorModelMetaProperty'
  34
  35 import Classifier from './descriptors/Classifier'
  36 import ClassifierMatchAttributes from './descriptors/ClassifierMatchAttributes'
  37 import ConnectionPoint from './descriptors/ConnectionPoint'
  38 import VnfdConnectionPointRef from './descriptors/VnfdConnectionPointRef'
  39 import ConstituentVnfd from './descriptors/ConstituentVnfd'
  40 import ConstituentVnfdConnectionPoint from './descriptors/ConstituentVnfdConnectionPoint'
  41 import ForwardingGraph from './descriptors/ForwardingGraph'
  42 import InternalConnectionPoint from './descriptors/InternalConnectionPoint'
  43 import InternalVirtualLink from './descriptors/InternalVirtualLink'
  44 import NetworkService from './descriptors/NetworkService'
  45 import PhysicalNetworkFunction from './descriptors/PhysicalNetworkFunction'
  46 import RecordServicePath from './descriptors/RecordServicePath'
  47 import RspConnectionPointRef from './descriptors/RspConnectionPointRef'
  48 import VirtualDeploymentUnit from './descriptors/VirtualDeploymentUnit'
  49 import VirtualLink from './descriptors/VirtualLink'
  50 import VirtualNetworkFunction from './descriptors/VirtualNetworkFunction'
  51 import VirtualNetworkFunctionReadOnlyWrapper from './descriptors/VirtualNetworkFunctionReadOnlyWrapper'
  52 import InternalConnectionPointRef from './descriptors/InternalConnectionPointRef'
  53 import VirtualNetworkFunctionConnectionPoint from './descriptors/VirtualNetworkFunctionConnectionPoint'
  54 import VirtualDeploymentUnitInternalConnectionPoint from './descriptors/VirtualDeploymentUnitInternalConnectionPoint'
  55 import VirtualNetworkFunctionAccessPointMap from './descriptors/VirtualNetworkFunctionAccessPointMap'
  56 function findChildDescriptorModelAndUpdateModel(model, parent) {
  57         if (parent instanceof DescriptorModel) {
  58                 const child = parent.findChildByUid(model);
  59                 if (child) {
  60                         child.model = model;
  61                         return child;
  62                 }
  63         }
  64 }
  65
  66 let identity = 0;
  67
  68 class DescriptorModelFactory {
  69
  70
  71         static containerIdentity(d) {
  72                 const parentId = UID.from(d && d.parent);
  73                 // note the incremental counter is to always force d3 models to update
  74                 return (parentId ? parentId + ':' : '') + UID.from(d) + ':' + identity++;
  75         }
  76
  77         /**
  78          * Create a reduce function that creates a DescriptorModel element tree
  79          * representation of a Catalog Item and then returns a flat list of
  80          * DescriptorModel elements. The first item in the array is root.
  81
  82          * @returns {Function}
  83          */
  84         static buildCatalogItemFactory(catalogs) {
  85
  86                 function findCatalogItemByTypeAndId(type, id) {
  87                         return catalogs.filter(catalog => catalog.type === type).reduce((a, b) => a.concat(b.descriptors), []).filter(d => d.id === id)[0];
  88                 }
  89
  90                 function mapVLD(vld, containerList) {
  91                         containerList.push(vld);
  92                         vld.connection.forEach(d => containerList.push(d));
  93                 }
  94
  95                 function mapIVLD(ivld, containerList) {
  96                         containerList.push(ivld);
  97                         ivld.connection.forEach(d => containerList.push(d));
  98                 }
  99
 100                 function mapRspConnectionPoint(cp, containerList) {
 101                         containerList.push(cp);
 102                 }
 103
 104                 function mapClassifier(classifier, containerList) {
 105                         containerList.push(classifier);
 106                         // get the referenced vnfd required for rendering the connection point
 107                         const vnfdRef = findCatalogItemByTypeAndId('vnfd', classifier.model['vnfd-id-ref']);
 108                         if (vnfdRef) {
 109                                 classifier.uiState.vnfdRef = vnfdRef;
 110                         }
 111                         classifier.matchAttributes.forEach(attr => containerList.push(attr));
 112                 }
 113
 114                 function mapRSP(rsp, containerList) {
 115                         containerList.push(rsp);
 116                         rsp.vnfdConnectionPointRef.forEach(cpRef => mapRspConnectionPoint(cpRef, containerList));
 117                 }
 118
 119                 function mapFG(fg, containerList) {
 120                         containerList.push(fg);
 121                         fg.rsp.forEach(rsp => mapRSP(rsp, containerList));
 122                         fg.classifier.forEach(classifier => mapClassifier(classifier, containerList));
 123                 }
 124         function mapConfigParameterMap(ap, containerList) {
 125             containerList.push(ap);
 126         }
 127
 128                 function mapVDU(vdu, containerList) {
 129                         containerList.push(vdu);
 130                         vdu.connectionPoint.forEach(d => containerList.push(d));
 131                 }
 132
 133                 function mapCVNFD(cvnfd, containerList) {
 134                         // get the referenced vnfd required for rendering the connection points
 135                         const vnfdRef = findCatalogItemByTypeAndId('vnfd', cvnfd.model['vnfd-id-ref']);
 136                         if (!vnfdRef) {
 137                                 console.warn('No VNFD found in catalog with id: ' + cvnfd['vnfd-id-ref']);
 138                         }
 139                         cvnfd.vnfdRef = vnfdRef;
 140                         containerList.push(cvnfd);
 141                         cvnfd.vld.forEach(vld => mapIVLD(vld, containerList));
 142                         cvnfd.connectionPoint.forEach(cp => containerList.push(cp));
 143                 }
 144
 145                 function mapNSD(nsd, containerList) {
 146                         containerList.push(nsd);
 147                         nsd.constituentVnfd.forEach(cvnfd => mapCVNFD(cvnfd, containerList));
 148                         nsd.vld.forEach(vld => mapVLD(vld, containerList));
 149                         nsd.vnffgd.forEach(fg => mapFG(fg, containerList));
 150             nsd.configParameterMap.forEach(ap => mapConfigParameterMap(ap, containerList));
 151                 }
 152
 153                 function mapVNFD(vnfd, containerList) {
 154                         containerList.push(vnfd);
 155                         vnfd.vdu.forEach(vdu => mapVDU(vdu, containerList));
 156                         vnfd.vld.forEach(vld => mapIVLD(vld, containerList));
 157                         vnfd.connectionPoint.forEach(cp => containerList.push(cp));
 158                 }
 159
 160                 function mapPNFD(pnfd, containerList) {
 161                         containerList.push(pnfd);
 162                 }
 163
 164                 return (containerList, obj) => {
 165                         if (_isEmpty(obj)) {
 166                                 return containerList;
 167                         }
 168                         switch (obj.uiState.type) {
 169                         case 'nsd':
 170                                 mapNSD(DescriptorModelFactory.newNetworkService(obj), containerList);
 171                                 break;
 172                         case 'vnfd':
 173                                 mapVNFD(DescriptorModelFactory.newVirtualNetworkFunction(obj), containerList);
 174                                 break;
 175                         case 'pnfd':
 176                                 mapPNFD(DescriptorModelFactory.newPhysicalNetworkFunction(obj), containerList);
 177                                 break;
 178                         default:
 179                                 throw new ReferenceError('only catalog items can be rendered in the canvas. unexpected type: ' + obj.uiState.type);
 180                         }
 181                         return containerList;
 182                 };
 183
 184         }
 185
 186         static newNetworkService(model, parent) {
 187                 return findChildDescriptorModelAndUpdateModel(model, parent) || new NetworkService(model, parent);
 188         }
 189
 190         static newConstituentVnfd(model, parent) {
 191                 return findChildDescriptorModelAndUpdateModel(model, parent) || new ConstituentVnfd(model, parent);
 192         }
 193
 194         static newVirtualNetworkFunction(model, parent) {
 195                 return findChildDescriptorModelAndUpdateModel(model, parent) || new VirtualNetworkFunction(model, parent);
 196         }
 197
 198         static newVirtualNetworkFunctionConnectionPoint(model, parent) {
 199                 return findChildDescriptorModelAndUpdateModel(model, parent) || new VirtualNetworkFunctionConnectionPoint(model, parent);
 200         }
 201
 202         static newInternalConnectionPoint(model, parent) {
 203                 return findChildDescriptorModelAndUpdateModel(model, parent) || new InternalConnectionPoint(model, parent);
 204         }
 205
 206         static newVirtualDeploymentUnit(model, parent) {
 207                 return findChildDescriptorModelAndUpdateModel(model, parent) || new VirtualDeploymentUnit(model, parent);
 208         }
 209
 210         static newVirtualDeploymentUnitInternalConnectionPoint(model, parent) {
 211                 return findChildDescriptorModelAndUpdateModel(model, parent) || new VirtualDeploymentUnitInternalConnectionPoint(model, parent);
 212         }
 213
 214         static newVirtualLink(model, parent) {
 215                 return findChildDescriptorModelAndUpdateModel(model, parent) || new VirtualLink(model, parent);
 216         }
 217
 218         static newInternalVirtualLink(model, parent, readonly) {
 219                 return findChildDescriptorModelAndUpdateModel(model, parent) || new InternalVirtualLink(model, parent, readonly);
 220         }
 221
 222         static newPhysicalNetworkFunction(model, parent) {
 223                 return findChildDescriptorModelAndUpdateModel(model, parent) || new PhysicalNetworkFunction(model, parent);
 224         }
 225
 226         static newConstituentVnfdConnectionPoint(model, parent, readonly) {
 227                 return findChildDescriptorModelAndUpdateModel(model, parent) || new ConstituentVnfdConnectionPoint(model, parent, readonly);
 228         }
 229
 230         static newVnfdConnectionPointRef(model, parent) {
 231                 return findChildDescriptorModelAndUpdateModel(model, parent) || new VnfdConnectionPointRef(model, parent);
 232         }
 233
 234     static newVirtualNetworkFunctionAccessPointMap(model, parent) {
 235         return findChildDescriptorModelAndUpdateModel(model, parent) || new VirtualNetworkFunctionAccessPointMap(model, parent);
 236     }
 237         static newForwardingGraph(model, parent) {
 238                 return findChildDescriptorModelAndUpdateModel(model, parent) || new ForwardingGraph(model, parent);
 239         }
 240
 241         static newRecordServicePath(model, parent) {
 242                 return findChildDescriptorModelAndUpdateModel(model, parent) || new RecordServicePath(model, parent);
 243         }
 244
 245         static newRspConnectionPointRef(model, parent) {
 246                 return findChildDescriptorModelAndUpdateModel(model, parent) || new RspConnectionPointRef(model, parent);
 247         }
 248
 249         static newVirtualNetworkFunctionReadOnlyWrapper(vnfdToWrap, parent) {
 250                 let model;
 251                 if (vnfdToWrap instanceof DescriptorModel) {
 252                         if (vnfdToWrap instanceof VirtualNetworkFunction) {
 253                                 model = vnfdToWrap.model;
 254                         } else {
 255                                 throw new ReferenceError(`expected a VirtualNetworkFunction but got a ${vnfdToWrap.className}`);
 256                         }
 257                 } else {
 258                         model = vnfdToWrap;
 259                 }
 260                 return new VirtualNetworkFunctionReadOnlyWrapper(_cloneDeep(model), parent);
 261         }
 262
 263         static newClassifier(model, parent) {
 264                 return findChildDescriptorModelAndUpdateModel(model, parent) || new Classifier(model, parent);
 265         }
 266
 267         static newClassifierMatchAttributes(model, parent) {
 268                 return findChildDescriptorModelAndUpdateModel(model, parent) || new ClassifierMatchAttributes(model, parent);
 269         }
 270
 271         static newInternalConnectionPointRef(model, parent) {
 272                 // note do not find children bc model is not an object it is a leaf-list primative and so the class manages it
 273                 return findChildDescriptorModelAndUpdateModel(model, parent) || new InternalConnectionPointRef(model, parent);
 274         }
 275
 276         /**
 277          * Special instance of a RecordServicePath that will create its parent ForwardingGraph it does not exist.
 278          *
 279          * This is useful to present a stub RSP as an initiator to create Paths without explicitly creating an RSP - just
 280          * start building a path and it auto-magically builds the RSP.
 281          *
 282          * @param parent
 283          * @param model
 284          */
 285         static newRecordServicePathFactory(model, parent) {
 286                 return new AutoCreateRecordServicePath(model, parent);
 287         }
 288
 289         static isContainer(obj) {
 290                 return obj instanceof DescriptorModel;
 291         }
 292
 293         static isConnector(obj) {
 294                 return obj instanceof ConnectionPoint;
 295         }
 296
 297         static isConnectionPoint(obj) {
 298                 return obj instanceof ConnectionPoint;
 299         }
 300
 301         static isConstituentVnfd(obj) {
 302                 return obj instanceof ConstituentVnfd;
 303         }
 304
 305         static isConstituentVnfdWithServiceChain(obj, chain) {
 306                 return obj instanceof ConstituentVnfd && obj.vnfdServiceFunctionChain === chain;
 307         }
 308
 309         static isNetworkService(obj) {
 310                 return obj instanceof NetworkService;
 311         }
 312
 313         static isVnfdConnectionPointRef(obj) {
 314                 return obj instanceof VnfdConnectionPointRef;
 315         }
 316
 317         static isRecordServicePath(obj) {
 318                 return obj instanceof RecordServicePath;
 319         }
 320
 321         static isRspConnectionPointRef(obj) {
 322                 return obj instanceof RspConnectionPointRef;
 323         }
 324
 325         static isVirtualLink(obj) {
 326                 return obj instanceof VirtualLink;
 327         }
 328
 329         static isVirtualNetworkFunction(obj) {
 330                 return obj instanceof VirtualNetworkFunction;
 331         }
 332
 333     static isVirtualNetworkFunctionAccessPointMap(obj) {
 334         return obj instanceof VirtualNetworkFunctionAccessPointMap;
 335     }
 336         static isForwardingGraph(obj) {
 337                 return obj instanceof ForwardingGraph;
 338         }
 339
 340         static isInternalConnectionPoint(obj) {
 341                 return obj instanceof InternalConnectionPoint;
 342         }
 343
 344         static isInternalVirtualLink(obj) {
 345                 return obj instanceof InternalVirtualLink;
 346         }
 347
 348         static get VirtualLink () {
 349                 return VirtualLink;
 350         }
 351
 352         static get NetworkService () {
 353                 return NetworkService;
 354         }
 355
 356     static get VirtualNetworkFunctionAccessPointMap () {
 357         return VirtualNetworkFunctionAccessPointMap;
 358     }
 359         static get ForwardingGraph () {
 360                 return ForwardingGraph;
 361         }
 362
 363         static get VirtualNetworkFunction () {
 364                 return VirtualNetworkFunction;
 365         }
 366
 367         static get ConstituentVnfd () {
 368                 return ConstituentVnfd;
 369         }
 370
 371         static get Classifier() {
 372                 return Classifier;
 373         }
 374
 375         static get ClassifierMatchAttributes() {
 376                 return ClassifierMatchAttributes;
 377         }
 378
 379         static get VnfdConnectionPointRef() {
 380                 return VnfdConnectionPointRef;
 381         }
 382
 383         static get VirtualDeploymentUnit() {
 384                 return VirtualDeploymentUnit;
 385         }
 386
 387         static get InternalConnectionPoint() {
 388                 return InternalConnectionPoint;
 389         }
 390
 391         static get InternalVirtualLink() {
 392                 return InternalVirtualLink;
 393         }
 394
 395         static get InternalConnectionPointRef() {
 396                 return InternalConnectionPointRef;
 397         }
 398
 399         static get VirtualNetworkFunctionConnectionPoint() {
 400                 return VirtualNetworkFunctionConnectionPoint;
 401         }
 402
 403         static get VirtualDeploymentUnitInternalConnectionPoint() {
 404                 return VirtualDeploymentUnitInternalConnectionPoint;
 405         }
 406
 407 }
 408
 409 /**
 410  * Auto create a RecordServicePath when a VnfdConnectionPointRef is added.
 411  */
 412 class AutoCreateRecordServicePath extends RecordServicePath {
 413
 414         constructor(model, parent) {
 415                 super(model, null);
 416                 this.parent = parent;
 417                 this.isFactory = true;
 418         }
 419
 420         create() {
 421                 return this.parent.createRsp();
 422         }
 423
 424         createVnfdConnectionPointRef(obj) {
 425                 const rsp = this.create();
 426                 rsp.createVnfdConnectionPointRef(obj);
 427                 return rsp;
 428         }
 429
 430 }
 431
 432 export default DescriptorModelFactory;