vnfmarket-be/vnf-sdk-marketplace/src/main/java/org/onap/vnfsdk/marketplace/wrapper/PackageWrapper.java

   1 /**
   2  * Copyright 2017 Huawei Technologies Co., Ltd.
   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
  17 package org.onap.vnfsdk.marketplace.wrapper;
  18
  19 import java.io.BufferedInputStream;
  20 import java.io.File;
  21 import java.io.FileInputStream;
  22 import java.io.IOException;
  23 import java.io.InputStream;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.List;
  27 import java.util.concurrent.Callable;
  28 import java.util.concurrent.ExecutorService;
  29 import java.util.concurrent.Executors;
  30
  31 import javax.ws.rs.core.HttpHeaders;
  32 import javax.ws.rs.core.MediaType;
  33 import javax.ws.rs.core.Response;
  34 import javax.ws.rs.core.Response.Status;
  35
  36 import org.apache.commons.io.IOUtils;
  37 import org.apache.commons.lang3.StringUtils;
  38 import org.eclipse.jetty.http.HttpStatus;
  39 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
  40 import org.onap.vnfsdk.marketplace.common.CommonConstant;
  41 import org.onap.vnfsdk.marketplace.common.CommonErrorResponse;
  42 import org.onap.vnfsdk.marketplace.common.FileUtil;
  43 import org.onap.vnfsdk.marketplace.common.RestUtil;
  44 import org.onap.vnfsdk.marketplace.common.ToolUtil;
  45 import org.onap.vnfsdk.marketplace.db.entity.PackageData;
  46 import org.onap.vnfsdk.marketplace.db.exception.ErrorCodeException;
  47 import org.onap.vnfsdk.marketplace.db.exception.MarketplaceResourceException;
  48 import org.onap.vnfsdk.marketplace.db.resource.PackageManager;
  49 import org.onap.vnfsdk.marketplace.db.util.MarketplaceDbUtil;
  50 import org.onap.vnfsdk.marketplace.entity.request.PackageBasicInfo;
  51 import org.onap.vnfsdk.marketplace.entity.response.PackageMeta;
  52 import org.onap.vnfsdk.marketplace.entity.response.UploadPackageResponse;
  53 import org.onap.vnfsdk.marketplace.filemanage.FileManagerFactory;
  54 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoardingOperResult;
  55 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoardingResult;
  56 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoardingSteps;
  57 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoradingRequest;
  58 import org.onap.vnfsdk.marketplace.onboarding.hooks.functiontest.FunctionTestExceutor;
  59 import org.onap.vnfsdk.marketplace.onboarding.hooks.functiontest.FunctionTestHook;
  60 import org.onap.vnfsdk.marketplace.onboarding.hooks.validatelifecycle.ValidateLifecycleTestResponse;
  61 import org.onap.vnfsdk.marketplace.onboarding.onboardmanager.OnBoardingHandler;
  62 import org.open.infc.grpc.Result;
  63 import org.open.infc.grpc.client.OpenRemoteCli;
  64 import org.slf4j.Logger;
  65 import org.slf4j.LoggerFactory;
  66
  67 public class PackageWrapper {
  68
  69     private static PackageWrapper packageWrapper;
  70
  71     private static final Logger LOG = LoggerFactory.getLogger(PackageWrapper.class);
  72
  73     private static final boolean DISABLE_VALIDATION = true;
  74
  75     private static final String FILE_FORMAT = ".csar";
  76
  77     /**
  78      * get PackageWrapper instance.
  79      *
  80      * @return package wrapper instance
  81      */
  82     public static PackageWrapper getInstance() {
  83         if(packageWrapper == null) {
  84             packageWrapper = new PackageWrapper();
  85         }
  86         return packageWrapper;
  87     }
  88
  89     public Response updateValidateStatus(InputStream inputStream) throws IOException {
  90         String reqParam = IOUtils.toString(inputStream);
  91         LOG.info("updateValidateStatus request param:{}" , reqParam);
  92         if(StringUtils.isBlank(reqParam)) {
  93             LOG.error("The updateValidateStatus request params can't be null");
  94             return Response.status(Status.EXPECTATION_FAILED).build();
  95         }
  96
  97         ValidateLifecycleTestResponse lyfValidateResp = null;
  98         // TBD - Use Gson - jackson has security issue/
  99
 100         if(!checkOperationSucess(lyfValidateResp)) {
 101             return Response.status(Status.EXPECTATION_FAILED).build();
 102         }
 103
 104         String funcTestResponse = FunctionTestExceutor.executeFunctionTest(reqParam);
 105         if(null == funcTestResponse) {
 106             return Response.status(Status.EXPECTATION_FAILED).build();
 107         }
 108
 109         if(!funcTestResponse.contains(CommonConstant.SUCCESS_STR)) {
 110             return Response.status(Status.EXPECTATION_FAILED).build();
 111         }
 112
 113         return Response.ok().build();
 114     }
 115
 116     private boolean checkOperationSucess(ValidateLifecycleTestResponse lyfValidateResp) {
 117         boolean bOperStatus = false;
 118         if(null == lyfValidateResp) {
 119             LOG.error("ValidateLifecycleTestResponse  is NUll !!!");
 120             return bOperStatus;
 121         }
 122         if(lyfValidateResp.getLifecycleStatus().equalsIgnoreCase(CommonConstant.SUCCESS_STR)
 123                 && lyfValidateResp.getValidateStatus().equalsIgnoreCase(CommonConstant.SUCCESS_STR)) {
 124             String lyfValidateResponse = lyfValidateResp.getLifecycleStatus() + File.separator+lyfValidateResp.getValidateStatus();
 125             LOG.error("Lifecycle/Validation Response failed :{}" , lyfValidateResponse);
 126             bOperStatus = true;
 127         }
 128         return bOperStatus;
 129     }
 130
 131     /**
 132      * query package list by condition.
 133      *
 134      * @param name package name
 135      * @param provider package provider
 136      * @param version package version
 137      * @param deletionPending package deletionPending
 138      * @param type package type
 139      * @return Response
 140      */
 141     public Response queryPackageListByCond(String name, String provider, String version, String deletionPending,
 142             String type) {
 143         List<PackageData> dbresult = new ArrayList<>();
 144         List<PackageMeta> result = new ArrayList<>();
 145         LOG.info("query package info.name:{} provider:{} version{} deletionPending{} type:{}" , name , provider , version
 146                 , deletionPending , type);
 147         try {
 148             dbresult = PackageManager.getInstance().queryPackage(name, provider, version, deletionPending, type);
 149             result = PackageWrapperUtil.packageDataList2PackageMetaList(dbresult);
 150             return Response.ok(ToolUtil.objectToString(result)).build();
 151         } catch(MarketplaceResourceException e1) {
 152             LOG.error("query package by csarId from db error ! ", e1);
 153             return RestUtil.getRestException(e1.getMessage());
 154         }
 155     }
 156
 157     /**
 158      * query package by id.
 159      *
 160      * @param csarId package id
 161      * @return Response
 162      */
 163     public Response queryPackageById(String csarId) {
 164         PackageData dbResult = PackageWrapperUtil.getPackageInfoById(csarId);
 165         PackageMeta result = PackageWrapperUtil.packageData2PackageMeta(dbResult);
 166         return Response.ok(ToolUtil.objectToString(result)).build();
 167     }
 168
 169     /**
 170      * upload package.
 171      *
 172      * @param uploadedInputStream inputStream
 173      * @param fileDetail package detail
 174      * @param head http header
 175      * @return Response
 176      * @throws Exception e
 177      */
 178     public Response uploadPackage(InputStream uploadedInputStream, FormDataContentDisposition fileDetail,
 179             String details, HttpHeaders head) {
 180         LOG.info("Upload/Reupload request Received !!!!");
 181         try {
 182             String packageId = MarketplaceDbUtil.generateId();
 183             return handlePackageUpload(packageId, uploadedInputStream, fileDetail, details, head);
 184         } catch(IOException e) {
 185             LOG.error("can't get package id", e);
 186         }
 187         return Response.status(Status.INTERNAL_SERVER_ERROR).build();
 188     }
 189
 190     private UploadPackageResponse manageUpload(String packageId, String fileName, String fileLocation, String details,
 191             String contentRange) throws ErrorCodeException {
 192         String localDirName = ToolUtil.getTempDir(CommonConstant.CATALOG_CSAR_DIR_NAME, fileName);
 193         PackageBasicInfo basicInfo = PackageWrapperUtil.getPacageBasicInfo(fileLocation);
 194         UploadPackageResponse result = new UploadPackageResponse();
 195         Boolean isEnd = PackageWrapperUtil.isUploadEnd(contentRange);
 196         if(Boolean.TRUE.equals(isEnd)) {
 197             PackageMeta packageMeta =
 198                     PackageWrapperUtil.getPackageMeta(packageId, fileName, fileLocation, basicInfo, details);
 199             try {
 200                 String path = basicInfo.getType().toString() + File.separator + basicInfo.getProvider() + File.separator
 201                         + packageMeta.getCsarId() + File.separator + fileName.replace(FILE_FORMAT, "") + File.separator
 202                         + basicInfo.getVersion();
 203
 204                 String dowloadUri = File.separator + path + File.separator;
 205                 packageMeta.setDownloadUri(dowloadUri);
 206
 207                 String jsonPackageMeta = ToolUtil.objectToString(packageMeta);
 208                 LOG.info("dest path is : {}" , path);
 209                 LOG.info("packageMeta = {}" , jsonPackageMeta);
 210
 211                 PackageData packageData = PackageWrapperUtil.getPackageData(packageMeta);
 212
 213                 List<PackageData> lstPkgData =
 214                         PackageManager.getInstance().queryPackage(packageMeta.getName(), "", "", "", "");
 215                 if(!lstPkgData.isEmpty()) {
 216                     LOG.error("Package name is not unique");
 217                     throw new ErrorCodeException(HttpStatus.INTERNAL_SERVER_ERROR_500, "Package name already exists");
 218                 }
 219
 220                 String destPath = File.separator + path + File.separator + File.separator;
 221                 boolean uploadResult = FileManagerFactory.createFileManager().upload(localDirName, destPath);
 222                 if(uploadResult) {
 223                     OnBoradingRequest oOnboradingRequest = new OnBoradingRequest();
 224                     oOnboradingRequest.setCsarId(packageId);
 225                     oOnboradingRequest.setPackageName(fileName);
 226                     oOnboradingRequest.setPackagePath(localDirName);
 227
 228                     packageData.setCsarId(packageId);
 229                     packageData.setDownloadCount(-1);
 230                     PackageData packateDbData = PackageManager.getInstance().addPackage(packageData);
 231
 232                     String jsonPackageDbData = ToolUtil.objectToString(packateDbData);
 233                     LOG.info("Store package data to database succed ! packateDbData = {}"
 234                             , jsonPackageDbData);
 235                     LOG.info("upload package file end, fileName:{}" , fileName);
 236
 237                     result.setCsarId(packateDbData.getCsarId());
 238
 239                     addOnBoardingRequest(oOnboradingRequest);
 240
 241                     String jsonoOnboradingRequest = ToolUtil.objectToString(oOnboradingRequest);
 242                     LOG.info("OnboradingRequest Data : {}" , jsonoOnboradingRequest);
 243                 }
 244             } catch(NullPointerException e) {
 245                 String jsonBasicInfo =  ToolUtil.objectToString(basicInfo);
 246                 LOG.error("Package basicInfo is incorrect ! basicIonfo = {} {}" , jsonBasicInfo, e);
 247                 return null;
 248             }
 249         }
 250         return result;
 251     }
 252
 253     /**
 254      * Interface for Uploading package
 255      *
 256      * @param packageId
 257      * @param uploadedInputStream
 258      * @param fileDetail
 259      * @param details
 260      * @param head
 261      * @return
 262      * @throws IOException
 263      * @throws MarketplaceResourceException
 264      */
 265     private Response handlePackageUpload(String packageId, InputStream uploadedInputStream,
 266             FormDataContentDisposition fileDetail, String details, HttpHeaders head) throws IOException {
 267         boolean bResult = handleDataValidate(packageId, uploadedInputStream, fileDetail);
 268         if(!bResult) {
 269             LOG.error("Validation of Input received for Package Upload failed !!!");
 270             return Response.status(Status.EXPECTATION_FAILED)
 271                     .entity(new CommonErrorResponse("Input package is empty or exception happened during validation"))
 272                     .build();
 273         }
 274
 275         String fileName = "temp_" + packageId + FILE_FORMAT;
 276         if(null != fileDetail) {
 277             String jsonFileDetail = ToolUtil.objectToString(fileDetail);
 278             LOG.info("the fileDetail = {}" , jsonFileDetail);
 279
 280             fileName = ToolUtil.processFileName(fileDetail.getFileName());
 281         }
 282
 283         String localDirName = ToolUtil.getTempDir(CommonConstant.CATALOG_CSAR_DIR_NAME, fileName);
 284
 285         String contentRange = null;
 286         if(head != null) {
 287             contentRange = head.getHeaderString(CommonConstant.HTTP_HEADER_CONTENT_RANGE);
 288         }
 289         LOG.info("store package chunk file, fileName:{} contentRange:{}", fileName , contentRange);
 290         if(ToolUtil.isEmptyString(contentRange)) {
 291             int fileSize = uploadedInputStream.available();
 292             contentRange = "0-" + fileSize + "/" + fileSize;
 293         }
 294
 295         String fileLocation = ToolUtil.storeChunkFileInLocal(localDirName, fileName, uploadedInputStream);
 296         LOG.info("the fileLocation when upload package is :{}" , fileLocation);
 297
 298         uploadedInputStream.close();
 299
 300         if (!DISABLE_VALIDATION) {
 301             try {
 302                 Result result = OpenRemoteCli.run("localhost", 50051, null, Arrays.asList( "--product", "onap-vtp", "csar-validate", "--csar", fileLocation, "--format", "json" ));
 303                 LOG.info("CSAR validation is successful{}" , result.getOutput());
 304
 305                 int exitCode = result.getExitCode();
 306                 String output = result.getOutput();
 307
 308                 if((exitCode != 0) ||  !output.contains("\"error\":\"SUCCESS\"")) {
 309                   LOG.error("Could not validate failed");
 310                   return Response.status(Status.EXPECTATION_FAILED).entity(new CommonErrorResponse(output))
 311                           .build();
 312                 }
 313             } catch (Exception e) {
 314                 LOG.error("CSAR validation panicked", e);
 315                 return Response.serverError().entity(
 316                         new CommonErrorResponse("Exception occurred while validating csar package:" + e.getMessage()))
 317                         .build();
 318             }
 319         }
 320
 321         UploadPackageResponse result = null;
 322         try {
 323             result = manageUpload(packageId, fileName, fileLocation, details, contentRange);
 324         } catch(ErrorCodeException e) {
 325             LOG.error("ErrorCodeException occurs ",e);
 326             return Response.status(Status.EXPECTATION_FAILED)
 327                     .entity(new CommonErrorResponse("Package Name already exists")).build();
 328         }
 329         if(null != result) {
 330             return Response.ok(ToolUtil.objectToString(result), MediaType.APPLICATION_JSON).build();
 331         } else {
 332             return Response.serverError().build();
 333         }
 334     }
 335
 336     /**
 337      * Execute OnBarding request
 338      *
 339      * @param oOnboradingRequest
 340      */
 341     private void addOnBoardingRequest(final OnBoradingRequest oOnboradingRequest) {
 342         ExecutorService es = Executors.newFixedThreadPool(CommonConstant.ONBOARDING_THREAD_COUNT);
 343         Callable<Integer> callableInteger = () -> {
 344             new OnBoardingHandler().handleOnBoardingReq(oOnboradingRequest);
 345             return CommonConstant.SUCESS;
 346         };
 347         es.submit(callableInteger);
 348     }
 349
 350     /**
 351      * delete package by package id.
 352      *
 353      * @param csarId package id
 354      * @return Response
 355      */
 356     public Response delPackage(String csarId) {
 357         LOG.info("delete package  info.csarId:{}" , csarId);
 358         if(ToolUtil.isEmptyString(csarId)) {
 359             LOG.error("delete package  fail, csarid is null");
 360             return Response.serverError().build();
 361         }
 362         deletePackageDataById(csarId);
 363         return Response.ok().build();
 364     }
 365
 366     /**
 367      * Delete Package by CSAR ID
 368      *
 369      * @param csarId
 370      */
 371     private void deletePackageDataById(String csarId) {
 372         String packagePath = PackageWrapperUtil.getPackagePath(csarId);
 373         if(packagePath == null) {
 374             LOG.error("package path is null! ");
 375         }
 376
 377         // Delete Package
 378         FileManagerFactory.createFileManager().delete(packagePath);
 379         // Delete Results Data
 380         FileManagerFactory.createFileManager().delete(File.separator + csarId);
 381
 382         // delete package data from database
 383         try {
 384             PackageManager.getInstance().deletePackage(csarId);
 385         } catch(MarketplaceResourceException e1) {
 386             String message = e1.getMessage();
 387             LOG.error("delete package  by csarId from db error ! {} {}" , message, e1);
 388         }
 389     }
 390
 391     /**
 392      * download package by package id.
 393      *
 394      * @param csarId package id
 395      * @return Response
 396      */
 397     public Response downloadCsarPackagesById(String csarId) {
 398         PackageData packageData = PackageWrapperUtil.getPackageInfoById(csarId);
 399
 400         String packageName = packageData.getName();
 401         String path = org.onap.vnfsdk.marketplace.filemanage.http.ToolUtil.getHttpServerAbsolutePath()
 402                 + File.separatorChar + packageData.getType() + File.separatorChar + packageData.getProvider()
 403                 + File.separatorChar + packageData.getCsarId() + File.separator + packageName + File.separatorChar
 404                 + packageData.getVersion() + File.separator + packageName + FILE_FORMAT;
 405
 406         LOG.info("downloadCsarPackagesById path is :  {}" , path);
 407
 408         File csarFile = new File(path);
 409         if(!csarFile.exists()) {
 410             return Response.status(Status.INTERNAL_SERVER_ERROR).build();
 411         }
 412
 413         LOG.info("downloadCsarPackagesById ABS path is :  {}" , csarFile.getAbsolutePath());
 414
 415         try {
 416             InputStream fis = new BufferedInputStream(new FileInputStream(csarFile.getAbsolutePath()));
 417             return Response.ok(fis).header("Content-Disposition", "attachment; filename=\"" + csarFile.getName() + "\"")
 418                     .build();
 419         } catch(Exception e1) {
 420             LOG.error("download vnf package fail.", e1);
 421             return RestUtil.getRestException(e1.getMessage());
 422         }
 423     }
 424
 425     /**
 426      * get package file uri.
 427      *
 428      * @param csarId package id
 429      * @param relativePath file relative path
 430      * @return Response
 431      */
 432     public Response getCsarFileUri(String csarId) {
 433         return downloadCsarPackagesById(csarId);
 434     }
 435
 436     /**
 437      * Interface to Update Download count for CSAR ID
 438      *
 439      * @param csarId
 440      * @return
 441      */
 442     public Response updateDwonloadCount(String csarId) {
 443         return handleDownladCountUpdate(csarId) ? Response.ok().build()
 444                 : Response.status(Status.EXPECTATION_FAILED).build();
 445     }
 446
 447     /**
 448      * Handle downlowa count update
 449      *
 450      * @param csarId
 451      * @return
 452      */
 453     private boolean handleDownladCountUpdate(String csarId) {
 454         boolean bupdateSucess = false;
 455         try {
 456             PackageManager.getInstance().updateDownloadCount(csarId);
 457             bupdateSucess = true;
 458         } catch(Exception exp) {
 459             LOG.error("Updating Donwload count failed for Package with ID !!! : {} {}" , exp.getMessage(), exp);
 460         }
 461         return bupdateSucess;
 462     }
 463
 464     /**
 465      * Interface to Re upload Package
 466      *
 467      * @param csarId
 468      * @param uploadedInputStream
 469      * @param fileDetail
 470      * @param details
 471      * @param head
 472      * @return
 473      * @throws Exception
 474      */
 475     public Response reUploadPackage(String csarId, InputStream uploadedInputStream,
 476             FormDataContentDisposition fileDetail, String details, HttpHeaders head)
 477             {
 478         LOG.info("Reupload request Received !!!!");
 479
 480         // STEP 1: Validate Input Data
 481         // ----------------------------
 482         boolean bResult = handleDataValidate(csarId, uploadedInputStream, fileDetail);
 483         if(!bResult) {
 484             LOG.error("Validation of Input received for Package Upload failed during Reload!!!");
 485             return Response.status(Status.EXPECTATION_FAILED).build();
 486         }
 487
 488         try {
 489             // STEP 2: Delete All Package Data based on package id
 490             // ----------------------------------------------------
 491             deletePackageDataById(csarId);
 492
 493             // STEP 3: upload package with same package id
 494             // -------------------------------------------
 495             return handlePackageUpload(csarId, uploadedInputStream, fileDetail, details, head);
 496         } catch(IOException e) {
 497             LOG.error("delete package failed", e);
 498         }
 499         return Response.status(Status.INTERNAL_SERVER_ERROR).build();
 500     }
 501
 502     /**
 503      * Interface to get OnBoarding Result by Operation Type
 504      *
 505      * @param csarId
 506      * @param operTypeId
 507      * @param operId
 508      * @return
 509      */
 510     public Response getOnBoardingResult(String csarId, String operTypeId, String operId) {
 511         LOG.info("getOnBoardingResult request csarId:{} operTypeId:{} operId:{}", csarId , operTypeId , operId);
 512         try {
 513             PackageData packageData = PackageWrapperUtil.getPackageInfoById(csarId);
 514             if(null == packageData) {
 515                 return Response.status(Response.Status.PRECONDITION_FAILED).build();
 516             }
 517
 518             handleDelayExec(operId);
 519
 520             OnBoardingResult oOnBoardingResult = FunctionTestHook.getOnBoardingResult(packageData);
 521             if(null == oOnBoardingResult) {
 522                 return Response.status(Response.Status.PRECONDITION_FAILED).build();
 523             }
 524             filterOnBoardingResultByOperId(oOnBoardingResult, operId);
 525
 526             String strResult = ToolUtil.objectToString(oOnBoardingResult);
 527             LOG.info("getOnBoardingResult response : {}" , strResult);
 528             return Response.ok(strResult, "application/json").build();
 529         } catch(NullPointerException e) {
 530             LOG.error("Null param in getOnBoardingResult", e);
 531             return Response.status(Response.Status.BAD_REQUEST).build();
 532         }
 533     }
 534
 535     private void filterOnBoardingResultByOperId(OnBoardingResult oOnBoardingResult, String operId) {
 536         if(0 == operId.compareToIgnoreCase("all")) {
 537             return;
 538         }
 539         if(0 == operId.compareToIgnoreCase("download")) {
 540             List<OnBoardingOperResult> operResultListTemp = new ArrayList<>();
 541             OnBoardingOperResult operResultListTmp = new OnBoardingOperResult();
 542             operResultListTmp.setOperId("download");
 543             operResultListTmp.setStatus(0);
 544             operResultListTemp.add(operResultListTmp);
 545             oOnBoardingResult.setOperResult(operResultListTemp);
 546             return;
 547         }
 548         List<OnBoardingOperResult> operResultListOut = new ArrayList<>();
 549         List<OnBoardingOperResult> operResultList = oOnBoardingResult.getOperResult();
 550         for(OnBoardingOperResult operResult : operResultList) {
 551             if(0 == operResult.getOperId().compareToIgnoreCase(operId)) {
 552                 operResultListOut.add(operResult);
 553             }
 554         }
 555         oOnBoardingResult.setOperResult(operResultListOut);
 556     }
 557
 558     /**
 559      * Interface to get OnBoarding Status by Operation ID
 560      *
 561      * @param csarId
 562      * @param operTypeId
 563      * @return
 564      */
 565     public Response getOperResultByOperTypeId(String csarId, String operTypeId) {
 566         LOG.error("getOnBoardingResult request : csarId:{} operTypeId:{}" , csarId , operTypeId);
 567         if(null == csarId || null == operTypeId || csarId.isEmpty() || operTypeId.isEmpty()) {
 568             return Response.status(Status.BAD_REQUEST).build();
 569         }
 570
 571         PackageData packageData = PackageWrapperUtil.getPackageInfoById(csarId);
 572         if(null == packageData) {
 573             LOG.error("Failed to find package for PackageID:{}" , csarId);
 574             return Response.status(Status.PRECONDITION_FAILED).build();
 575         }
 576
 577         // Get result key to fetch Function Test Results
 578         // ---------------------------------------------
 579         String strResult = FunctionTestHook.getFuncTestResults(packageData);
 580         if(null == strResult) {
 581             LOG.error("NULL reponse for getOperResultByOperTypeId response :{}" , strResult);
 582             return Response.status(Status.INTERNAL_SERVER_ERROR).build();
 583         }
 584         LOG.info("getOperResultByOperTypeId response :{}" , strResult);
 585         return Response.ok(strResult, MediaType.APPLICATION_JSON).build();
 586     }
 587
 588     private boolean handleDataValidate(String packageId, InputStream uploadedInputStream,
 589             FormDataContentDisposition fileDetail) {
 590         boolean bvalidateOk = false;
 591         if((null != uploadedInputStream) && (fileDetail != null) && !ToolUtil.isEmptyString(packageId)) {
 592             bvalidateOk = true;
 593         }
 594         return bvalidateOk;
 595     }
 596
 597     /**
 598      * Interface to get OnBoarding Steps
 599      *
 600      * @return
 601      */
 602     public Response getOnBoardingSteps() {
 603         LOG.info("Get OnBoarding Steps request Received !!!");
 604
 605         String filePath = org.onap.vnfsdk.marketplace.filemanage.http.ToolUtil.getAppDeployPath() + File.separator
 606                 + "generalconfig/OnBoardingSteps.json";
 607         LOG.info("Onboarding Steps Json file Path  :{}" , filePath);
 608
 609         OnBoardingSteps oOnBoardingSteps =
 610                 (OnBoardingSteps)FileUtil.readJsonDatafFromFile(filePath, OnBoardingSteps.class);
 611         if(null == oOnBoardingSteps) {
 612             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
 613         }
 614         String strResult = ToolUtil.objectToString(oOnBoardingSteps);
 615         LOG.info("getOnBoardingSteps response :{}" , strResult);
 616         return Response.ok(strResult, MediaType.APPLICATION_JSON).build();
 617     }
 618
 619     private void handleDelayExec(String operId) {
 620         if(0 == operId.compareToIgnoreCase(CommonConstant.FunctionTest.FUNCTEST_EXEC)) {
 621             try {
 622                 Thread.sleep(8000);
 623             } catch(InterruptedException e) {
 624                 LOG.info("handleDelayExex response : ", e);
 625                 Thread.currentThread().interrupt();
 626             }
 627         }
 628     }
 629 }