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