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 = true;
 140         let configPrimitive = vnfrs[vnfrIndex]['vnf-configuration']['config-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'] && 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         };
 162
 163         if (parameters.length > 0) {
 164             vnfPrimitive[0].parameter = parameters;
 165         }
 166
 167         payload['vnf-list'].push({
 168             'member_vnf_index_ref': vnfrs[vnfrIndex]['member-vnf-index-ref'],
 169             'vnfr-id-ref': vnfrs[vnfrIndex]['id'],
 170             'vnf-primitive': vnfPrimitive
 171         })
 172         if (isValid) {
 173             this.execNsConfigPrimitive(payload);
 174         }
 175         return isValid;
 176     }
 177     constructAndTriggerNsConfigPrimitive(data) {
 178         let nsConfigPrimitiveIndexToExecute = data.nsConfigPrimitiveIndex;
 179         let nsConfigPrimitives = data.nsConfigPrimitives;
 180         let nsConfigPrimitive = data.nsConfigPrimitives[nsConfigPrimitiveIndexToExecute];
 181
 182         let payload = {
 183             name: nsConfigPrimitive['name'],
 184             nsr_id_ref: nsConfigPrimitive['nsr_id_ref'],
 185             'vnf-list': [],
 186             'parameter': [],
 187             'parameter-group': [],
 188         };
 189         let vnfList = [];
 190         nsConfigPrimitive['vnf-primitive-group'].map((vnf) => {
 191
 192             let vnfPrimitiveList = []
 193             vnf['inputs'].map((vnfPrimitive) => {
 194
 195                 let parameterList = [];
 196
 197                 const filterAndAddByValue = (paramObj) => {
 198                     let nameValuePair = null;
 199
 200                     if (paramObj['value'] != undefined) {
 201                         nameValuePair = {
 202                             name: paramObj.name,
 203                             value: paramObj.value
 204                         };
 205                     } else if (paramObj['default-value'] != undefined) {
 206                         nameValuePair = {
 207                             name: paramObj.name,
 208                             value: paramObj['default-value']
 209                         }
 210                     }
 211                     if (nameValuePair) {
 212                         parameterList.push(nameValuePair);
 213                     }
 214
 215                     return paramObj['value'] != undefined;
 216                 }
 217
 218                 vnfPrimitive['parameter'].filter(filterAndAddByValue);
 219
 220                 if (parameterList.length > 0) {
 221                     vnfPrimitiveList.push({
 222                         name: vnfPrimitive['name'],
 223                         index: vnfPrimitive['index'],
 224                         parameter: parameterList
 225                     });
 226                 }
 227             });
 228
 229             vnfList.push({
 230                 'member_vnf_index_ref': vnf['member-vnf-index-ref'],
 231                 'vnfr-id-ref': vnf['vnfr-id-ref'],
 232                 'vnf-primitive': vnfPrimitiveList
 233             });
 234         });
 235
 236         payload['vnf-list'] = vnfList;
 237
 238         let nsConfigPrimitiveParameterGroupParameters = [];
 239         nsConfigPrimitive['parameter-group'] && nsConfigPrimitive['parameter-group'].map((nsConfigPrimitiveParameterGroup) => {
 240             let nsConfigPrimitiveParameters = [];
 241             nsConfigPrimitiveParameterGroup['parameter'] && nsConfigPrimitiveParameterGroup['parameter'].map((nsConfigPrimitiveParameterGroupParameter) => {
 242                 if (nsConfigPrimitiveParameterGroupParameter['value'] != undefined) {
 243                     nsConfigPrimitiveParameters.push({
 244                         'name': nsConfigPrimitiveParameterGroupParameter.name,
 245                         'value': nsConfigPrimitiveParameterGroupParameter.value
 246                     });
 247                 }
 248             });
 249             nsConfigPrimitiveParameterGroupParameters.push({
 250                 'name': nsConfigPrimitiveParameterGroup.name,
 251                 'parameter': nsConfigPrimitiveParameters
 252             });
 253         });
 254
 255         payload['parameter-group'] = nsConfigPrimitiveParameterGroupParameters;
 256
 257         let nsConfigPrimitiveParameters = [];
 258         nsConfigPrimitive['parameter'] && nsConfigPrimitive['parameter'].map((nsConfigPrimitiveParameter) => {
 259             if (nsConfigPrimitiveParameter['value'] != undefined && nsConfigPrimitiveParameter['value'] != ""
 260                 )
 261             {
 262                 nsConfigPrimitiveParameters.push({
 263                     'name': nsConfigPrimitiveParameter.name,
 264                     'value': nsConfigPrimitiveParameter.value
 265                 });
 266             } else {
 267                 if ( (nsConfigPrimitiveParameter['value'] == undefined)
 268                    && nsConfigPrimitiveParameter['default-value']) {
 269                     nsConfigPrimitiveParameters.push({
 270                         'name': nsConfigPrimitiveParameter.name,
 271                         'value': nsConfigPrimitiveParameter['default-value']
 272                     });
 273                 }
 274             }
 275         });
 276
 277         payload['parameter'] = nsConfigPrimitiveParameters;
 278
 279         this.execNsConfigPrimitive(payload);
 280     }
 281     execNsConfigPrimitiveSuccess(data) {}
 282     createScalingGroupInstanceSuccess(data) {}
 283     deleteScalingGroupInstanceSuccess(data) {}
 284     triggerCreateScalingGroupInstance(params) {
 285         this.createScalingGroupInstance(params);
 286     }
 287     triggerDeleteScalingGroupInstance(params) {
 288         this.deleteScalingGroupInstance(params);
 289     }
 290     validateInputs(data) {
 291         let nsConfigPrimitiveIndexToExecute = data.nsConfigPrimitiveIndex;
 292         let nsConfigPrimitives = data.nsConfigPrimitives;
 293         let nsConfigPrimitive = data.nsConfigPrimitives[nsConfigPrimitiveIndexToExecute];
 294         let isValid = true;
 295         //Check parameter groups for required fields
 296         nsConfigPrimitive['parameter-group'] && nsConfigPrimitive['parameter-group'].map((parameterGroup, parameterGroupIndex) => {
 297             let isMandatory = parameterGroup.mandatory != 'false';
 298             let optionalChecked = parameterGroup.optionalChecked;
 299             let isActiveOptional = (optionalChecked && !isMandatory);
 300             if (isActiveOptional || isMandatory) {
 301                 parameterGroup['parameter'] && parameterGroup['parameter'].map((parameter, parameterIndex) => {
 302                     let msg = 'Parameter Group: ' + parameterGroup.name + ' is not valid';
 303                     if (isValid) {
 304                         isValid = validateParameter(parameter);
 305                     }
 306                 });
 307             }
 308         });
 309
 310         //Check top level parameters for required fields
 311         nsConfigPrimitive['parameter'] && nsConfigPrimitive['parameter'].map((parameter, parameterIndex) => {
 312                 if (isValid) {
 313                     isValid = validateParameter(parameter);
 314                 }
 315         });
 316
 317         nsConfigPrimitive['vnf-primitive-group'] && nsConfigPrimitive['vnf-primitive-group'].map((vnfPrimitiveGroup, vnfPrimitiveGroupIndex) => {
 318             vnfPrimitiveGroup['inputs'] && vnfPrimitiveGroup['inputs'].map((input, inputIndex) => {
 319                 input['parameter'] && input['parameter'].map((param) => {
 320                     if (isValid) {
 321                         isValid = validateParameter(param);
 322                     }
 323                 })
 324             })
 325         });
 326
 327         return isValid;
 328     }
 329
 330     createVirtualLinkSuccess(data) {}
 331     editVirtualLinkSuccess(data) {}
 332     deleteVirtualLinkSuccess(data) {}
 333
 334     triggerCreateVirtualLink(params) {
 335         this.createVirtualLink(params);
 336     }
 337
 338     triggerDeleteVirtualLink(params) {
 339         this.deleteVirtualLink(params);
 340     }
 341
 342     triggerEditVirtualLink(params) {
 343         this.editVirtualLink(params);
 344     }
 345 }
 346
 347
 348
 349 function validateParameter(parameter, msg) {
 350     if ((parameter['hidden'] == 'true') || (parameter['read-only'] == 'true')) {
 351         if (!parameter['default-value']) {
 352             var errorMsg = 'Your descriptor has hidden or read-only parameters with no default-values. Please rectify this.';
 353             console.log(errorMsg);
 354             return false;
 355         } else {
 356             parameter.value = parameter['default-value'];
 357         }
 358     }
 359
 360     if (parameter.mandatory == "true") {
 361         if(parameter.hasOwnProperty('value')){
 362             if (!parameter.value) {
 363                 return false;
 364             }
 365         } else {
 366             if (!parameter['default-value']) {
 367                 return false;
 368             } else {
 369                 parameter.value = parameter['default-value'];
 370             }
 371         }
 372     };
 373
 374     // if (parameter.value == '' || !parameter.value) {
 375     //     if (parameter['default-value']) {
 376     //         parameter.value = parameter['default-value'];
 377     //     }
 378     // };
 379
 380     return true;
 381 };
 382
 383 function connectionManager(type, connection) {
 384     let self = this;
 385     let ws = window.multiplexer.channel(connection);
 386     if (!connection) {
 387         console.warn('There was an issue connecting to the ' + type + ' socket');
 388         return;
 389     }
 390     if (self.socket) {
 391         self.handleCloseSocket();
 392     }
 393
 394     self.setState({
 395         socket: ws.ws,
 396         channelId: connection
 397     });
 398     ws.onmessage = function(data) {
 399
 400         let recordData = JSON.parse(data.data);
 401
 402         let nsrsData = recordData['nsrs'] || null;
 403
 404         let navigatorState = {};
 405
 406         if (nsrsData) {
 407             let nav = [];
 408             let nsrs = nsrsData[0];
 409             nav.push({
 410                 name: nsrs.name,
 411                 id: nsrs.id,
 412                 nsd_name: nsrs.nsd_name,
 413                 type: 'nsr',
 414                 logo: nsrs.nsd && nsrs.nsd.logo,
 415                 logoId: nsrs.nsd && nsrs.nsd && nsrs.nsd.id
 416             });
 417
 418             // Scaled VNFRs
 419             let scaledVnfrs = [];
 420
 421             nsrs['scaling-group-record'] && nsrs['scaling-group-record'].map((sgr, sgrIndex) => {
 422                 sgr['instance'] && sgr['instance'].map((sgInstance, sgInstanceIndex) => {
 423                     let scaledVnfNav = {
 424                         type: 'sgr',
 425                         scalingGroupName: sgr['scaling-group-name-ref'],
 426                         scalingGroupInstanceId: sgInstance['instance-id'],
 427                         vnfr: []
 428                     }
 429
 430                     sgInstance['vnfrs'] && sgInstance['vnfrs'].map((vnfr, vnfrIndex) => {
 431                         scaledVnfrs.push(vnfr);
 432                         let vnfrObj = _.findWhere(nsrs.vnfrs, {id: vnfr});
 433                         scaledVnfNav.vnfr.push({
 434                             name: vnfrObj['short-name'],
 435                             id: vnfr,
 436                             type: 'vnfr',
 437                             logo: vnfrObj['vnfd'] && vnfrObj['vnfd']['logo'],
 438                             logoId: vnfrObj['vnfd'] && vnfrObj['vnfd']['id']
 439                         });
 440                     });
 441                     nav.push(scaledVnfNav);
 442                 });
 443             });
 444
 445             // Non-scaled VNFRs
 446             nsrs.vnfrs.map(function(vnfr, vnfrIndex) {
 447                 if (_.indexOf(scaledVnfrs, vnfr.id) == -1) {
 448                     nav.push({
 449                         name: vnfr["short-name"],
 450                         id: vnfr.id,
 451                         type: 'vnfr',
 452                         logo: vnfr['vnfd'] && vnfr['vnfd']['logo'],
 453                         logoId: vnfr['vnfd'] && vnfr['vnfd']['id']
 454                     });
 455                 }
 456             });
 457             navigatorState = {
 458                 nav: nav,
 459                 recordID: nsrs.id,
 460                 isLoading: false,
 461             };
 462         }
 463
 464         navigatorState = _.extend(navigatorState, {
 465             recordData: recordData,
 466             recordType: type,
 467             cardLoading: false,
 468             // ,isLoading: false
 469         });
 470
 471         self.setState(navigatorState);
 472     };
 473 }
 474
 475 export default Alt.createStore(RecordViewStore);