gerrit.onap Code Review - vnfsdk/refrepo.git/blob

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