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