gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   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.openecomp.sdc.vendorsoftwareproduct.impl;
  18
  19 import static org.openecomp.sdc.tosca.csar.CSARConstants.MANIFEST_PNF_METADATA;
  20 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_MANIFEST;
  21 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ORIG_PATH_FILE_NAME;
  22 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_PATH_FILE_NAME;
  23 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.candidateDataNotProcessedOrAbortedErrorBuilder;
  24 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.invalidProcessedCandidate;
  25 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder.vspMissingDeploymentFlavorErrorBuilder;
  26 import static org.openecomp.sdc.tosca.csar.CSARConstants.MAIN_SERVICE_TEMPLATE_MF_FILE_NAME;
  27
  28 import java.io.BufferedOutputStream;
  29 import java.io.ByteArrayInputStream;
  30 import java.io.ByteArrayOutputStream;
  31 import java.io.File;
  32 import java.io.FileOutputStream;
  33 import java.io.IOException;
  34 import java.io.InputStream;
  35 import java.io.OutputStream;
  36 import java.nio.ByteBuffer;
  37 import java.util.ArrayList;
  38 import java.util.Collection;
  39 import java.util.Collections;
  40 import java.util.HashMap;
  41 import java.util.HashSet;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.Objects;
  45 import java.util.Optional;
  46 import java.util.Set;
  47 import java.util.zip.ZipInputStream;
  48 import java.util.zip.ZipOutputStream;
  49 import org.apache.commons.collections4.CollectionUtils;
  50 import org.apache.commons.collections4.MapUtils;
  51 import org.apache.commons.lang3.tuple.ImmutablePair;
  52 import org.apache.commons.lang3.tuple.Pair;
  53 import org.openecomp.core.dao.UniqueValueDao;
  54 import org.openecomp.core.enrichment.api.EnrichmentManager;
  55 import org.openecomp.core.enrichment.factory.EnrichmentManagerFactory;
  56 import org.openecomp.core.model.dao.EnrichedServiceModelDao;
  57 import org.openecomp.core.model.dao.ServiceModelDao;
  58 import org.openecomp.core.model.types.ServiceElement;
  59 import org.openecomp.core.util.UniqueValueUtil;
  60 import org.openecomp.core.utilities.file.FileContentHandler;
  61 import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
  62 import org.openecomp.core.utilities.json.JsonUtil;
  63 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
  64 import org.openecomp.core.validation.api.ValidationManager;
  65 import org.openecomp.core.validation.util.MessageContainerUtil;
  66 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  67 import org.openecomp.sdc.common.errors.CoreException;
  68 import org.openecomp.sdc.common.errors.ErrorCode;
  69 import org.openecomp.sdc.common.errors.ValidationErrorBuilder;
  70 import org.openecomp.sdc.common.utils.CommonUtil;
  71 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  72 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  73 import org.openecomp.sdc.tosca.csar.OnboardingToscaMetadata;
  74 import org.openecomp.sdc.tosca.csar.ToscaMetadata;
  75 import org.openecomp.sdc.tosca.csar.SOL004ManifestOnboarding;
  76 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  77 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
  78 import org.openecomp.sdc.validation.util.ValidationManagerUtil;
  79 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
  80 import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsService;
  81 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  82 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManagerFactory;
  83 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
  84 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
  85 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  86 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
  87 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  88 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
  89 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  90 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  91 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  92 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  93 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
  94 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDao;
  95 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  96 import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDao;
  97 import org.openecomp.sdc.vendorsoftwareproduct.dao.errors.VendorSoftwareProductNotFoundErrorBuilder;
  98 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
  99 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
 100 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
 101 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
 102 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
 103 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
 104 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
 105 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
 106 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
 107 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 108 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspQuestionnaireEntity;
 109 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
 110 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentErrorBuilder;
 111 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
 112 import org.openecomp.sdc.vendorsoftwareproduct.errors.FileCreationErrorBuilder;
 113 import org.openecomp.sdc.vendorsoftwareproduct.errors.InformationArtifactCreationErrorBuilder;
 114 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
 115 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageInvalidErrorBuilder;
 116 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageNotFoundErrorBuilder;
 117 import org.openecomp.sdc.vendorsoftwareproduct.errors.TranslationFileCreationErrorBuilder;
 118 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder;
 119 import org.openecomp.sdc.tosca.csar.Manifest;
 120 import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactGenerator;
 121 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.etsi.ETSIService;
 122 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 123 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.etsi.ETSIServiceImpl;
 124 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
 125 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
 126 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireValidationResult;
 127 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
 128 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.FilesDataStructure;
 129 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
 130 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityId;
 131 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
 132 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
 133 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
 134 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
 135 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
 136 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQuestionnaireSchemaInput;
 137 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
 138 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
 139 import org.openecomp.sdc.vendorsoftwareproduct.utils.ComponentDependencyTracker;
 140 import org.openecomp.sdc.versioning.VersioningManager;
 141 import org.openecomp.sdc.versioning.VersioningManagerFactory;
 142 import org.openecomp.sdc.versioning.VersioningUtil;
 143 import org.openecomp.sdc.versioning.dao.types.Version;
 144
 145 public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductManager {
 146
 147   private VspMergeDao vspMergeDao;
 148   private OrchestrationTemplateDao orchestrationTemplateDao;
 149   private OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager;
 150   private VendorSoftwareProductInfoDao vspInfoDao;
 151   private VendorLicenseFacade vendorLicenseFacade;
 152   private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
 153   private EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
 154   private VendorLicenseArtifactsService licenseArtifactsService;
 155   private InformationArtifactGenerator informationArtifactGenerator;
 156   private PackageInfoDao packageInfoDao;
 157   private DeploymentFlavorDao deploymentFlavorDao;
 158   private ComponentDao componentDao;
 159   private ComponentDependencyModelDao componentDependencyModelDao;
 160   private NicDao nicDao;
 161   private ComputeDao computeDao;
 162   private ImageDao imageDao;
 163   private ManualVspToscaManager manualVspToscaManager;
 164   private UniqueValueUtil uniqueValueUtil;
 165   private CandidateService candidateService;
 166
 167   @Override
 168   public ValidationResponse validate(VspDetails vspDetails) throws IOException {
 169     List<ErrorCode> vspErrors = new ArrayList<>(validateVspFields(vspDetails));
 170     ValidationResponse validationResponse = new ValidationResponse();
 171     if (Objects.nonNull(vspDetails.getOnboardingMethod())
 172         && OnboardingMethod.Manual.name().equals(vspDetails.getOnboardingMethod())) {
 173       validateManualOnboardingMethod(vspDetails, validationResponse, vspErrors);
 174     } else {
 175       validateOrchestrationTemplateCandidate(validationResponse, vspErrors, vspDetails.getId(), vspDetails.getVersion());
 176       if (!validationResponse.isValid()) {
 177         return validationResponse;
 178       }
 179       validateLicense(vspDetails, vspErrors);
 180       OrchestrationTemplateEntity orchestrationTemplate =
 181           orchestrationTemplateDao.get(vspDetails.getId(), vspDetails.getVersion());
 182       ToscaServiceModel serviceModel =
 183           serviceModelDao.getServiceModel( vspDetails.getId(), vspDetails.getVersion());
 184       if (isOrchestrationTemplateMissing(orchestrationTemplate)
 185           || isServiceModelMissing(serviceModel)) {
 186         vspErrors.add(VendorSoftwareProductInvalidErrorBuilder
 187             .vendorSoftwareProductMissingServiceModelErrorBuilder(vspDetails.getId(),
 188                 vspDetails.getVersion()));
 189       }
 190       validationResponse.setUploadDataErrors(validateOrchestrationTemplate(orchestrationTemplate));
 191     }
 192
 193     QuestionnaireValidationResult questionnaireValidationResult = validateQuestionnaire
 194         (vspDetails.getId(), vspDetails.getVersion(), vspDetails.getOnboardingMethod());
 195
 196     if (Objects.nonNull(questionnaireValidationResult)) {
 197       if (validationResponse.getQuestionnaireValidationResult() == null || validationResponse
 198           .getQuestionnaireValidationResult().getValidationData() == null) {
 199         validationResponse.setQuestionnaireValidationResult(questionnaireValidationResult);
 200       } else {
 201         validationResponse.getQuestionnaireValidationResult().getValidationData().addAll
 202             (questionnaireValidationResult.getValidationData());
 203       }
 204     }
 205
 206     Collection<ComponentDependencyModelEntity> componentDependencies =
 207         componentDependencyModelDao.list(new ComponentDependencyModelEntity(vspDetails.getId(), vspDetails.getVersion(), null));
 208
 209     if (validateComponentDependencies(componentDependencies)) {
 210       vspErrors
 211           .add(ComponentDependencyModelErrorBuilder.getcyclicDependencyComponentErrorBuilder());
 212     }
 213     validationResponse
 214         .setVspErrors(vspErrors);
 215     validationResponse.setLicensingDataErrors(validateLicensingData(vspDetails));
 216     return validationResponse;
 217   }
 218
 219   private void validateLicense(VspDetails vspDetails, List<ErrorCode> vspErrors) {
 220     if (vspDetails.getVlmVersion() != null || vspDetails.getLicenseAgreement() != null
 221             || vspDetails.getFeatureGroups() != null) {
 222       vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
 223     }
 224   }
 225
 226   private void validateOrchestrationTemplateCandidate(ValidationResponse validationResponse,
 227                                                       List<ErrorCode> vspErrors, String vspId,
 228                                                       Version version) {
 229     orchestrationTemplateCandidateManager.getInfo(vspId, version)
 230         .ifPresent(candidateInfo -> {
 231           String fileName = candidateInfo.getFileName();
 232           vspErrors.add(candidateInfo.getValidationData().isEmpty()
 233               ? candidateDataNotProcessedOrAbortedErrorBuilder(fileName)
 234               : invalidProcessedCandidate(fileName));
 235           validationResponse.setVspErrors(vspErrors);
 236         });
 237   }
 238
 239   private void validateManualOnboardingMethod(VspDetails vspDetails,
 240                                               ValidationResponse validationResponse,
 241                                               List<ErrorCode> vspErrors) {
 242     vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
 243
 244     Collection<DeploymentFlavorEntity> deploymentFlavors = deploymentFlavorDao
 245         .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails.getVersion(), null));
 246     if (CollectionUtils.isEmpty(deploymentFlavors)) {
 247       vspErrors.add(vspMissingDeploymentFlavorErrorBuilder());
 248     }
 249     vspErrors.addAll(validateDeploymentFlavors(deploymentFlavors));
 250
 251     Set<CompositionEntityValidationData> componentValidationResult =
 252         componentValidation(vspDetails.getId(), vspDetails.getVersion());
 253     if (!CollectionUtils.isEmpty(componentValidationResult)) {
 254       if (validationResponse.getQuestionnaireValidationResult() == null
 255           || validationResponse.getQuestionnaireValidationResult().getValidationData() == null) {
 256         validationResponse.setQuestionnaireValidationResult(
 257             new QuestionnaireValidationResult(componentValidationResult));
 258       } else {
 259         validationResponse.getQuestionnaireValidationResult().getValidationData()
 260             .addAll(componentValidationResult);
 261       }
 262     }
 263   }
 264
 265   @Override
 266   public Map<String, List<ErrorMessage>> compile(String vspId, Version version) {
 267     ToscaServiceModel serviceModel =
 268         OnboardingMethod.Manual.name().equals(getValidatedVsp(vspId, version).getOnboardingMethod())
 269             //Generate Tosca service model for Manual Onboarding flow
 270             ? manualVspToscaManager
 271             .generateToscaModel(manualVspToscaManager.gatherVspInformation(vspId, version))
 272             : serviceModelDao.getServiceModel(vspId, version);
 273
 274     return compile(vspId, version, serviceModel);
 275   }
 276
 277   private boolean validateComponentDependencies(
 278       Collection<ComponentDependencyModelEntity> componentDependencies) {
 279     ComponentDependencyTracker dependencyTracker = new ComponentDependencyTracker();
 280
 281     for (ComponentDependencyModelEntity componentDependency : componentDependencies) {
 282       dependencyTracker.addDependency(componentDependency.getSourceComponentId(),
 283           componentDependency.getTargetComponentId());
 284     }
 285     return dependencyTracker.isCyclicDependencyPresent();
 286   }
 287
 288   private Collection<ErrorCode> validateDeploymentFlavors(
 289       Collection<DeploymentFlavorEntity> deploymentFlavors) {
 290
 291     Collection<ErrorCode> errorCodeList = new ArrayList<>();
 292     if (!CollectionUtils.isEmpty(deploymentFlavors)) {
 293       deploymentFlavors.forEach(deploymentFlavor -> {
 294         DeploymentFlavorEntity deployment = deploymentFlavorDao.get(deploymentFlavor);
 295         DeploymentFlavor deploymentLocalFlavor = deployment.getDeploymentFlavorCompositionData();
 296         if (deploymentLocalFlavor != null) {
 297           if (deploymentLocalFlavor.getFeatureGroupId() == null) {
 298             ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder.
 299                 getFeatureGroupMandatoryErrorBuilder(deploymentLocalFlavor.getModel());
 300             errorCodeList.add(deploymentFlavorErrorBuilder);
 301           }
 302           validateComponentComputeAssociations(errorCodeList, deploymentFlavor,
 303               deployment, deploymentLocalFlavor);
 304         }
 305       });
 306     }
 307     return errorCodeList;
 308   }
 309
 310   private void validateComponentComputeAssociations(Collection<ErrorCode> errorCodeList,
 311                                                     DeploymentFlavorEntity deploymentFlavor,
 312                                                     DeploymentFlavorEntity deployment,
 313                                                     DeploymentFlavor deploymentlocalFlavor) {
 314     List<ComponentComputeAssociation> componentComputeAssociations =
 315         deploymentlocalFlavor.getComponentComputeAssociations();
 316     if (CollectionUtils.isEmpty(componentComputeAssociations)) {
 317         validateCompositionEntity(errorCodeList, deploymentFlavor, deployment, deploymentlocalFlavor);
 318     } else {
 319       componentComputeAssociations.forEach(componentComputeAssociation -> {
 320         if (componentComputeAssociation == null
 321             || !(componentComputeAssociation.getComponentId() != null
 322             && componentComputeAssociation.getComputeFlavorId() != null)) {
 323             validateCompositionEntity(errorCodeList, deploymentFlavor, deployment, deploymentlocalFlavor);
 324         }
 325       });
 326     }
 327   }
 328
 329   private void validateCompositionEntity(Collection<ErrorCode> errorCodeList,
 330                                                                              DeploymentFlavorEntity deploymentFlavor,
 331                                                                              DeploymentFlavorEntity deployment,
 332                                                                              DeploymentFlavor deploymentlocalFlavor){
 333     CompositionEntityValidationData compositionEntityValidationData = new
 334             CompositionEntityValidationData(CompositionEntityType.deployment, deploymentFlavor
 335             .getId());
 336     compositionEntityValidationData.setEntityName(deployment
 337             .getDeploymentFlavorCompositionData().getModel());
 338     ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 339             .getInvalidComponentComputeAssociationErrorBuilder(
 340                     deploymentlocalFlavor.getModel());
 341     errorCodeList.add(deploymentFlavorErrorBuilder);
 342   }
 343
 344   private Set<CompositionEntityValidationData> componentValidation(String vspId, Version version) {
 345     Set<CompositionEntityValidationData> validationData = new HashSet<>();
 346     Collection<ComponentEntity> components =
 347         componentDao.list(new ComponentEntity(vspId, version, null));
 348     if (!CollectionUtils.isEmpty(components)) {
 349       components.forEach(component -> {
 350         validateImage(vspId, version, validationData, component);
 351         validateNic(vspId, version, validationData, component);
 352
 353       });
 354     }
 355
 356     return validationData;
 357   }
 358
 359   private void validateNic(String vspId, Version version,
 360                            Set<CompositionEntityValidationData> validationData,
 361                            ComponentEntity component) {
 362     Collection<NicEntity> nics =
 363         nicDao.list(new NicEntity(vspId, version, component.getId(), null));
 364     if (CollectionUtils.isNotEmpty(nics)) {
 365       nics.forEach(nicEntity -> {
 366         NicEntity nic = nicDao.get(new NicEntity(vspId, version, component.getId(),
 367             nicEntity.getId()));
 368         NetworkType networkType = nic.getNicCompositionData().getNetworkType();
 369         String networkId = nic.getNicCompositionData().getNetworkId();
 370         if (networkType.equals(NetworkType.Internal) && networkId == null) {
 371           CompositionEntityValidationData compositionEntityValidationData = new
 372               CompositionEntityValidationData(CompositionEntityType.nic, nic.getId());
 373           compositionEntityValidationData.setEntityName(nic.getNicCompositionData().getName());
 374           ErrorCode nicInternalNetworkErrorBuilder = NicInternalNetworkErrorBuilder
 375               .getNicNullNetworkIdInternalNetworkIdErrorBuilder();
 376           List<String> errors = new ArrayList<>();
 377           errors.add(nicInternalNetworkErrorBuilder.message());
 378           compositionEntityValidationData.setErrors(errors);
 379           validationData.add(compositionEntityValidationData);
 380         }
 381       });
 382     }
 383   }
 384
 385   private void validateImage(String vspId, Version version,
 386                              Set<CompositionEntityValidationData> validationData,
 387                              ComponentEntity component) {
 388     Collection<ImageEntity> images =
 389         imageDao.list(new ImageEntity(vspId, version, component.getId(), null));
 390     if (CollectionUtils.isEmpty(images)) {
 391       CompositionEntityValidationData compositionEntityValidationData = new
 392           CompositionEntityValidationData(component.getType(), component.getId());
 393       compositionEntityValidationData
 394           .setEntityName(component.getComponentCompositionData().getDisplayName());
 395       ErrorCode vfcMissingImageErrorBuilder =
 396           ComponentErrorBuilder.vfcMissingImageErrorBuilder();
 397       List<String> errors = new ArrayList<>();
 398       errors.add(vfcMissingImageErrorBuilder.message());
 399       compositionEntityValidationData.setErrors(errors);
 400       validationData.add(compositionEntityValidationData);
 401     }
 402   }
 403
 404   private List<ErrorCode> validateVspFields(VspDetails vspDetails) {
 405     List<ErrorCode> errors = new ArrayList<>();
 406
 407     if (vspDetails.getName() == null) {
 408       errors.add(createMissingMandatoryFieldError("name"));
 409     }
 410     if (vspDetails.getDescription() == null) {
 411       errors.add(createMissingMandatoryFieldError("description"));
 412     }
 413     if (vspDetails.getVendorId() == null) {
 414       errors.add(createMissingMandatoryFieldError("vendor Id"));
 415     }
 416     if (vspDetails.getCategory() == null) {
 417       errors.add(createMissingMandatoryFieldError("category"));
 418     }
 419     if (vspDetails.getSubCategory() == null) {
 420       errors.add(createMissingMandatoryFieldError("sub category"));
 421     }
 422     return errors;
 423   }
 424
 425   private List<ErrorCode> validateMandatoryLicenseFields(VspDetails vspDetails) {
 426     List<ErrorCode> errors = new ArrayList<>();
 427     if (vspDetails.getVlmVersion() == null) {
 428       errors.add(createMissingMandatoryFieldError("licensing version"));
 429     }
 430     if (vspDetails.getLicenseAgreement() == null) {
 431       errors.add(createMissingMandatoryFieldError("license agreement"));
 432     }
 433     if (CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
 434       errors.add(createMissingMandatoryFieldError("feature groups"));
 435     }
 436     return errors;
 437   }
 438
 439   private static ErrorCode createMissingMandatoryFieldError(String fieldName) {
 440     return new ValidationErrorBuilder("must be supplied", fieldName).build();
 441   }
 442
 443   private Map<String, List<ErrorMessage>> compile(String vendorSoftwareProductId, Version version,
 444                                                   ToscaServiceModel serviceModel) {
 445     if (isServiceModelMissing(serviceModel)) {
 446       return null;
 447     }
 448
 449     enrichedServiceModelDao.deleteAll(vendorSoftwareProductId, version);
 450
 451     EnrichmentManager<ToscaServiceModel> enrichmentManager =
 452         EnrichmentManagerFactory.getInstance().createInterface();
 453     enrichmentManager.init(vendorSoftwareProductId, version);
 454     enrichmentManager.setModel(serviceModel);
 455     Map<String, List<ErrorMessage>> enrichErrors = enrichmentManager.enrich();
 456
 457     enrichedServiceModelDao
 458         .storeServiceModel(vendorSoftwareProductId, version, enrichmentManager.getModel());
 459
 460     return enrichErrors;
 461   }
 462
 463   private Collection<ErrorCode> validateLicensingData(VspDetails vspDetails) {
 464     if (vspDetails.getVendorId() != null) {
 465       Optional<ErrorCode> errorCode = vendorLicenseFacade.validateVendorForUsage(vspDetails.getVendorId(),vspDetails.getVlmVersion());
 466       if (errorCode.isPresent()) {
 467         return Collections.singleton(errorCode.get());
 468       }
 469     }
 470
 471     if (vspDetails.getVendorId() == null || vspDetails.getVlmVersion() == null
 472         || vspDetails.getLicenseAgreement() == null
 473         || CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
 474       return Collections.emptyList();
 475     }
 476     return vendorLicenseFacade
 477         .validateLicensingData(vspDetails.getVendorId(), vspDetails.getVlmVersion(),
 478             vspDetails.getLicenseAgreement(), vspDetails.getFeatureGroups());
 479   }
 480
 481   @Override
 482   public VspDetails createVsp(VspDetails vspDetails) {
 483     vspInfoDao.create(vspDetails);
 484     vspInfoDao.updateQuestionnaireData(vspDetails.getId(), vspDetails.getVersion(),
 485         new JsonSchemaDataGenerator(getVspQuestionnaireSchema(null)).generateData());
 486     return vspDetails;
 487   }
 488
 489   @Override
 490   public void updateVsp(VspDetails vspDetails) {
 491     VspDetails retrieved = vspInfoDao.get(vspDetails);
 492     if (retrieved == null) {
 493       throw new CoreException((new ErrorCode.ErrorCodeBuilder()
 494           .withMessage(String.format("Vsp with id %s and version %s does not exist.",
 495               vspDetails.getId(), vspDetails.getVersion().getId()))).build());
 496     }
 497     vspDetails.setOnboardingMethod(retrieved.getOnboardingMethod());
 498
 499     //If any existing feature group is removed from VSP which is also associated in DF then
 500     //update DF to remove feature group associations.
 501     updateDeploymentFlavor(vspDetails);
 502
 503     updateUniqueName(retrieved.getName(), vspDetails.getName());
 504     vspInfoDao.update(vspDetails);
 505   }
 506
 507   private void updateDeploymentFlavor(VspDetails vspDetails) {
 508     final List<String> featureGroups = vspDetails.getFeatureGroups();
 509     if (featureGroups != null) {
 510       final Collection<DeploymentFlavorEntity> deploymentFlavorEntities = deploymentFlavorDao
 511           .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails
 512               .getVersion(), null));
 513       if (Objects.nonNull(deploymentFlavorEntities)) {
 514         for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 515           updateDeploymentFlavourEntity(featureGroups, deploymentFlavorEntity);
 516         }
 517       }
 518     }
 519   }
 520
 521   private void updateDeploymentFlavourEntity(List<String> featureGroups,
 522                                              DeploymentFlavorEntity deploymentFlavorEntity) {
 523     final String featureGroupId =
 524         deploymentFlavorEntity.getDeploymentFlavorCompositionData().getFeatureGroupId();
 525     if (!featureGroups.contains(featureGroupId)) {
 526       DeploymentFlavor deploymentFlavorCompositionData =
 527           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 528       deploymentFlavorCompositionData.setFeatureGroupId(null);
 529       deploymentFlavorEntity.setDeploymentFlavorCompositionData
 530           (deploymentFlavorCompositionData);
 531       deploymentFlavorDao.update(deploymentFlavorEntity);
 532     }
 533   }
 534
 535
 536   @Override
 537   public VspDetails getVsp(String vspId, Version version) {
 538     return getValidatedVsp(vspId, version);
 539   }
 540
 541   private VspDetails getValidatedVsp(String vspId, Version version) {
 542     VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
 543     if (vsp == null) {
 544       throw new CoreException(new VendorSoftwareProductNotFoundErrorBuilder(vspId).build());
 545     }
 546     return vsp;
 547   }
 548
 549   @Override
 550   public void deleteVsp(String vspId, Version version) {
 551     vspMergeDao.deleteHint(vspId, version);
 552   }
 553
 554   @Override
 555   public List<PackageInfo> listPackages(String category, String subCategory) {
 556     return packageInfoDao.listByCategory(category, subCategory);
 557   }
 558
 559   @Override
 560   public File getTranslatedFile(String vspId, Version version) {
 561     PackageInfo packageInfo = packageInfoDao.get(new PackageInfo(vspId, version));
 562     if (packageInfo == null) {
 563       throw new CoreException(new PackageNotFoundErrorBuilder(vspId, version).build());
 564     }
 565
 566     ByteBuffer translatedFileBuffer = packageInfo.getTranslatedFile();
 567     if (translatedFileBuffer == null) {
 568       throw new CoreException(new PackageInvalidErrorBuilder(vspId, version).build());
 569     }
 570
 571     File translatedFile = new File(VendorSoftwareProductConstants.VSP_PACKAGE_ZIP);
 572
 573     try (FileOutputStream fos = new FileOutputStream(translatedFile)) {
 574       fos.write(translatedFileBuffer.array());
 575     } catch (IOException exception) {
 576       throw new CoreException(new TranslationFileCreationErrorBuilder(vspId, version).build(),
 577           exception);
 578     }
 579     return translatedFile;
 580   }
 581
 582   @Override
 583   public byte[] getOrchestrationTemplateFile(String vspId, Version version) {
 584     OrchestrationTemplateEntity uploadData = orchestrationTemplateDao.get(vspId, version);
 585     ByteBuffer contentData = uploadData.getContentData();
 586     if (contentData == null) {
 587       return new byte[0];
 588     }
 589
 590     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 591
 592     try (final ZipOutputStream zos = new ZipOutputStream(baos);
 593          ZipInputStream ignored = new ZipInputStream(
 594              new ByteArrayInputStream(contentData.array()))) {
 595       zos.write(contentData.array());
 596     } catch (IOException exception) {
 597       throw new CoreException(new FileCreationErrorBuilder(vspId).build(), exception);
 598     }
 599     return baos.toByteArray();
 600   }
 601
 602   @Override
 603   public OrchestrationTemplateEntity getOrchestrationTemplateInfo(String vspId, Version version) {
 604     return orchestrationTemplateDao.getInfo(vspId, version);
 605   }
 606
 607   @Override
 608   public Optional<FilesDataStructure> getOrchestrationTemplateStructure(String vspId,
 609                                                                         Version version) {
 610     Optional<String> jsonFileDataStructure =
 611         orchestrationTemplateDao.getOrchestrationTemplateStructure(vspId, version);
 612
 613     if (jsonFileDataStructure.isPresent() && JsonUtil.isValidJson(jsonFileDataStructure.get())) {
 614       return Optional
 615           .of(JsonUtil.json2Object(jsonFileDataStructure.get(), FilesDataStructure.class));
 616     } else {
 617       return Optional.empty();
 618     }
 619   }
 620
 621   @Override
 622   public PackageInfo createPackage(String vspId, Version version) throws IOException {
 623     ToscaServiceModel toscaServiceModel = enrichedServiceModelDao.getServiceModel(vspId, version);
 624     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 625     Version vlmVersion = vspDetails.getVlmVersion();
 626     if (vlmVersion != null) {
 627       populateVersionsForVlm(vspDetails.getVendorId(), vlmVersion);
 628     }
 629     PackageInfo packageInfo = createPackageInfo(vspDetails);
 630
 631     ToscaFileOutputServiceCsarImpl toscaServiceTemplateServiceCsar =
 632         new ToscaFileOutputServiceCsarImpl();
 633     FileContentHandler licenseArtifacts = licenseArtifactsService
 634         .createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion,
 635             vspDetails.getFeatureGroups());
 636     ETSIService etsiService = new ETSIServiceImpl();
 637     if(etsiService.isSol004WithToscaMetaDirectory(toscaServiceModel.getArtifactFiles())){
 638         FileContentHandler handler = toscaServiceModel.getArtifactFiles();
 639         try(InputStream manifestInputStream = getManifest(handler)) {
 640           Manifest onboardingManifest = new SOL004ManifestOnboarding();
 641           onboardingManifest.parse(manifestInputStream);
 642           etsiService.moveNonManoFileToArtifactFolder(handler, onboardingManifest);
 643           //VSP PNF resource type is supported only for sol004 csar for now, default VSP resource type is VF
 644           packageInfo.setResourceType(getResourceType(onboardingManifest));
 645         }
 646     }
 647     packageInfo.setTranslatedFile(ByteBuffer.wrap(
 648         toscaServiceTemplateServiceCsar.createOutputFile(toscaServiceModel, licenseArtifacts)));
 649
 650     packageInfoDao.create(packageInfo);
 651     return packageInfo;
 652   }
 653
 654   private String getResourceType(Manifest onboardingManifest) {
 655     //Valid manifest should contain whether vnf or pnf related metadata data exclusively in SOL004 standard,
 656     // validation of manifest done during package upload stage
 657     if(onboardingManifest != null && !onboardingManifest.getMetadata().isEmpty()
 658             && MANIFEST_PNF_METADATA.stream().anyMatch(e -> onboardingManifest.getMetadata().containsKey(e))){
 659         return ResourceTypeEnum.PNF.name();
 660     }
 661     //VNF is default resource type
 662     return ResourceTypeEnum.VF.name();
 663   }
 664
 665   private InputStream getManifest(FileContentHandler handler) throws IOException {
 666     ToscaMetadata metadata = getMetadata(handler);
 667     return getManifestInputStream(handler, metadata.getMetaEntries().get(TOSCA_META_ETSI_ENTRY_MANIFEST));
 668   }
 669
 670   private ToscaMetadata getMetadata(FileContentHandler handler) throws IOException {
 671     ToscaMetadata metadata;
 672     if(handler.containsFile(TOSCA_META_PATH_FILE_NAME)){
 673       metadata = OnboardingToscaMetadata.parseToscaMetadataFile(handler.getFileContent(TOSCA_META_PATH_FILE_NAME));
 674
 675     }else if(handler.containsFile(TOSCA_META_ORIG_PATH_FILE_NAME)){
 676       metadata = OnboardingToscaMetadata.parseToscaMetadataFile(handler.getFileContent(TOSCA_META_ORIG_PATH_FILE_NAME));
 677     }else {
 678       throw new IOException("TOSCA.meta file not found!");
 679     }
 680     return metadata;
 681   }
 682
 683   private InputStream getManifestInputStream(FileContentHandler handler, String manifestLocation) throws IOException {
 684     InputStream io;
 685     if(manifestLocation == null || !handler.containsFile(manifestLocation)){
 686       io = handler.getFileContent(MAIN_SERVICE_TEMPLATE_MF_FILE_NAME);
 687     }else {
 688       io = handler.getFileContent(manifestLocation);
 689     }
 690
 691     if(io == null){
 692       throw new IOException("Manifest file not found!");
 693     }
 694     return io;
 695   }
 696
 697   void populateVersionsForVlm(String vlmId, Version vlmVersion) {
 698     VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
 699     versioningManager.list(vlmId).stream()
 700         .filter(version -> version.getId().equalsIgnoreCase(vlmVersion.getId()))
 701         .findAny()
 702         .ifPresent(version -> {
 703           vlmVersion.setMinor(version.getMinor());
 704           vlmVersion.setMajor(version.getMajor());
 705         });
 706   }
 707
 708   private PackageInfo createPackageInfo(VspDetails vspDetails) {
 709     PackageInfo packageInfo = new PackageInfo(vspDetails.getId(), vspDetails.getVersion());
 710     packageInfo.setVspName(vspDetails.getName());
 711     packageInfo.setVspDescription(vspDetails.getDescription());
 712     packageInfo.setCategory(vspDetails.getCategory());
 713     packageInfo.setSubCategory(vspDetails.getSubCategory());
 714     packageInfo.setVendorName(vspDetails.getVendorName());
 715     packageInfo.setPackageType(VendorSoftwareProductConstants.CSAR);
 716     packageInfo.setVendorRelease("1.0"); //todo TBD
 717     return packageInfo;
 718   }
 719
 720   @Override
 721
 722   public QuestionnaireResponse getVspQuestionnaire(String vspId, Version version) {
 723     VspQuestionnaireEntity retrieved = vspInfoDao.getQuestionnaire(vspId, version);
 724     VersioningUtil.validateEntityExistence(retrieved, new VspQuestionnaireEntity(vspId, version),
 725         VspDetails.ENTITY_TYPE);
 726
 727     String questionnaireData = retrieved.getQuestionnaireData();
 728
 729     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 730     questionnaireResponse.setData(questionnaireData);
 731     questionnaireResponse.setSchema(getVspQuestionnaireSchema(null));
 732     return questionnaireResponse;
 733   }
 734
 735   @Override
 736   public void updateVspQuestionnaire(String vspId, Version version, String questionnaireData) {
 737     vspInfoDao.updateQuestionnaireData(vspId, version, questionnaireData);
 738   }
 739
 740
 741   private Map<String, List<ErrorMessage>> validateOrchestrationTemplate(
 742       OrchestrationTemplateEntity orchestrationTemplate) throws IOException {
 743
 744     if (isOrchestrationTemplateMissing(orchestrationTemplate)) {
 745       return null;
 746     }
 747     Map<String, List<ErrorMessage>> validationErrors = new HashMap<>();
 748
 749     FileContentHandler fileContentMap = CommonUtil.validateAndUploadFileContent(
 750         OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplate.getFileSuffix()),
 751         orchestrationTemplate.getContentData().array());
 752
 753     if (CommonUtil.isFileOriginFromZip(orchestrationTemplate.getFileSuffix())) {
 754       ValidationManager validationManager =
 755           ValidationManagerUtil.initValidationManager(fileContentMap);
 756       validationErrors.putAll(validationManager.validate());
 757     }
 758
 759     return
 760         MapUtils.isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, validationErrors))
 761             ? null : validationErrors;
 762   }
 763
 764   private QuestionnaireValidationResult validateQuestionnaire(String vspId, Version version,
 765                                                               String onboardingMethod) {
 766     // The apis of CompositionEntityDataManager used here are stateful!
 767     // so, it must be re-created from scratch when it is used!
 768     CompositionEntityDataManager compositionEntityDataManager =
 769         CompositionEntityDataManagerFactory.getInstance().createInterface();
 770     compositionEntityDataManager
 771         .addEntity(vspInfoDao.getQuestionnaire(vspId, version), null);
 772
 773     Collection<NicEntity> nics = nicDao.listByVsp(vspId, version);
 774
 775     Map<String, List<String>> nicNamesByComponent = new HashMap<>();
 776     for (NicEntity nicEntity : nics) {
 777       compositionEntityDataManager.addEntity(nicEntity, null);
 778
 779       Nic nic = nicEntity.getNicCompositionData();
 780       if (nic != null && nic.getName() != null) {
 781         List<String> nicNames =
 782             nicNamesByComponent.computeIfAbsent(nicEntity.getComponentId(), k -> new ArrayList<>());
 783         nicNames.add(nic.getName());
 784       }
 785     }
 786
 787     Collection<ComponentEntity> components =
 788         componentDao.listCompositionAndQuestionnaire(vspId, version);
 789     components.forEach(component -> compositionEntityDataManager.addEntity(component,
 790         new ComponentQuestionnaireSchemaInput(nicNamesByComponent.get(component.getId()),
 791             JsonUtil.json2Object(component.getQuestionnaireData(), Map.class), null,
 792                                                      OnboardingMethod.Manual.name().equals(onboardingMethod))));
 793
 794     Collection<ComputeEntity> computes = computeDao.listByVsp(vspId, version);
 795     computes.forEach(compute -> compositionEntityDataManager.addEntity(compute, null));
 796
 797     if (OnboardingMethod.Manual.name().equals(onboardingMethod)) {
 798       Collection<ImageEntity> images = imageDao.listByVsp(vspId, version);
 799       images.forEach(image -> compositionEntityDataManager.addEntity(image, null));
 800     }
 801
 802     Map<CompositionEntityId, Collection<String>> errorsByEntityId =
 803         compositionEntityDataManager.validateEntitiesQuestionnaire();
 804     if (MapUtils.isNotEmpty(errorsByEntityId)) {
 805       compositionEntityDataManager.buildTrees();
 806       compositionEntityDataManager.addErrorsToTrees(errorsByEntityId);
 807       return new QuestionnaireValidationResult(
 808           compositionEntityDataManager.getAllErrorsByVsp(vspId));
 809     }
 810     return null;
 811   }
 812
 813   @Override
 814   public File getInformationArtifact(String vspId, Version version) {
 815     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 816
 817     if (vspDetails == null) {
 818       return null;
 819     }
 820
 821     String vspName = vspDetails.getName();
 822     ByteBuffer infoArtifactAsByteBuffer;
 823     File infoArtifactFile;
 824     try {
 825       infoArtifactAsByteBuffer = ByteBuffer.wrap(informationArtifactGenerator.generate(vspId,
 826           version).getBytes());
 827
 828       infoArtifactFile =
 829           new File(
 830               String.format(VendorSoftwareProductConstants.INFORMATION_ARTIFACT_NAME, vspName));
 831       try (OutputStream out = new BufferedOutputStream(new FileOutputStream(infoArtifactFile))) {
 832         out.write(infoArtifactAsByteBuffer.array());
 833       }
 834
 835     } catch (IOException ex) {
 836       throw new CoreException(new InformationArtifactCreationErrorBuilder(vspId).build(), ex);
 837     }
 838     return infoArtifactFile;
 839   }
 840
 841   String getVspQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 842     return SchemaGenerator
 843         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
 844   }
 845
 846   @Override
 847   public Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException {
 848
 849     OrchestrationTemplateEntity orchestrationTemplateEntity =
 850         orchestrationTemplateDao.get(vspId, version);
 851
 852     if (isOrchestrationTemplateMissing(orchestrationTemplateEntity)) {
 853       return Optional.empty();
 854     }
 855
 856     if (CommonUtil.isFileOriginFromZip(orchestrationTemplateEntity.getFileSuffix())) {
 857       return Optional.of(new ImmutablePair<>(OnboardingTypesEnum.ZIP.toString(), candidateService
 858           .getZipData(orchestrationTemplateEntity.getContentData())));
 859     }
 860     return Optional.of(new ImmutablePair<>(orchestrationTemplateEntity.getFileSuffix(),
 861         orchestrationTemplateEntity.getContentData().array()));
 862   }
 863
 864   void updateUniqueName(String oldVspName, String newVspName) {
 865     uniqueValueUtil.updateUniqueValue(
 866         VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME,
 867         oldVspName, newVspName);
 868   }
 869
 870   @Override
 871   public Collection<ComputeEntity> getComputeByVsp(String vspId, Version version) {
 872     return computeDao.listByVsp(vspId, version);
 873   }
 874
 875   private boolean isOrchestrationTemplateMissing(
 876       OrchestrationTemplateEntity orchestrationTemplate) {
 877     return orchestrationTemplate == null
 878         || orchestrationTemplate.getContentData() == null
 879         || orchestrationTemplate.getFileSuffix() == null
 880         || orchestrationTemplate.getFileName() == null;
 881   }
 882
 883   private boolean isServiceModelMissing(ToscaServiceModel serviceModel) {
 884     return serviceModel == null || serviceModel.getEntryDefinitionServiceTemplate() == null;
 885   }
 886
 887   public static class Builder{
 888     private VspMergeDao vspMergeDao;
 889     private OrchestrationTemplateDao orchestrationTemplateDao;
 890     private OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager;
 891     private VendorSoftwareProductInfoDao vspInfoDao;
 892     private VendorLicenseFacade vendorLicenseFacade;
 893     private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
 894     private EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
 895     private VendorLicenseArtifactsService licenseArtifactsService;
 896     private InformationArtifactGenerator informationArtifactGenerator;
 897     private PackageInfoDao packageInfoDao;
 898     private DeploymentFlavorDao deploymentFlavorDao;
 899     private ComponentDao componentDao;
 900     private ComponentDependencyModelDao componentDependencyModelDao;
 901     private NicDao nicDao;
 902     private ComputeDao computeDao;
 903     private ImageDao imageDao;
 904     private ManualVspToscaManager manualVspToscaManager;
 905     private UniqueValueDao uniqueValueDao;
 906     private CandidateService candidateService;
 907
 908     public Builder vspMerge(VspMergeDao vspMergeDao){
 909       this.vspMergeDao = vspMergeDao;
 910       return this;
 911     }
 912
 913     public Builder orchestrationTemplate(OrchestrationTemplateDao orchestrationTemplateDao) {
 914       this.orchestrationTemplateDao = orchestrationTemplateDao;
 915       return this;
 916     }
 917
 918     public Builder orchestrationTemplateCandidateManager(OrchestrationTemplateCandidateManager orchestrationTemplateCandidateManager) {
 919       this.orchestrationTemplateCandidateManager = orchestrationTemplateCandidateManager;
 920       return this;
 921     }
 922
 923     public Builder vspInfo(VendorSoftwareProductInfoDao vspInfoDao) {
 924       this.vspInfoDao = vspInfoDao;
 925       return this;
 926     }
 927
 928     public Builder vendorLicenseFacade(VendorLicenseFacade vendorLicenseFacade) {
 929       this.vendorLicenseFacade = vendorLicenseFacade;
 930       return this;
 931     }
 932
 933     public Builder serviceModel(ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao) {
 934       this.serviceModelDao = serviceModelDao;
 935       return this;
 936     }
 937
 938     public Builder enrichedServiceModel(EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao) {
 939       this.enrichedServiceModelDao = enrichedServiceModelDao;
 940       return this;
 941     }
 942
 943     public Builder licenseArtifactsService(VendorLicenseArtifactsService licenseArtifactsService) {
 944       this.licenseArtifactsService = licenseArtifactsService;
 945       return this;
 946     }
 947
 948     public Builder informationArtifactGenerator(InformationArtifactGenerator informationArtifactGenerator) {
 949       this.informationArtifactGenerator = informationArtifactGenerator;
 950       return this;
 951     }
 952
 953     public Builder packageInfo(PackageInfoDao packageInfoDao) {
 954       this.packageInfoDao = packageInfoDao;
 955       return this;
 956     }
 957
 958     public Builder deploymentFlavor(DeploymentFlavorDao deploymentFlavorDao) {
 959       this.deploymentFlavorDao = deploymentFlavorDao;
 960       return this;
 961     }
 962
 963     public Builder component(ComponentDao componentDao) {
 964       this.componentDao = componentDao;
 965       return this;
 966     }
 967
 968     public Builder componentDependencyModel(ComponentDependencyModelDao componentDependencyModelDao) {
 969       this.componentDependencyModelDao = componentDependencyModelDao;
 970       return this;
 971     }
 972
 973     public Builder nic(NicDao nicDao) {
 974       this.nicDao = nicDao;
 975       return this;
 976     }
 977
 978     public Builder compute(ComputeDao computeDao) {
 979       this.computeDao = computeDao;
 980       return this;
 981     }
 982
 983     public Builder image(ImageDao imageDao) {
 984       this.imageDao = imageDao;
 985       return this;
 986     }
 987
 988     public Builder manualVspToscaManager(ManualVspToscaManager manualVspToscaManager) {
 989       this.manualVspToscaManager = manualVspToscaManager;
 990       return this;
 991     }
 992
 993     public Builder uniqueValue(UniqueValueDao uniqueValueDao) {
 994       this.uniqueValueDao = uniqueValueDao;
 995       return this;
 996     }
 997
 998     public Builder candidateService(CandidateService candidateService) {
 999       this.candidateService = candidateService;
1000       return this;
1001     }
1002
1003     private void registerToVersioning() {
1004       if(serviceModelDao != null) {
1005         serviceModelDao.registerVersioning(
1006                 VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
1007       }
1008       if(enrichedServiceModelDao != null) {
1009         enrichedServiceModelDao.registerVersioning(
1010                 VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
1011       }
1012     }
1013
1014     public VendorSoftwareProductManager build(){
1015       VendorSoftwareProductManagerImpl vendorSoftwareProductManager = new VendorSoftwareProductManagerImpl();
1016       vendorSoftwareProductManager.vspMergeDao = this.vspMergeDao;
1017       vendorSoftwareProductManager.orchestrationTemplateDao = this.orchestrationTemplateDao;
1018       vendorSoftwareProductManager.orchestrationTemplateCandidateManager = this.orchestrationTemplateCandidateManager;
1019       vendorSoftwareProductManager.vspInfoDao = this.vspInfoDao;
1020       vendorSoftwareProductManager.vendorLicenseFacade = this.vendorLicenseFacade;
1021       vendorSoftwareProductManager.serviceModelDao = this.serviceModelDao;
1022       vendorSoftwareProductManager.enrichedServiceModelDao = this.enrichedServiceModelDao;
1023       vendorSoftwareProductManager.licenseArtifactsService = this.licenseArtifactsService;
1024       vendorSoftwareProductManager.informationArtifactGenerator = this.informationArtifactGenerator;
1025       vendorSoftwareProductManager.packageInfoDao = this.packageInfoDao;
1026       vendorSoftwareProductManager.deploymentFlavorDao = this.deploymentFlavorDao;
1027       vendorSoftwareProductManager.componentDao = this.componentDao;
1028       vendorSoftwareProductManager.componentDependencyModelDao = this.componentDependencyModelDao;
1029       vendorSoftwareProductManager.nicDao = this.nicDao;
1030       vendorSoftwareProductManager.computeDao = this.computeDao;
1031       vendorSoftwareProductManager.imageDao = this.imageDao;
1032       vendorSoftwareProductManager.manualVspToscaManager = this.manualVspToscaManager;
1033       vendorSoftwareProductManager.uniqueValueUtil = new UniqueValueUtil(this.uniqueValueDao);
1034       vendorSoftwareProductManager.candidateService = candidateService;
1035       this.registerToVersioning();
1036       return vendorSoftwareProductManager;
1037     }
1038   }
1039
1040 }