import org.onap.sdc.tosca.services.YamlUtil;
import org.openecomp.core.utilities.file.FileContentHandler;
import org.openecomp.core.utilities.file.FileUtils;
- import org.openecomp.sdc.be.csar.storage.ArtifactStorageManager;
import org.openecomp.sdc.be.csar.storage.StorageFactory;
import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.plugins.etsi.nfv.nsd.builder.NsdToscaMetadataBuilder;
* @param vspId - VSP ID
*/
void delete(String vspId);
+
}
*/
public interface PackageSizeReducer {
+ /**
+ * Reduces the package in the given path based on the package reducer configuration.
+ *
+ * @param path the package path
+ * @return the reduced package in bytes
+ */
byte[] reduce(Path path);
}
package org.openecomp.sdc.be.csar.storage;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
+import lombok.Data;
-@AllArgsConstructor
-@Getter
+@Data
public class MinIoStorageArtifactStorageConfig implements ArtifactStorageConfig {
private final boolean isEnabled;
private final String tempPath;
private final int uploadPartSize;
- @AllArgsConstructor
- @Getter
+ @Data
public static class EndPoint {
private final String host;
private final boolean secure;
}
- @AllArgsConstructor
- @Getter
+ @Data
public static class Credentials {
private final String accessKey;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.FilenameUtils;
import org.openecomp.sdc.be.csar.storage.exception.CsarSizeReducerException;
+import org.openecomp.sdc.common.CommonConfigurationManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Set<String> ALLOWED_CERTIFICATE_EXTENSIONS = Set.of("cert", "crt");
private static final String CSAR_EXTENSION = "csar";
private static final String UNEXPECTED_PROBLEM_HAPPENED_WHILE_READING_THE_CSAR = "An unexpected problem happened while reading the CSAR '%s'";
+ private static final String EXTERNAL_CSAR_STORE = "externalCsarStore";
+
@Getter
private final AtomicBoolean reduced = new AtomicBoolean(false);
private final CsarPackageReducerConfiguration configuration;
- public MinIoStorageCsarSizeReducer(final CsarPackageReducerConfiguration configuration) {
+ public MinIoStorageCsarSizeReducer() {
+ this.configuration = readPackageReducerConfiguration();
+ }
+
+ MinIoStorageCsarSizeReducer(final CsarPackageReducerConfiguration configuration) {
this.configuration = configuration;
}
+ private CsarPackageReducerConfiguration readPackageReducerConfiguration() {
+ final var commonConfigurationManager = CommonConfigurationManager.getInstance();
+ final List<String> foldersToStrip = commonConfigurationManager.getConfigValue(EXTERNAL_CSAR_STORE, "foldersToStrip", new ArrayList<>());
+ final int sizeLimit = commonConfigurationManager.getConfigValue(EXTERNAL_CSAR_STORE, "sizeLimit", 1000000);
+ final int thresholdEntries = commonConfigurationManager.getConfigValue(EXTERNAL_CSAR_STORE, "thresholdEntries", 10000);
+ LOGGER.info("Folders to strip: '{}'", String.join(", ", foldersToStrip));
+ final Set<Path> foldersToStripPathSet = foldersToStrip.stream().map(Path::of).collect(Collectors.toSet());
+ return new CsarPackageReducerConfiguration(foldersToStripPathSet, sizeLimit, thresholdEntries);
+ }
+
@Override
public byte[] reduce(final Path csarPackagePath) {
if (hasSignedPackageStructure(csarPackagePath)) {
zf.entries().asIterator().forEachRemaining(zipProcessingFunction.getProcessZipConsumer(csarPackagePath, zf, zos));
} catch (final IOException ex1) {
rollback(reducedCsarPath);
- LOGGER.error("Could not read ZIP stream '{}'", csarPackagePath.toString(), ex1);
+ LOGGER.error("Could not read ZIP stream '{}'", csarPackagePath, ex1);
final var errorMsg = String.format(UNEXPECTED_PROBLEM_HAPPENED_WHILE_READING_THE_CSAR, csarPackagePath);
throw new CsarSizeReducerException(errorMsg, ex1);
}
.map(ZipEntry::getName).map(Path::of)
.collect(Collectors.toList());
} catch (final IOException e) {
- LOGGER.error("Failed to read ZipFile '{}'", csarPackagePath.toString(), e);
+ LOGGER.error("Failed to read ZipFile '{}'", csarPackagePath, e);
final var errorMsg = String.format(UNEXPECTED_PROBLEM_HAPPENED_WHILE_READING_THE_CSAR, csarPackagePath);
throw new CsarSizeReducerException(errorMsg, e);
}
import static org.openecomp.sdc.be.csar.storage.StorageFactory.StorageType.NONE;
import static org.openecomp.sdc.be.csar.storage.StorageFactory.StorageType.findByName;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
import lombok.NoArgsConstructor;
import org.openecomp.sdc.common.CommonConfigurationManager;
import org.openecomp.sdc.logging.api.Logger;
public Optional<PackageSizeReducer> createPackageSizeReducer() {
switch (getConfiguredArtifactStorageType()) {
case MINIO: // MinIoStorage enabled
- return Optional.of(new MinIoStorageCsarSizeReducer(readPackageReducerConfiguration()));
+ return Optional.of(new MinIoStorageCsarSizeReducer());
default:// all configured, nothing enabled
return Optional.empty();
}
return findByName(storageType);
}
- private CsarPackageReducerConfiguration readPackageReducerConfiguration() {
- final var commonConfigurationManager = CommonConfigurationManager.getInstance();
- final List<String> foldersToStrip = commonConfigurationManager.getConfigValue(EXTERNAL_CSAR_STORE, "foldersToStrip", new ArrayList<>());
- final int sizeLimit = commonConfigurationManager.getConfigValue(EXTERNAL_CSAR_STORE, "sizeLimit", 1000000);
- final int thresholdEntries = commonConfigurationManager.getConfigValue(EXTERNAL_CSAR_STORE, "thresholdEntries", 10000);
- LOGGER.info("Folders to strip: '{}'", String.join(", ", foldersToStrip));
- final Set<Path> foldersToStripPathSet = foldersToStrip.stream().map(Path::of).collect(Collectors.toSet());
- return new CsarPackageReducerConfiguration(foldersToStripPathSet, sizeLimit, thresholdEntries);
- }
-
public enum StorageType {
NONE,
MINIO;
import static org.openecomp.sdc.common.errors.Messages.ERROR_HAS_OCCURRED_WHILE_REDUCING_THE_ARTIFACT_SIZE;
import static org.openecomp.sdc.common.errors.Messages.NO_FILE_WAS_UPLOADED_OR_FILE_NOT_EXIST;
import static org.openecomp.sdc.common.errors.Messages.PACKAGE_PROCESS_ERROR;
+import static org.openecomp.sdc.common.errors.Messages.PACKAGE_REDUCER_NOT_CONFIGURED;
import static org.openecomp.sdc.common.errors.Messages.UNEXPECTED_PROBLEM_HAPPENED_WHILE_GETTING;
import static org.openecomp.sdcrests.vsp.rest.exception.OrchestrationTemplateCandidateUploadManagerExceptionSupplier.vspUploadAlreadyInProgress;
private final OrchestrationTemplateCandidateManager candidateManager;
private final VendorSoftwareProductManager vendorSoftwareProductManager;
private final ActivityLogManager activityLogManager;
- private final ArtifactStorageManager artifactStorageManager;
- private final StorageFactory storageFactory;
- private final PackageSizeReducer packageSizeReducer;
private final OrchestrationTemplateCandidateUploadManager orchestrationTemplateCandidateUploadManager;
+ private final StorageFactory storageFactory;
@Autowired
public OrchestrationTemplateCandidateImpl(final OrchestrationTemplateCandidateUploadManager orchestrationTemplateCandidateUploadManager) {
this.candidateManager = OrchestrationTemplateCandidateManagerFactory.getInstance().createInterface();
this.vendorSoftwareProductManager = VspManagerFactory.getInstance().createInterface();
this.activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
- LOGGER.info("Instantiating artifactStorageManager");
this.storageFactory = new StorageFactory();
- this.artifactStorageManager = storageFactory.createArtifactStorageManager();
- LOGGER.info("Instantiating packageSizeReducer");
- this.packageSizeReducer = storageFactory.createPackageSizeReducer().orElse(null);
this.orchestrationTemplateCandidateUploadManager = orchestrationTemplateCandidateUploadManager;
}
public OrchestrationTemplateCandidateImpl(final OrchestrationTemplateCandidateManager candidateManager,
final VendorSoftwareProductManager vendorSoftwareProductManager,
final ActivityLogManager activityLogManager,
- final ArtifactStorageManager artifactStorageManager,
- final PackageSizeReducer packageSizeReducer,
- final OrchestrationTemplateCandidateUploadManager orchestrationTemplateCandidateUploadManager) {
+ final OrchestrationTemplateCandidateUploadManager orchestrationTemplateCandidateUploadManager,
+ final StorageFactory storageFactory) {
this.candidateManager = candidateManager;
this.vendorSoftwareProductManager = vendorSoftwareProductManager;
this.activityLogManager = activityLogManager;
- this.artifactStorageManager = artifactStorageManager;
- this.storageFactory = new StorageFactory();
- this.packageSizeReducer = packageSizeReducer;
+ this.storageFactory = storageFactory;
this.orchestrationTemplateCandidateUploadManager = orchestrationTemplateCandidateUploadManager;
}
ArtifactInfo artifactInfo = null;
final ArtifactStorageManager artifactStorageManager = storageFactory.createArtifactStorageManager();
if (artifactStorageManager.isEnabled()) {
- artifactInfo = handleArtifactStorage(vspId, versionId, filename, dataHandler);
+ artifactInfo = handleArtifactStorage(vspId, versionId, filename, dataHandler, artifactStorageManager);
fileToUploadBytes = artifactInfo.getBytes();
} else {
fileToUploadBytes = fileToUpload.getObject(byte[].class);
}
private ArtifactInfo handleArtifactStorage(final String vspId, final String versionId, final String filename,
- final DataHandler artifactDataHandler) {
+ final DataHandler artifactDataHandler,
+ final ArtifactStorageManager artifactStorageManager) {
+ final PackageSizeReducer packageSizeReducer = storageFactory.createPackageSizeReducer().orElse(null);
+ if (packageSizeReducer == null) {
+ throw new ArtifactStorageException(PACKAGE_REDUCER_NOT_CONFIGURED.getErrorMessage());
+ }
+
final Path tempArtifactPath;
try {
final ArtifactStorageConfig storageConfiguration = artifactStorageManager.getStorageConfiguration();
LOGGER.error("Package Size Reducer not configured", e);
throw new ArtifactStorageException(ERROR_HAS_OCCURRED_WHILE_PERSISTING_THE_ARTIFACT.formatMessage(filename));
}
+
try {
- LOGGER.debug("STARTED -> reducing '{}'", tempArtifactPath.toString());
+ LOGGER.debug("STARTED -> reducing '{}'", tempArtifactPath);
artifactInfo.setBytes(packageSizeReducer.reduce(tempArtifactPath));
- LOGGER.debug("FINISHED -> reducing '{}'", tempArtifactPath.toString());
+ LOGGER.debug("FINISHED -> reducing '{}'", tempArtifactPath);
+ } catch (final Exception e) {
+ LOGGER.debug("ERROR -> reducing '{}'", tempArtifactPath, e);
+ throw new ArtifactStorageException(ERROR_HAS_OCCURRED_WHILE_REDUCING_THE_ARTIFACT_SIZE.formatMessage(filename), e);
+ }
+
+ try {
Files.delete(tempArtifactPath);
} catch (final Exception e) {
- LOGGER.error("Package Size Reducer not configured", e);
- throw new ArtifactStorageException(ERROR_HAS_OCCURRED_WHILE_REDUCING_THE_ARTIFACT_SIZE.formatMessage(filename));
+ LOGGER.warn("Could not delete temporary package at '{}'", tempArtifactPath, e);
}
+
return artifactInfo;
}
private final ActivityLogManager activityLogManager;
private final NotificationPropagationManager notifier;
private final UniqueValueUtil uniqueValueUtil;
- private final ArtifactStorageManager artifactStorageManager;
+ private final StorageFactory storageFactory;
private final CatalogVspClient catalogVspClient;
-
public VendorSoftwareProductsImpl() {
this.itemManager = AsdcItemManagerFactory.getInstance().createInterface();
this.permissionsManager = PermissionsManagerFactory.getInstance().createInterface();
this.activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
this.notifier = NotificationPropagationManagerFactory.getInstance().createInterface();
this.uniqueValueUtil = new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
- this.artifactStorageManager = new StorageFactory().createArtifactStorageManager();
+ this.storageFactory = new StorageFactory();
this.catalogVspClient = new CatalogVspClientImpl();
}
ActivityLogManager activityLogManager,
NotificationPropagationManager notifier,
UniqueValueUtil uniqueValueUtil,
- ArtifactStorageManager artifactStorageManager,
+ final StorageFactory storageFactory,
CatalogVspClient catalogVspClient) {
this.itemManager = itemManager;
this.permissionsManager = permissionsManager;
this.activityLogManager = activityLogManager;
this.notifier = notifier;
this.uniqueValueUtil = uniqueValueUtil;
- this.artifactStorageManager = artifactStorageManager;
+ this.storageFactory = storageFactory;
this.catalogVspClient = catalogVspClient;
}
}
Integer certifiedVersionsCounter = vsp.getVersionStatusCounters().get(VersionStatus.Certified);
+ final ArtifactStorageManager artifactStorageManager = storageFactory.createArtifactStorageManager();
if (Objects.isNull(certifiedVersionsCounter) || certifiedVersionsCounter == 0) {
- if (artifactStorageManager.isEnabled() && !deleteVspFromStorage(vspId)) {
+ if (artifactStorageManager.isEnabled() && !deleteVspFromStorage(vspId, artifactStorageManager)) {
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity(new Exception(Messages.DELETE_VSP_FROM_STORAGE_ERROR.formatMessage(vspId))).build();
}
} else {
final var isVspArchived = getVspList(null, ItemStatus.ARCHIVED.name(), user).stream().anyMatch(item -> item.getId().equals(vspId));
if (isVspArchived) {
- if (artifactStorageManager.isEnabled() && !deleteVspFromStorage(vspId)) {
+ if (artifactStorageManager.isEnabled() && !deleteVspFromStorage(vspId, artifactStorageManager)) {
return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
.entity(new Exception(Messages.DELETE_VSP_FROM_STORAGE_ERROR.formatMessage(vspId))).build();
}
}
}
- private boolean deleteVspFromStorage(final String vspId) {
+ private boolean deleteVspFromStorage(final String vspId, final ArtifactStorageManager artifactStorageManager) {
try {
artifactStorageManager.delete(vspId);
} catch (final Exception e) {
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatchers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
@Mock
private ActivityLogManager activityLogManager;
@Mock
- private ArtifactStorageManager artifactStorageManager;
- @Mock
private PackageSizeReducer packageSizeReducer;
@Mock
private OrchestrationTemplateCandidateUploadManager orchestrationTemplateCandidateUploadManager;
private StorageFactory storageFactory;
@Mock
private Attachment fileToUpload;
+ @Mock
+ private ArtifactStorageManager artifactStorageManager;
@InjectMocks
private OrchestrationTemplateCandidateImpl orchestrationTemplateCandidate;
+ @TempDir
+ Path tempDir;
+
@BeforeEach
- public void setUp() {
- try {
- MockitoAnnotations.openMocks(this);
- UploadFileResponse uploadFileResponse = new UploadFileResponse();
- uploadFileResponse.setOnboardingType(OnboardingTypesEnum.ZIP);
- uploadFileResponse.setNetworkPackageName("test");
- when(candidateManager.upload(any(), any())).thenReturn(uploadFileResponse);
-
- // get using the candidate manager.
- Optional<Pair<String, byte[]>> zipFile = Optional.of(Pair.of("Hello", "World".getBytes()));
-
- when(candidateManager.get(
- ArgumentMatchers.eq(candidateId),
- ArgumentMatchers.any())).thenReturn(zipFile);
-
- when(vendorSoftwareProductManager.get(
- ArgumentMatchers.eq(softwareProductId),
- ArgumentMatchers.any())).thenReturn(zipFile);
-
- OrchestrationTemplateActionResponse processResponse = new OrchestrationTemplateActionResponse();
- processResponse.setStatus(UploadFileStatus.Success);
- when(candidateManager.process(
- ArgumentMatchers.eq(candidateId),
- ArgumentMatchers.any())).thenReturn(processResponse);
-
- ValidationResponse vr = new ValidationResponse();
- when(candidateManager.updateFilesDataStructure(
- ArgumentMatchers.eq(candidateId),
- ArgumentMatchers.any(),
- ArgumentMatchers.any())).thenReturn(vr);
-
- FilesDataStructure fds = new FilesDataStructure();
- fds.setArtifacts(Arrays.asList("a", "b"));
- fds.setNested(Arrays.asList("foo", "bar"));
- fds.setUnassigned(Arrays.asList("c", "d"));
- fds.setModules(Arrays.asList(new Module(), new Module()));
-
- when(candidateManager.getFilesDataStructure(
- ArgumentMatchers.eq(candidateId),
- ArgumentMatchers.any())).thenReturn(Optional.of(fds));
-
- } catch (Exception e) {
- logger.error(e.getMessage(), e);
- }
+ public void setUp() throws IOException {
+ MockitoAnnotations.openMocks(this);
+ UploadFileResponse uploadFileResponse = new UploadFileResponse();
+ uploadFileResponse.setOnboardingType(OnboardingTypesEnum.ZIP);
+ uploadFileResponse.setNetworkPackageName("test");
+ when(candidateManager.upload(any(), any())).thenReturn(uploadFileResponse);
+
+ // get using the candidate manager.
+ Optional<Pair<String, byte[]>> zipFile = Optional.of(Pair.of("Hello", "World".getBytes()));
+
+ when(candidateManager.get(
+ ArgumentMatchers.eq(candidateId),
+ ArgumentMatchers.any())).thenReturn(zipFile);
+
+ when(vendorSoftwareProductManager.get(
+ ArgumentMatchers.eq(softwareProductId),
+ ArgumentMatchers.any())).thenReturn(zipFile);
+
+ OrchestrationTemplateActionResponse processResponse = new OrchestrationTemplateActionResponse();
+ processResponse.setStatus(UploadFileStatus.Success);
+ when(candidateManager.process(
+ ArgumentMatchers.eq(candidateId),
+ ArgumentMatchers.any())).thenReturn(processResponse);
+
+ ValidationResponse vr = new ValidationResponse();
+ when(candidateManager.updateFilesDataStructure(
+ ArgumentMatchers.eq(candidateId),
+ ArgumentMatchers.any(),
+ ArgumentMatchers.any())).thenReturn(vr);
+
+ FilesDataStructure fds = new FilesDataStructure();
+ fds.setArtifacts(Arrays.asList("a", "b"));
+ fds.setNested(Arrays.asList("foo", "bar"));
+ fds.setUnassigned(Arrays.asList("c", "d"));
+ fds.setModules(Arrays.asList(new Module(), new Module()));
+
+ when(candidateManager.getFilesDataStructure(
+ ArgumentMatchers.eq(candidateId),
+ ArgumentMatchers.any())).thenReturn(Optional.of(fds));
+ when(storageFactory.createArtifactStorageManager()).thenReturn(artifactStorageManager);
+ when(storageFactory.createPackageSizeReducer()).thenReturn(Optional.of(packageSizeReducer));
}
@Test
assertTrue(((UploadFileResponseDto) response.getEntity()).getErrors().isEmpty());
}
+ @Test
+ void uploadArtifactStorageTest() throws IOException {
+ //given
+ final String vspId = "vspId";
+ final String versionId = "versionId";
+ when(orchestrationTemplateCandidateUploadManager.findLatestStatus(vspId, versionId, user)).thenReturn(Optional.empty());
+ final UUID lockId = UUID.randomUUID();
+ when(orchestrationTemplateCandidateUploadManager.putUploadInProgress(vspId, versionId, user))
+ .thenReturn(createVspUploadStatus(lockId, VspUploadStatus.UPLOADING));
+ when(orchestrationTemplateCandidateUploadManager.putUploadInValidation(vspId, versionId, user))
+ .thenReturn(createVspUploadStatus(lockId, VspUploadStatus.VALIDATING));
+ when(orchestrationTemplateCandidateUploadManager.putUploadInProcessing(vspId, versionId, user))
+ .thenReturn(createVspUploadStatus(lockId, VspUploadStatus.PROCESSING));
+ when(artifactStorageManager.isEnabled()).thenReturn(true);
+ final MinIoStorageArtifactStorageConfig minIoConfig =
+ new MinIoStorageArtifactStorageConfig(true,
+ new EndPoint("", 9000, true),
+ new Credentials("", ""), tempDir.toString(), 1000
+ );
+
+ when(artifactStorageManager.getStorageConfiguration()).thenReturn(minIoConfig);
+ final MinIoArtifactInfo artifactInfo = new MinIoArtifactInfo(vspId, versionId);
+ final Attachment attachmentMock = mockAttachment("filename.csar", this.getClass().getResource("/files/sample-not-signed.csar"));
+ final byte[] attachmentBytes = attachmentMock.getObject(byte[].class);
+ artifactInfo.setBytes(attachmentBytes);
+ final ArgumentCaptor<Path> reduceTempDirectoryArg = ArgumentCaptor.forClass(Path.class);
+ when(packageSizeReducer.reduce(reduceTempDirectoryArg.capture())).thenReturn(attachmentBytes);
+ when(artifactStorageManager.upload(eq(vspId), eq(versionId), any(InputStream.class))).thenReturn(artifactInfo);
+ //when
+ Response response = orchestrationTemplateCandidate.upload(vspId, versionId, attachmentMock, user);
+ //then
+ assertEquals(Status.OK.getStatusCode(), response.getStatus());
+ assertTrue(((UploadFileResponseDto) response.getEntity()).getErrors().isEmpty());
+ final Path actualReduceTempFolder = reduceTempDirectoryArg.getValue();
+ final Path expectedReduceTempFolder = tempDir.resolve(Path.of(vspId, versionId));
+ assertTrue(actualReduceTempFolder.startsWith(expectedReduceTempFolder),
+ String.format("Reduce temporary directory should be '%s'", expectedReduceTempFolder));
+ }
+
@NotNull
private VspUploadStatusDto createVspUploadStatus(final UUID lockId, final VspUploadStatus uploadStatus) {
final VspUploadStatusDto vspUploadStatusProcessing = new VspUploadStatusDto();
@Test
void uploadNotSignedArtifactStorageManagerIsEnabledTest() throws IOException {
- when(storageFactory.createArtifactStorageManager()).thenReturn(artifactStorageManager);
when(artifactStorageManager.isEnabled()).thenReturn(true);
when(artifactStorageManager.getStorageConfiguration()).thenReturn(new MinIoStorageArtifactStorageConfig
(true, new EndPoint("host", 9000, false), new Credentials("accessKey", "secretKey"), "tempPath", 10_000_000));
import org.openecomp.sdc.activitylog.ActivityLogManager;
import org.openecomp.sdc.be.csar.storage.ArtifactStorageManager;
import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.be.csar.storage.StorageFactory;
import org.openecomp.sdc.itempermissions.PermissionsManager;
import org.openecomp.sdc.notification.services.NotificationPropagationManager;
import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
private ArtifactStorageManager artifactStorageManager;
@Mock
private CatalogVspClient catalogVspClient;
+ @Mock
+ private StorageFactory storageFactory;
@InjectMocks
private VendorSoftwareProductsImpl vendorSoftwareProducts;
item.setType("vsp");
item.setId(vspId);
when(itemManager.get(vspId)).thenReturn(item);
+ when(storageFactory.createArtifactStorageManager()).thenReturn(artifactStorageManager);
}
@Test
EXTERNAL_CSAR_STORE_CONFIGURATION_FAILURE_MISSING("externalCsarStore configuration failure, missing '%s'"),
ERROR_HAS_OCCURRED_WHILE_PERSISTING_THE_ARTIFACT("An error has occurred while persisting the artifact: %s"),
ERROR_HAS_OCCURRED_WHILE_REDUCING_THE_ARTIFACT_SIZE("An error has occurred while reducing the artifact's size: %s"),
- UNEXPECTED_PROBLEM_HAPPENED_WHILE_GETTING("An unexpected problem happened while getting '%s'");
+ UNEXPECTED_PROBLEM_HAPPENED_WHILE_GETTING("An unexpected problem happened while getting '%s'"),
+ PACKAGE_REDUCER_NOT_CONFIGURED("Could not process the package. Package reducer is not configured");
// @formatter:on
private final String errorMessage;
private static final Logger LOGGER = LoggerFactory.getLogger(OrchestrationTemplateCandidateDaoZusammenImpl.class);
private static final String EMPTY_DATA = "{}";
private final ZusammenAdaptor zusammenAdaptor;
- private final ArtifactStorageManager artifactStorageManager;
+ private final StorageFactory storageFactory;
public OrchestrationTemplateCandidateDaoZusammenImpl(final ZusammenAdaptor zusammenAdaptor) {
this.zusammenAdaptor = zusammenAdaptor;
LOGGER.info("Instantiating artifactStorageManager");
- this.artifactStorageManager = new StorageFactory().createArtifactStorageManager();
+ this.storageFactory = new StorageFactory();
}
@Override
final String originalFileSuffix = candidateData.getOriginalFileSuffix();
originalPackageElement.getInfo().addProperty(InfoPropertyName.ORIGINAL_FILE_NAME.getVal(), originalFileName);
originalPackageElement.getInfo().addProperty(InfoPropertyName.ORIGINAL_FILE_SUFFIX.getVal(), originalFileSuffix);
+ final ArtifactStorageManager artifactStorageManager = storageFactory.createArtifactStorageManager();
originalPackageElement.getInfo().addProperty("storeCsarsExternally", artifactStorageManager.isEnabled());
if (artifactStorageManager.isEnabled()) {
final ArtifactInfo candidateArtifactInfo = candidateData.getArtifactInfo();
Code Review / sdc.git / commitdiff