gerrit.onap Code Review - usecase-ui/server.git/blob

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