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