ms/cds-sdc-listener/application/src/main/java/org/onap/ccsdk/cds/cdssdclistener/service/ListenerServiceImpl.java

   1 /*
   2  * Copyright © 2017-2019 AT&T, Bell Canada
   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.ccsdk.cds.cdssdclistener.service;
  18
  19 import static java.nio.file.Files.walk;
  20 import static org.onap.sdc.utils.DistributionStatusEnum.COMPONENT_DONE_ERROR;
  21 import static org.onap.sdc.utils.DistributionStatusEnum.COMPONENT_DONE_OK;
  22 import com.google.protobuf.ByteString;
  23 import io.grpc.ManagedChannel;
  24 import java.io.File;
  25 import java.io.FileOutputStream;
  26 import java.io.IOException;
  27 import java.io.InputStream;
  28 import java.io.OutputStream;
  29 import java.nio.file.Files;
  30 import java.nio.file.Path;
  31 import java.nio.file.Paths;
  32 import java.util.Enumeration;
  33 import java.util.List;
  34 import java.util.Optional;
  35 import java.util.regex.Pattern;
  36 import java.util.stream.Collectors;
  37 import java.util.stream.Stream;
  38 import java.util.zip.ZipEntry;
  39 import java.util.zip.ZipFile;
  40 import org.apache.commons.io.FileUtils;
  41 import org.apache.tomcat.util.http.fileupload.IOUtils;
  42 import org.onap.ccsdk.cds.cdssdclistener.client.CdsSdcListenerAuthClientInterceptor;
  43 import org.onap.ccsdk.cds.cdssdclistener.dto.CdsSdcListenerDto;
  44 import org.onap.ccsdk.cds.cdssdclistener.handler.BluePrintProcesssorHandler;
  45 import org.onap.ccsdk.cds.cdssdclistener.status.CdsSdcListenerStatus;
  46 import org.onap.ccsdk.cds.cdssdclistener.util.FileUtil;
  47 import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
  48 import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput;
  49 import org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk;
  50 import org.onap.sdc.api.results.IDistributionClientDownloadResult;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53 import org.springframework.beans.factory.annotation.Autowired;
  54 import org.springframework.beans.factory.annotation.Value;
  55 import org.springframework.boot.context.properties.ConfigurationProperties;
  56 import org.springframework.stereotype.Component;
  57
  58 @Component
  59 @ConfigurationProperties("listenerservice")
  60 public class ListenerServiceImpl implements ListenerService {
  61
  62     @Autowired
  63     private BluePrintProcesssorHandler bluePrintProcesssorHandler;
  64
  65     @Autowired
  66     private CdsSdcListenerAuthClientInterceptor cdsSdcListenerAuthClientInterceptor;
  67
  68     @Autowired
  69     private CdsSdcListenerStatus listenerStatus;
  70
  71     @Autowired
  72     private CdsSdcListenerDto cdsSdcListenerDto;
  73
  74     @Value("${listenerservice.config.grpcAddress}")
  75     private String grpcAddress;
  76
  77     @Value("${listenerservice.config.grpcPort}")
  78     private int grpcPort;
  79
  80     private static final String CBA_ZIP_PATH = "Artifacts/Resources/[a-zA-Z0-9-_]+/Deployment/CONTROLLER_BLUEPRINT_ARCHIVE/[a-zA-Z0-9-_]+[.]zip";
  81     private static final int SUCCESS_CODE = 200;
  82     private static final Logger LOGGER = LoggerFactory.getLogger(ListenerServiceImpl.class);
  83
  84     @Override
  85     public void extractBluePrint(String csarArchivePath, String cbaArchivePath) {
  86         Path cbaStorageDir = getStorageDirectory(cbaArchivePath);
  87         try (ZipFile zipFile = new ZipFile(csarArchivePath)) {
  88             Enumeration<? extends ZipEntry> entries = zipFile.entries();
  89             while (entries.hasMoreElements()) {
  90                 ZipEntry entry = entries.nextElement();
  91                 String fileName = entry.getName();
  92                 if (Pattern.matches(CBA_ZIP_PATH, fileName)) {
  93                     final String cbaArchiveName = Paths.get(fileName).getFileName().toString();
  94                     LOGGER.info("Storing the CBA archive {}", cbaArchiveName);
  95                     storeBluePrint(zipFile, cbaArchiveName, cbaStorageDir, entry);
  96                 }
  97             }
  98
  99         } catch (Exception e) {
 100             LOGGER.error("Failed to extract blueprint {}", e);
 101         }
 102     }
 103
 104     private void storeBluePrint(ZipFile zipFile, String fileName, Path cbaArchivePath, ZipEntry entry) {
 105         Path targetLocation = cbaArchivePath.resolve(fileName);
 106         LOGGER.info("The target location for zip file is {}", targetLocation);
 107         File targetZipFile = new File(targetLocation.toString());
 108
 109         try {
 110             targetZipFile.createNewFile();
 111         } catch (IOException e) {
 112             LOGGER.error("Could not able to create file {}", targetZipFile, e);
 113         }
 114
 115         try (InputStream inputStream = zipFile.getInputStream(entry); OutputStream out = new FileOutputStream(
 116             targetZipFile)) {
 117             IOUtils.copy(inputStream, out);
 118             LOGGER.info("Successfully store the CBA archive {} at this location", targetZipFile);
 119         } catch (Exception e) {
 120             LOGGER.error("Failed to put zip file into target location {}, {}", targetLocation, e);
 121         }
 122     }
 123
 124     @Override
 125     public void saveBluePrintToCdsDatabase(Path cbaArchivePath, ManagedChannel channel) {
 126         Optional<List<File>> zipFiles = FileUtil.getFilesFromDisk(cbaArchivePath);
 127         zipFiles.ifPresent(files -> prepareRequestForCdsBackend(files, channel, cbaArchivePath.toString()));
 128     }
 129
 130     @Override
 131     public void extractCsarAndStore(IDistributionClientDownloadResult result, String csarArchivePath) {
 132
 133         // Create CSAR storage directory
 134         Path csarStorageDir = getStorageDirectory(csarArchivePath);
 135         byte[] payload = result.getArtifactPayload();
 136         String csarFileName = result.getArtifactFilename();
 137         Path targetLocation = csarStorageDir.resolve(csarFileName);
 138
 139         LOGGER.info("The target location for the CSAR file is {}", targetLocation);
 140
 141         File targetCsarFile = new File(targetLocation.toString());
 142
 143         try (FileOutputStream outFile = new FileOutputStream(targetCsarFile)) {
 144             outFile.write(payload, 0, payload.length);
 145         } catch (Exception e) {
 146             LOGGER.error("Failed to put CSAR file into target location {}, {}", targetLocation, e);
 147         }
 148     }
 149
 150     private Path getStorageDirectory(String path) {
 151         Path fileStorageLocation = Paths.get(path).toAbsolutePath().normalize();
 152
 153         if (!fileStorageLocation.toFile().exists()) {
 154             try {
 155                 return Files.createDirectories(fileStorageLocation);
 156             } catch (IOException e) {
 157                 LOGGER.error("Fail to create directory {}, {}", e, fileStorageLocation);
 158             }
 159         }
 160         return fileStorageLocation;
 161     }
 162
 163     private void prepareRequestForCdsBackend(List<File> files, ManagedChannel managedChannel, String path) {
 164         final String distributionId = cdsSdcListenerDto.getDistributionId();
 165
 166         files.forEach(zipFile -> {
 167             try {
 168                 final BluePrintUploadInput request = generateBluePrintUploadInputBuilder(zipFile);
 169
 170                 // Send request to CDS Backend.
 171                 final Status responseStatus = bluePrintProcesssorHandler.sendRequest(request, managedChannel);
 172
 173                 if (responseStatus.getCode() != SUCCESS_CODE) {
 174                     final String errorMessage = String.format("Failed to store the CBA archive into CDS DB due to %s",
 175                         responseStatus.getErrorMessage());
 176                     listenerStatus.sendResponseStatusBackToSDC(distributionId,
 177                         COMPONENT_DONE_ERROR, errorMessage);
 178                     LOGGER.error(errorMessage);
 179
 180                 } else {
 181                     LOGGER.info(responseStatus.getMessage());
 182                     listenerStatus.sendResponseStatusBackToSDC(distributionId,
 183                         COMPONENT_DONE_OK, null);
 184                 }
 185
 186             } catch (Exception e) {
 187                 final String errorMessage = String.format("Failure due to %s", e.getMessage());
 188                 listenerStatus.sendResponseStatusBackToSDC(distributionId, COMPONENT_DONE_ERROR, errorMessage);
 189                 LOGGER.error("Failure due to {}", e);
 190             } finally {
 191                 FileUtil.deleteFile(zipFile, path);
 192             }
 193         });
 194     }
 195
 196     private BluePrintUploadInput generateBluePrintUploadInputBuilder(File file) throws IOException {
 197         byte[] bytes = FileUtils.readFileToByteArray(file);
 198         FileChunk fileChunk = FileChunk.newBuilder().setChunk(ByteString.copyFrom(bytes)).build();
 199
 200         return BluePrintUploadInput.newBuilder()
 201                 .setFileChunk(fileChunk)
 202                 .build();
 203     }
 204 }