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