@GET
@Path("/")
@Produces(MediaType.APPLICATION_OCTET_STREAM)
- @ApiOperation(value = "Get uploaded candidate HEAT file",
- notes = "Downloads in process candidate HEAT file",
+ @ApiOperation(value = "Get uploaded Network Package file",
+ notes = "Downloads in uploaded Network Package file",
response = File.class)
Response get(
@PathParam("vspId") String vspId,
import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
import org.openecomp.sdc.activitylog.dao.type.ActivityType;
import org.openecomp.sdc.common.errors.Messages;
+import org.openecomp.sdc.datatypes.error.ErrorLevel;
+import org.openecomp.sdc.datatypes.error.ErrorMessage;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManagerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
import static org.openecomp.core.utilities.file.FileUtils.getFileExtension;
import static org.openecomp.core.utilities.file.FileUtils.getNetworkPackageName;
+import static org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder.getErrorWithParameters;
@Named
@Service("orchestrationTemplateCandidate")
@Scope(value = "prototype")
public class OrchestrationTemplateCandidateImpl implements OrchestrationTemplateCandidate {
-
+ private static final Logger LOGGER =
+ LoggerFactory.getLogger(OrchestrationTemplateCandidateImpl.class);
private OrchestrationTemplateCandidateManager candidateManager =
OrchestrationTemplateCandidateManagerFactory.getInstance().createInterface();
private VendorSoftwareProductManager vendorSoftwareProductManager = VspManagerFactory
@Override
public Response get(String vspId, String versionId, String user) throws IOException {
Optional<Pair<String, byte[]>> zipFile = candidateManager.get(vspId, new Version(versionId));
-
- if (!zipFile.isPresent()) {
- return Response.status(Response.Status.NOT_FOUND).build();
+ String fileName = null;
+ if (zipFile.isPresent()) {
+ fileName = "Candidate." + zipFile.get().getLeft();
+ } else {
+ zipFile = vendorSoftwareProductManager.get(vspId, new Version((versionId)));
+
+ if (!zipFile.isPresent()) {
+ ErrorMessage errorMessage = new ErrorMessage(ErrorLevel.ERROR,
+ getErrorWithParameters(
+ Messages.NO_FILE_WAS_UPLOADED_OR_FILE_NOT_EXIST.getErrorMessage(),
+ ""));
+ LOGGER.error(errorMessage.getMessage());
+ return Response.status(Response.Status.NOT_FOUND).build();
+ }
+ fileName = "Processed." + zipFile.get().getLeft();
}
Response.ResponseBuilder response = Response.ok(zipFile.get().getRight());
- String filename = "Candidate." + zipFile.get().getLeft();
- response.header("Content-Disposition", "attachment; filename=" + filename);
+ response.header("Content-Disposition", "attachment; filename=" + fileName);
return response.build();
}
package org.openecomp.sdc.vendorsoftwareproduct;
+import org.apache.commons.lang3.tuple.Pair;
import org.openecomp.sdc.datatypes.error.ErrorMessage;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
File getInformationArtifact(String vspId, Version version);
+ public Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException;
Collection<ComputeEntity> getComputeByVsp(String vspId, Version version);
}
import org.openecomp.core.utilities.json.JsonUtil;
import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.common.errors.Messages;
import org.openecomp.sdc.common.utils.CommonUtil;
import org.openecomp.sdc.common.utils.SdcCommon;
-import org.openecomp.sdc.datatypes.error.ErrorLevel;
import org.openecomp.sdc.datatypes.error.ErrorMessage;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
import java.util.Map;
import java.util.Optional;
-import static org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder.getErrorWithParameters;
-
public class OrchestrationTemplateCandidateManagerImpl
implements OrchestrationTemplateCandidateManager {
private static final Logger LOGGER =
fetchCandidateDataEntity(vspId, version);
if (!candidateDataEntity.isPresent()) {
- ErrorMessage errorMessage = new ErrorMessage(ErrorLevel.ERROR,
- getErrorWithParameters(Messages.NO_FILE_WAS_UPLOADED_OR_FILE_NOT_EXIST.getErrorMessage(),
- ""));
- LOGGER.error(errorMessage.getMessage());
return Optional.empty();
}
OnboardingTypesEnum type =
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
import org.openecomp.core.dao.UniqueValueDao;
import org.openecomp.core.enrichment.api.EnrichmentManager;
import org.openecomp.core.enrichment.factory.EnrichmentManagerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.errors.TranslationFileCreationErrorBuilder;
import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder;
import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactGenerator;
+import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireValidationResult;
private final ImageDao imageDao;
private final ManualVspToscaManager manualVspToscaManager;
private final UniqueValueUtil uniqueValueUtil;
+ private final CandidateService candidateService;
public VendorSoftwareProductManagerImpl(
VspMergeDao vspMergeDao,
ComputeDao computeDao,
ImageDao imageDao,
ManualVspToscaManager manualVspToscaManager,
- UniqueValueDao uniqueValueDao) {
+ UniqueValueDao uniqueValueDao,
+ CandidateService candidateService) {
this.vspMergeDao = vspMergeDao;
this.orchestrationTemplateDao = orchestrationTemplateDataDao;
this.orchestrationTemplateCandidateManager = orchestrationTemplateCandidateManager;
this.imageDao = imageDao;
this.manualVspToscaManager = manualVspToscaManager;
this.uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
+ this.candidateService = candidateService;
registerToVersioning();
}
.generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
}
+ @Override
+ public Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException {
+
+ OrchestrationTemplateEntity orchestrationTemplateEntity =
+ orchestrationTemplateDao.get(vspId, version);
+
+ if (isOrchestrationTemplateMissing(orchestrationTemplateEntity)) {
+ return Optional.empty();
+ }
+
+ if (CommonUtil.isFileOriginFromZip(orchestrationTemplateEntity.getFileSuffix())) {
+ return Optional.of(new ImmutablePair<>(OnboardingTypesEnum.ZIP.toString(), candidateService
+ .getZipData(orchestrationTemplateEntity.getContentData())));
+ }
+ return Optional.of(new ImmutablePair<>(orchestrationTemplateEntity.getFileSuffix(),
+ orchestrationTemplateEntity.getContentData().array()));
+ }
+
void updateUniqueName(String oldVspName, String newVspName) {
uniqueValueUtil.updateUniqueValue(
VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME,
import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
import org.openecomp.sdc.vendorsoftwareproduct.dao.*;
+import org.openecomp.sdc.vendorsoftwareproduct.factory.CandidateServiceFactory;
import org.openecomp.sdc.vendorsoftwareproduct.factory.InformationArtifactGeneratorFactory;
public class VspManagerFactoryImpl extends VspManagerFactory {
ComputeDaoFactory.getInstance().createInterface(),
ImageDaoFactory.getInstance().createInterface(),
new ManualVspToscaManagerImpl(),
- UniqueValueDaoFactory.getInstance().createInterface());
+ UniqueValueDaoFactory.getInstance().createInterface(), CandidateServiceFactory
+ .getInstance().createInterface());
@Override
public VendorSoftwareProductManager createInterface() {
OrchestrationTemplateCandidateData getOrchestrationTemplateCandidateInfo(String vspId,
Version version);
+ byte[] getZipData(ByteBuffer contentData) throws IOException;
+
void deleteOrchestrationTemplateCandidate(String vspId, Version version);
Optional<ByteArrayInputStream> fetchZipFileByteArrayInputStream(String vspId,
zusammenAdaptor.getElementByName(context, elementContext, null,
ElementType.OrchestrationTemplateCandidate.name());
if (candidateElement.isPresent()) {
- if (VspZusammenUtil.hasEmptyData(candidateElement.get().getData())) {
+ if (VspZusammenUtil.isEmpty(candidateElement.get().getData())) {
return null;
}
OrchestrationTemplateCandidateData candidateData = new OrchestrationTemplateCandidateData();
import java.io.ByteArrayInputStream;
import java.nio.ByteBuffer;
+import java.util.Collection;
import java.util.Optional;
import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement;
public class OrchestrationTemplateDaoZusammenImpl implements OrchestrationTemplateDao {
- private static final Logger LOGGER = LoggerFactory.getLogger
- (OrchestrationTemplateDaoZusammenImpl.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(
+ OrchestrationTemplateDaoZusammenImpl.class);
private ZusammenAdaptor zusammenAdaptor;
public OrchestrationTemplateDaoZusammenImpl(ZusammenAdaptor zusammenAdaptor) {
Optional<Element> orchestrationTemplateElement = zusammenAdaptor
.getElementByName(context, elementContext, vspModel.get().getId(),
ElementType.OrchestrationTemplate.name());
- if (!orchestrationTemplateElement.isPresent()) {
+ if (orchestrationTemplateElement.isPresent() &&
+ VspZusammenUtil.hasEmptyData(orchestrationTemplateElement.get().getData())) {
return orchestrationTemplate;
}
- if (!VspZusammenUtil.hasEmptyData(orchestrationTemplateElement.get().getData())) {
- orchestrationTemplate.setContentData(
+ orchestrationTemplate.setContentData(
ByteBuffer.wrap(FileUtils.toByteArray(orchestrationTemplateElement.get().getData())));
+
+ Collection<Element> subElements = orchestrationTemplateElement.get().getSubElements();
+ if (subElements.isEmpty()) {
+ return orchestrationTemplate;
}
- Optional<Element> validationDataElement =
- zusammenAdaptor.getElementByName(context, elementContext,
- orchestrationTemplateElement.get().getElementId(),
- ElementType.OrchestrationTemplateValidationData.name());
- if (validationDataElement.isPresent()) {
- orchestrationTemplate.setFileSuffix(validationDataElement.get().getInfo()
- .getProperty(InfoPropertyName.FILE_SUFFIX.getVal()));
- orchestrationTemplate.setFileName(validationDataElement.get().getInfo()
- .getProperty(InfoPropertyName.FILE_NAME.getVal()));
- if (!VspZusammenUtil.hasEmptyData(validationDataElement.get().getData())) {
- orchestrationTemplate.setValidationData(
- new String(FileUtils.toByteArray(validationDataElement.get().getData())));
+ for (Element element : subElements) {
+ Optional<Element> subElement = zusammenAdaptor.getElement(context,
+ elementContext, element.getElementId().toString());
+
+ if (subElement.get().getInfo().getName().equals(ElementType
+ .OrchestrationTemplateValidationData.name())) {
+ orchestrationTemplate.setFileSuffix(subElement.get().getInfo()
+ .getProperty(InfoPropertyName.FILE_SUFFIX.getVal()));
+ orchestrationTemplate.setFileName(subElement.get().getInfo()
+ .getProperty(InfoPropertyName.FILE_NAME.getVal()));
+ if (!VspZusammenUtil.hasEmptyData(subElement.get().getData())) {
+ orchestrationTemplate.setValidationData(
+ new String(FileUtils.toByteArray(subElement.get().getData())));
+ }
+ } else if (subElement.get().getInfo().getName().equals(ElementType
+ .OrchestrationTemplateStructure.name())) {
+ orchestrationTemplate.setFilesDataStructure(new String(FileUtils.toByteArray(subElement
+ .get().getData())));
+
}
}
return orchestrationTemplate;
return head;
}
+ static boolean isEmpty(InputStream elementData) {
+ byte[] byteElementData;
+ if (Objects.isNull(elementData)) {
+ return true;
+ }
+ try {
+ byteElementData = IOUtils.toByteArray(elementData);
+ } catch (IOException e) {
+ return false;
+ }
+ return ArrayUtils.isEmpty(byteElementData);
+ }
+
static boolean hasEmptyData(InputStream elementData) {
String EMPTY_DATA = "{}";
byte[] byteElementData;
return baos.toByteArray();
}
+ @Override
+ public byte[] getZipData(ByteBuffer contentData)
+ throws IOException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+ try (final ZipOutputStream zos = new ZipOutputStream(baos);
+ ZipInputStream zipStream = new ZipInputStream(
+ new ByteArrayInputStream(contentData.array()))) {
+ ZipEntry zipEntry;
+ while ((zipEntry = zipStream.getNextEntry()) != null) {
+ ZipEntry locZipEntry = new ZipEntry(zipEntry.getName());
+ zos.putNextEntry(locZipEntry);
+ byte[] buf = new byte[1024];
+ int len;
+ while ((len = zipStream.read(buf)) > 0) {
+ zos.write(buf, 0, (len < buf.length) ? len : buf.length);
+ }
+ zos.closeEntry();
+ }
+ }
+ return baos.toByteArray();
+ }
+
@Override
public Optional<List<ErrorMessage>> validateFileDataStructure(
FilesDataStructure filesDataStructure) {
Code Review / sdc.git / commitdiff