skyquake/plugins/launchpad/src/recordViewer/recordViewStore.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 import RecordViewActions from './recordViewActions.js';
  19 import RecordViewSource from './recordViewSource.js';
  20 // import source
  21 // import AppHeaderActions from 'widgets/header/headerActions.js';
  22 import Alt from '../alt';
  23 import _ from 'underscore';
  24
  25 class RecordViewStore {
  26     constructor() {
  27         this.isLoading = true;
  28         this.cardLoading = true;
  29         this.detailLoading = true;
  30         //Reference to current socket
  31         this.socket = null;
  32         //Reference to current record type
  33         //"vnfr", "nsr", "default"
  34         this.recordType = "default";
  35         //Reference to current record ID
  36         //uuid or null
  37         this.recordID = null;
  38         //Record data
  39         //object or null
  40         this.recordData = null;
  41         this.nav = [];
  42         this.vnfrs = {};
  43         this.configPrimitives = [];
  44         this.jobData = [];
  45         this.bindActions(RecordViewActions);
  46         this.exportPublicMethods({
  47             constructAndTriggerVnfConfigPrimitive: this.constructAndTriggerVnfConfigPrimitive,
  48             constructAndTriggerNsConfigPrimitive: this.constructAndTriggerNsConfigPrimitive,
  49             triggerCreateScalingGroupInstance: this.triggerCreateScalingGroupInstance,
  50             triggerDeleteScalingGroupInstance: this.triggerDeleteScalingGroupInstance,
  51             validateInputs: this.validateInputs,
  52             handleCloseSocket: this.handleCloseSocket,
  53             handleCloseJobSocket: this.handleCloseJobSocket,
  54             triggerCreateVirtualLink: this.triggerCreateVirtualLink,
  55             triggerEditVirtualLink: this.triggerEditVirtualLink,
  56             triggerDeleteVirtualLink: this.triggerDeleteVirtualLink
  57         })
  58         this.exportAsync(RecordViewSource);
  59     }
  60     handleLogout = () => {
  61
  62     }
  63     handleCloseSocket = () => {
  64         if (this.socket) {
  65             window.multiplexer.channel(this.channelId).close();
  66         }
  67     }
  68     handleCloseJobSocket = () => {
  69         if (this.jobSocket) {
  70             window.multiplexer.channel(this.jobSocketChannelId).close();
  71         }
  72     }
  73     loadRecord(record) {
  74         this.setState({
  75             cardLoading: true,
  76             recordID: record.id
  77         });
  78     }
  79     getNSRSocketLoading() {
  80         this.setState({
  81             cardLoading: true
  82         })
  83     }
  84     getVNFRSocketLoading() {
  85         this.setState({
  86             cardLoading: true
  87         })
  88     }
  89     getConfigSocketJobSuccess(connection) {
  90         let self = this;
  91         let ws = window.multiplexer.channel(connection);
  92         if (!connection) {
  93             console.warn('There was an issue connecting to the Config Job socket');
  94             return;
  95         }
  96         if (self.socket) {
  97             self.handleCloseJobSocket();
  98         }
  99
 100         self.setState({
 101             jobSocket: ws.ws,
 102             jobSocketChannelId: connection
 103         });
 104         ws.onmessage = function(data) {
 105             let jobData = JSON.parse(data.data);
 106             jobData = jobData.nsrs[0]["config-agent-job"] || [];
 107             self.setState({jobData:jobData});
 108         };
 109         ws.onerror = function(data) {
 110             console.log('err', data)
 111         }
 112     }
 113     getVNFRSocketSuccess(connection) {
 114         // debugger;
 115         connectionManager.call(this, 'vnfr', connection);
 116     }
 117     getNSRSocketSuccess(connection) {
 118         connectionManager.call(this, 'nsr', connection);
 119     }
 120     getRawLoading() {
 121         this.setState({
 122             detailLoading: true
 123         })
 124     }
 125     getRawSuccess(data) {
 126         this.setState({
 127             rawData: data,
 128             detailLoading: false
 129         })
 130     }
 131     getNSRSuccess(data) {
 132
 133     }
 134     constructAndTriggerVnfConfigPrimitive(data) {
 135         let vnfrs = data.vnfrs;
 136         let vnfrIndex = data.vnfrIndex;
 137         let configPrimitiveIndex = data.configPrimitiveIndex;
 138         let payload = {};
 139         let isValid = false;
 140         let configPrimitive = vnfrs[vnfrIndex]['vnf-configuration']['service-primitive'][configPrimitiveIndex];
 141
 142         payload['name'] = '';
 143         payload['nsr_id_ref'] = vnfrs[vnfrIndex]['nsr-id-ref'];
 144         payload['vnf-list'] = [];
 145         payload['triggered-by'] = 'vnf-primitive';
 146         let parameters = [];
 147         configPrimitive['parameter'].map((parameter) => {
 148             if(!isValid) {
 149                 isValid = validateParameter(parameter);
 150             }
 151             parameters.push({
 152                 name: parameter['name'],
 153                 value: parameter['value'] || parameter['default-value']
 154             });
 155         });
 156
 157         let vnfPrimitive = [];
 158         vnfPrimitive[0] = {
 159             name: configPrimitive['name'],
 160             index: configPrimitiveIndex,
 161             parameter: parameters
 162         }
 163
 164         payload['vnf-list'].push({
 165             'member_vnf_index_ref': vnfrs[vnfrIndex]['member-vnf-index-ref'],
 166             'vnfr-id-ref': vnfrs[vnfrIndex]['id'],
 167             'vnf-primitive': vnfPrimitive
 168         })
 169         if (isValid) {
 170             this.execNsConfigPrimitive(payload);
 171         }
 172         return isValid;
 173     }
 174     constructAndTriggerNsConfigPrimitive(data) {
 175         let nsConfigPrimitiveIndexToExecute = data.nsConfigPrimitiveIndex;
 176         let nsConfigPrimitives = data.nsConfigPrimitives;
 177         let nsConfigPrimitive = data.nsConfigPrimitives[nsConfigPrimitiveIndexToExecute];
 178
 179         let payload = {
 180             name: nsConfigPrimitive['name'],
 181             nsr_id_ref: nsConfigPrimitive['nsr_id_ref'],
 182             'vnf-list': [],
 183             'parameter': [],
 184             'parameter-group': [],
 185         };
 186         let vnfList = [];
 187         nsConfigPrimitive['vnf-primitive-group'].map((vnf) => {
 188
 189             let vnfPrimitiveList = []
 190             vnf['inputs'].map((vnfPrimitive) => {
 191
 192                 let parameterList = [];
 193
 194                 const filterAndAddByValue = (paramObj) => {
 195                     let nameValuePair = null;
 196
 197                     if (paramObj['value'] != undefined) {
 198                         nameValuePair = {
 199                             name: paramObj.name,
 200                             value: paramObj.value
 201                         };
 202                     } else if (paramObj['default-value'] != undefined) {
 203                         nameValuePair = {
 204                             name: paramObj.name,
 205                             value: paramObj['default-value']
 206                         }
 207                     }
 208                     if (nameValuePair) {
 209                         parameterList.push(nameValuePair);
 210                     }
 211
 212                     return paramObj['value'] != undefined;
 213                 }
 214
 215                 vnfPrimitive['parameter'].filter(filterAndAddByValue);
 216
 217                 if (parameterList.length > 0) {
 218                     vnfPrimitiveList.push({
 219                         name: vnfPrimitive['name'],
 220                         index: vnfPrimitive['index'],
 221                         parameter: parameterList
 222                     });
 223                 }
 224             });
 225
 226             vnfList.push({
 227                 'member_vnf_index_ref': vnf['member-vnf-index-ref'],
 228                 'vnfr-id-ref': vnf['vnfr-id-ref'],
 229                 'vnf-primitive': vnfPrimitiveList
 230             });
 231         });
 232
 233         payload['vnf-list'] = vnfList;
 234
 235         let nsConfigPrimitiveParameterGroupParameters = [];
 236         nsConfigPrimitive['parameter-group'] && nsConfigPrimitive['parameter-group'].map((nsConfigPrimitiveParameterGroup) => {
 237             let nsConfigPrimitiveParameters = [];
 238             nsConfigPrimitiveParameterGroup['parameter'] && nsConfigPrimitiveParameterGroup['parameter'].map((nsConfigPrimitiveParameterGroupParameter) => {
 239                 if (nsConfigPrimitiveParameterGroupParameter['value'] != undefined) {
 240                     nsConfigPrimitiveParameters.push({
 241                         'name': nsConfigPrimitiveParameterGroupParameter.name,
 242                         'value': nsConfigPrimitiveParameterGroupParameter.value
 243                     });
 244                 }
 245             });
 246             nsConfigPrimitiveParameterGroupParameters.push({
 247                 'name': nsConfigPrimitiveParameterGroup.name,
 248                 'parameter': nsConfigPrimitiveParameters
 249             });
 250         });
 251
 252         payload['parameter-group'] = nsConfigPrimitiveParameterGroupParameters;
 253
 254         let nsConfigPrimitiveParameters = [];
 255         nsConfigPrimitive['parameter'] && nsConfigPrimitive['parameter'].map((nsConfigPrimitiveParameter) => {
 256             if (nsConfigPrimitiveParameter['value'] != undefined && nsConfigPrimitiveParameter['value'] != ""
 257                 )
 258             {
 259                 nsConfigPrimitiveParameters.push({
 260                     'name': nsConfigPrimitiveParameter.name,
 261                     'value': nsConfigPrimitiveParameter.value
 262                 });
 263             } else {
 264                 if ( (nsConfigPrimitiveParameter['value'] == undefined)
 265                    && nsConfigPrimitiveParameter['default-value']) {
 266                     nsConfigPrimitiveParameters.push({
 267                         'name': nsConfigPrimitiveParameter.name,
 268                         'value': nsConfigPrimitiveParameter['default-value']
 269                     });
 270                 }
 271             }
 272         });
 273
 274         payload['parameter'] = nsConfigPrimitiveParameters;
 275
 276         this.execNsConfigPrimitive(payload);
 277     }
 278     execNsConfigPrimitiveSuccess(data) {}
 279     createScalingGroupInstanceSuccess(data) {}
 280     deleteScalingGroupInstanceSuccess(data) {}
 281     triggerCreateScalingGroupInstance(params) {
 282         this.createScalingGroupInstance(params);
 283     }
 284     triggerDeleteScalingGroupInstance(params) {
 285         this.deleteScalingGroupInstance(params);
 286     }
 287     validateInputs(data) {
 288         let nsConfigPrimitiveIndexToExecute = data.nsConfigPrimitiveIndex;
 289         let nsConfigPrimitives = data.nsConfigPrimitives;
 290         let nsConfigPrimitive = data.nsConfigPrimitives[nsConfigPrimitiveIndexToExecute];
 291         let isValid = true;
 292         //Check parameter groups for required fields
 293         nsConfigPrimitive['parameter-group'] && nsConfigPrimitive['parameter-group'].map((parameterGroup, parameterGroupIndex) => {
 294             let isMandatory = parameterGroup.mandatory != 'false';
 295             let optionalChecked = parameterGroup.optionalChecked;
 296             let isActiveOptional = (optionalChecked && !isMandatory);
 297             if (isActiveOptional || isMandatory) {
 298                 parameterGroup['parameter'] && parameterGroup['parameter'].map((parameter, parameterIndex) => {
 299                     let msg = 'Parameter Group: ' + parameterGroup.name + ' is not valid';
 300                     if (isValid) {
 301                         isValid = validateParameter(parameter);
 302                     }
 303                 });
 304             }
 305         });
 306
 307         //Check top level parameters for required fields
 308         nsConfigPrimitive['parameter'] && nsConfigPrimitive['parameter'].map((parameter, parameterIndex) => {
 309                 if (isValid) {
 310                     isValid = validateParameter(parameter);
 311                 }
 312         });
 313
 314         nsConfigPrimitive['vnf-primitive-group'] && nsConfigPrimitive['vnf-primitive-group'].map((vnfPrimitiveGroup, vnfPrimitiveGroupIndex) => {
 315             vnfPrimitiveGroup['inputs'] && vnfPrimitiveGroup['inputs'].map((input, inputIndex) => {
 316                 input['parameter'] && input['parameter'].map((param) => {
 317                     if (isValid) {
 318                         isValid = validateParameter(param);
 319                     }
 320                 })
 321             })
 322         });
 323
 324         return isValid;
 325     }
 326
 327     createVirtualLinkSuccess(data) {}
 328     editVirtualLinkSuccess(data) {}
 329     deleteVirtualLinkSuccess(data) {}
 330
 331     triggerCreateVirtualLink(params) {
 332         this.createVirtualLink(params);
 333     }
 334
 335     triggerDeleteVirtualLink(params) {
 336         this.deleteVirtualLink(params);
 337     }
 338
 339     triggerEditVirtualLink(params) {
 340         this.editVirtualLink(params);
 341     }
 342 }
 343
 344
 345
 346 function validateParameter(parameter, msg) {
 347     if ((parameter['hidden'] == 'true') || (parameter['read-only'] == 'true')) {
 348         if (!parameter['default-value']) {
 349             var errorMsg = 'Your descriptor has hidden or read-only parameters with no default-values. Please rectify this.';
 350             console.log(errorMsg);
 351             return false;
 352         } else {
 353             parameter.value = parameter['default-value'];
 354         }
 355     }
 356
 357     if (parameter.mandatory == "true") {
 358         if(parameter.hasOwnProperty('value')){
 359             if (!parameter.value) {
 360                 return false;
 361             }
 362         } else {
 363             if (!parameter['default-value']) {
 364                 return false;
 365             } else {
 366                 parameter.value = parameter['default-value'];
 367             }
 368         }
 369     };
 370
 371     // if (parameter.value == '' || !parameter.value) {
 372     //     if (parameter['default-value']) {
 373     //         parameter.value = parameter['default-value'];
 374     //     }
 375     // };
 376
 377     return true;
 378 };
 379
 380 function connectionManager(type, connection) {
 381     let self = this;
 382     let ws = window.multiplexer.channel(connection);
 383     if (!connection) {
 384         console.warn('There was an issue connecting to the ' + type + ' socket');
 385         return;
 386     }
 387     if (self.socket) {
 388         self.handleCloseSocket();
 389     }
 390
 391     self.setState({
 392         socket: ws.ws,
 393         channelId: connection
 394     });
 395     ws.onmessage = function(data) {
 396
 397         let recordData = JSON.parse(data.data);
 398
 399         let nsrsData = recordData['nsrs'] || null;
 400
 401         let navigatorState = {};
 402
 403         if (nsrsData) {
 404             let nav = [];
 405             let nsrs = nsrsData[0];
 406             nav.push({
 407                 name: nsrs.name,
 408                 id: nsrs.id,
 409                 nsd_name: nsrs.nsd_name,
 410                 type: 'nsr'
 411             });
 412
 413             // Scaled VNFRs
 414             let scaledVnfrs = [];
 415
 416             nsrs['scaling-group-record'] && nsrs['scaling-group-record'].map((sgr, sgrIndex) => {
 417                 sgr['instance'] && sgr['instance'].map((sgInstance, sgInstanceIndex) => {
 418                     let scaledVnfNav = {
 419                         type: 'sgr',
 420                         scalingGroupName: sgr['scaling-group-name-ref'],
 421                         scalingGroupInstanceId: sgInstance['instance-id'],
 422                         vnfr: []
 423                     }
 424
 425                     sgInstance['vnfrs'] && sgInstance['vnfrs'].map((vnfr, vnfrIndex) => {
 426                         scaledVnfrs.push(vnfr);
 427                         scaledVnfNav.vnfr.push({
 428                             name: _.findWhere(nsrs.vnfrs, {id: vnfr})['short-name'],
 429                             id: vnfr,
 430                             type: 'vnfr'
 431                         });
 432                     });
 433                     nav.push(scaledVnfNav);
 434                 });
 435             });
 436
 437             // Non-scaled VNFRs
 438             nsrs.vnfrs.map(function(vnfr, vnfrIndex) {
 439                 if (_.indexOf(scaledVnfrs, vnfr.id) == -1) {
 440                     nav.push({
 441                         name: vnfr["short-name"],
 442                         id: vnfr.id,
 443                         type: 'vnfr'
 444                     });
 445                 }
 446             });
 447             navigatorState = {
 448                 nav: nav,
 449                 recordID: nsrs.id,
 450                 isLoading: false,
 451             };
 452         }
 453
 454         navigatorState = _.extend(navigatorState, {
 455             recordData: recordData,
 456             recordType: type,
 457             cardLoading: false,
 458             // ,isLoading: false
 459         });
 460
 461         self.setState(navigatorState);
 462     };
 463 }
 464
 465 export default Alt.createStore(RecordViewStore);