1 files changed, 210 insertions, 0 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-externaltesting-lib/openecomp-sdc-externaltesting-impl/src/main/java/org/openecomp/core/externaltesting/impl/CsarMetadataVariableResolver.java b/openecomp-be/lib/openecomp-sdc-externaltesting-lib/openecomp-sdc-externaltesting-impl/src/main/java/org/openecomp/core/externaltesting/impl/CsarMetadataVariableResolver.java
new file mode 100644
index 0000000000..191fff0c6c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-externaltesting-lib/openecomp-sdc-externaltesting-impl/src/main/java/org/openecomp/core/externaltesting/impl/CsarMetadataVariableResolver.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright © 2019 iconectiv
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.core.externaltesting.impl;
+
+import lombok.EqualsAndHashCode;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.openecomp.core.externaltesting.api.VtpTestExecutionRequest;
+import org.openecomp.core.externaltesting.errors.ExternalTestingException;
+import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
+import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManagerFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.util.MultiValueMap;
+
+import javax.annotation.PostConstruct;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+/**
+ * The CSAR Metadata variable resolver is responsible for processing of
+ * variables in the test request.  It looks for variables with the "csar:" prefix
+ * and extracts the contents of the uploaded CSAR file for a VSP.
+ */
+public class CsarMetadataVariableResolver implements VariableResolver {
+
+  private Logger logger = LoggerFactory.getLogger(CsarMetadataVariableResolver.class);
+
+  static final String VSP_ID = "vspId";
+  static final String VSP_VERSION = "vspVersion";
+  static final String CSAR_PREFIX = "csar:";
+
+  private VersioningManager versioningManager;
+  private VendorSoftwareProductManager vendorSoftwareProductManager;
+  private OrchestrationTemplateCandidateManager candidateManager;
+
+  CsarMetadataVariableResolver(VersioningManager versioningManager,
+                                      VendorSoftwareProductManager vendorSoftwareProductManager,
+                                      OrchestrationTemplateCandidateManager candidateManager) {
+    this();
+    this.versioningManager = versioningManager;
+    this.vendorSoftwareProductManager = vendorSoftwareProductManager;
+    this.candidateManager = candidateManager;
+  }
+
+  CsarMetadataVariableResolver() {
+
+  }
+
+  @PostConstruct
+  public void init() {
+    if (versioningManager == null) {
+      versioningManager = VersioningManagerFactory.getInstance().createInterface();
+    }
+    if (vendorSoftwareProductManager == null) {
+      vendorSoftwareProductManager =
+          VspManagerFactory.getInstance().createInterface();
+    }
+    if (candidateManager == null) {
+      candidateManager =
+          OrchestrationTemplateCandidateManagerFactory.getInstance().createInterface();
+    }
+  }
+
+  @Override
+  public boolean resolvesVariablesForRequest(VtpTestExecutionRequest requestItem) {
+    Map<String,String> params = requestItem.getParameters();
+
+    // no params, quickly return.
+    if (params == null) {
+      return false;
+    }
+
+    // no match, quickly return
+    if (!params.containsKey(VSP_ID) || !params.containsKey(VSP_VERSION)) {
+      return false;
+    }
+
+    return (params.keySet().stream().anyMatch(s -> StringUtils.startsWith(s, CSAR_PREFIX)));
+  }
+
+  @Override
+  public void resolve(VtpTestExecutionRequest requestItem, MultiValueMap<String, Object> body) {
+    logger.debug("run {} variable resolver...", this.getClass().getSimpleName());
+    Map<String,String> params = requestItem.getParameters();
+    String vspId = params.get(VSP_ID);
+    String version = params.get(VSP_VERSION);
+
+    try {
+      extractMetadata(requestItem, body, vspId, version);
+    }
+    catch (IOException ex) {
+      logger.error("metadata extraction failed", ex);
+    }
+  }
+
+  /**
+   * Extract the metadata from the VSP CSAR file.
+   * @param requestItem item to add metadata to for processing
+   * @param vspId VSP identifier
+   * @param version VSP version
+   */
+  @SuppressWarnings("WeakerAccess")
+  protected void extractMetadata(VtpTestExecutionRequest requestItem, MultiValueMap<String, Object> body, String vspId, String version) throws IOException {
+
+    Version ver = new Version(version);
+    logger.debug("attempt to retrieve archive for VSP {} version {}", vspId, ver.getId());
+
+    Optional<Pair<String, byte[]>> ozip = candidateManager.get(vspId, new Version(version));
+    if (!ozip.isPresent()) {
+      ozip = vendorSoftwareProductManager.get(vspId, ver);
+    }
+
+    if (!ozip.isPresent()) {
+      List<Version> versions = versioningManager.list(vspId);
+      String knownVersions = versions
+          .stream()
+          .map(v -> String.format("%d.%d: %s (%s)", v.getMajor(), v.getMinor(), v.getStatus(), v.getId()))
+          .collect(Collectors.joining("\n"));
+
+      String detail = String.format("Unable to find archive for VSP ID %s and Version %s.  Known versions are:\n%s",
+        vspId, version, knownVersions);
+
+      throw new ExternalTestingException("Archive Processing Failed", 500, detail);
+    }
+
+    // safe here to do get.
+    Pair<String, byte[]> zip = ozip.get();
+    processArchive(requestItem, body, zip.getRight());
+  }
+
+  @EqualsAndHashCode(callSuper = false)
+  private class NamedByteArrayResource extends ByteArrayResource {
+    private String filename;
+    private NamedByteArrayResource(byte[] bytes, String filename) {
+      super(bytes, filename);
+      this.filename = filename;
+    }
+    @Override
+    public String getFilename() {
+      return this.filename;
+    }
+
+  }
+
+  @SuppressWarnings("WeakerAccess")
+  protected void processArchive(VtpTestExecutionRequest requestItem, MultiValueMap<String, Object> body, byte[] zip) {
+    try {
+      ZipInputStream zipStream = new ZipInputStream(new ByteArrayInputStream(zip));
+      ZipEntry entry;
+      while ((entry = zipStream.getNextEntry()) != null) {
+        String entryName = entry.getName();
+        logger.debug("csar contains entry {}", entryName);
+        Map<String,String> params = requestItem.getParameters();
+          params.forEach((key,val) -> {
+            if (key.startsWith(CSAR_PREFIX)) {
+              addToBody(requestItem, body, zipStream, entryName, key);
+            }
+        });
+      }
+    } catch (IOException ex) {
+      logger.error("IO Exception parsing zip", ex);
+    }
+  }
+
+  private void addToBody(VtpTestExecutionRequest requestItem, MultiValueMap<String, Object> body, ZipInputStream zipStream, String entryName, String key) {
+    String filename = key.substring(CSAR_PREFIX.length());
+    logger.debug("match {} with {}", entryName, filename);
+    if (StringUtils.equals(entryName, filename)) {
+      try {
+        NamedByteArrayResource res = new NamedByteArrayResource(IOUtils.toByteArray(zipStream), filename);
+        body.add("file", res);
+
+        // we've added the file to the body.   need to replace the value in the request for this
+        // parameter to match the VTP requirement that it start with a file URL protocol handler.
+        requestItem.getParameters().put(key, "file://" + entryName);
+
+      } catch (IOException ex) {
+        logger.error("failed to read zip entry content for {}", entryName, ex);
+      }
+    }
+  }
+}