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 serviceInstanceId,String jobId, String responseId,String operationType) {        try {
 172         Response<JobStatus> response = vfcService.getNsLcmJobStatus(jobId, responseId).execute();
 173         if (response.isSuccessful()) {
 174             return response.body();
 175         } else {
 176             logger.info(String.format("Can not get Job status[code=%s, message=%s]", response.code(), response.message()));
 177             throw new VfcException("VFC service getNsLcmJobStatus is not available!");
 178         }
 179     } catch (IOException e) {
 180         throw new VfcException("VFC service getNsLcmJobStatus is not available!", e);
 181     }}
 182
 183     @Override
 184     public DistributionResult deleteNsPackage(String csarId) {
 185         try {
 186             Response<DistributionResult> response = vfcService.deleteNsPackage(csarId).execute();
 187             if (response.isSuccessful()) {
 188                 return response.body();
 189             } else {
 190                 logger.info(String.format("Can not delete NS packages[code=%s, message=%s]", response.code(), response.message()));
 191                 throw new VfcException("VFC service is not available!");
 192             }
 193         } catch (IOException e) {
 194             throw new VfcException("VFC service is not available!", e);
 195         }
 196     }
 197
 198     @Override
 199     public Job deleteVfPackage(String csarId) {
 200         try {
 201             Response<Job> response = vfcService.deleteVnfPackage(csarId).execute();
 202             if (response.isSuccessful()) {
 203                 return response.body();
 204             } else {
 205                 logger.info(String.format("Can not delete VF packages[code=%s, message=%s]", response.code(), response.message()));
 206                 throw new VfcException("VFC service is not available!");
 207             }
 208         } catch (IOException e) {
 209             throw new VfcException("VFC service is not available!", e);
 210         }
 211     }
 212
 213         @Override
 214         public String getVnfPackages() {
 215                 String result="";
 216         try {
 217                 logger.info("vfc getVnfPackages is starting!");
 218             Response<ResponseBody> response = this.vfcService.getVnfPackages().execute();
 219             logger.info("vfc getVnfPackages has finished!");
 220             if (response.isSuccessful()) {
 221                 result=new String(response.body().bytes());
 222             } else {
 223                 logger.info(String.format("Can not get getVnfPackages[code=%s, message=%s]", response.code(), response.message()));
 224                 result=Constant.CONSTANT_FAILED;;
 225             }
 226         } catch (IOException e) {
 227             logger.error("getVnfPackages occur exception:"+e);
 228             result=Constant.CONSTANT_FAILED;;
 229         }
 230         return result;
 231         }
 232
 233         @Override
 234         public String getNetworkServicePackages() {
 235
 236                 String result="";
 237         try {
 238                 logger.info("vfc getNetworkServicePackages is starting!");
 239             Response<ResponseBody> response = this.vfcService.getNetworkServicePackages().execute();
 240             logger.info("vfc getNetworkServicePackages has finished!");
 241             if (response.isSuccessful()) {
 242                 result=new String(response.body().bytes());
 243             } else {
 244                 logger.info(String.format("Can not get getNetworkServicePackages[code=%s, message=%s]", response.code(), response.message()));
 245                 result=Constant.CONSTANT_FAILED;;
 246             }
 247         } catch (IOException e) {
 248             logger.error("getNetworkServicePackages occur exception:"+e);
 249             result=Constant.CONSTANT_FAILED;;
 250         }
 251         return result;
 252
 253         }
 254
 255         @Override
 256         public String getPnfPackages() {
 257
 258                 String result="";
 259         try {
 260                 logger.info("vfc getPnfPackages is starting!");
 261             Response<ResponseBody> response = this.vfcService.getPnfPackages().execute();
 262             logger.info("vfc getPnfPackages has finished!");
 263             if (response.isSuccessful()) {
 264                 result=new String(response.body().bytes());
 265             } else {
 266                 logger.info(String.format("Can not get getPnfPackages[code=%s, message=%s]", response.code(), response.message()));
 267                 result=Constant.CONSTANT_FAILED;;
 268             }
 269         } catch (IOException e) {
 270             logger.error("getPnfPackages occur exception:"+e);
 271             result=Constant.CONSTANT_FAILED;;
 272         }
 273         return result;
 274
 275         }
 276
 277         @Override
 278         public String downLoadNsPackage(String nsdInfoId) {
 279
 280                 String result="";
 281         try {
 282                 logger.info("vfc downLoadNsPackage is starting!");
 283             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(nsdInfoId).execute();
 284             logger.info("vfc downLoadNsPackage has finished!");
 285             if (response.isSuccessful()) {
 286                 result=Constant.CONSTANT_SUCCESS;
 287             } else {
 288                 logger.info(String.format("Can not get downLoadNsPackage[code=%s, message=%s]", response.code(), response.message()));
 289                 result=Constant.CONSTANT_FAILED;;
 290             }
 291         } catch (IOException e) {
 292             logger.error("downLoadNsPackage occur exception:"+e);
 293             result=Constant.CONSTANT_FAILED;;
 294         }
 295         return result;
 296
 297         }
 298
 299         @Override
 300         public String downLoadPnfPackage(String pnfdInfoId) {
 301
 302                 String result="";
 303         try {
 304                 logger.info("vfc downLoadPnfPackage is starting!");
 305             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(pnfdInfoId).execute();
 306             logger.info("vfc downLoadPnfPackage has finished!");
 307             if (response.isSuccessful()) {
 308                 result=Constant.CONSTANT_SUCCESS;
 309             } else {
 310                 logger.info(String.format("Can not get downLoadPnfPackage[code=%s, message=%s]", response.code(), response.message()));
 311                 result=Constant.CONSTANT_FAILED;;
 312             }
 313         } catch (IOException e) {
 314             logger.error("downLoadPnfPackage occur exception:"+e);
 315             result=Constant.CONSTANT_FAILED;;
 316         }
 317         return result;
 318
 319         }
 320
 321         @Override
 322         public String downLoadVnfPackage(String vnfPkgId) {
 323
 324                 String result="";
 325         try {
 326                 logger.info("vfc downLoadVnfPackage is starting!");
 327             Response<ResponseBody> response = this.vfcService.downLoadNsPackage(vnfPkgId).execute();
 328             logger.info("vfc downLoadVnfPackage has finished!");
 329             if (response.isSuccessful()) {
 330                 result=Constant.CONSTANT_SUCCESS;
 331             } else {
 332                 logger.info(String.format("Can not get downLoadVnfPackage[code=%s, message=%s]", response.code(), response.message()));
 333                 result=Constant.CONSTANT_FAILED;;
 334             }
 335         } catch (IOException e) {
 336             logger.error("downLoadVnfPackage occur exception:"+e);
 337             result=Constant.CONSTANT_FAILED;;
 338         }
 339         return result;
 340
 341         }
 342
 343         @Override
 344         public String deleteNsdPackage(String nsdInfoId) {
 345                 Response<ResponseBody> response=null;
 346                 String result="";
 347         try {
 348                 logger.info("vfc deleteNsdPackage is starting!");
 349             response = this.vfcService.deleteNsdPackage(nsdInfoId).execute();
 350             logger.info("vfc deleteNsdPackage has finished!");
 351             if (response.isSuccessful()) {
 352                 result=Constant.CONSTANT_SUCCESS;
 353             } else {
 354                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 355                 result=Constant.CONSTANT_FAILED;;
 356             }
 357         } catch (IOException e) {
 358                 if(e.getMessage().contains("204")){
 359                         return Constant.CONSTANT_SUCCESS;
 360                 }
 361             logger.error("deleteNsdPackage occur exception:"+e);
 362             result=Constant.CONSTANT_FAILED;;
 363         }
 364         return result;
 365
 366         }
 367
 368         @Override
 369         public String deleteVnfPackage(String vnfPkgId) {
 370                 Response<ResponseBody> response=null;
 371                 String result="";
 372         try {
 373                 logger.info("vfc deleteVnfPackage is starting!");
 374             response = this.vfcService.deleteVnfdPackage(vnfPkgId).execute();
 375             logger.info("vfc deleteVnfPackage has finished!");
 376             if (response.isSuccessful()) {
 377                 result=Constant.CONSTANT_SUCCESS;
 378             } else {
 379                 logger.info(String.format("Can not get deleteNsdPackage[code=%s, message=%s]", response.code(), response.message()));
 380                 result=Constant.CONSTANT_FAILED;;
 381             }
 382         } catch (IOException e) {
 383                 if(e.getMessage().contains("204")){
 384                         return Constant.CONSTANT_SUCCESS;
 385                 }
 386             logger.error("deleteVnfPackage occur exception:"+e);
 387             result=Constant.CONSTANT_FAILED;;
 388         }
 389         return result;
 390
 391         }
 392
 393         @Override
 394         public String deletePnfPackage(String pnfdInfoId) {
 395                 Response<ResponseBody> response=null;
 396                 String result="";
 397         try {
 398                 logger.info("vfc deletePnfPackage is starting!");
 399                 response = this.vfcService.deletePnfdPackage(pnfdInfoId).execute();
 400             logger.info("vfc deletePnfPackage has finished!");
 401             if (response.isSuccessful()) {
 402                 result=Constant.CONSTANT_SUCCESS;
 403             } else {
 404                 logger.info(String.format("Can not get deletePnfPackage[code=%s, message=%s]", response.code(), response.message()));
 405                 result=Constant.CONSTANT_FAILED;;
 406             }
 407         } catch (IOException e) {
 408                 if(e.getMessage().contains("204")){
 409                         return Constant.CONSTANT_SUCCESS;
 410                 }
 411             logger.error("deletePnfPackage occur exception:"+e);
 412             result=Constant.CONSTANT_FAILED;;
 413         }
 414         return result;
 415
 416         }
 417
 418         @Override
 419         public List<String> getNetworkServiceInfo() {
 420                 List<String> result = new ArrayList<>();
 421         try {
 422                 logger.info("vfc getNetworkServiceInfo is starting!");
 423             Response<nsServiceRsp> response = this.vfcService.getNetworkServiceInfo().execute();
 424             logger.info("vfc getNetworkServiceInfo has finished!");
 425             if (response.isSuccessful()) {
 426                 List<String> nsServices = response.body().nsServices;
 427                 if(nsServices.size()>0){
 428                         for(String nsService:nsServices){
 429                                 JSONObject object =  JSON.parseObject(nsService);
 430                                 String serviceInstanceId=object.get("nsInstanceId").toString();
 431                                 ServiceBean serviceBean = serviceLcmService.getServiceBeanByServiceInStanceId(serviceInstanceId);
 432                                 object.put("serviceDomain",serviceBean.getServiceDomain());
 433                                 object.put("childServiceInstances","[]");
 434                                 result.add(object.toString());
 435                         }
 436                 }
 437                 return result;
 438             } else {
 439                 logger.info(String.format("Can not get getNetworkServiceInfo[code=%s, message=%s]", response.code(), response.message()));
 440                 return Collections.emptyList();
 441             }
 442         } catch (IOException e) {
 443             logger.error("getNetworkServiceInfo occur exception:"+e);
 444             return Collections.emptyList();
 445         }
 446
 447         }
 448
 449         @Override
 450         public String createNetworkServiceInstance(HttpServletRequest request) {
 451                 String result = "";
 452         try {
 453                 logger.info("aai createNetworkServiceInstance is starting");
 454                 RequestBody requestBody = extractBody(request);
 455             Response<ResponseBody> response = vfcService.createNetworkServiceInstance(requestBody).execute();
 456                         logger.info("aai createNetworkServiceInstance has finished");
 457             if (response.isSuccessful()) {
 458                 result=new String(response.body().bytes());
 459             } else {
 460                 result=Constant.CONSTANT_FAILED;
 461                 logger.error(String.format("Can not createNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 462             }
 463         } catch (Exception e) {
 464                 result=Constant.CONSTANT_FAILED;
 465                 logger.error("createNetworkServiceInstance occur exception:"+e);
 466         }
 467         return result;
 468         }
 469
 470         @Override
 471         public String deleteNetworkServiceInstance(String nsInstanceId) {
 472                 Response response = null;
 473                 String result="";
 474         try {
 475                 logger.info("vfc deleteNetworkServiceInstance is starting!");
 476             response = this.vfcService.deleteNetworkServiceInstance(nsInstanceId).execute();
 477             logger.info("vfc deleteNetworkServiceInstance has finished!");
 478             if (response.isSuccessful()) {
 479                 result=Constant.CONSTANT_SUCCESS;
 480             } else {
 481                 logger.info(String.format("Can not get deleteNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 482                 result=Constant.CONSTANT_FAILED;;
 483             }
 484         } catch (IOException e) {
 485                 if(e.getMessage().contains("204")){
 486                         return Constant.CONSTANT_SUCCESS;
 487                 }
 488             logger.error("deleteNetworkServiceInstance occur exception:"+e);
 489             result=Constant.CONSTANT_FAILED;
 490         }
 491         return result;
 492
 493         }
 494
 495         @Override
 496         public String terminateNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 497                 String result = "";
 498         try {
 499                 logger.info("aai terminateNetworkServiceInstance is starting");
 500                 RequestBody requestBody = extractBody(request);
 501             Response<ResponseBody> response = vfcService.terminateNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 502                         logger.info("aai terminateNetworkServiceInstance has finished");
 503             if (response.isSuccessful()) {
 504                 result=new String(response.body().bytes());
 505             } else {
 506                 result=Constant.CONSTANT_FAILED;
 507                 logger.error(String.format("Can not terminateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 508             }
 509         } catch (Exception e) {
 510                 result=Constant.CONSTANT_FAILED;
 511                 logger.error("terminateNetworkServiceInstance occur exception:"+e);
 512         }
 513         return result;
 514         }
 515
 516         @Override
 517         public String healNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 518                 String result = "";
 519         try {
 520                 logger.info("aai healNetworkServiceInstance is starting");
 521                 RequestBody requestBody = extractBody(request);
 522             Response<ResponseBody> response = vfcService.healNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 523                         logger.info("aai healNetworkServiceInstance has finished");
 524             if (response.isSuccessful()) {
 525                 result=new String(response.body().bytes());
 526             } else {
 527                 result=Constant.CONSTANT_FAILED;
 528                 logger.error(String.format("Can not healNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 529             }
 530         } catch (Exception e) {
 531                 result=Constant.CONSTANT_FAILED;
 532                 logger.error("healNetworkServiceInstance occur exception:"+e);
 533         }
 534         return result;
 535         }
 536
 537         @Override
 538         public String scaleNetworkServiceInstance(HttpServletRequest request,String networkServiceInstanceId) {
 539                 String result = "";
 540         try {
 541                 logger.info("aai scaleNetworkServiceInstance is starting");
 542                 RequestBody requestBody = extractBody(request);
 543             Response<ResponseBody> response = vfcService.scaleNetworkServiceInstance(networkServiceInstanceId,requestBody).execute();
 544                         logger.info("aai scaleNetworkServiceInstance has finished");
 545             if (response.isSuccessful()) {
 546                 result=new String(response.body().bytes());
 547             } else {
 548                 result=Constant.CONSTANT_FAILED;
 549                 logger.error(String.format("Can not scaleNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 550             }
 551         } catch (Exception e) {
 552                 result=Constant.CONSTANT_FAILED;
 553                 logger.error("scaleNetworkServiceInstance occur exception:"+e);
 554         }
 555         return result;
 556         }
 557
 558         @Override
 559         public String createNetworkServiceData(HttpServletRequest request) {
 560                 String result = "";
 561         try {
 562                 logger.info("aai createNetworkServiceData is starting");
 563                 RequestBody requestBody = extractBody(request);
 564             Response<ResponseBody> response = vfcService.createNetworkServiceData(requestBody).execute();
 565                         logger.info("aai createNetworkServiceData has finished");
 566             if (response.isSuccessful()) {
 567                 result=new String(response.body().bytes());
 568             } else {
 569                 result=Constant.CONSTANT_FAILED;
 570                 logger.error(String.format("Can not createNetworkServiceData[code=%s, message=%s]", response.code(), response.message()));
 571             }
 572         } catch (Exception e) {
 573                 result=Constant.CONSTANT_FAILED;
 574                 logger.error("createNetworkServiceData occur exception:"+e);
 575         }
 576         return result;
 577         }
 578
 579         @Override
 580         public String createVnfData(HttpServletRequest request) {
 581                 String result = "";
 582         try {
 583                 logger.info("aai createVnfData is starting");
 584                 RequestBody requestBody = extractBody(request);
 585             Response<ResponseBody> response = vfcService.createVnfData(requestBody).execute();
 586                         logger.info("aai createVnfData has finished");
 587             if (response.isSuccessful()) {
 588                 result=new String(response.body().bytes());
 589             } else {
 590                 result=Constant.CONSTANT_FAILED;
 591                 logger.error(String.format("Can not createVnfData[code=%s, message=%s]", response.code(), response.message()));
 592             }
 593         } catch (Exception e) {
 594                 result=Constant.CONSTANT_FAILED;
 595                 logger.error("createVnfData occur exception:"+e);
 596         }
 597         return result;
 598         }
 599
 600         @Override
 601         public String createPnfData(HttpServletRequest request) {
 602                 String result = "";
 603         try {
 604                 logger.info("aai createPnfData is starting");
 605                 RequestBody requestBody = extractBody(request);
 606             Response<ResponseBody> response = vfcService.createPnfData(requestBody).execute();
 607                         logger.info("aai createPnfData has finished");
 608             if (response.isSuccessful()) {
 609                 result=new String(response.body().bytes());
 610             } else {
 611                 result=Constant.CONSTANT_FAILED;
 612                 logger.error(String.format("Can not createPnfData[code=%s, message=%s]", response.code(), response.message()));
 613             }
 614         } catch (Exception e) {
 615                 result=Constant.CONSTANT_FAILED;
 616                 logger.error("createPnfData occur exception:"+e);
 617         }
 618         return result;
 619         }
 620
 621         @Override
 622         public String getNsdInfo(String nsdInfoId) {
 623
 624                 String result="";
 625         try {
 626                 logger.info("vfc getNsdInfo is starting!");
 627             Response<ResponseBody> response = this.vfcService.getNsdInfo(nsdInfoId).execute();
 628             logger.info("vfc getNsdInfo has finished!");
 629             if (response.isSuccessful()) {
 630                 result=Constant.CONSTANT_SUCCESS;
 631             } else {
 632                 logger.info(String.format("Can not get getNsdInfo[code=%s, message=%s]", response.code(), response.message()));
 633                 result=Constant.CONSTANT_FAILED;;
 634             }
 635         } catch (IOException e) {
 636             logger.error("getNsdInfo occur exception:"+e);
 637             result=Constant.CONSTANT_FAILED;;
 638         }
 639         return result;
 640
 641         }
 642
 643         @Override
 644         public String getVnfInfo(String vnfPkgId) {
 645
 646                 String result="";
 647         try {
 648                 logger.info("vfc getVnfInfo is starting!");
 649             Response<ResponseBody> response = this.vfcService.getVnfInfo(vnfPkgId).execute();
 650             logger.info("vfc getVnfInfo has finished!");
 651             if (response.isSuccessful()) {
 652                 result=Constant.CONSTANT_SUCCESS;
 653             } else {
 654                 logger.info(String.format("Can not get getVnfInfo[code=%s, message=%s]", response.code(), response.message()));
 655                 result=Constant.CONSTANT_FAILED;;
 656             }
 657         } catch (IOException e) {
 658             logger.error("getVnfInfo occur exception:"+e);
 659             result=Constant.CONSTANT_FAILED;;
 660         }
 661         return result;
 662
 663         }
 664
 665         @Override
 666         public String getPnfInfo(String pnfdInfoId) {
 667
 668                 String result="";
 669         try {
 670                 logger.info("vfc getPnfInfo is starting!");
 671             Response<ResponseBody> response = this.vfcService.getPnfInfo(pnfdInfoId).execute();
 672             logger.info("vfc getPnfInfo has finished!");
 673             if (response.isSuccessful()) {
 674                 result=Constant.CONSTANT_SUCCESS;
 675             } else {
 676                 logger.info(String.format("Can not get getPnfInfo[code=%s, message=%s]", response.code(), response.message()));
 677                 result=Constant.CONSTANT_FAILED;;
 678             }
 679         } catch (IOException e) {
 680             logger.error("getPnfInfo occur exception:"+e);
 681             result=Constant.CONSTANT_FAILED;;
 682         }
 683         return result;
 684
 685         }
 686
 687         @Override
 688         public String listNsTemplates() {
 689
 690                 String result="";
 691         try {
 692                 logger.info("vfc listNsTemplates is starting!");
 693             Response<ResponseBody> response = this.vfcService.listNsTemplates().execute();
 694             logger.info("vfc listNsTemplates has finished!");
 695             if (response.isSuccessful()) {
 696                 result=new String(response.body().bytes());
 697             } else {
 698                 logger.info(String.format("Can not get listNsTemplates[code=%s, message=%s]", response.code(), response.message()));
 699                 result=Constant.CONSTANT_FAILED;;
 700             }
 701         } catch (IOException e) {
 702             logger.error("listNsTemplates occur exception:"+e);
 703             result=Constant.CONSTANT_FAILED;;
 704         }
 705         return result;
 706
 707         }
 708
 709         @Override
 710         public String fetchNsTemplateData(HttpServletRequest request) {
 711                 String result = "";
 712         try {
 713                 logger.info("aai fetchNsTemplateData is starting");
 714                 RequestBody requestBody = extractBody(request);
 715             Response<ResponseBody> response = vfcService.fetchNsTemplateData(requestBody).execute();
 716                         logger.info("aai fetchNsTemplateData has finished");
 717             if (response.isSuccessful()) {
 718                 result=new String(response.body().bytes());
 719             } else {
 720                 result=Constant.CONSTANT_FAILED;
 721                 logger.error(String.format("Can not fetchNsTemplateData[code=%s, message=%s]", response.code(), response.message()));
 722             }
 723         } catch (Exception e) {
 724                 result=Constant.CONSTANT_FAILED;
 725                 logger.error("fetchNsTemplateData occur exception:"+e);
 726         }
 727         return result;
 728         }
 729
 730         @Override
 731         public JSONObject fetchTemplateInfo(HttpServletRequest request) {
 732                 JSONObject result = new JSONObject();;
 733         try {
 734                 logger.info("aai fetchTemplateInfo is starting");
 735                 RequestBody requestBody = extractBody(request);
 736             Response<ResponseBody> response = vfcService.fetchTemplateInfo(requestBody).execute();
 737                         logger.info("aai fetchTemplateInfo has finished");
 738             if (response.isSuccessful()) {
 739                 result.put("status", Constant.CONSTANT_SUCCESS);
 740                 result.put("result",JSONObject.parseObject(new String(response.body().bytes())));
 741             } else {
 742                 result.put("status", Constant.CONSTANT_FAILED);
 743                 result.put("error",String.format("Can not fetchTemplateInfo[code=%s, message=%s]", response.code(), response.message()));
 744                 logger.error(String.format("Can not fetchTemplateInfo[code=%s, message=%s]", response.code(), response.message()));
 745             }
 746         } catch (Exception e) {
 747                 result.put("status", Constant.CONSTANT_FAILED);
 748                 result.put("errorMessage","fetchTemplateInfo occur exception:"+e);
 749         }
 750         return result;
 751         }
 752
 753         @Override
 754         public String instantiateNetworkServiceInstance(HttpServletRequest request, String serviceInstanceId) {
 755                 String result = "";
 756         try {
 757                 logger.info("aai instantiateNetworkServiceInstance is starting");
 758                 RequestBody requestBody = extractBody(request);
 759             Response<ResponseBody> response = vfcService.instantiateNetworkServiceInstance(requestBody,serviceInstanceId).execute();
 760                         logger.info("aai instantiateNetworkServiceInstance has finished");
 761             if (response.isSuccessful()) {
 762                 result=new String(response.body().bytes());
 763             } else {
 764                 result=Constant.CONSTANT_FAILED;
 765                 logger.error(String.format("Can not instantiateNetworkServiceInstance[code=%s, message=%s]", response.code(), response.message()));
 766             }
 767         } catch (Exception e) {
 768                 result=Constant.CONSTANT_FAILED;
 769                 logger.error("instantiateNetworkServiceInstance occur exception:"+e);
 770         }
 771         return result;
 772         }
 773
 774         @Override
 775         public String getVnfInfoById(String vnfinstid) {
 776
 777                 String result="";
 778         try {
 779                 logger.info("vfc getVnfInfoById is starting!");
 780             Response<ResponseBody> response = this.vfcService.getVnfInfoById(vnfinstid).execute();
 781             logger.info("vfc getVnfInfoById has finished!");
 782             if (response.isSuccessful()) {
 783                 result=new String(response.body().bytes());
 784             } else {
 785                 logger.info(String.format("Can not get getVnfInfoById[code=%s, message=%s]", response.code(), response.message()));
 786                 result=Constant.CONSTANT_FAILED;;
 787             }
 788         } catch (IOException e) {
 789             logger.error("getVnfInfoById occur exception:"+e);
 790             result=Constant.CONSTANT_FAILED;;
 791         }
 792         return result;
 793
 794         }
 795 }