openo-portal/portal-lifecyclemgr/src/main/webapp/lifecyclemgr/js/gsolcm.js

   1 /*
   2  * Copyright 2016 ZTE Corporation.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 var templateParameters = {
  17     changed: true,
  18     parameters: [],
  19     vimInfos: []
  20 };
  21
  22 var lcmHandler = function () {
  23     this._addOwnEvents();
  24 };
  25
  26 lcmHandler.prototype = {
  27     _addOwnEvents: function () {
  28         $('#createNS').click(this.okAction);
  29     },
  30     okAction: function () {
  31         if(!checkLocation(templateParameters.parameters)) {
  32                 alert('Location must be selected in Template Parameters');
  33                 return;
  34         }
  35         $.isLoading({ text: "Creating service..." });
  36         var serviceInstance = {
  37             serviceTemplateId: $("#svcTempl").val(),
  38             serviceName: $('#svcName').val(),
  39             description: $('#svcDesc').val(),
  40             inputParameters: collectServiceParameters(templateParameters.parameters)
  41         };
  42         var gatewayService = '/openoapi/servicegateway/v1/services';
  43         $.when(
  44             fetchServiceTemplateBy(serviceInstance.serviceTemplateId)
  45         ).then(
  46             function(template) {
  47                 serviceInstance.templateName = template.name;
  48                 serviceInstance.serviceType = template.serviceType;
  49                 return createNetworkServiceInstance(template, serviceInstance, gatewayService);
  50             }
  51         ).then(
  52             function(serviceInstance) {
  53                 updateTable(serviceInstance);
  54                 $.isLoading('hide');
  55                 $('#vmAppDialog').removeClass('in').css('display', 'none');
  56             }
  57         );
  58     }
  59 };
  60
  61 function checkLocation(parameters) {
  62         var checkPass = true;
  63         var i = 0;
  64         for(i = 0; i < parameters.length; i++) {
  65                 if(parameters[i].type === 'location') {
  66                         var value = $('#' + parameters[i].id).val();
  67                         if(value === undefined || value === 'select') {
  68                                 checkPass = false;
  69                         }
  70                 }
  71         }
  72         return checkPass;
  73 }
  74
  75 function initParameterTab() {
  76         // Service template was not changed. Do not re-initiate the parameter tab.
  77     if (!templateParameters.changed) {
  78         return;
  79     }
  80     var templateId = $("#svcTempl").val();
  81     if ('select' === templateId) {
  82         document.getElementById("templateParameterTab").innerHTML = '';
  83         return;
  84     }
  85         $.when(
  86                 fetchServiceTemplateBy(templateId)
  87         ).then(
  88             function(template) {
  89                 if(template.serviceType === 'GSO') {
  90                         return fetchGsoTemplateInputParameters(templateId);
  91                 } else if(template.serviceType === 'NFVO') {
  92                         return fetchNfvoTemplateInputParameters(templateId);
  93                 } else if(template.serviceType === 'SDNO') {
  94                         return fetchSdnoTemplateInputParameters(templateId);
  95                 }
  96             }
  97         ).then(
  98             function(parameters) {
  99                 var components = transformToComponents(parameters);
 100                 document.getElementById("templateParameterTab").innerHTML = components;
 101             }
 102         );
 103 }
 104
 105 function fetchServiceTemplateBy(templateId) {
 106     var defer = $.Deferred();
 107     var serviceTemplateUri = '/openoapi/catalog/v1/servicetemplates/' + templateId;
 108     var template = {};
 109     $.when(
 110         $.ajax({
 111             type: "GET",
 112             url: serviceTemplateUri,
 113             contentType: "application/json"
 114         })
 115     ).then(
 116         function(response) {
 117             template.name = response.templateName;
 118             template.gsarId = response.csarId;
 119             template.id = response.id;
 120             return fetchCsar(template.gsarId);
 121         }
 122     ).then(
 123         function(response) {
 124             if(response.type === 'GSAR') {
 125                 template.serviceType = 'GSO';
 126             } else if(response.type === 'NSAR' || response.type === 'NFAR') {
 127                 template.serviceType = 'NFVO';
 128             } else if(response.type === 'SSAR') {
 129                 template.serviceType = "SDNO";
 130             }
 131             defer.resolve(template)
 132         }
 133     );
 134     return defer;
 135 }
 136
 137 function fetchCsar(csarId) {
 138         var queryCsarUri = '/openoapi/catalog/v1/csars/' + csarId;
 139         return $.ajax({
 140                 type: "GET",
 141                 url: queryCsarUri,
 142                 contentType: "application/json"
 143         });
 144 }
 145
 146 function fetchGsoTemplateInputParameters(templateId) {
 147         var defer = $.Deferred();
 148     $.when(
 149         fetchTemplateParameterDefinitions(templateId),
 150         fetchGsoNestingTemplateParameters(templateId),
 151         fetchVimInfo(),
 152         fetchSdnController()
 153     ).then(
 154         function (templateParameterResponse, nestingTempatesParas, vimInfoResponse, sdnControllersResponse) {
 155                 var inputParas = concat(templateParameterResponse[0].inputs, nestingTempatesParas);
 156                 var vims = translateToVimInfo(vimInfoResponse[0]);
 157             var sdnControllers = translateToSdnControllers(sdnControllersResponse[0]);
 158             templateParameters = translateToTemplateParameters(inputParas, vims, sdnControllers);
 159             defer.resolve(templateParameters);
 160         }
 161     );
 162     return defer;
 163 }
 164
 165 function fetchGsoNestingTemplateParameters(templateId) {
 166         var defer = $.Deferred();
 167         $.when(
 168                 fetchNodeTemplates(templateId)
 169         ).then(
 170             function(nodeTemplates) {
 171                 var count = nodeTemplates.length;
 172                 if(count ===0) {
 173                         defer.resolve([]);
 174                         return;
 175                 }
 176                 var nestingParasAggregatation = aggregate(count, function(nestingParas) {
 177                         defer.resolve(nestingParas);
 178                 });
 179                 nodeTemplates.forEach(function(nodeTemplate) {
 180                         var nestingNodeUri = '/openoapi/catalog/v1/servicetemplates/nesting?nodeTypeIds=' + nodeTemplate.type;
 181                         $.when(
 182                                 $.ajax({
 183                                         type: "GET",
 184                                         url: nestingNodeUri
 185                                 })
 186                         ).then(
 187                             function(serviceTemplates) {
 188                                 var nodeAggregatation = aggregate(serviceTemplates.length, function(oneNodeParameters) {
 189                                         nestingParasAggregatation.notify(oneNodeParameters);
 190                                 });
 191                                 serviceTemplates.forEach(function(serviceTemplate) {
 192                                                         if(serviceTemplate === null || serviceTemplate === undefined || serviceTemplate.inputs === undefined || serviceTemplate.csarId === undefined)
 193                                                         {
 194                                                                 nodeAggregatation.notify([]);
 195                                                                 return;
 196                                                         }
 197                                         var inputs = serviceTemplate.inputs.map(function(input) {
 198                                 input.showName = input.name;
 199                                                 input.name = nodeTemplate.type + '.' + input.name;
 200                                                 return input;
 201                                         });
 202                                         $.when(
 203                                                 fetchCsar(serviceTemplate.csarId)
 204                                         ).then(
 205                                             function(response) {
 206                                                 if(response.type === 'NSAR' || response.type === 'NFAR') {
 207                                                         inputs.push({
 208                                                                 name: nodeTemplate.type + '.location',
 209                                                                 type: 'location',
 210                                                                 description: nodeTemplate.name + ' Location',
 211                                                                 required: 'true',
 212                                             showName: nodeTemplate.name + ' Location'
 213                                                         });
 214                                         inputs.push({
 215                                             name: nodeTemplate.type + '.sdncontroller',
 216                                             type: 'sdncontroller',
 217                                             description: nodeTemplate.name + ' SDN Controller',
 218                                             required: 'true',
 219                                             showName: nodeTemplate.name + ' SDN Controller'
 220                                         });
 221                                     }
 222                                                 nodeAggregatation.notify(inputs);
 223                                             }
 224                                         );
 225                                 });
 226                             }
 227                         );
 228                 });
 229             }
 230         );
 231         return defer;
 232 }
 233
 234 function fetchNodeTemplates(templateId) {
 235         var nodeTemplateUri = '/openoapi/catalog/v1/servicetemplates/'+ templateId +'/nodetemplates';
 236         return $.ajax({
 237                 type: "GET",
 238                 url: nodeTemplateUri
 239         });
 240 }
 241
 242 function aggregate(n, deferFun) {
 243         var aggregation = $.Deferred();
 244         var count = n;
 245         var result = [];
 246         aggregation.progress(function(array) {
 247                 pushAll(result, array);
 248                 count--;
 249                 if(count === 0) {
 250                         deferFun(result);
 251                 }
 252         });
 253         return aggregation;
 254 }
 255
 256 function concat(array1, array2) {
 257         var result = [];
 258         pushAll(result, array1);
 259         pushAll(result, array2);
 260         return result;
 261 }
 262
 263 function pushAll(acc, array) {
 264         var result = acc;
 265         array.forEach(function(element) {
 266                 result.push(element)
 267         })
 268         return result;
 269 }
 270
 271 function translateToTemplateParameters(inputs, vims, controllers) {
 272     var inputParameters = [];
 273     var i;
 274     for (i = 0; i < inputs.length; i += 1) {
 275         inputParameters[i] = {
 276             name: inputs[i].name,
 277             type: inputs[i].type,
 278             description: inputs[i].description,
 279             defaultValue: inputs[i].defaultValue,
 280             required: inputs[i].required,
 281             id: 'parameters_' + i,
 282             value: inputs[i].defaultValue || ''
 283         };
 284     }
 285     return {changed: false, parameters: inputParameters, vimInfos: vims, sdnControllers: controllers};
 286 }
 287
 288 function fetchNfvoTemplateInputParameters(templateId) {
 289         var defer = $.Deferred();
 290         $.when(
 291                 fetchTemplateParameterDefinitions(templateId),
 292                 fetchVimInfo(),
 293         fetchSdnController()
 294         ).then(
 295             function (templateParameterResponse, vimInfoResponse, sdnControllerResponse) {
 296                 var vims = translateToVimInfo(vimInfoResponse[0]);
 297             var sdnControllers = translateToSdnControllers(sdnControllerResponse[0]);
 298                 var inputParas = templateParameterResponse[0].inputs;
 299                 inputParas.push({
 300                         name: 'location',
 301                         type: 'location',
 302                         description: 'Location',
 303                         required: 'true',
 304                 showName: 'Location'
 305                 });
 306             inputParas.push({
 307                 name: 'sdncontroller',
 308                 type: 'sdncontroller',
 309                 description: 'SDN Controller',
 310                 required: 'true',
 311                 showName: 'SDN Controller'
 312             });
 313                 templateParameters = translateToTemplateParameters(inputParas, vims, sdnControllers);
 314             defer.resolve(templateParameters);
 315             }
 316         );
 317         return defer;
 318 }
 319
 320 function fetchSdnoTemplateInputParameters(templateId) {
 321         var defer = $.Deferred();
 322         $.when(
 323                 fetchTemplateParameterDefinitions(templateId)
 324         ).then(
 325             function (templateParameterResponse) {
 326                 templateParameters = translateToTemplateParameters(templateParameterResponse.inputs, [], []);
 327             defer.resolve(templateParameters);
 328             }
 329         );
 330         return defer;
 331 }
 332
 333 function fetchTemplateParameterDefinitions(templateId) {
 334     var queryParametersUri = '/openoapi/catalog/v1/servicetemplates/' + templateId + '/parameters';
 335     return $.ajax({
 336         type: "GET",
 337         url: queryParametersUri
 338     });
 339 }
 340
 341 function fetchVimInfo() {
 342     var vimQueryUri = '/openoapi/extsys/v1/vims';
 343     return $.ajax({
 344         type: "GET",
 345         url: vimQueryUri
 346     });
 347 }
 348
 349 function fetchSdnController() {
 350     var sdnControllerUri = '/openoapi/extsys/v1/sdncontrollers';
 351     return $.ajax({
 352         type: "GET",
 353         url: sdnControllerUri
 354     });
 355 }
 356
 357 function translateToVimInfo(vims) {
 358         return vims.map(function (vim) {
 359                 return {
 360                         optionId: vim.vimId,
 361                         optionName: vim.name
 362                 };
 363         });
 364 }
 365
 366 function translateToSdnControllers(controllers) {
 367     return controllers.map(function(controller) {
 368         return {
 369             optionId: controller.sdnControllerId,
 370             optionName: controller.name
 371         };
 372     });
 373 }
 374
 375 function transformToComponents(templateParas) {
 376         var inputs = templateParas.parameters;
 377         var vimInfos = templateParas.vimInfos;
 378     var sdnControllers = templateParas.sdnControllers;
 379         var components = '';
 380         inputs.forEach(function (inputPara) {
 381                 if(inputPara.type === 'location') {
 382                         components = components + generateComboxComponent(inputPara, vimInfos);
 383                 } else if(inputPara.type === 'sdncontroller') {
 384             components = components + generateComboxComponent(inputPara, sdnControllers);
 385         } else {
 386                         components = components + generateComponent(inputPara);
 387                 }
 388         });
 389         return components;
 390 }
 391
 392 function generateComboxComponent(inputPara, items) {
 393     var component = '<div class="form-group" style="margin-left:25px;margin-bottom:15px;">' +
 394         '<label class="col-sm-3 control-label">' +
 395         '<span>'+ inputPara.showName +'</span>' +
 396         '<span class="required">*</span>' +
 397         '</label>' +
 398         '<div class="col-sm-7">' +
 399         '<select class="form-control" style ="padding-top: 0px;padding-bottom: 0px;"' +
 400         ' id="' + inputPara.id + '" name="'+ inputPara.name +'">' +
 401         transformToOptions(items) +
 402         '</select></div></div>';
 403     return component;
 404 }
 405
 406 function transformToOptions(items) {
 407     var options = '<option value="select">--select--</option>';
 408     var i;
 409     for (i = 0; i < items.length; i += 1) {
 410         var option = '<option value="' + items[i].optionId + '">' + items[i].optionName + '</option>';
 411         options = options + option;
 412     }
 413     return options;
 414 }
 415
 416 function generateComponent(inputPara) {
 417         var component = '<div class="mT15 form-group" style="margin-left:25px;">' +
 418             '<label class="col-sm-3 control-label">' +
 419             '<span>' + inputPara.showName + '</span>' + generateRequiredLabel(inputPara) +
 420             '</label>' +
 421             '<div class="col-sm-7">' +
 422             '<input type="text" id="' + inputPara.id + '" name="parameter description" class="form-control" placeholder="' +
 423             inputPara.showName + '" value="' + inputPara.value + '" />' +
 424             '</div></div>';
 425     return component;
 426 }
 427
 428 function generateRequiredLabel(parameter) {
 429     var requiredLabel = '';
 430     if (parameter.required === 'true') {
 431         requiredLabel = '<span class="required">*</span>';
 432     }
 433     return requiredLabel;
 434 }
 435
 436 function createNetworkServiceInstance(template, serviceInstance, gatewayService) {
 437     if (template.serviceType === 'GSO') {
 438         return createGsoServiceInstance(gatewayService, serviceInstance, template);
 439     } else if (template.serviceType === 'NFVO') {
 440         return createNfvoServiceInstance(gatewayService, serviceInstance, template);
 441     } else if (template.serviceType === 'SDNO') {
 442         return createSdnoServiceInstance(gatewayService, serviceInstance);
 443     }
 444 }
 445
 446 function createGsoServiceInstance(gatewayService, serviceInstance, serviceTemplate) {
 447     var defer = $.Deferred();
 448     var gsoLcmUri = '/openoapi/gso/v1/services';
 449     var parameter = {
 450         'service': {
 451                 'name': serviceInstance.serviceName,
 452                 'description': serviceInstance.description,
 453                 'serviceDefId': serviceTemplate.gsarId,
 454                 'templateId': serviceInstance.serviceTemplateId,
 455                 'templateName': serviceTemplate.name,
 456                 'gatewayUri': gsoLcmUri,
 457                 'parameters': serviceInstance.inputParameters
 458         }
 459     };
 460     $.when($.ajax({
 461         type: "POST",
 462         url: gatewayService,
 463         contentType: "application/json",
 464         dataType: "json",
 465         data: JSON.stringify(parameter)
 466     })).then(function(response) {
 467         serviceInstance.serviceId = response.serviceId;
 468         defer.resolve(serviceInstance);
 469     });
 470     return defer;
 471 }
 472
 473 function createNfvoServiceInstance(gatewayService, serviceInstance, template) {
 474     var nfvoLcmNsUri = '/openoapi/nslcm/v1/ns';
 475     serviceInstance.nsdId = template.id;
 476     return createServiceInstance(gatewayService, nfvoLcmNsUri, serviceInstance);
 477 }
 478
 479 function createSdnoServiceInstance(gatewayService, serviceInstance) {
 480     var sdnoLcmNsUri = '/openoapi/sdnonslcm/v1/ns';
 481     serviceInstance.nsdId = serviceInstance.serviceTemplateId;
 482     return createServiceInstance(gatewayService, sdnoLcmNsUri, serviceInstance);
 483 }
 484
 485 function createServiceInstance(gatewayService, nsUri, serviceInstance) {
 486     var defer = $.Deferred();
 487     var sParameter = {
 488         'nsdId': serviceInstance.nsdId,
 489         'nsName': serviceInstance.serviceName,
 490         'description': serviceInstance.description,
 491         'gatewayUri': nsUri
 492     };
 493     $.when($.ajax({
 494         type: "POST",
 495         url: gatewayService,
 496         contentType: "application/json",
 497         dataType: "json",
 498         data: JSON.stringify(sParameter)
 499     })).then(function(response) {
 500         var nsInstanceId = response.serviceId;
 501         serviceInstance.serviceId = nsInstanceId;
 502         var initNsUrl = nsUri + '/' + nsInstanceId + '/instantiate';
 503         var parameter = {
 504             'gatewayUri': initNsUrl,
 505             'nsInstanceId': nsInstanceId,
 506             'additionalParamForNs': serviceInstance.inputParameters
 507         };
 508         return $.ajax({
 509             type: "POST",
 510             url: gatewayService,
 511             contentType: "application/json",
 512             dataType: "json",
 513             data: JSON.stringify(parameter)
 514         });
 515     }).then(function() {
 516         defer.resolve(serviceInstance);
 517     });
 518     return defer;
 519 }
 520
 521
 522 function collectServiceParameters(parameters) {
 523     var serviceParameters = {};
 524     var i;
 525     for (i = 0; i < parameters.length; i += 1) {
 526         var value = $('#' + parameters[i].id).val();
 527         serviceParameters[parameters[i].name] = value;
 528     }
 529     return serviceParameters;
 530 }
 531
 532 function updateTable(serviceInstance) {
 533     serviceInstance.createTime = formatDate(new Date());
 534     $('#sai').bootstrapTable("append", serviceInstance);
 535 }
 536
 537 function formatDate(date) {
 538     var year = date.getFullYear();
 539     var month = date.getMonth() + 1;
 540     var day = date.getDate();
 541     var hh = date.getHours();
 542     var mm = date.getMinutes();
 543     var ss = date.getSeconds();
 544     return year + "-" + month + "-" + day + " " + hh + ":" + mm + ":" + ss;
 545 }
 546
 547 function deleteNe(rowId, row) {
 548     var deleteHandle = function(result) {
 549         if(result) {
 550             $.isLoading({ text: "Deleting service..." });
 551             var instanceId = row.serviceId;
 552             var serviceType = row.serviceType;
 553             var gatewayService = '/openoapi/servicegateway/v1/services/' + instanceId + '/terminate';
 554             var remove = function () {
 555                 $.isLoading( "hide" );
 556                 $('#sai').bootstrapTable('remove', {field: 'serviceId', values: [instanceId]});
 557             };
 558             if(serviceType === 'GSO') {
 559                 deleteGsoServiceInstance(gatewayService, instanceId, remove);
 560             } else if (serviceType === 'NFVO') {
 561                 var nfvoNsUri = '/openoapi/nslcm/v1/ns';
 562                 deleteNonGsoServiceInstance(gatewayService, nfvoNsUri, instanceId, remove);
 563             } else if (serviceType === 'SDNO') {
 564                 var sdnoNsUri = '/openoapi/sdnonslcm/v1/ns';
 565                 deleteNonGsoServiceInstance(gatewayService, sdnoNsUri, instanceId, remove);
 566             }
 567         }
 568     };
 569     bootbox.confirm("Do you confirm to delete service?", deleteHandle);
 570 }
 571
 572 function deleteGsoServiceInstance(gatewayService, instanceId, remove) {
 573     var gsoLcmUri = '/openoapi/gso/v1/services';
 574     $.when(
 575         deleteNetworkServiceInstance(gatewayService, gsoLcmUri, instanceId)
 576     ).then(
 577         function() {
 578             remove();
 579         }
 580     );
 581 }
 582
 583 function deleteNonGsoServiceInstance(gatewayService, nsUri, instanceId, remove) {
 584     $.when(
 585         terminateNetworkServiceInstance(gatewayService, nsUri, instanceId)
 586     ).then(
 587         function() {
 588             return deleteNetworkServiceInstance(gatewayService, nsUri, instanceId);
 589         }
 590     ).then(
 591         function() {
 592             remove();
 593         }
 594     );
 595 }
 596
 597 function deleteNetworkServiceInstance(gatewayService, nsUri, instanceId) {
 598     var instanceUri = nsUri + '/' + instanceId;
 599     var parameter = {
 600         'operation': "DELETE",
 601         'gatewayUri': instanceUri
 602     };
 603     return $.ajax({
 604         type: "POST",
 605         url: gatewayService,
 606         contentType: "application/json",
 607         dataType: "json",
 608         data: JSON.stringify(parameter)
 609     });
 610 }
 611
 612 function terminateNetworkServiceInstance(gatewayService, nsUri, instanceId) {
 613     var instanceUri = nsUri + '/' + instanceId;
 614     var nsTerminateUri = instanceUri + '/terminate';
 615     var terminateParameter = {
 616         'nsInstanceId': instanceId,
 617         'terminationType': "graceful",
 618         'gracefulTerminationTimeout': "60",
 619         'operation': "POST",
 620         'gatewayUri': nsTerminateUri
 621     };
 622     return $.ajax({
 623         type: "POST",
 624         url: gatewayService,
 625         contentType: "application/json",
 626         dataType: "json",
 627         data: JSON.stringify(terminateParameter)
 628     });
 629 }