server/src/main/java/org/onap/usecaseui/server/service/lcm/impl/DefaultPackageDistributionService.java

   1 /**
   2  * Copyright 2016-2017 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 package org.onap.usecaseui.server.service.lcm.impl;
  17
  18 import static org.onap.usecaseui.server.service.lcm.domain.sdc.consts.SDCConsts.CATEGORY_NS;
  19 import static org.onap.usecaseui.server.service.lcm.domain.sdc.consts.SDCConsts.DISTRIBUTION_STATUS_DISTRIBUTED;
  20 import static org.onap.usecaseui.server.service.lcm.domain.sdc.consts.SDCConsts.RESOURCETYPE_VF;
  21
  22 import static org.onap.usecaseui.server.util.RestfulServices.create;
  23 import static org.onap.usecaseui.server.util.RestfulServices.extractBody;
  24
  25 import java.io.BufferedReader;
  26 import java.io.IOException;
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import javax.annotation.Resource;
  33 import javax.servlet.http.HttpServletRequest;
  34
  35 import org.onap.usecaseui.server.bean.ServiceBean;
  36 import org.onap.usecaseui.server.bean.lcm.VfNsPackageInfo;
  37 import org.onap.usecaseui.server.constant.Constant;
  38 import org.onap.usecaseui.server.service.lcm.PackageDistributionService;
  39 import org.onap.usecaseui.server.service.lcm.ServiceLcmService;
  40 import org.onap.usecaseui.server.service.lcm.domain.aai.bean.nsServiceRsp;
  41 import org.onap.usecaseui.server.service.lcm.domain.sdc.SDCCatalogService;
  42 import org.onap.usecaseui.server.service.lcm.domain.sdc.bean.SDCServiceTemplate;
  43 import org.onap.usecaseui.server.service.lcm.domain.sdc.bean.Vnf;
  44 import org.onap.usecaseui.server.service.lcm.domain.vfc.VfcService;
  45 import org.onap.usecaseui.server.service.lcm.domain.vfc.beans.Csar;
  46 import org.onap.usecaseui.server.service.lcm.domain.vfc.beans.DistributionResult;
  47 import org.onap.usecaseui.server.service.lcm.domain.vfc.beans.Job;
  48 import org.onap.usecaseui.server.service.lcm.domain.vfc.beans.JobStatus;
  49 import org.onap.usecaseui.server.service.lcm.domain.vfc.exceptions.VfcException;
  50 import org.onap.usecaseui.server.util.RestfulServices;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  54 import org.springframework.stereotype.Service;
  55
  56 import com.alibaba.fastjson.JSON;
  57 import com.alibaba.fastjson.JSONObject;
  58
  59 import okhttp3.RequestBody;
  60 import okhttp3.ResponseBody;
  61 import retrofit2.Response;
  62
  63 @Service("PackageDistributionService")
  64 @org.springframework.context.annotation.Configuration
  65 @EnableAspectJAutoProxy
  66 public class DefaultPackageDistributionService implements PackageDistributionService {
  67
  68     private static final Logger logger = LoggerFactory.getLogger(DefaultPackageDistributionService.class);
  69
  70     private SDCCatalogService sdcCatalogService;
  71
  72     private VfcService vfcService;
  73
  74     @Resource(name="ServiceLcmService")
  75     private ServiceLcmService serviceLcmService;
  76
  77     public DefaultPackageDistributionService() {
  78         this(create(SDCCatalogService.class), create(VfcService.class));
  79     }
  80
  81     public DefaultPackageDistributionService(SDCCatalogService sdcCatalogService, VfcService vfcService) {
  82         this.sdcCatalogService = sdcCatalogService;
  83         this.vfcService = vfcService;
  84     }
  85
  86     public void setServiceLcmService(ServiceLcmService serviceLcmService) {
  87         this.serviceLcmService = serviceLcmService;
  88     }
  89
  90     @Override
  91     public VfNsPackageInfo retrievePackageInfo() {
  92             List<SDCServiceTemplate> nsTemplate = sdcNsPackageInfo();
  93             List<Vnf> vnf = sdcVfPackageInfo();
  94             return new VfNsPackageInfo(nsTemplate, vnf);
  95     }
  96
  97     @Override
  98     public List<Vnf> sdcVfPackageInfo() {
  99         try {
 100             Response<List<Vnf>> response = sdcCatalogService.listResources(RESOURCETYPE_VF).execute();
 101             if (response.isSuccessful()) {
 102                 return response.body();
 103             } else {
 104                 logger.info(String.format("Can not get VF resources[code=%s, message=%s]", response.code(), response.message()));
 105                 return Collections.emptyList();
 106             }
 107         } catch (IOException e) {
 108             logger.error("sdcVfPackageInfo occur exception.Details:"+e.getMessage());
 109         }
 110         return null;
 111     }
 112
 113     @Override
 114     public List<SDCServiceTemplate> sdcNsPackageInfo() {
 115         try {
 116             Response<List<SDCServiceTemplate>> response = sdcCatalogService.listServices(CATEGORY_NS, DISTRIBUTION_STATUS_DISTRIBUTED).execute();
 117             if (response.isSuccessful()) {
 118                 return response.body();
 119             } else {
 120                 logger.info(String.format("Can not get NS services[code=%s, message=%s]", response.code(), response.message()));
 121                 return Collections.emptyList();
 122             }
 123         } catch (IOException e) {
 124             logger.error("sdcNsPackageInfo occur exception.Details:"+e.getMessage());
 125         }
 126         return null;
 127     }
 128
 129     @Override
 130     public DistributionResult postNsPackage(Csar csar) {
 131         try {
 132             Response<DistributionResult> response = vfcService.distributeNsPackage(csar).execute();
 133             if (response.isSuccessful()) {
 134                 return response.body();
 135             } else {
 136                 logger.info(String.format("Can not post NS packages[code=%s, message=%s]", response.code(), response.message()));
 137                 throw new VfcException("VFC service is not available!");
 138             }
 139         } catch (IOException e) {
 140             throw new VfcException("VFC service is not available!", e);
 141         }
 142     }
 143
 144     @Override
 145     public Job postVfPackage(Csar csar) {
 146         try {
 147             Response<Job> response = vfcService.distributeVnfPackage(csar).execute();
 148             if (response.isSuccessful()) {
 149                 return response.body();
 150             } else {
 151                 logger.info(String.format("Can not get VF packages[code=%s, message=%s]", response.code(), response.message()));
 152                 throw new VfcException("VFC service is not available!");
 153             }
 154         } catch (IOException e) {
 155             throw new VfcException("VFC service is not available!", e);
 156         }
 157     }
 158
 159     @Override
 160     public JobStatus getJobStatus(String jobId, String responseId) {
 161         try {
 162             Response<JobStatus> response = vfcService.getJobStatus(jobId, responseId).execute();
 163             if (response.isSuccessful()) {
 164                 return response.body();
 165             } else {
 166                 logger.info(String.format("Can not get Job status[code=%s, message=%s]", response.code(), response.message()));
 167                 throw new VfcException("VFC service is not available!");
 168             }
 169         } catch (IOException e) {
 170             throw new VfcException("VFC service is not available!", e);
 171         }
 172     }
 173
 174     @Override
 175     public JobStatus getNsLcmJobStatus(String serviceInstanceId,String jobId, String responseId,String operationType) {        try {
 176         Response<JobStatus> response = vfcService.getNsLcmJobStatus(jobId, responseId).execute();
 177         if (response.isSuccessful()) {
 178             return response.body();
 179         } else {
 180             logger.info(String.format("Can not get Job status[code=%s, message=%s]", response.code(), response.message()));
 181             throw new VfcException("VFC service getNsLcmJobStatus is not available!");
 182         }
 183     } catch (IOException e) {
 184         throw new VfcException("VFC service getNsLcmJobStatus is not available!", e);
 185     }}
 186
 187     @Override
 188     public DistributionResult deleteNsPackage(String csarId) {
 189         try {
 190             Response<DistributionResult> response = vfcService.deleteNsPackage(csarId).execute();
 191             if (response.isSuccessful()) {
 192                 return response.body();
 193             } else {
 194                 logger.info(String.format("Can not delete NS packages[code=%s, message=%s]", response.code(), response.message()));
 195                 throw new VfcException("VFC service is not available!");
 196             }
 197         } catch (IOException e) {
 198             throw new VfcException("VFC service is not available!", e);
 199         }
 200     }
 201
 202     @Override
 203     public Job deleteVfPackage(String csarId) {
 204         try {
 205             Response<Job> response = vfcService.deleteVnfPackage(csarId).execute();
 206             if (response.isSuccessful()) {
 207                 return response.body();
 208             } else {
 209                 logger.info(String.format("Can not delete VF packages[code=%s, message=%s]", response.code(), response.message()));
 210                 throw new VfcException("VFC service is not available!");
 211             }
 212         } catch (IOException e) {
 213             throw new VfcException("VFC service is not available!", e);
 214         }
 215     }
 216
 217     @Override
 218     public String getVnfPackages() {
 219         String result="";
 220         try {
 221             logger.info("vfc getVnfPackages is starting!");
 222             Response<ResponseBody> response = this.vfcService.getVnfPackages().execute();
 223             logger.info("vfc getVnfPackages has finished!");
 224             if (response.isSuccessful()) {
 225                 result=new String(response.body().bytes());
 226             } else {
 227                 logger.info(String.format("Can not get getVnfPackages[code=%s, message=%s]", response.code(), response.message()));
 228                 result=Constant.CONSTANT_FAILED;;
 229             }
 230         } catch (IOException e) {
 231             logger.error("getVnfPackages occur exception:"+e);
 232             result=Constant.CONSTANT_FAILED;;
 233         }
 234         return result;
 235     }
 236
 237     @Override
 238     public String getNetworkServicePackages() {
 239
 240         String result="";
 241         try {
 242             logger.info("vfc getNetworkServicePackages is starting!");
 243             Response<ResponseBody> response = this.vfcService.getNetworkServicePackages().execute();
 244             logger.info("vfc getNetworkServicePackages has finished!");
 245             if (response.isSuccessful()) {
 246                 result=new String(response.body().bytes());
 247             } else {
 248                 logger.info(String.format("Can not get getNetworkServicePackages[code=%s, message=%s]", response.code(), response.message()));
 249                 result=Constant.CONSTANT_FAILED;;
 250             }
 251         } catch (IOException e) {
 252             logger.error("getNetworkServicePackages occur exception:"+e);
 253             result=Constant.CONSTANT_FAILED;;
 254         }
 255         return result;
 256
 257     }
 258
 259     @Override
 260     public String getPnfPackages() {
 261
 262         String result="";
 263         try {
 264             logger.info("vfc getPnfPackages is starting!");
 265             Response<ResponseBody> response = this.vfcService.getPnfPackages().execute();
 266             logger.info("vfc getPnfPackages has finished!");
 267             if (response.isSuccessful()) {
 268                 result=new String(response.body().bytes());
 269             } else {
 270                 logger.info(String.format("Can not get getPnfPackages[code=%s, message=%s]", response.code(), response.message()));
 271                 result=Constant.CONSTANT_FAILED;;
 272             }
 273         } catch (IOException e) {
 274             logger.error("getPnfPackages occur exception:"+e);
 275             result=Constant.CONSTANT_FAILED;;
 276         }
 277         return result;
 278
 279     }
 280
 281     @Override
 282     public String downLoadNsPackage(String nsdInfoId) {
 283
 284         String result="";
 285         try {
 286             logger.info("vfc downLoadNsPackage is starting!");
 287             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(nsdInfoId).execute();
 288             logger.info("vfc downLoadNsPackage has finished!");
 289             if (response.isSuccessful()) {
 290                 result=Constant.CONSTANT_SUCCESS;
 291             } else {
 292                 logger.info(String.format("Can not get downLoadNsPackage[code=%s, message=%s]", response.code(), response.message()));
 293                 result=Constant.CONSTANT_FAILED;;
 294             }
 295         } catch (IOException e) {
 296             logger.error("downLoadNsPackage occur exception:"+e);
 297             result=Constant.CONSTANT_FAILED;;
 298         }
 299         return result;
 300
 301     }
 302
 303     @Override
 304     public String downLoadPnfPackage(String pnfdInfoId) {
 305
 306         String result="";
 307         try {
 308             logger.info("vfc downLoadPnfPackage is starting!");
 309             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(pnfdInfoId).execute();
 310             logger.info("vfc downLoadPnfPackage has finished!");
 311             if (response.isSuccessful()) {
 312                 result=Constant.CONSTANT_SUCCESS;
 313             } else {
 314                 logger.info(String.format("Can not get downLoadPnfPackage[code=%s, message=%s]", response.code(), response.message()));
 315                 result=Constant.CONSTANT_FAILED;;
 316             }
 317         } catch (IOException e) {
 318             logger.error("downLoadPnfPackage occur exception:"+e);
 319             result=Constant.CONSTANT_FAILED;;
 320         }
 321         return result;
 322
 323     }
 324
 325     @Override
 326     public String downLoadVnfPackage(String vnfPkgId) {
 327
 328         String result="";
 329         try {
 330             logger.info("vfc downLoadVnfPackage is starting!");
 331             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(vnfPkgId).execute();
 332             logger.info("vfc downLoadVnfPackage has finished!");
 333             if (response.isSuccessful()) {
 334                 result=Constant.CONSTANT_SUCCESS;
 335             } else {
 336                 logger.info(String.format("Can not get downLoadVnfPackage[code=%s, message=%s]", response.code(), response.message()));
 337                 result=Constant.CONSTANT_FAILED;;
 338             }
 339         } catch (IOException e) {
 340             logger.error("downLoadVnfPackage occur exception:"+e);
 341             result=Constant.CONSTANT_FAILED;;
 342         }
 343         return result;
 344
 345     }
 346
 347     @Override
 348     public String deleteNsdPackage(String nsdInfoId) {
 349         Response<ResponseBody> response=null;
 350         String result="";
 351         try {
 352             logger.info("vfc deleteNsdPackage is starting!");
 353             response = this.vfcService.deleteNsdPackage(nsdInfoId).execute();
 354             logger.info("vfc deleteNsdPackage has finished!");
 355             if (response.isSuccessful()) {
 356                 result=Constant.CONSTANT_SUCCESS;
 357             } else {
 358                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 359                 result=Constant.CONSTANT_FAILED;;
 360             }
 361         } catch (IOException e) {
 362             if(e.getMessage().contains("204")){
 363                 return Constant.CONSTANT_SUCCESS;
 364             }
 365             logger.error("deleteNsdPackage occur exception:"+e);
 366             result=Constant.CONSTANT_FAILED;;
 367         }
 368         return result;
 369
 370     }
 371
 372     @Override
 373     public String deleteVnfPackage(String vnfPkgId) {
 374         Response<ResponseBody> response=null;
 375         String result="";
 376         try {
 377             logger.info("vfc deleteVnfPackage is starting!");
 378             response = this.vfcService.deleteVnfdPackage(vnfPkgId).execute();
 379             logger.info("vfc deleteVnfPackage has finished!");
 380             if (response.isSuccessful()) {
 381                 result=Constant.CONSTANT_SUCCESS;
 382             } else {
 383                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 384                 result=Constant.CONSTANT_FAILED;;
 385             }
 386         } catch (IOException e) {
 387             if(e.getMessage().contains("204")){
 388                 return Constant.CONSTANT_SUCCESS;
 389             }
 390             logger.error("deleteVnfPackage occur exception:"+e);
 391             result=Constant.CONSTANT_FAILED;;
 392         }
 393         return result;
 394
 395     }
 396
 397     @Override
 398     public String deletePnfPackage(String pnfdInfoId) {
 399         Response<ResponseBody> response=null;
 400         String result="";
 401         try {
 402             logger.info("vfc deletePnfPackage is starting!");
 403             response = this.vfcService.deletePnfdPackage(pnfdInfoId).execute();
 404             logger.info("vfc deletePnfPackage has finished!");
 405             if (response.isSuccessful()) {
 406                 result=Constant.CONSTANT_SUCCESS;
 407             } else {
 408                 logger.info(String.format("Can not get deletePnfPackage[code=%s, message=%s]", response.code(), response.message()));
 409                 result=Constant.CONSTANT_FAILED;;
 410             }
 411         } catch (IOException e) {
 412             if(e.getMessage().contains("204")){
 413                 return Constant.CONSTANT_SUCCESS;
 414             }
 415             logger.error("deletePnfPackage occur exception:"+e);
 416             result=Constant.CONSTANT_FAILED;;
 417         }
 418         return result;
 419
 420     }
 421
 422     @Override
 423     public List<String> getNetworkServiceInfo() {
 424         List<String> result = new ArrayList<>();
 425         try {
 426             logger.info("vfc getNetworkServiceInfo is starting!");
 427             Response<nsServiceRsp> response = this.vfcService.getNetworkServiceInfo().execute();
 428             logger.info("vfc getNetworkServiceInfo has finished!");
 429             if (response.isSuccessful()) {
 430                 List<String> nsServices = response.body().nsServices;
 431                 if(nsServices.size()>0){
 432                     for(String nsService:nsServices){
 433                         JSONObject object =  JSON.parseObject(nsService);
 434                         String serviceInstanceId=object.get("nsInstanceId").toString();
 435                         ServiceBean serviceBean = serviceLcmService.getServiceBeanByServiceInStanceId(serviceInstanceId);
 436                         object.put("serviceDomain",serviceBean.getServiceDomain());
 437                         object.put("childServiceInstances","[]");
 438                         result.add(object.toString());
 439                     }
 440                 }
 441                 return result;
 442             } else {
 443                 logger.info(String.format("Can not get getNetworkServiceInfo[code=%s, message=%s]", response.code(), response.message()));
 444                 return Collections.emptyList();
 445             }
 446         } catch (IOException e) {
 447             logger.error("getNetworkServiceInfo occur exception:"+e);
 448             return Collections.emptyList();
 449         }
 450
 451     }
 452
 453     @Override
 454     public String createNetworkServiceInstance(HttpServletRequest request) {
 455         String result = "";
 456         try {
 457             logger.info("aai createNetworkServiceInstance is starting");
 458             RequestBody requestBody = extractBody(request);
 459             Response<ResponseBody> response = vfcService.createNetworkServiceInstance(requestBody).execute();
 460             logger.info("aai createNetworkServiceInstance has finished");
 461             if (response.isSuccessful()) {
 462                 result=new String(response.body().bytes());
 463             } else {
 464                 result=Constant.CONSTANT_FAILED;
 465                 logger.error(String.format("Can not createNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 466             }
 467         } catch (Exception e) {
 468             result=Constant.CONSTANT_FAILED;
 469             logger.error("createNetworkServiceInstance occur exception:"+e);
 470         }
 471         return result;
 472     }
 473
 474     @Override
 475     public String deleteNetworkServiceInstance(String nsInstanceId) {
 476         Response response = null;
 477         String result="";
 478         try {
 479             logger.info("vfc deleteNetworkServiceInstance is starting!");
 480             response = this.vfcService.deleteNetworkServiceInstance(nsInstanceId).execute();
 481             logger.info("vfc deleteNetworkServiceInstance has finished!");
 482             if (response.isSuccessful()) {
 483                 result=Constant.CONSTANT_SUCCESS;
 484             } else {
 485                 logger.info(String.format("Can not get deleteNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 486                 result=Constant.CONSTANT_FAILED;;
 487             }
 488         } catch (IOException e) {
 489             if(e.getMessage().contains("204")){
 490                 return Constant.CONSTANT_SUCCESS;
 491             }
 492             logger.error("deleteNetworkServiceInstance occur exception:"+e);
 493             result=Constant.CONSTANT_FAILED;
 494         }
 495         return result;
 496
 497     }
 498
 499     @Override
 500     public String terminateNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 501         String result = "";
 502         try {
 503             logger.info("aai terminateNetworkServiceInstance is starting");
 504             RequestBody requestBody = extractBody(request);
 505             Response<ResponseBody> response = vfcService.terminateNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 506             logger.info("aai terminateNetworkServiceInstance has finished");
 507             if (response.isSuccessful()) {
 508                 result=new String(response.body().bytes());
 509             } else {
 510                 result=Constant.CONSTANT_FAILED;
 511                 logger.error(String.format("Can not terminateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 512             }
 513         } catch (Exception e) {
 514             result=Constant.CONSTANT_FAILED;
 515             logger.error("terminateNetworkServiceInstance occur exception:"+e);
 516         }
 517         return result;
 518     }
 519
 520     @Override
 521     public String healNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 522         String result = "";
 523         try {
 524             logger.info("aai healNetworkServiceInstance is starting");
 525             RequestBody requestBody = extractBody(request);
 526             Response<ResponseBody> response = vfcService.healNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 527             logger.info("aai healNetworkServiceInstance has finished");
 528             if (response.isSuccessful()) {
 529                 result=new String(response.body().bytes());
 530             } else {
 531                 result=Constant.CONSTANT_FAILED;
 532                 logger.error(String.format("Can not healNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 533             }
 534         } catch (Exception e) {
 535             result=Constant.CONSTANT_FAILED;
 536             logger.error("healNetworkServiceInstance occur exception:"+e);
 537         }
 538         return result;
 539     }
 540
 541     @Override
 542     public String scaleNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 543         String result = "";
 544         try {
 545             logger.info("aai scaleNetworkServiceInstance is starting");
 546             RequestBody requestBody = extractBody(request);
 547             Response<ResponseBody> response = vfcService.scaleNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 548             logger.info("aai scaleNetworkServiceInstance has finished");
 549             if (response.isSuccessful()) {
 550                 result=new String(response.body().bytes());
 551             } else {
 552                 result=Constant.CONSTANT_FAILED;
 553                 logger.error(String.format("Can not scaleNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 554             }
 555         } catch (Exception e) {
 556             result=Constant.CONSTANT_FAILED;
 557             logger.error("scaleNetworkServiceInstance occur exception:"+e);
 558         }
 559         return result;
 560     }
 561
 562     @Override
 563     public String createNetworkServiceData(HttpServletRequest request) {
 564         String result = "";
 565         try {
 566             logger.info("aai createNetworkServiceData is starting");
 567             RequestBody requestBody = extractBody(request);
 568             Response<ResponseBody> response = vfcService.createNetworkServiceData(requestBody).execute();
 569             logger.info("aai createNetworkServiceData has finished");
 570             if (response.isSuccessful()) {
 571                 result=new String(response.body().bytes());
 572             } else {
 573                 result=Constant.CONSTANT_FAILED;
 574                 logger.error(String.format("Can not createNetworkServiceData[code=%s, message=%s]", response.code(), response.message()));
 575             }
 576         } catch (Exception e) {
 577             result=Constant.CONSTANT_FAILED;
 578             logger.error("createNetworkServiceData occur exception:"+e);
 579         }
 580         return result;
 581     }
 582
 583     @Override
 584     public String createVnfData(HttpServletRequest request) {
 585         String result = "";
 586         try {
 587             logger.info("aai createVnfData is starting");
 588             RequestBody requestBody = extractBody(request);
 589             Response<ResponseBody> response = vfcService.createVnfData(requestBody).execute();
 590             logger.info("aai createVnfData has finished");
 591             if (response.isSuccessful()) {
 592                 result=new String(response.body().bytes());
 593             } else {
 594                 result=Constant.CONSTANT_FAILED;
 595                 logger.error(String.format("Can not createVnfData[code=%s, message=%s]", response.code(), response.message()));
 596             }
 597         } catch (Exception e) {
 598             result=Constant.CONSTANT_FAILED;
 599             logger.error("createVnfData occur exception:"+e);
 600         }
 601         return result;
 602     }
 603
 604     @Override
 605     public String createPnfData(HttpServletRequest request) {
 606         String result = "";
 607         try {
 608             logger.info("aai createPnfData is starting");
 609             RequestBody requestBody = extractBody(request);
 610             Response<ResponseBody> response = vfcService.createPnfData(requestBody).execute();
 611             logger.info("aai createPnfData has finished");
 612             if (response.isSuccessful()) {
 613                 result=new String(response.body().bytes());
 614             } else {
 615                 result=Constant.CONSTANT_FAILED;
 616                 logger.error(String.format("Can not createPnfData[code=%s, message=%s]", response.code(), response.message()));
 617             }
 618         } catch (Exception e) {
 619             result=Constant.CONSTANT_FAILED;
 620             logger.error("createPnfData occur exception:"+e);
 621         }
 622         return result;
 623     }
 624
 625     @Override
 626     public String getNsdInfo(String nsdInfoId) {
 627
 628         String result="";
 629         try {
 630             logger.info("vfc getNsdInfo is starting!");
 631             Response<ResponseBody> response = this.vfcService.getNsdInfo(nsdInfoId).execute();
 632             logger.info("vfc getNsdInfo has finished!");
 633             if (response.isSuccessful()) {
 634                 result=Constant.CONSTANT_SUCCESS;
 635             } else {
 636                 logger.info(String.format("Can not get getNsdInfo[code=%s, message=%s]", response.code(), response.message()));
 637                 result=Constant.CONSTANT_FAILED;;
 638             }
 639         } catch (IOException e) {
 640             logger.error("getNsdInfo occur exception:"+e);
 641             result=Constant.CONSTANT_FAILED;;
 642         }
 643         return result;
 644
 645     }
 646
 647     @Override
 648     public String getVnfInfo(String vnfPkgId) {
 649
 650         String result="";
 651         try {
 652             logger.info("vfc getVnfInfo is starting!");
 653             Response<ResponseBody> response = this.vfcService.getVnfInfo(vnfPkgId).execute();
 654             logger.info("vfc getVnfInfo has finished!");
 655             if (response.isSuccessful()) {
 656                 result=Constant.CONSTANT_SUCCESS;
 657             } else {
 658                 logger.info(String.format("Can not get getVnfInfo[code=%s, message=%s]", response.code(), response.message()));
 659                 result=Constant.CONSTANT_FAILED;;
 660             }
 661         } catch (IOException e) {
 662             logger.error("getVnfInfo occur exception:"+e);
 663             result=Constant.CONSTANT_FAILED;;
 664         }
 665         return result;
 666
 667     }
 668
 669     @Override
 670     public String getPnfInfo(String pnfdInfoId) {
 671
 672         String result="";
 673         try {
 674             logger.info("vfc getPnfInfo is starting!");
 675             Response<ResponseBody> response = this.vfcService.getPnfInfo(pnfdInfoId).execute();
 676             logger.info("vfc getPnfInfo has finished!");
 677             if (response.isSuccessful()) {
 678                 result=Constant.CONSTANT_SUCCESS;
 679             } else {
 680                 logger.info(String.format("Can not get getPnfInfo[code=%s, message=%s]", response.code(), response.message()));
 681                 result=Constant.CONSTANT_FAILED;;
 682             }
 683         } catch (IOException e) {
 684             logger.error("getPnfInfo occur exception:"+e);
 685             result=Constant.CONSTANT_FAILED;;
 686         }
 687         return result;
 688
 689     }
 690
 691     @Override
 692     public String listNsTemplates() {
 693
 694         String result="";
 695         try {
 696             logger.info("vfc listNsTemplates is starting!");
 697             Response<ResponseBody> response = this.vfcService.listNsTemplates().execute();
 698             logger.info("vfc listNsTemplates has finished!");
 699             if (response.isSuccessful()) {
 700                 result=new String(response.body().bytes());
 701             } else {
 702                 logger.info(String.format("Can not get listNsTemplates[code=%s, message=%s]", response.code(), response.message()));
 703                 result=Constant.CONSTANT_FAILED;;
 704             }
 705         } catch (IOException e) {
 706             logger.error("listNsTemplates occur exception:"+e);
 707             result=Constant.CONSTANT_FAILED;;
 708         }
 709         return result;
 710
 711     }
 712
 713     @Override
 714     public String fetchNsTemplateData(HttpServletRequest request) {
 715         String result = "";
 716         try {
 717             logger.info("aai fetchNsTemplateData is starting");
 718             RequestBody requestBody = extractBody(request);
 719             Response<ResponseBody> response = vfcService.fetchNsTemplateData(requestBody).execute();
 720             logger.info("aai fetchNsTemplateData has finished");
 721             if (response.isSuccessful()) {
 722                 result=new String(response.body().bytes());
 723             } else {
 724                 result=Constant.CONSTANT_FAILED;
 725                 logger.error(String.format("Can not fetchNsTemplateData[code=%s, message=%s]", response.code(), response.message()));
 726             }
 727         } catch (Exception e) {
 728             result=Constant.CONSTANT_FAILED;
 729             logger.error("fetchNsTemplateData occur exception:"+e);
 730         }
 731         return result;
 732     }
 733
 734     @Override
 735     public JSONObject fetchCCVPNTemplateData(HttpServletRequest request, String csarId) {
 736         JSONObject result = new JSONObject();
 737         try {
 738             RequestBody requestBody = extractBody(request);
 739             // search template from vfc catalog
 740             Response<ResponseBody> getResponse = this.vfcService.servicePackages(csarId).execute();
 741
 742             if (getResponse.isSuccessful()) {
 743                 // call vfc template parser
 744                 logger.info("calling ccvpn template file parser is starting");
 745                 Response<ResponseBody> response = vfcService.fetchTemplateInfo(requestBody).execute();
 746                 logger.info("calling ccvpn template file parser has finished");
 747                 if (response.isSuccessful()) {
 748                     result.put("status", Constant.CONSTANT_SUCCESS);
 749                     result.put("result", JSONObject.parseObject(new String(response.body().bytes())));
 750                 } else {
 751                     result.put("status", Constant.CONSTANT_FAILED);
 752                     result.put("error", String.format("Can not parse ccvpn template file. Detail Info [code=%s, message=%s]", response.code(), response.message()));
 753                     logger.error(String.format("Can not parse ccvpn template file. Detail Info [code=%s, message=%s]", response.code(), response.message()));
 754                }
 755             } else {
 756                 // distribute template files to vfc catalog
 757                 Response<ResponseBody> postResponse = this.vfcService.servicePackages(requestBody).execute();
 758                 if (postResponse.isSuccessful()) {
 759                     // call vfc template parser
 760                     logger.info("calling ccvpn template file parser is starting");
 761                     Response<ResponseBody> response = vfcService.fetchTemplateInfo(requestBody).execute();
 762                     logger.info("calling ccvpn template file parser has finished");
 763                     if (response.isSuccessful()) {
 764                         result.put("status", Constant.CONSTANT_SUCCESS);
 765                         result.put("result",JSONObject.parseObject(new String(response.body().bytes())));
 766                     } else {
 767                         result.put("status", Constant.CONSTANT_FAILED);
 768                         result.put("error",String.format("Can not parse ccvpn template file. Detail Info [code=%s, message=%s]", response.code(), response.message()));
 769                         logger.error(String.format("Can not parse ccvpn template file. Detail Info [code=%s, message=%s]", response.code(), response.message()));
 770                     }
 771                 } else {
 772                     result.put("status", Constant.CONSTANT_FAILED);
 773                     result.put("error",String.format("Can not distribute ccvpn template file. Detail Info [code=%s, message=%s]", postResponse.code(), postResponse.message()));
 774                     logger.error(String.format("Can not distribute ccvpn template file. Detail Info [code=%s, message=%s]", postResponse.code(), postResponse.message()));
 775                }
 776             }
 777         } catch (Exception e) {
 778             result.put("status", Constant.CONSTANT_FAILED);
 779             result.put("errorMessage", "calling ccvpn template parser happened exception:"+e);
 780         }
 781         return result;
 782     }
 783
 784     @Override
 785     public String instantiateNetworkServiceInstance(HttpServletRequest request, String serviceInstanceId) {
 786         String result = "";
 787         try {
 788             logger.info("aai instantiateNetworkServiceInstance is starting");
 789             RequestBody requestBody = extractBody(request);
 790             Response<ResponseBody> response = vfcService.instantiateNetworkServiceInstance(requestBody,serviceInstanceId).execute();
 791             logger.info("aai instantiateNetworkServiceInstance has finished");
 792             if (response.isSuccessful()) {
 793                 result=new String(response.body().bytes());
 794             } else {
 795                 result=Constant.CONSTANT_FAILED;
 796                 logger.error(String.format("Can not instantiateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 797             }
 798         } catch (Exception e) {
 799             result=Constant.CONSTANT_FAILED;
 800             logger.error("instantiateNetworkServiceInstance occur exception:"+e);
 801         }
 802         return result;
 803     }
 804
 805     @Override
 806     public String getVnfInfoById(String vnfinstid) {
 807
 808         String result="";
 809         try {
 810             logger.info("vfc getVnfInfoById is starting!");
 811             Response<ResponseBody> response = this.vfcService.getVnfInfoById(vnfinstid).execute();
 812             logger.info("vfc getVnfInfoById has finished!");
 813             if (response.isSuccessful()) {
 814                 result=new String(response.body().bytes());
 815             } else {
 816                 logger.info(String.format("Can not get getVnfInfoById[code=%s, message=%s]", response.code(), response.message()));
 817                 result=Constant.CONSTANT_FAILED;;
 818             }
 819         } catch (IOException e) {
 820             logger.error("getVnfInfoById occur exception:"+e);
 821             result=Constant.CONSTANT_FAILED;;
 822         }
 823         return result;
 824
 825     }
 826 }