Code Review / vnfsdk / refrepo.git / blob
? search:


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