2 * Copyright © 2016-2018 European Support Limited
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.openecomp.sdc.vendorsoftwareproduct.impl;
18 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.candidateDataNotProcessedOrAbortedErrorBuilder;
19 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.invalidProcessedCandidate;
20 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.vspMissingDeploymentFlavorErrorBuilder;
22 import java.io.BufferedOutputStream;
23 import java.io.ByteArrayInputStream;
24 import java.io.ByteArrayOutputStream;
26 import java.io.FileInputStream;
27 import java.io.FileOutputStream;
28 import java.io.IOException;
29 import java.io.InputStream;
30 import java.io.OutputStream;
31 import java.nio.ByteBuffer;
32 import java.nio.file.Path;
33 import java.util.ArrayList;
34 import java.util.Collection;
35 import java.util.Collections;
36 import java.util.HashMap;
37 import java.util.HashSet;
38 import java.util.List;
40 import java.util.Objects;
41 import java.util.Optional;
43 import java.util.zip.ZipInputStream;
44 import java.util.zip.ZipOutputStream;
45 import org.apache.commons.collections4.CollectionUtils;
46 import org.apache.commons.collections4.MapUtils;
47 import org.apache.commons.lang3.tuple.ImmutablePair;
48 import org.apache.commons.lang3.tuple.Pair;
49 import org.openecomp.core.dao.UniqueValueDao;
50 import org.openecomp.core.enrichment.api.EnrichmentManager;
51 import org.openecomp.core.enrichment.factory.EnrichmentManagerFactory;
52 import org.openecomp.core.model.dao.EnrichedServiceModelDao;
53 import org.openecomp.core.model.dao.ServiceModelDao;
54 import org.openecomp.core.util.UniqueValueUtil;
55 import org.openecomp.core.utilities.file.FileContentHandler;
56 import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
57 import org.openecomp.core.utilities.json.JsonUtil;
58 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
59 import org.openecomp.core.validation.api.ValidationManager;
60 import org.openecomp.core.validation.util.MessageContainerUtil;
61 import org.openecomp.sdc.common.errors.CoreException;
62 import org.openecomp.sdc.common.errors.ErrorCode;
63 import org.openecomp.sdc.common.errors.ValidationErrorBuilder;
64 import org.openecomp.sdc.common.utils.CommonUtil;
65 import org.openecomp.sdc.common.utils.SdcCommon;
66 import org.openecomp.sdc.datatypes.error.ErrorLevel;
67 import org.openecomp.sdc.datatypes.error.ErrorMessage;
68 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
69 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
70 import org.openecomp.sdc.logging.api.Logger;
71 import org.openecomp.sdc.logging.api.LoggerFactory;
72 import org.openecomp.sdc.tosca.csar.Manifest;
73 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
74 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
75 import org.openecomp.sdc.validation.util.ValidationManagerUtil;
76 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
77 import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsService;
78 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
79 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManagerFactory;
80 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
81 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
82 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
83 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
84 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
85 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
86 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
87 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
88 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
89 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
90 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
91 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDao;
92 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
93 import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDao;
94 import org.openecomp.sdc.vendorsoftwareproduct.dao.errors.VendorSoftwareProductNotFoundErrorBuilder;
95 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
96 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
97 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
98 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
99 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
100 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
101 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
102 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
103 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
104 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
105 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspQuestionnaireEntity;
106 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
107 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentErrorBuilder;
108 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
109 import org.openecomp.sdc.vendorsoftwareproduct.errors.FileCreationErrorBuilder;
110 import org.openecomp.sdc.vendorsoftwareproduct.errors.InformationArtifactCreationErrorBuilder;
111 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
112 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageInvalidErrorBuilder;
113 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageNotFoundErrorBuilder;
114 import org.openecomp.sdc.vendorsoftwareproduct.errors.TranslationFileCreationErrorBuilder;
115 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder;
116 import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactGenerator;
117 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
118 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.etsi.ETSIService;
119 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.etsi.ETSIServiceImpl;
120 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
121 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
122 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireValidationResult;
123 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
124 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.FilesDataStructure;
125 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
126 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityId;
127 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
128 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
129 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
130 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
131 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
132 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQuestionnaireSchemaInput;
133 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
134 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
135 import org.openecomp.sdc.vendorsoftwareproduct.utils.ComponentDependencyTracker;
136 import org.openecomp.sdc.versioning.VersioningManager;
137 import org.openecomp.sdc.versioning.VersioningManagerFactory;
138 import org.openecomp.sdc.versioning.VersioningUtil;
139 import org.openecomp.sdc.versioning.dao.types.Version;
141 public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductManager {
143 private static final Logger LOGGER = LoggerFactory.getLogger(VendorSoftwareProductManager.class);
144 private VspMergeDao vspMergeDao;
145 private OrchestrationTemplateDao orchestrationTemplateDao;
146 private OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager;
147 private VendorSoftwareProductInfoDao vspInfoDao;
148 private VendorLicenseFacade vendorLicenseFacade;
149 private ServiceModelDao<ToscaServiceModel> serviceModelDao;
150 private EnrichedServiceModelDao<ToscaServiceModel> enrichedServiceModelDao;
151 private VendorLicenseArtifactsService licenseArtifactsService;
152 private InformationArtifactGenerator informationArtifactGenerator;
153 private PackageInfoDao packageInfoDao;
154 private DeploymentFlavorDao deploymentFlavorDao;
155 private ComponentDao componentDao;
156 private ComponentDependencyModelDao componentDependencyModelDao;
157 private NicDao nicDao;
158 private ComputeDao computeDao;
159 private ImageDao imageDao;
160 private ManualVspToscaManager manualVspToscaManager;
161 private UniqueValueUtil uniqueValueUtil;
162 private CandidateService candidateService;
164 private static ErrorCode createMissingMandatoryFieldError(String fieldName) {
165 return new ValidationErrorBuilder("must be supplied", fieldName).build();
169 public ValidationResponse validate(VspDetails vspDetails) throws IOException {
170 List<ErrorCode> vspErrors = new ArrayList<>(validateVspFields(vspDetails));
171 ValidationResponse validationResponse = new ValidationResponse();
172 if (Objects.nonNull(vspDetails.getOnboardingMethod()) && OnboardingMethod.Manual.name().equals(vspDetails.getOnboardingMethod())) {
173 validateManualOnboardingMethod(vspDetails, validationResponse, vspErrors);
175 validateOrchestrationTemplateCandidate(validationResponse, vspErrors, vspDetails.getId(), vspDetails.getVersion());
176 if (!validationResponse.isValid()) {
177 return validationResponse;
179 validateLicense(vspDetails, vspErrors);
180 OrchestrationTemplateEntity orchestrationTemplate = orchestrationTemplateDao.get(vspDetails.getId(), vspDetails.getVersion());
181 ToscaServiceModel serviceModel = serviceModelDao.getServiceModel(vspDetails.getId(), vspDetails.getVersion());
182 if (isOrchestrationTemplateMissing(orchestrationTemplate) || isServiceModelMissing(serviceModel)) {
183 vspErrors.add(VendorSoftwareProductInvalidErrorBuilder
184 .vendorSoftwareProductMissingServiceModelErrorBuilder(vspDetails.getId(), vspDetails.getVersion()));
186 validationResponse.setUploadDataErrors(validateOrchestrationTemplate(orchestrationTemplate));
188 QuestionnaireValidationResult questionnaireValidationResult = validateQuestionnaire(vspDetails.getId(), vspDetails.getVersion(),
189 vspDetails.getOnboardingMethod());
190 if (Objects.nonNull(questionnaireValidationResult)) {
191 if (validationResponse.getQuestionnaireValidationResult() == null
192 || validationResponse.getQuestionnaireValidationResult().getValidationData() == null) {
193 validationResponse.setQuestionnaireValidationResult(questionnaireValidationResult);
195 validationResponse.getQuestionnaireValidationResult().getValidationData().addAll(questionnaireValidationResult.getValidationData());
198 Collection<ComponentDependencyModelEntity> componentDependencies = componentDependencyModelDao
199 .list(new ComponentDependencyModelEntity(vspDetails.getId(), vspDetails.getVersion(), null));
200 if (validateComponentDependencies(componentDependencies)) {
201 vspErrors.add(ComponentDependencyModelErrorBuilder.getCyclicDependencyComponentErrorBuilder());
203 validationResponse.setVspErrors(vspErrors);
204 validationResponse.setLicensingDataErrors(validateLicensingData(vspDetails));
205 return validationResponse;
208 private void validateLicense(VspDetails vspDetails, List<ErrorCode> vspErrors) {
209 if (vspDetails.getVlmVersion() != null || vspDetails.getLicenseAgreement() != null || vspDetails.getFeatureGroups() != null) {
210 vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
214 private void validateOrchestrationTemplateCandidate(ValidationResponse validationResponse, List<ErrorCode> vspErrors, String vspId,
216 orchestrationTemplateCandidateManager.getInfo(vspId, version).ifPresent(candidateInfo -> {
217 String fileName = candidateInfo.getFileName();
218 vspErrors.add(candidateInfo.getValidationData().isEmpty() ? candidateDataNotProcessedOrAbortedErrorBuilder(fileName)
219 : invalidProcessedCandidate(fileName));
220 validationResponse.setVspErrors(vspErrors);
224 private void validateManualOnboardingMethod(VspDetails vspDetails, ValidationResponse validationResponse, List<ErrorCode> vspErrors) {
225 vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
226 Collection<DeploymentFlavorEntity> deploymentFlavors = deploymentFlavorDao
227 .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails.getVersion(), null));
228 if (CollectionUtils.isEmpty(deploymentFlavors)) {
229 vspErrors.add(vspMissingDeploymentFlavorErrorBuilder());
231 vspErrors.addAll(validateDeploymentFlavors(deploymentFlavors));
232 Set<CompositionEntityValidationData> componentValidationResult = componentValidation(vspDetails.getId(), vspDetails.getVersion());
233 if (!CollectionUtils.isEmpty(componentValidationResult)) {
234 if (validationResponse.getQuestionnaireValidationResult() == null
235 || validationResponse.getQuestionnaireValidationResult().getValidationData() == null) {
236 validationResponse.setQuestionnaireValidationResult(new QuestionnaireValidationResult(componentValidationResult));
238 validationResponse.getQuestionnaireValidationResult().getValidationData().addAll(componentValidationResult);
244 public Map<String, List<ErrorMessage>> compile(String vspId, Version version) {
245 ToscaServiceModel serviceModel = OnboardingMethod.Manual.name().equals(getValidatedVsp(vspId, version).getOnboardingMethod())
246 //Generate Tosca service model for Manual Onboarding flow
247 ? manualVspToscaManager.generateToscaModel(manualVspToscaManager.gatherVspInformation(vspId, version))
248 : serviceModelDao.getServiceModel(vspId, version);
249 return compile(vspId, version, serviceModel);
252 private boolean validateComponentDependencies(Collection<ComponentDependencyModelEntity> componentDependencies) {
253 ComponentDependencyTracker dependencyTracker = new ComponentDependencyTracker();
254 for (ComponentDependencyModelEntity componentDependency : componentDependencies) {
255 dependencyTracker.addDependency(componentDependency.getSourceComponentId(), componentDependency.getTargetComponentId());
257 return dependencyTracker.isCyclicDependencyPresent();
260 private Collection<ErrorCode> validateDeploymentFlavors(Collection<DeploymentFlavorEntity> deploymentFlavors) {
261 Collection<ErrorCode> errorCodeList = new ArrayList<>();
262 if (!CollectionUtils.isEmpty(deploymentFlavors)) {
263 deploymentFlavors.forEach(deploymentFlavor -> {
264 DeploymentFlavorEntity deployment = deploymentFlavorDao.get(deploymentFlavor);
265 DeploymentFlavor deploymentLocalFlavor = deployment.getDeploymentFlavorCompositionData();
266 if (deploymentLocalFlavor != null) {
267 if (deploymentLocalFlavor.getFeatureGroupId() == null) {
268 ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
269 .getFeatureGroupMandatoryErrorBuilder(deploymentLocalFlavor.getModel());
270 errorCodeList.add(deploymentFlavorErrorBuilder);
272 validateComponentComputeAssociations(errorCodeList, deploymentFlavor, deployment, deploymentLocalFlavor);
276 return errorCodeList;
279 private void validateComponentComputeAssociations(Collection<ErrorCode> errorCodeList, DeploymentFlavorEntity deploymentFlavor,
280 DeploymentFlavorEntity deployment, DeploymentFlavor deploymentlocalFlavor) {
281 List<ComponentComputeAssociation> componentComputeAssociations = deploymentlocalFlavor.getComponentComputeAssociations();
282 if (CollectionUtils.isEmpty(componentComputeAssociations)) {
283 validateCompositionEntity(errorCodeList, deploymentFlavor, deployment, deploymentlocalFlavor);
285 componentComputeAssociations.forEach(componentComputeAssociation -> {
286 if (componentComputeAssociation == null || !(componentComputeAssociation.getComponentId() != null
287 && componentComputeAssociation.getComputeFlavorId() != null)) {
288 validateCompositionEntity(errorCodeList, deploymentFlavor, deployment, deploymentlocalFlavor);
294 private void validateCompositionEntity(Collection<ErrorCode> errorCodeList, DeploymentFlavorEntity deploymentFlavor,
295 DeploymentFlavorEntity deployment, DeploymentFlavor deploymentlocalFlavor) {
296 CompositionEntityValidationData compositionEntityValidationData = new CompositionEntityValidationData(CompositionEntityType.deployment,
297 deploymentFlavor.getId());
298 compositionEntityValidationData.setEntityName(deployment.getDeploymentFlavorCompositionData().getModel());
299 ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
300 .getInvalidComponentComputeAssociationErrorBuilder(deploymentlocalFlavor.getModel());
301 errorCodeList.add(deploymentFlavorErrorBuilder);
304 private Set<CompositionEntityValidationData> componentValidation(String vspId, Version version) {
305 Set<CompositionEntityValidationData> validationData = new HashSet<>();
306 Collection<ComponentEntity> components = componentDao.list(new ComponentEntity(vspId, version, null));
307 if (!CollectionUtils.isEmpty(components)) {
308 components.forEach(component -> {
309 validateImage(vspId, version, validationData, component);
310 validateNic(vspId, version, validationData, component);
313 return validationData;
316 private void validateNic(String vspId, Version version, Set<CompositionEntityValidationData> validationData, ComponentEntity component) {
317 Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, component.getId(), null));
318 if (CollectionUtils.isNotEmpty(nics)) {
319 nics.forEach(nicEntity -> {
320 NicEntity nic = nicDao.get(new NicEntity(vspId, version, component.getId(), nicEntity.getId()));
321 NetworkType networkType = nic.getNicCompositionData().getNetworkType();
322 String networkId = nic.getNicCompositionData().getNetworkId();
323 if (networkType.equals(NetworkType.Internal) && networkId == null) {
324 CompositionEntityValidationData compositionEntityValidationData = new CompositionEntityValidationData(CompositionEntityType.nic,
326 compositionEntityValidationData.setEntityName(nic.getNicCompositionData().getName());
327 ErrorCode nicInternalNetworkErrorBuilder = NicInternalNetworkErrorBuilder.getNicNullNetworkIdInternalNetworkIdErrorBuilder();
328 List<String> errors = new ArrayList<>();
329 errors.add(nicInternalNetworkErrorBuilder.message());
330 compositionEntityValidationData.setErrors(errors);
331 validationData.add(compositionEntityValidationData);
337 private void validateImage(String vspId, Version version, Set<CompositionEntityValidationData> validationData, ComponentEntity component) {
338 Collection<ImageEntity> images = imageDao.list(new ImageEntity(vspId, version, component.getId(), null));
339 if (CollectionUtils.isEmpty(images)) {
340 CompositionEntityValidationData compositionEntityValidationData = new CompositionEntityValidationData(component.getType(),
342 compositionEntityValidationData.setEntityName(component.getComponentCompositionData().getDisplayName());
343 ErrorCode vfcMissingImageErrorBuilder = ComponentErrorBuilder.vfcMissingImageErrorBuilder();
344 List<String> errors = new ArrayList<>();
345 errors.add(vfcMissingImageErrorBuilder.message());
346 compositionEntityValidationData.setErrors(errors);
347 validationData.add(compositionEntityValidationData);
351 private List<ErrorCode> validateVspFields(VspDetails vspDetails) {
352 List<ErrorCode> errors = new ArrayList<>();
353 if (vspDetails.getName() == null) {
354 errors.add(createMissingMandatoryFieldError("name"));
356 if (vspDetails.getDescription() == null) {
357 errors.add(createMissingMandatoryFieldError("description"));
359 if (vspDetails.getVendorId() == null) {
360 errors.add(createMissingMandatoryFieldError("vendor Id"));
362 if (vspDetails.getCategory() == null) {
363 errors.add(createMissingMandatoryFieldError("category"));
365 if (vspDetails.getSubCategory() == null) {
366 errors.add(createMissingMandatoryFieldError("sub category"));
371 private List<ErrorCode> validateMandatoryLicenseFields(VspDetails vspDetails) {
372 List<ErrorCode> errors = new ArrayList<>();
373 if (vspDetails.getVlmVersion() == null) {
374 errors.add(createMissingMandatoryFieldError("licensing version"));
376 if (vspDetails.getLicenseAgreement() == null) {
377 errors.add(createMissingMandatoryFieldError("license agreement"));
379 if (CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
380 errors.add(createMissingMandatoryFieldError("feature groups"));
385 private Map<String, List<ErrorMessage>> compile(String vendorSoftwareProductId, Version version, ToscaServiceModel serviceModel) {
386 if (isServiceModelMissing(serviceModel)) {
389 enrichedServiceModelDao.deleteAll(vendorSoftwareProductId, version);
390 if (CollectionUtils.isNotEmpty(serviceModel.getModelList())) {
391 enrichedServiceModelDao.storeServiceModel(vendorSoftwareProductId, version, serviceModel);
392 return Collections.emptyMap();
394 final EnrichmentManager<ToscaServiceModel> enrichmentManager = EnrichmentManagerFactory.getInstance().createInterface();
395 enrichmentManager.init(vendorSoftwareProductId, version);
396 enrichmentManager.setModel(serviceModel);
397 final Map<String, List<ErrorMessage>> enrichErrors = enrichmentManager.enrich();
398 enrichedServiceModelDao.storeServiceModel(vendorSoftwareProductId, version, enrichmentManager.getModel());
402 private Collection<ErrorCode> validateLicensingData(VspDetails vspDetails) {
403 if (vspDetails.getVendorId() != null) {
404 Optional<ErrorCode> errorCode = vendorLicenseFacade.validateVendorForUsage(vspDetails.getVendorId(), vspDetails.getVlmVersion());
405 if (errorCode.isPresent()) {
406 return Collections.singleton(errorCode.get());
409 if (vspDetails.getVendorId() == null || vspDetails.getVlmVersion() == null || vspDetails.getLicenseAgreement() == null || CollectionUtils
410 .isEmpty(vspDetails.getFeatureGroups())) {
411 return Collections.emptyList();
413 return vendorLicenseFacade.validateLicensingData(vspDetails.getVendorId(), vspDetails.getVlmVersion(), vspDetails.getLicenseAgreement(),
414 vspDetails.getFeatureGroups());
418 public VspDetails createVsp(VspDetails vspDetails) {
419 vspInfoDao.create(vspDetails);
420 vspInfoDao.updateQuestionnaireData(vspDetails.getId(), vspDetails.getVersion(),
421 new JsonSchemaDataGenerator(getVspQuestionnaireSchema(null)).generateData());
426 public void updateVsp(VspDetails vspDetails) {
427 VspDetails retrieved = vspInfoDao.get(vspDetails);
428 if (retrieved == null) {
429 throw new CoreException((new ErrorCode.ErrorCodeBuilder()
430 .withMessage(String.format("Vsp with id %s and version %s does not exist.", vspDetails.getId(), vspDetails.getVersion().getId())))
433 vspDetails.setOnboardingMethod(retrieved.getOnboardingMethod());
434 //If any existing feature group is removed from VSP which is also associated in DF then
436 //update DF to remove feature group associations.
437 updateDeploymentFlavor(vspDetails);
438 updateUniqueName(retrieved.getName(), vspDetails.getName());
439 vspInfoDao.update(vspDetails);
442 private void updateDeploymentFlavor(VspDetails vspDetails) {
443 final List<String> featureGroups = vspDetails.getFeatureGroups();
444 if (featureGroups != null) {
445 final Collection<DeploymentFlavorEntity> deploymentFlavorEntities = deploymentFlavorDao
446 .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails.getVersion(), null));
447 if (Objects.nonNull(deploymentFlavorEntities)) {
448 for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
449 updateDeploymentFlavourEntity(featureGroups, deploymentFlavorEntity);
455 private void updateDeploymentFlavourEntity(List<String> featureGroups, DeploymentFlavorEntity deploymentFlavorEntity) {
456 final String featureGroupId = deploymentFlavorEntity.getDeploymentFlavorCompositionData().getFeatureGroupId();
457 if (!featureGroups.contains(featureGroupId)) {
458 DeploymentFlavor deploymentFlavorCompositionData = deploymentFlavorEntity.getDeploymentFlavorCompositionData();
459 deploymentFlavorCompositionData.setFeatureGroupId(null);
460 deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavorCompositionData);
461 deploymentFlavorDao.update(deploymentFlavorEntity);
466 public VspDetails getVsp(String vspId, Version version) {
467 return getValidatedVsp(vspId, version);
470 private VspDetails getValidatedVsp(String vspId, Version version) {
471 VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
473 throw new CoreException(new VendorSoftwareProductNotFoundErrorBuilder(vspId).build());
479 public void deleteVsp(String vspId, Version version) {
480 vspMergeDao.deleteHint(vspId, version);
484 public List<PackageInfo> listPackages(String category, String subCategory) {
485 return packageInfoDao.listByCategory(category, subCategory);
489 public File getTranslatedFile(String vspId, Version version) {
490 PackageInfo packageInfo = packageInfoDao.get(new PackageInfo(vspId, version));
491 if (packageInfo == null) {
492 throw new CoreException(new PackageNotFoundErrorBuilder(vspId, version).build());
494 ByteBuffer translatedFileBuffer = packageInfo.getTranslatedFile();
495 if (translatedFileBuffer == null) {
496 throw new CoreException(new PackageInvalidErrorBuilder(vspId, version).build());
498 File translatedFile = new File(VendorSoftwareProductConstants.VSP_PACKAGE_ZIP);
499 try (FileOutputStream fos = new FileOutputStream(translatedFile)) {
500 fos.write(translatedFileBuffer.array());
501 } catch (IOException exception) {
502 throw new CoreException(new TranslationFileCreationErrorBuilder(vspId, version).build(), exception);
504 return translatedFile;
508 public byte[] getOrchestrationTemplateFile(String vspId, Version version) {
509 OrchestrationTemplateEntity uploadData = orchestrationTemplateDao.get(vspId, version);
510 ByteBuffer contentData = uploadData.getContentData();
511 if (contentData == null) {
514 ByteArrayOutputStream baos = new ByteArrayOutputStream();
515 try (final ZipOutputStream zos = new ZipOutputStream(baos); ZipInputStream ignored = new ZipInputStream(
516 new ByteArrayInputStream(contentData.array()))) {
517 zos.write(contentData.array());
518 } catch (IOException exception) {
519 throw new CoreException(new FileCreationErrorBuilder(vspId).build(), exception);
521 return baos.toByteArray();
525 public OrchestrationTemplateEntity getOrchestrationTemplateInfo(String vspId, Version version) {
526 return orchestrationTemplateDao.getInfo(vspId, version);
530 public Optional<FilesDataStructure> getOrchestrationTemplateStructure(String vspId, Version version) {
531 Optional<String> jsonFileDataStructure = orchestrationTemplateDao.getOrchestrationTemplateStructure(vspId, version);
532 if (jsonFileDataStructure.isPresent() && JsonUtil.isValidJson(jsonFileDataStructure.get())) {
533 return Optional.of(JsonUtil.json2Object(jsonFileDataStructure.get(), FilesDataStructure.class));
535 return Optional.empty();
540 public PackageInfo createPackage(final String vspId, final Version version) throws IOException {
541 final ToscaServiceModel toscaServiceModel = enrichedServiceModelDao.getServiceModel(vspId, version);
542 final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
543 final Version vlmVersion = vspDetails.getVlmVersion();
544 if (vlmVersion != null) {
545 populateVersionsForVlm(vspDetails.getVendorId(), vlmVersion);
547 final PackageInfo packageInfo = createPackageInfo(vspDetails);
548 final ToscaFileOutputServiceCsarImpl toscaServiceTemplateServiceCsar = new ToscaFileOutputServiceCsarImpl();
549 final FileContentHandler licenseArtifacts = licenseArtifactsService
550 .createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion, vspDetails.getFeatureGroups());
551 final ETSIService etsiService = new ETSIServiceImpl();
552 if (etsiService.isSol004WithToscaMetaDirectory(toscaServiceModel.getArtifactFiles())) {
553 final FileContentHandler handler = toscaServiceModel.getArtifactFiles();
554 final Manifest manifest = etsiService.getManifest(handler);
555 final Optional<Map<String, Path>> fromToMovedPaths = etsiService.moveNonManoFileToArtifactFolder(handler);
556 fromToMovedPaths.ifPresent(it -> etsiService.updateMainDescriptorPaths(toscaServiceModel, it));
557 packageInfo.setResourceType(etsiService.getResourceType(manifest).name());
558 if (CollectionUtils.isEmpty(vspDetails.getModelIdList())) {
559 packageInfo.setVendorRelease(etsiService.getHighestCompatibleSpecificationVersion(handler).getOriginalValue());
562 packageInfo.setTranslatedFile(ByteBuffer.wrap(toscaServiceTemplateServiceCsar.createOutputFile(toscaServiceModel, licenseArtifacts)));
563 packageInfoDao.create(packageInfo);
567 void populateVersionsForVlm(String vlmId, Version vlmVersion) {
568 VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
569 versioningManager.list(vlmId).stream().filter(version -> version.getId().equalsIgnoreCase(vlmVersion.getId())).findAny()
570 .ifPresent(version -> {
571 vlmVersion.setMinor(version.getMinor());
572 vlmVersion.setMajor(version.getMajor());
576 private PackageInfo createPackageInfo(final VspDetails vspDetails) {
577 final var packageInfo = new PackageInfo(vspDetails.getId(), vspDetails.getVersion());
578 packageInfo.setVspName(vspDetails.getName());
579 packageInfo.setVspDescription(vspDetails.getDescription());
580 packageInfo.setCategory(vspDetails.getCategory());
581 packageInfo.setSubCategory(vspDetails.getSubCategory());
582 packageInfo.setVendorName(vspDetails.getVendorName());
583 packageInfo.setPackageType(VendorSoftwareProductConstants.CSAR);
584 packageInfo.setVendorRelease("1.0"); //todo TBD
585 if (CollectionUtils.isNotEmpty(vspDetails.getModelIdList())) {
586 packageInfo.setModels(new HashSet<>(vspDetails.getModelIdList()));
592 public QuestionnaireResponse getVspQuestionnaire(String vspId, Version version) {
593 VspQuestionnaireEntity retrieved = vspInfoDao.getQuestionnaire(vspId, version);
594 VersioningUtil.validateEntityExistence(retrieved, new VspQuestionnaireEntity(vspId, version), VspDetails.ENTITY_TYPE);
595 String questionnaireData = retrieved.getQuestionnaireData();
596 QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
597 questionnaireResponse.setData(questionnaireData);
598 questionnaireResponse.setSchema(getVspQuestionnaireSchema(null));
599 return questionnaireResponse;
603 public void updateVspQuestionnaire(String vspId, Version version, String questionnaireData) {
604 vspInfoDao.updateQuestionnaireData(vspId, version, questionnaireData);
607 private Map<String, List<ErrorMessage>> validateOrchestrationTemplate(OrchestrationTemplateEntity orchestrationTemplate) throws IOException {
608 if (isOrchestrationTemplateMissing(orchestrationTemplate)) {
611 Map<String, List<ErrorMessage>> validationErrors = new HashMap<>();
612 FileContentHandler fileContentMap = CommonUtil
613 .validateAndUploadFileContent(OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplate.getFileSuffix()),
614 orchestrationTemplate.getContentData().array());
615 try (InputStream zipFileManifest = fileContentMap.getFileContentAsStream(SdcCommon.MANIFEST_NAME)) {
616 addDummyHeatBase(zipFileManifest, fileContentMap);
617 } catch (Exception e) {
618 LOGGER.error("Invalid package content", e);
620 if (CommonUtil.isFileOriginFromZip(orchestrationTemplate.getFileSuffix())) {
621 ValidationManager validationManager = ValidationManagerUtil.initValidationManager(fileContentMap);
622 validationErrors.putAll(validationManager.validate());
624 return MapUtils.isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, validationErrors)) ? null : validationErrors;
627 private FileContentHandler addDummyHeatBase(InputStream zipFileManifest, FileContentHandler fileContentMap) {
628 ManifestContent manifestContent = JsonUtil.json2Object(zipFileManifest, ManifestContent.class);
629 for (FileData fileData : manifestContent.getData()) {
630 if ((fileData.getFile()).contains("dummy_ignore.yaml")) {
631 String filePath = new File("").getAbsolutePath() + "/resources";
632 File envFilePath = new File(filePath + "/base_template.env");
633 File baseFilePath = new File(filePath + "/base_template.yaml");
634 try (InputStream envStream = new FileInputStream(envFilePath); InputStream baseStream = new FileInputStream(baseFilePath);) {
635 fileContentMap.addFile("base_template_dummy_ignore.env", envStream);
636 fileContentMap.addFile("base_template_dummy_ignore.yaml", baseStream);
637 } catch (Exception e) {
638 LOGGER.error("File not found error {}", e);
642 return fileContentMap;
645 private QuestionnaireValidationResult validateQuestionnaire(String vspId, Version version, String onboardingMethod) {
646 // The apis of CompositionEntityDataManager used here are stateful!
648 // so, it must be re-created from scratch when it is used!
649 CompositionEntityDataManager compositionEntityDataManager = CompositionEntityDataManagerFactory.getInstance().createInterface();
650 compositionEntityDataManager.addEntity(vspInfoDao.getQuestionnaire(vspId, version), null);
651 Collection<NicEntity> nics = nicDao.listByVsp(vspId, version);
652 Map<String, List<String>> nicNamesByComponent = new HashMap<>();
653 for (NicEntity nicEntity : nics) {
654 compositionEntityDataManager.addEntity(nicEntity, null);
655 Nic nic = nicEntity.getNicCompositionData();
656 if (nic != null && nic.getName() != null) {
657 List<String> nicNames = nicNamesByComponent.computeIfAbsent(nicEntity.getComponentId(), k -> new ArrayList<>());
658 nicNames.add(nic.getName());
661 Collection<ComponentEntity> components = componentDao.listCompositionAndQuestionnaire(vspId, version);
662 components.forEach(component -> compositionEntityDataManager.addEntity(component,
663 new ComponentQuestionnaireSchemaInput(nicNamesByComponent.get(component.getId()),
664 JsonUtil.json2Object(component.getQuestionnaireData(), Map.class), null, OnboardingMethod.Manual.name().equals(onboardingMethod))));
665 Collection<ComputeEntity> computes = computeDao.listByVsp(vspId, version);
666 computes.forEach(compute -> compositionEntityDataManager.addEntity(compute, null));
667 if (OnboardingMethod.Manual.name().equals(onboardingMethod)) {
668 Collection<ImageEntity> images = imageDao.listByVsp(vspId, version);
669 images.forEach(image -> compositionEntityDataManager.addEntity(image, null));
671 Map<CompositionEntityId, Collection<String>> errorsByEntityId = compositionEntityDataManager.validateEntitiesQuestionnaire();
672 if (MapUtils.isNotEmpty(errorsByEntityId)) {
673 compositionEntityDataManager.buildTrees();
674 compositionEntityDataManager.addErrorsToTrees(errorsByEntityId);
675 return new QuestionnaireValidationResult(compositionEntityDataManager.getAllErrorsByVsp(vspId));
681 public File getInformationArtifact(String vspId, Version version) {
682 VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
683 if (vspDetails == null) {
686 String vspName = vspDetails.getName();
687 ByteBuffer infoArtifactAsByteBuffer;
688 File infoArtifactFile;
690 infoArtifactAsByteBuffer = ByteBuffer.wrap(informationArtifactGenerator.generate(vspId, version).getBytes());
691 infoArtifactFile = new File(String.format(VendorSoftwareProductConstants.INFORMATION_ARTIFACT_NAME, vspName));
692 try (OutputStream out = new BufferedOutputStream(new FileOutputStream(infoArtifactFile))) {
693 out.write(infoArtifactAsByteBuffer.array());
695 } catch (IOException ex) {
696 throw new CoreException(new InformationArtifactCreationErrorBuilder(vspId).build(), ex);
698 return infoArtifactFile;
701 String getVspQuestionnaireSchema(SchemaTemplateInput schemaInput) {
702 return SchemaGenerator.generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
706 public Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException {
707 OrchestrationTemplateEntity orchestrationTemplateEntity = orchestrationTemplateDao.get(vspId, version);
708 if (isOrchestrationTemplateMissing(orchestrationTemplateEntity)) {
709 return Optional.empty();
711 if (CommonUtil.isFileOriginFromZip(orchestrationTemplateEntity.getFileSuffix())) {
712 return Optional.of(new ImmutablePair<>(OnboardingTypesEnum.ZIP.toString(),
713 candidateService.getZipData(orchestrationTemplateEntity.getContentData())));
715 return Optional.of(new ImmutablePair<>(orchestrationTemplateEntity.getFileSuffix(), orchestrationTemplateEntity.getContentData().array()));
718 void updateUniqueName(String oldVspName, String newVspName) {
719 uniqueValueUtil.updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME, oldVspName, newVspName);
723 public Collection<ComputeEntity> getComputeByVsp(String vspId, Version version) {
724 return computeDao.listByVsp(vspId, version);
727 private boolean isOrchestrationTemplateMissing(OrchestrationTemplateEntity orchestrationTemplate) {
728 return orchestrationTemplate == null || orchestrationTemplate.getContentData() == null || orchestrationTemplate.getFileSuffix() == null
729 || orchestrationTemplate.getFileName() == null;
732 private boolean isServiceModelMissing(ToscaServiceModel serviceModel) {
733 return serviceModel == null || serviceModel.getEntryDefinitionServiceTemplate() == null;
736 public static class Builder {
738 private VspMergeDao vspMergeDao;
739 private OrchestrationTemplateDao orchestrationTemplateDao;
740 private OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager;
741 private VendorSoftwareProductInfoDao vspInfoDao;
742 private VendorLicenseFacade vendorLicenseFacade;
743 private ServiceModelDao<ToscaServiceModel> serviceModelDao;
744 private EnrichedServiceModelDao<ToscaServiceModel> enrichedServiceModelDao;
745 private VendorLicenseArtifactsService licenseArtifactsService;
746 private InformationArtifactGenerator informationArtifactGenerator;
747 private PackageInfoDao packageInfoDao;
748 private DeploymentFlavorDao deploymentFlavorDao;
749 private ComponentDao componentDao;
750 private ComponentDependencyModelDao componentDependencyModelDao;
751 private NicDao nicDao;
752 private ComputeDao computeDao;
753 private ImageDao imageDao;
754 private ManualVspToscaManager manualVspToscaManager;
755 private UniqueValueDao uniqueValueDao;
756 private CandidateService candidateService;
758 public Builder vspMerge(VspMergeDao vspMergeDao) {
759 this.vspMergeDao = vspMergeDao;
763 public Builder orchestrationTemplate(OrchestrationTemplateDao orchestrationTemplateDao) {
764 this.orchestrationTemplateDao = orchestrationTemplateDao;
768 public Builder orchestrationTemplateCandidateManager(OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager) {
769 this.orchestrationTemplateCandidateManager = orchestrationTemplateCandidateManager;
773 public Builder vspInfo(VendorSoftwareProductInfoDao vspInfoDao) {
774 this.vspInfoDao = vspInfoDao;
778 public Builder vendorLicenseFacade(VendorLicenseFacade vendorLicenseFacade) {
779 this.vendorLicenseFacade = vendorLicenseFacade;
783 public Builder serviceModel(ServiceModelDao<ToscaServiceModel> serviceModelDao) {
784 this.serviceModelDao = serviceModelDao;
788 public Builder enrichedServiceModel(EnrichedServiceModelDao<ToscaServiceModel> enrichedServiceModelDao) {
789 this.enrichedServiceModelDao = enrichedServiceModelDao;
793 public Builder licenseArtifactsService(VendorLicenseArtifactsService licenseArtifactsService) {
794 this.licenseArtifactsService = licenseArtifactsService;
798 public Builder informationArtifactGenerator(InformationArtifactGenerator informationArtifactGenerator) {
799 this.informationArtifactGenerator = informationArtifactGenerator;
803 public Builder packageInfo(PackageInfoDao packageInfoDao) {
804 this.packageInfoDao = packageInfoDao;
808 public Builder deploymentFlavor(DeploymentFlavorDao deploymentFlavorDao) {
809 this.deploymentFlavorDao = deploymentFlavorDao;
813 public Builder component(ComponentDao componentDao) {
814 this.componentDao = componentDao;
818 public Builder componentDependencyModel(ComponentDependencyModelDao componentDependencyModelDao) {
819 this.componentDependencyModelDao = componentDependencyModelDao;
823 public Builder nic(NicDao nicDao) {
824 this.nicDao = nicDao;
828 public Builder compute(ComputeDao computeDao) {
829 this.computeDao = computeDao;
833 public Builder image(ImageDao imageDao) {
834 this.imageDao = imageDao;
838 public Builder manualVspToscaManager(ManualVspToscaManager manualVspToscaManager) {
839 this.manualVspToscaManager = manualVspToscaManager;
843 public Builder uniqueValue(UniqueValueDao uniqueValueDao) {
844 this.uniqueValueDao = uniqueValueDao;
848 public Builder candidateService(CandidateService candidateService) {
849 this.candidateService = candidateService;
853 private void registerToVersioning() {
854 if (serviceModelDao != null) {
855 serviceModelDao.registerVersioning(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
857 if (enrichedServiceModelDao != null) {
858 enrichedServiceModelDao.registerVersioning(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
862 public VendorSoftwareProductManager build() {
863 VendorSoftwareProductManagerImpl vendorSoftwareProductManager = new VendorSoftwareProductManagerImpl();
864 vendorSoftwareProductManager.vspMergeDao = this.vspMergeDao;
865 vendorSoftwareProductManager.orchestrationTemplateDao = this.orchestrationTemplateDao;
866 vendorSoftwareProductManager.orchestrationTemplateCandidateManager = this.orchestrationTemplateCandidateManager;
867 vendorSoftwareProductManager.vspInfoDao = this.vspInfoDao;
868 vendorSoftwareProductManager.vendorLicenseFacade = this.vendorLicenseFacade;
869 vendorSoftwareProductManager.serviceModelDao = this.serviceModelDao;
870 vendorSoftwareProductManager.enrichedServiceModelDao = this.enrichedServiceModelDao;
871 vendorSoftwareProductManager.licenseArtifactsService = this.licenseArtifactsService;
872 vendorSoftwareProductManager.informationArtifactGenerator = this.informationArtifactGenerator;
873 vendorSoftwareProductManager.packageInfoDao = this.packageInfoDao;
874 vendorSoftwareProductManager.deploymentFlavorDao = this.deploymentFlavorDao;
875 vendorSoftwareProductManager.componentDao = this.componentDao;
876 vendorSoftwareProductManager.componentDependencyModelDao = this.componentDependencyModelDao;
877 vendorSoftwareProductManager.nicDao = this.nicDao;
878 vendorSoftwareProductManager.computeDao = this.computeDao;
879 vendorSoftwareProductManager.imageDao = this.imageDao;
880 vendorSoftwareProductManager.manualVspToscaManager = this.manualVspToscaManager;
881 vendorSoftwareProductManager.uniqueValueUtil = new UniqueValueUtil(this.uniqueValueDao);
882 vendorSoftwareProductManager.candidateService = candidateService;
883 this.registerToVersioning();
884 return vendorSoftwareProductManager;