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