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         try {
  73             List<SDCServiceTemplate> nsTemplate = getNsTemplate();
  74             List<Vnf> vnf = getVFResource();
  75             return new VfNsPackageInfo(nsTemplate, vnf);
  76         } catch (IOException e) {
  77             throw new SDCCatalogException("SDC Service is not available!", e);
  78         }
  79     }
  80
  81     private List<Vnf> getVFResource() throws IOException {
  82         Response<List<Vnf>> response = sdcCatalogService.listResources(RESOURCETYPE_VF).execute();
  83         if (response.isSuccessful()) {
  84             return response.body();
  85         } else {
  86             logger.info(String.format("Can not get VF resources[code=%s, message=%s]", response.code(), response.message()));
  87             return Collections.emptyList();
  88         }
  89     }
  90
  91     private List<SDCServiceTemplate> getNsTemplate() throws IOException {
  92         Response<List<SDCServiceTemplate>> response = sdcCatalogService.listServices(CATEGORY_NS, DISTRIBUTION_STATUS_DISTRIBUTED).execute();
  93         if (response.isSuccessful()) {
  94             return response.body();
  95         } else {
  96             logger.info(String.format("Can not get NS services[code=%s, message=%s]", response.code(), response.message()));
  97             return Collections.emptyList();
  98         }
  99     }
 100
 101     @Override
 102     public DistributionResult postNsPackage(Csar csar) {
 103         try {
 104             Response<DistributionResult> response = vfcService.distributeNsPackage(csar).execute();
 105             if (response.isSuccessful()) {
 106                 return response.body();
 107             } else {
 108                 logger.info(String.format("Can not post NS packages[code=%s, message=%s]", response.code(), response.message()));
 109                 throw new VfcException("VFC service is not available!");
 110             }
 111         } catch (IOException e) {
 112             throw new VfcException("VFC service is not available!", e);
 113         }
 114     }
 115
 116     @Override
 117     public Job postVfPackage(Csar csar) {
 118         try {
 119             Response<Job> response = vfcService.distributeVnfPackage(csar).execute();
 120             if (response.isSuccessful()) {
 121                 return response.body();
 122             } else {
 123                 logger.info(String.format("Can not get VF packages[code=%s, message=%s]", response.code(), response.message()));
 124                 throw new VfcException("VFC service is not available!");
 125             }
 126         } catch (IOException e) {
 127             throw new VfcException("VFC service is not available!", e);
 128         }
 129     }
 130
 131     @Override
 132     public JobStatus getJobStatus(String jobId, String responseId) {
 133         try {
 134             Response<JobStatus> response = vfcService.getJobStatus(jobId, responseId).execute();
 135             if (response.isSuccessful()) {
 136                 return response.body();
 137             } else {
 138                 logger.info(String.format("Can not get Job status[code=%s, message=%s]", response.code(), response.message()));
 139                 throw new VfcException("VFC service is not available!");
 140             }
 141         } catch (IOException e) {
 142             throw new VfcException("VFC service is not available!", e);
 143         }
 144     }
 145
 146     @Override
 147     public DistributionResult deleteNsPackage(String csarId) {
 148         try {
 149             Response<DistributionResult> response = vfcService.deleteNsPackage(csarId).execute();
 150             if (response.isSuccessful()) {
 151                 return response.body();
 152             } else {
 153                 logger.info(String.format("Can not delete NS packages[code=%s, message=%s]", response.code(), response.message()));
 154                 throw new VfcException("VFC service is not available!");
 155             }
 156         } catch (IOException e) {
 157             throw new VfcException("VFC service is not available!", e);
 158         }
 159     }
 160
 161     @Override
 162     public Job deleteVfPackage(String csarId) {
 163         try {
 164             Response<Job> response = vfcService.deleteVnfPackage(csarId).execute();
 165             if (response.isSuccessful()) {
 166                 return response.body();
 167             } else {
 168                 logger.info(String.format("Can not delete VF packages[code=%s, message=%s]", response.code(), response.message()));
 169                 throw new VfcException("VFC service is not available!");
 170             }
 171         } catch (IOException e) {
 172             throw new VfcException("VFC service is not available!", e);
 173         }
 174     }
 175
 176         @Override
 177         public String getVnfPackages() {
 178                 String result="";
 179         try {
 180                 logger.info("vfc getVnfPackages is starting!");
 181             Response<ResponseBody> response = this.vfcService.getVnfPackages().execute();
 182             logger.info("vfc getVnfPackages has finished!");
 183             if (response.isSuccessful()) {
 184                 result=new String(response.body().bytes());
 185             } else {
 186                 logger.info(String.format("Can not get getVnfPackages[code=%s, message=%s]", response.code(), response.message()));
 187                 result=Constant.CONSTANT_FAILED;;
 188             }
 189         } catch (IOException e) {
 190             logger.error("getVnfPackages occur exception:"+e);
 191             result=Constant.CONSTANT_FAILED;;
 192         }
 193         return result;
 194         }
 195
 196         @Override
 197         public String getNetworkServicePackages() {
 198
 199                 String result="";
 200         try {
 201                 logger.info("vfc getNetworkServicePackages is starting!");
 202             Response<ResponseBody> response = this.vfcService.getNetworkServicePackages().execute();
 203             logger.info("vfc getNetworkServicePackages has finished!");
 204             if (response.isSuccessful()) {
 205                 result=new String(response.body().bytes());
 206             } else {
 207                 logger.info(String.format("Can not get getNetworkServicePackages[code=%s, message=%s]", response.code(), response.message()));
 208                 result=Constant.CONSTANT_FAILED;;
 209             }
 210         } catch (IOException e) {
 211             logger.error("getNetworkServicePackages occur exception:"+e);
 212             result=Constant.CONSTANT_FAILED;;
 213         }
 214         return result;
 215
 216         }
 217
 218         @Override
 219         public String getPnfPackages() {
 220
 221                 String result="";
 222         try {
 223                 logger.info("vfc getPnfPackages is starting!");
 224             Response<ResponseBody> response = this.vfcService.getPnfPackages().execute();
 225             logger.info("vfc getPnfPackages has finished!");
 226             if (response.isSuccessful()) {
 227                 result=new String(response.body().bytes());
 228             } else {
 229                 logger.info(String.format("Can not get getPnfPackages[code=%s, message=%s]", response.code(), response.message()));
 230                 result=Constant.CONSTANT_FAILED;;
 231             }
 232         } catch (IOException e) {
 233             logger.error("getPnfPackages occur exception:"+e);
 234             result=Constant.CONSTANT_FAILED;;
 235         }
 236         return result;
 237
 238         }
 239
 240         @Override
 241         public String downLoadNsPackage(String nsdInfoId) {
 242
 243                 String result="";
 244         try {
 245                 logger.info("vfc downLoadNsPackage is starting!");
 246             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(nsdInfoId).execute();
 247             logger.info("vfc downLoadNsPackage has finished!");
 248             if (response.isSuccessful()) {
 249                 result=Constant.CONSTANT_SUCCESS;
 250             } else {
 251                 logger.info(String.format("Can not get downLoadNsPackage[code=%s, message=%s]", response.code(), response.message()));
 252                 result=Constant.CONSTANT_FAILED;;
 253             }
 254         } catch (IOException e) {
 255             logger.error("downLoadNsPackage occur exception:"+e);
 256             result=Constant.CONSTANT_FAILED;;
 257         }
 258         return result;
 259
 260         }
 261
 262         @Override
 263         public String downLoadPnfPackage(String pnfdInfoId) {
 264
 265                 String result="";
 266         try {
 267                 logger.info("vfc downLoadPnfPackage is starting!");
 268             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(pnfdInfoId).execute();
 269             logger.info("vfc downLoadPnfPackage has finished!");
 270             if (response.isSuccessful()) {
 271                 result=Constant.CONSTANT_SUCCESS;
 272             } else {
 273                 logger.info(String.format("Can not get downLoadPnfPackage[code=%s, message=%s]", response.code(), response.message()));
 274                 result=Constant.CONSTANT_FAILED;;
 275             }
 276         } catch (IOException e) {
 277             logger.error("downLoadPnfPackage occur exception:"+e);
 278             result=Constant.CONSTANT_FAILED;;
 279         }
 280         return result;
 281
 282         }
 283
 284         @Override
 285         public String downLoadVnfPackage(String vnfPkgId) {
 286
 287                 String result="";
 288         try {
 289                 logger.info("vfc downLoadVnfPackage is starting!");
 290             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(vnfPkgId).execute();
 291             logger.info("vfc downLoadVnfPackage has finished!");
 292             if (response.isSuccessful()) {
 293                 result=Constant.CONSTANT_SUCCESS;
 294             } else {
 295                 logger.info(String.format("Can not get downLoadVnfPackage[code=%s, message=%s]", response.code(), response.message()));
 296                 result=Constant.CONSTANT_FAILED;;
 297             }
 298         } catch (IOException e) {
 299             logger.error("downLoadVnfPackage occur exception:"+e);
 300             result=Constant.CONSTANT_FAILED;;
 301         }
 302         return result;
 303
 304         }
 305
 306         @Override
 307         public String deleteNsdPackage(String nsdInfoId) {
 308
 309                 String result="";
 310         try {
 311                 logger.info("vfc deleteNsdPackage is starting!");
 312             Response<ResponseBody> response = this.vfcService.deleteNsdPackage(nsdInfoId).execute();
 313             logger.info("vfc deleteNsdPackage has finished!");
 314             if (response.isSuccessful()) {
 315                 result=Constant.CONSTANT_SUCCESS;
 316             } else {
 317                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 318                 result=Constant.CONSTANT_FAILED;;
 319             }
 320         } catch (IOException e) {
 321             logger.error("deleteNsdPackage occur exception:"+e);
 322             result=Constant.CONSTANT_FAILED;;
 323         }
 324         return result;
 325
 326         }
 327
 328         @Override
 329         public String deleteVnfPackage(String vnfPkgId) {
 330
 331                 String result="";
 332         try {
 333                 logger.info("vfc deleteVnfPackage is starting!");
 334             Response<ResponseBody> response = this.vfcService.deleteVnfdPackage(vnfPkgId).execute();
 335             logger.info("vfc deleteVnfPackage has finished!");
 336             if (response.isSuccessful()) {
 337                 result=Constant.CONSTANT_SUCCESS;
 338             } else {
 339                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 340                 result=Constant.CONSTANT_FAILED;;
 341             }
 342         } catch (IOException e) {
 343             logger.error("deleteVnfPackage occur exception:"+e);
 344             result=Constant.CONSTANT_FAILED;;
 345         }
 346         return result;
 347
 348         }
 349
 350         @Override
 351         public String deletePnfPackage(String pnfdInfoId) {
 352
 353                 String result="";
 354         try {
 355                 logger.info("vfc deletePnfPackage is starting!");
 356             Response<ResponseBody> response = this.vfcService.deletePnfdPackage(pnfdInfoId).execute();
 357             logger.info("vfc deletePnfPackage has finished!");
 358             if (response.isSuccessful()) {
 359                 result=Constant.CONSTANT_SUCCESS;
 360             } else {
 361                 logger.info(String.format("Can not get deletePnfPackage[code=%s, message=%s]", response.code(), response.message()));
 362                 result=Constant.CONSTANT_FAILED;;
 363             }
 364         } catch (IOException e) {
 365             logger.error("deletePnfPackage occur exception:"+e);
 366             result=Constant.CONSTANT_FAILED;;
 367         }
 368         return result;
 369
 370         }
 371
 372         @Override
 373         public String getNetworkServiceInfo() {
 374
 375                 String result="";
 376         try {
 377                 logger.info("vfc getNetworkServiceInfo is starting!");
 378             Response<ResponseBody> response = this.vfcService.getNetworkServiceInfo().execute();
 379             logger.info("vfc getNetworkServiceInfo has finished!");
 380             if (response.isSuccessful()) {
 381                 result=new String(response.body().bytes());
 382             } else {
 383                 logger.info(String.format("Can not get getNetworkServiceInfo[code=%s, message=%s]", response.code(), response.message()));
 384                 result=Constant.CONSTANT_FAILED;;
 385             }
 386         } catch (IOException e) {
 387             logger.error("getNetworkServiceInfo occur exception:"+e);
 388             result=Constant.CONSTANT_FAILED;;
 389         }
 390         return result;
 391
 392         }
 393
 394         @Override
 395         public String createNetworkServiceInstance(HttpServletRequest request) {
 396                 String result = "";
 397         try {
 398                 logger.info("aai createNetworkServiceInstance is starting");
 399                 RequestBody requestBody = extractBody(request);
 400             Response<ResponseBody> response = vfcService.createNetworkServiceInstance(requestBody).execute();
 401                         logger.info("aai createNetworkServiceInstance has finished");
 402             if (response.isSuccessful()) {
 403                 result=new String(response.body().bytes());
 404             } else {
 405                 result=Constant.CONSTANT_FAILED;
 406                 logger.error(String.format("Can not createNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 407             }
 408         } catch (Exception e) {
 409                 result=Constant.CONSTANT_FAILED;
 410                 logger.error("createNetworkServiceInstance occur exception:"+e);
 411         }
 412         return result;
 413         }
 414
 415         @Override
 416         public String deleteNetworkServiceInstance(String nsInstanceId) {
 417
 418                 String result="";
 419         try {
 420                 logger.info("vfc deleteNetworkServiceInstance is starting!");
 421             Response<ResponseBody> response = this.vfcService.deleteNetworkServiceInstance(nsInstanceId).execute();
 422             logger.info("vfc deleteNetworkServiceInstance has finished!");
 423             if (response.isSuccessful()) {
 424                 result=Constant.CONSTANT_SUCCESS;
 425             } else {
 426                 logger.info(String.format("Can not get deleteNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 427                 result=Constant.CONSTANT_FAILED;;
 428             }
 429         } catch (IOException e) {
 430             logger.error("deleteNetworkServiceInstance occur exception:"+e);
 431             result=Constant.CONSTANT_FAILED;;
 432         }
 433         return result;
 434
 435         }
 436
 437         @Override
 438         public String terminateNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 439                 String result = "";
 440         try {
 441                 logger.info("aai terminateNetworkServiceInstance is starting");
 442                 RequestBody requestBody = extractBody(request);
 443             Response<ResponseBody> response = vfcService.terminateNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 444                         logger.info("aai terminateNetworkServiceInstance has finished");
 445             if (response.isSuccessful()) {
 446                 result=new String(response.body().bytes());
 447             } else {
 448                 result=Constant.CONSTANT_FAILED;
 449                 logger.error(String.format("Can not terminateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 450             }
 451         } catch (Exception e) {
 452                 result=Constant.CONSTANT_FAILED;
 453                 logger.error("terminateNetworkServiceInstance occur exception:"+e);
 454         }
 455         return result;
 456         }
 457
 458         @Override
 459         public String healNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 460                 String result = "";
 461         try {
 462                 logger.info("aai healNetworkServiceInstance is starting");
 463                 RequestBody requestBody = extractBody(request);
 464             Response<ResponseBody> response = vfcService.healNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 465                         logger.info("aai healNetworkServiceInstance has finished");
 466             if (response.isSuccessful()) {
 467                 result=new String(response.body().bytes());
 468             } else {
 469                 result=Constant.CONSTANT_FAILED;
 470                 logger.error(String.format("Can not healNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 471             }
 472         } catch (Exception e) {
 473                 result=Constant.CONSTANT_FAILED;
 474                 logger.error("healNetworkServiceInstance occur exception:"+e);
 475         }
 476         return result;
 477         }
 478
 479         @Override
 480         public String scaleNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 481                 String result = "";
 482         try {
 483                 logger.info("aai scaleNetworkServiceInstance is starting");
 484                 RequestBody requestBody = extractBody(request);
 485             Response<ResponseBody> response = vfcService.scaleNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 486                         logger.info("aai scaleNetworkServiceInstance has finished");
 487             if (response.isSuccessful()) {
 488                 result=new String(response.body().bytes());
 489             } else {
 490                 result=Constant.CONSTANT_FAILED;
 491                 logger.error(String.format("Can not scaleNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 492             }
 493         } catch (Exception e) {
 494                 result=Constant.CONSTANT_FAILED;
 495                 logger.error("scaleNetworkServiceInstance occur exception:"+e);
 496         }
 497         return result;
 498         }
 499
 500         @Override
 501         public String createNetworkServiceData(HttpServletRequest request) {
 502                 String result = "";
 503         try {
 504                 logger.info("aai createNetworkServiceData is starting");
 505                 RequestBody requestBody = extractBody(request);
 506             Response<ResponseBody> response = vfcService.createNetworkServiceData(requestBody).execute();
 507                         logger.info("aai createNetworkServiceData has finished");
 508             if (response.isSuccessful()) {
 509                 result=new String(response.body().bytes());
 510             } else {
 511                 result=Constant.CONSTANT_FAILED;
 512                 logger.error(String.format("Can not createNetworkServiceData[code=%s, message=%s]", response.code(), response.message()));
 513             }
 514         } catch (Exception e) {
 515                 result=Constant.CONSTANT_FAILED;
 516                 logger.error("createNetworkServiceData occur exception:"+e);
 517         }
 518         return result;
 519         }
 520
 521         @Override
 522         public String createVnfData(HttpServletRequest request) {
 523                 String result = "";
 524         try {
 525                 logger.info("aai createVnfData is starting");
 526                 RequestBody requestBody = extractBody(request);
 527             Response<ResponseBody> response = vfcService.createVnfData(requestBody).execute();
 528                         logger.info("aai createVnfData has finished");
 529             if (response.isSuccessful()) {
 530                 result=new String(response.body().bytes());
 531             } else {
 532                 result=Constant.CONSTANT_FAILED;
 533                 logger.error(String.format("Can not createVnfData[code=%s, message=%s]", response.code(), response.message()));
 534             }
 535         } catch (Exception e) {
 536                 result=Constant.CONSTANT_FAILED;
 537                 logger.error("createVnfData occur exception:"+e);
 538         }
 539         return result;
 540         }
 541
 542         @Override
 543         public String createPnfData(HttpServletRequest request) {
 544                 String result = "";
 545         try {
 546                 logger.info("aai createPnfData is starting");
 547                 RequestBody requestBody = extractBody(request);
 548             Response<ResponseBody> response = vfcService.createPnfData(requestBody).execute();
 549                         logger.info("aai createPnfData has finished");
 550             if (response.isSuccessful()) {
 551                 result=new String(response.body().bytes());
 552             } else {
 553                 result=Constant.CONSTANT_FAILED;
 554                 logger.error(String.format("Can not createPnfData[code=%s, message=%s]", response.code(), response.message()));
 555             }
 556         } catch (Exception e) {
 557                 result=Constant.CONSTANT_FAILED;
 558                 logger.error("createPnfData occur exception:"+e);
 559         }
 560         return result;
 561         }
 562
 563         @Override
 564         public String getNsdInfo(String nsdInfoId) {
 565
 566                 String result="";
 567         try {
 568                 logger.info("vfc getNsdInfo is starting!");
 569             Response<ResponseBody> response = this.vfcService.getNsdInfo(nsdInfoId).execute();
 570             logger.info("vfc getNsdInfo has finished!");
 571             if (response.isSuccessful()) {
 572                 result=Constant.CONSTANT_SUCCESS;
 573             } else {
 574                 logger.info(String.format("Can not get getNsdInfo[code=%s, message=%s]", response.code(), response.message()));
 575                 result=Constant.CONSTANT_FAILED;;
 576             }
 577         } catch (IOException e) {
 578             logger.error("getNsdInfo occur exception:"+e);
 579             result=Constant.CONSTANT_FAILED;;
 580         }
 581         return result;
 582
 583         }
 584
 585         @Override
 586         public String getVnfInfo(String vnfPkgId) {
 587
 588                 String result="";
 589         try {
 590                 logger.info("vfc getVnfInfo is starting!");
 591             Response<ResponseBody> response = this.vfcService.getVnfInfo(vnfPkgId).execute();
 592             logger.info("vfc getVnfInfo has finished!");
 593             if (response.isSuccessful()) {
 594                 result=Constant.CONSTANT_SUCCESS;
 595             } else {
 596                 logger.info(String.format("Can not get getVnfInfo[code=%s, message=%s]", response.code(), response.message()));
 597                 result=Constant.CONSTANT_FAILED;;
 598             }
 599         } catch (IOException e) {
 600             logger.error("getVnfInfo occur exception:"+e);
 601             result=Constant.CONSTANT_FAILED;;
 602         }
 603         return result;
 604
 605         }
 606
 607         @Override
 608         public String getPnfInfo(String pnfdInfoId) {
 609
 610                 String result="";
 611         try {
 612                 logger.info("vfc getPnfInfo is starting!");
 613             Response<ResponseBody> response = this.vfcService.getPnfInfo(pnfdInfoId).execute();
 614             logger.info("vfc getPnfInfo has finished!");
 615             if (response.isSuccessful()) {
 616                 result=Constant.CONSTANT_SUCCESS;
 617             } else {
 618                 logger.info(String.format("Can not get getPnfInfo[code=%s, message=%s]", response.code(), response.message()));
 619                 result=Constant.CONSTANT_FAILED;;
 620             }
 621         } catch (IOException e) {
 622             logger.error("getPnfInfo occur exception:"+e);
 623             result=Constant.CONSTANT_FAILED;;
 624         }
 625         return result;
 626
 627         }
 628 }