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