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
 348                 String result="";
 349         try {
 350                 logger.info("vfc deleteNsdPackage is starting!");
 351             Response<ResponseBody> 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             logger.error("deleteNsdPackage occur exception:"+e);
 361             result=Constant.CONSTANT_FAILED;;
 362         }
 363         return result;
 364
 365         }
 366
 367         @Override
 368         public String deleteVnfPackage(String vnfPkgId) {
 369
 370                 String result="";
 371         try {
 372                 logger.info("vfc deleteVnfPackage is starting!");
 373             Response<ResponseBody> response = this.vfcService.deleteVnfdPackage(vnfPkgId).execute();
 374             logger.info("vfc deleteVnfPackage has finished!");
 375             if (response.isSuccessful()) {
 376                 result=Constant.CONSTANT_SUCCESS;
 377             } else {
 378                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 379                 result=Constant.CONSTANT_FAILED;;
 380             }
 381         } catch (IOException e) {
 382             logger.error("deleteVnfPackage occur exception:"+e);
 383             result=Constant.CONSTANT_FAILED;;
 384         }
 385         return result;
 386
 387         }
 388
 389         @Override
 390         public String deletePnfPackage(String pnfdInfoId) {
 391
 392                 String result="";
 393         try {
 394                 logger.info("vfc deletePnfPackage is starting!");
 395             Response<ResponseBody> response = this.vfcService.deletePnfdPackage(pnfdInfoId).execute();
 396             logger.info("vfc deletePnfPackage has finished!");
 397             if (response.isSuccessful()) {
 398                 result=Constant.CONSTANT_SUCCESS;
 399             } else {
 400                 logger.info(String.format("Can not get deletePnfPackage[code=%s, message=%s]", response.code(), response.message()));
 401                 result=Constant.CONSTANT_FAILED;;
 402             }
 403         } catch (IOException e) {
 404             logger.error("deletePnfPackage occur exception:"+e);
 405             result=Constant.CONSTANT_FAILED;;
 406         }
 407         return result;
 408
 409         }
 410
 411         @Override
 412         public List<String> getNetworkServiceInfo() {
 413                 List<String> result = new ArrayList<>();
 414         try {
 415                 logger.info("vfc getNetworkServiceInfo is starting!");
 416             Response<nsServiceRsp> response = this.vfcService.getNetworkServiceInfo().execute();
 417             logger.info("vfc getNetworkServiceInfo has finished!");
 418             if (response.isSuccessful()) {
 419                 List<String> nsServices = response.body().nsServices;
 420                 if(nsServices.size()>0){
 421                         for(String nsService:nsServices){
 422                                 JSONObject object =  JSON.parseObject(nsService);
 423                                 String serviceInstanceId=object.get("nsInstanceId").toString();
 424                                 ServiceBean serviceBean = serviceLcmService.getServiceBeanByServiceInStanceId(serviceInstanceId);
 425                                 object.put("serviceDomain",serviceBean.getServiceDomain());
 426                                 object.put("childServiceInstances","[]");
 427                                 result.add(object.toString());
 428                         }
 429                 }
 430                 return result;
 431             } else {
 432                 logger.info(String.format("Can not get getNetworkServiceInfo[code=%s, message=%s]", response.code(), response.message()));
 433                 return Collections.emptyList();
 434             }
 435         } catch (IOException e) {
 436             logger.error("getNetworkServiceInfo occur exception:"+e);
 437             return Collections.emptyList();
 438         }
 439
 440         }
 441
 442         @Override
 443         public String createNetworkServiceInstance(HttpServletRequest request) {
 444                 String result = "";
 445         try {
 446                 logger.info("aai createNetworkServiceInstance is starting");
 447                 RequestBody requestBody = extractBody(request);
 448             Response<ResponseBody> response = vfcService.createNetworkServiceInstance(requestBody).execute();
 449                         logger.info("aai createNetworkServiceInstance has finished");
 450             if (response.isSuccessful()) {
 451                 result=new String(response.body().bytes());
 452             } else {
 453                 result=Constant.CONSTANT_FAILED;
 454                 logger.error(String.format("Can not createNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 455             }
 456         } catch (Exception e) {
 457                 result=Constant.CONSTANT_FAILED;
 458                 logger.error("createNetworkServiceInstance occur exception:"+e);
 459         }
 460         return result;
 461         }
 462
 463         @Override
 464         public String deleteNetworkServiceInstance(String nsInstanceId) {
 465
 466                 String result="";
 467         try {
 468                 logger.info("vfc deleteNetworkServiceInstance is starting!");
 469             Response<ResponseBody> response = this.vfcService.deleteNetworkServiceInstance(nsInstanceId).execute();
 470             logger.info("vfc deleteNetworkServiceInstance has finished!");
 471             if (response.isSuccessful()) {
 472                 result=Constant.CONSTANT_SUCCESS;
 473             } else {
 474                 logger.info(String.format("Can not get deleteNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 475                 result=Constant.CONSTANT_FAILED;;
 476             }
 477         } catch (IOException e) {
 478             logger.error("deleteNetworkServiceInstance occur exception:"+e);
 479             result=Constant.CONSTANT_FAILED;;
 480         }
 481         return result;
 482
 483         }
 484
 485         @Override
 486         public String terminateNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 487                 String result = "";
 488         try {
 489                 logger.info("aai terminateNetworkServiceInstance is starting");
 490                 RequestBody requestBody = extractBody(request);
 491             Response<ResponseBody> response = vfcService.terminateNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 492                         logger.info("aai terminateNetworkServiceInstance has finished");
 493             if (response.isSuccessful()) {
 494                 result=new String(response.body().bytes());
 495             } else {
 496                 result=Constant.CONSTANT_FAILED;
 497                 logger.error(String.format("Can not terminateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 498             }
 499         } catch (Exception e) {
 500                 result=Constant.CONSTANT_FAILED;
 501                 logger.error("terminateNetworkServiceInstance occur exception:"+e);
 502         }
 503         return result;
 504         }
 505
 506         @Override
 507         public String healNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 508                 String result = "";
 509         try {
 510                 logger.info("aai healNetworkServiceInstance is starting");
 511                 RequestBody requestBody = extractBody(request);
 512             Response<ResponseBody> response = vfcService.healNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 513                         logger.info("aai healNetworkServiceInstance has finished");
 514             if (response.isSuccessful()) {
 515                 result=new String(response.body().bytes());
 516             } else {
 517                 result=Constant.CONSTANT_FAILED;
 518                 logger.error(String.format("Can not healNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 519             }
 520         } catch (Exception e) {
 521                 result=Constant.CONSTANT_FAILED;
 522                 logger.error("healNetworkServiceInstance occur exception:"+e);
 523         }
 524         return result;
 525         }
 526
 527         @Override
 528         public String scaleNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 529                 String result = "";
 530         try {
 531                 logger.info("aai scaleNetworkServiceInstance is starting");
 532                 RequestBody requestBody = extractBody(request);
 533             Response<ResponseBody> response = vfcService.scaleNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 534                         logger.info("aai scaleNetworkServiceInstance has finished");
 535             if (response.isSuccessful()) {
 536                 result=new String(response.body().bytes());
 537             } else {
 538                 result=Constant.CONSTANT_FAILED;
 539                 logger.error(String.format("Can not scaleNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 540             }
 541         } catch (Exception e) {
 542                 result=Constant.CONSTANT_FAILED;
 543                 logger.error("scaleNetworkServiceInstance occur exception:"+e);
 544         }
 545         return result;
 546         }
 547
 548         @Override
 549         public String createNetworkServiceData(HttpServletRequest request) {
 550                 String result = "";
 551         try {
 552                 logger.info("aai createNetworkServiceData is starting");
 553                 RequestBody requestBody = extractBody(request);
 554             Response<ResponseBody> response = vfcService.createNetworkServiceData(requestBody).execute();
 555                         logger.info("aai createNetworkServiceData has finished");
 556             if (response.isSuccessful()) {
 557                 result=new String(response.body().bytes());
 558             } else {
 559                 result=Constant.CONSTANT_FAILED;
 560                 logger.error(String.format("Can not createNetworkServiceData[code=%s, message=%s]", response.code(), response.message()));
 561             }
 562         } catch (Exception e) {
 563                 result=Constant.CONSTANT_FAILED;
 564                 logger.error("createNetworkServiceData occur exception:"+e);
 565         }
 566         return result;
 567         }
 568
 569         @Override
 570         public String createVnfData(HttpServletRequest request) {
 571                 String result = "";
 572         try {
 573                 logger.info("aai createVnfData is starting");
 574                 RequestBody requestBody = extractBody(request);
 575             Response<ResponseBody> response = vfcService.createVnfData(requestBody).execute();
 576                         logger.info("aai createVnfData has finished");
 577             if (response.isSuccessful()) {
 578                 result=new String(response.body().bytes());
 579             } else {
 580                 result=Constant.CONSTANT_FAILED;
 581                 logger.error(String.format("Can not createVnfData[code=%s, message=%s]", response.code(), response.message()));
 582             }
 583         } catch (Exception e) {
 584                 result=Constant.CONSTANT_FAILED;
 585                 logger.error("createVnfData occur exception:"+e);
 586         }
 587         return result;
 588         }
 589
 590         @Override
 591         public String createPnfData(HttpServletRequest request) {
 592                 String result = "";
 593         try {
 594                 logger.info("aai createPnfData is starting");
 595                 RequestBody requestBody = extractBody(request);
 596             Response<ResponseBody> response = vfcService.createPnfData(requestBody).execute();
 597                         logger.info("aai createPnfData has finished");
 598             if (response.isSuccessful()) {
 599                 result=new String(response.body().bytes());
 600             } else {
 601                 result=Constant.CONSTANT_FAILED;
 602                 logger.error(String.format("Can not createPnfData[code=%s, message=%s]", response.code(), response.message()));
 603             }
 604         } catch (Exception e) {
 605                 result=Constant.CONSTANT_FAILED;
 606                 logger.error("createPnfData occur exception:"+e);
 607         }
 608         return result;
 609         }
 610
 611         @Override
 612         public String getNsdInfo(String nsdInfoId) {
 613
 614                 String result="";
 615         try {
 616                 logger.info("vfc getNsdInfo is starting!");
 617             Response<ResponseBody> response = this.vfcService.getNsdInfo(nsdInfoId).execute();
 618             logger.info("vfc getNsdInfo has finished!");
 619             if (response.isSuccessful()) {
 620                 result=Constant.CONSTANT_SUCCESS;
 621             } else {
 622                 logger.info(String.format("Can not get getNsdInfo[code=%s, message=%s]", response.code(), response.message()));
 623                 result=Constant.CONSTANT_FAILED;;
 624             }
 625         } catch (IOException e) {
 626             logger.error("getNsdInfo occur exception:"+e);
 627             result=Constant.CONSTANT_FAILED;;
 628         }
 629         return result;
 630
 631         }
 632
 633         @Override
 634         public String getVnfInfo(String vnfPkgId) {
 635
 636                 String result="";
 637         try {
 638                 logger.info("vfc getVnfInfo is starting!");
 639             Response<ResponseBody> response = this.vfcService.getVnfInfo(vnfPkgId).execute();
 640             logger.info("vfc getVnfInfo has finished!");
 641             if (response.isSuccessful()) {
 642                 result=Constant.CONSTANT_SUCCESS;
 643             } else {
 644                 logger.info(String.format("Can not get getVnfInfo[code=%s, message=%s]", response.code(), response.message()));
 645                 result=Constant.CONSTANT_FAILED;;
 646             }
 647         } catch (IOException e) {
 648             logger.error("getVnfInfo occur exception:"+e);
 649             result=Constant.CONSTANT_FAILED;;
 650         }
 651         return result;
 652
 653         }
 654
 655         @Override
 656         public String getPnfInfo(String pnfdInfoId) {
 657
 658                 String result="";
 659         try {
 660                 logger.info("vfc getPnfInfo is starting!");
 661             Response<ResponseBody> response = this.vfcService.getPnfInfo(pnfdInfoId).execute();
 662             logger.info("vfc getPnfInfo has finished!");
 663             if (response.isSuccessful()) {
 664                 result=Constant.CONSTANT_SUCCESS;
 665             } else {
 666                 logger.info(String.format("Can not get getPnfInfo[code=%s, message=%s]", response.code(), response.message()));
 667                 result=Constant.CONSTANT_FAILED;;
 668             }
 669         } catch (IOException e) {
 670             logger.error("getPnfInfo occur exception:"+e);
 671             result=Constant.CONSTANT_FAILED;;
 672         }
 673         return result;
 674
 675         }
 676
 677         @Override
 678         public String listNsTemplates() {
 679
 680                 String result="";
 681         try {
 682                 logger.info("vfc listNsTemplates is starting!");
 683             Response<ResponseBody> response = this.vfcService.listNsTemplates().execute();
 684             logger.info("vfc listNsTemplates has finished!");
 685             if (response.isSuccessful()) {
 686                 result=new String(response.body().bytes());
 687             } else {
 688                 logger.info(String.format("Can not get listNsTemplates[code=%s, message=%s]", response.code(), response.message()));
 689                 result=Constant.CONSTANT_FAILED;;
 690             }
 691         } catch (IOException e) {
 692             logger.error("listNsTemplates occur exception:"+e);
 693             result=Constant.CONSTANT_FAILED;;
 694         }
 695         return result;
 696
 697         }
 698
 699         @Override
 700         public String fetchNsTemplateData(HttpServletRequest request) {
 701                 String result = "";
 702         try {
 703                 logger.info("aai fetchNsTemplateData is starting");
 704                 RequestBody requestBody = extractBody(request);
 705             Response<ResponseBody> response = vfcService.fetchNsTemplateData(requestBody).execute();
 706                         logger.info("aai fetchNsTemplateData has finished");
 707             if (response.isSuccessful()) {
 708                 result=new String(response.body().bytes());
 709             } else {
 710                 result=Constant.CONSTANT_FAILED;
 711                 logger.error(String.format("Can not fetchNsTemplateData[code=%s, message=%s]", response.code(), response.message()));
 712             }
 713         } catch (Exception e) {
 714                 result=Constant.CONSTANT_FAILED;
 715                 logger.error("fetchNsTemplateData occur exception:"+e);
 716         }
 717         return result;
 718         }
 719
 720         @Override
 721         public String instantiateNetworkServiceInstance(HttpServletRequest request, String serviceInstanceId) {
 722                 String result = "";
 723         try {
 724                 logger.info("aai instantiateNetworkServiceInstance is starting");
 725                 RequestBody requestBody = extractBody(request);
 726             Response<ResponseBody> response = vfcService.instantiateNetworkServiceInstance(requestBody,serviceInstanceId).execute();
 727                         logger.info("aai instantiateNetworkServiceInstance has finished");
 728             if (response.isSuccessful()) {
 729                 result=new String(response.body().bytes());
 730             } else {
 731                 result=Constant.CONSTANT_FAILED;
 732                 logger.error(String.format("Can not instantiateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 733             }
 734         } catch (Exception e) {
 735                 result=Constant.CONSTANT_FAILED;
 736                 logger.error("instantiateNetworkServiceInstance occur exception:"+e);
 737         }
 738         return result;
 739         }
 740
 741         @Override
 742         public String getVnfInfoById(String vnfinstid) {
 743
 744                 String result="";
 745         try {
 746                 logger.info("vfc getVnfInfoById is starting!");
 747             Response<ResponseBody> response = this.vfcService.getVnfInfoById(vnfinstid).execute();
 748             logger.info("vfc getVnfInfoById has finished!");
 749             if (response.isSuccessful()) {
 750                 result=new String(response.body().bytes());
 751             } else {
 752                 logger.info(String.format("Can not get getVnfInfoById[code=%s, message=%s]", response.code(), response.message()));
 753                 result=Constant.CONSTANT_FAILED;;
 754             }
 755         } catch (IOException e) {
 756             logger.error("getVnfInfoById occur exception:"+e);
 757             result=Constant.CONSTANT_FAILED;;
 758         }
 759         return result;
 760
 761         }
 762 }