gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 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 org.apache.commons.collections4.CollectionUtils;
  20 import org.apache.commons.collections4.MapUtils;
  21 import org.openecomp.core.enrichment.api.EnrichmentManager;
  22 import org.openecomp.core.enrichment.factory.EnrichmentManagerFactory;
  23 import org.openecomp.core.model.dao.EnrichedServiceModelDao;
  24 import org.openecomp.core.model.dao.ServiceModelDao;
  25 import org.openecomp.core.model.types.ServiceElement;
  26 import org.openecomp.core.util.UniqueValueUtil;
  27 import org.openecomp.core.utilities.file.FileContentHandler;
  28 import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
  29 import org.openecomp.core.utilities.json.JsonUtil;
  30 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
  31 import org.openecomp.core.validation.api.ValidationManager;
  32 import org.openecomp.core.validation.util.MessageContainerUtil;
  33 import org.openecomp.sdc.common.errors.CoreException;
  34 import org.openecomp.sdc.common.errors.ErrorCode;
  35 import org.openecomp.sdc.common.errors.ValidationErrorBuilder;
  36 import org.openecomp.sdc.common.utils.CommonUtil;
  37 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  38 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  39 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  40 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
  41 import org.openecomp.sdc.validation.util.ValidationManagerUtil;
  42 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
  43 import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsService;
  44 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  45 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManagerFactory;
  46 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
  47 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  48 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
  49 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  50 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
  51 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  52 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  53 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  54 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  55 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
  56 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDao;
  57 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  58 import org.openecomp.sdc.vendorsoftwareproduct.dao.errors.VendorSoftwareProductNotFoundErrorBuilder;
  59 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
  60 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  61 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  62 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  63 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  64 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  65 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
  66 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
  67 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
  68 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  69 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspQuestionnaireEntity;
  70 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
  71 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentErrorBuilder;
  72 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
  73 import org.openecomp.sdc.vendorsoftwareproduct.errors.FileCreationErrorBuilder;
  74 import org.openecomp.sdc.vendorsoftwareproduct.errors.InformationArtifactCreationErrorBuilder;
  75 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
  76 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageInvalidErrorBuilder;
  77 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageNotFoundErrorBuilder;
  78 import org.openecomp.sdc.vendorsoftwareproduct.errors.TranslationFileCreationErrorBuilder;
  79 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductInvalidErrorBuilder;
  80 import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactGenerator;
  81 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  82 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  83 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireValidationResult;
  84 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
  85 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  86 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityId;
  87 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  88 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  89 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  90 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  91 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  92 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQuestionnaireSchemaInput;
  93 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  94 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  95 import org.openecomp.sdc.vendorsoftwareproduct.utils.ComponentDependencyTracker;
  96 import org.openecomp.sdc.versioning.VersioningManager;
  97 import org.openecomp.sdc.versioning.VersioningManagerFactory;
  98 import org.openecomp.sdc.versioning.VersioningUtil;
  99 import org.openecomp.sdc.versioning.dao.types.Version;
 100
 101 import java.io.BufferedOutputStream;
 102 import java.io.ByteArrayInputStream;
 103 import java.io.ByteArrayOutputStream;
 104 import java.io.File;
 105 import java.io.FileOutputStream;
 106 import java.io.IOException;
 107 import java.io.OutputStream;
 108 import java.nio.ByteBuffer;
 109 import java.util.ArrayList;
 110 import java.util.Collection;
 111 import java.util.Collections;
 112 import java.util.HashMap;
 113 import java.util.HashSet;
 114 import java.util.List;
 115 import java.util.Map;
 116 import java.util.Objects;
 117 import java.util.Set;
 118 import java.util.zip.ZipInputStream;
 119 import java.util.zip.ZipOutputStream;
 120
 121 public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductManager {
 122
 123   private final OrchestrationTemplateDao orchestrationTemplateDao;
 124   private final VendorSoftwareProductInfoDao vspInfoDao;
 125   private final VendorLicenseFacade vendorLicenseFacade;
 126   private final ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
 127   private final EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
 128   private final VendorLicenseArtifactsService licenseArtifactsService;
 129   private final InformationArtifactGenerator informationArtifactGenerator;
 130   private final PackageInfoDao packageInfoDao;
 131   private final DeploymentFlavorDao deploymentFlavorDao;
 132   private final ComponentDao componentDao;
 133   private final ComponentDependencyModelDao componentDependencyModelDao;
 134   private final NicDao nicDao;
 135   private final ComputeDao computeDao;
 136   private final ImageDao imageDao;
 137   private final ManualVspToscaManager manualVspToscaManager;
 138
 139   public VendorSoftwareProductManagerImpl(
 140           OrchestrationTemplateDao orchestrationTemplateDataDao,
 141           VendorSoftwareProductInfoDao vspInfoDao,
 142           VendorLicenseFacade vendorLicenseFacade,
 143           ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao,
 144           EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao,
 145           VendorLicenseArtifactsService licenseArtifactsService,
 146           InformationArtifactGenerator informationArtifactGenerator,
 147           PackageInfoDao packageInfoDao,
 148           DeploymentFlavorDao deploymentFlavorDao,
 149           ComponentDao componentDao,
 150           ComponentDependencyModelDao componentDependencyModelDao,
 151           NicDao nicDao,
 152           ComputeDao computeDao,
 153           ImageDao imageDao,
 154           ManualVspToscaManager manualVspToscaManager) {
 155     this.orchestrationTemplateDao = orchestrationTemplateDataDao;
 156     this.vspInfoDao = vspInfoDao;
 157     this.vendorLicenseFacade = vendorLicenseFacade;
 158     this.serviceModelDao = serviceModelDao;
 159     this.enrichedServiceModelDao = enrichedServiceModelDao;
 160     this.licenseArtifactsService = licenseArtifactsService;
 161     this.informationArtifactGenerator = informationArtifactGenerator;
 162     this.packageInfoDao = packageInfoDao;
 163     this.deploymentFlavorDao = deploymentFlavorDao;
 164     this.componentDao = componentDao;
 165     this.componentDependencyModelDao = componentDependencyModelDao;
 166     this.nicDao = nicDao;
 167     this.computeDao = computeDao;
 168     this.imageDao = imageDao;
 169     this.manualVspToscaManager = manualVspToscaManager;
 170
 171     registerToVersioning();
 172   }
 173   private void registerToVersioning() {
 174     serviceModelDao.registerVersioning(
 175         VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
 176     enrichedServiceModelDao.registerVersioning(
 177         VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
 178   }
 179
 180
 181   @Override
 182   public ValidationResponse validate(String vspId, Version version) throws IOException {
 183     VspDetails vspDetails = getValidatedVsp(vspId, version);
 184     Collection<ComponentDependencyModelEntity> componentDependencies =
 185         componentDependencyModelDao.list(new ComponentDependencyModelEntity(vspId, version, null));
 186
 187     ValidationResponse validationResponse = new ValidationResponse();
 188     validationResponse.setQuestionnaireValidationResult(
 189         validateQuestionnaire(vspDetails.getId(), vspDetails.getVersion(),
 190             vspDetails.getOnboardingMethod()));
 191
 192     List<ErrorCode> vspErrors = new ArrayList<>(validateVspFields(vspDetails));
 193     if (validateComponentDependencies(componentDependencies)) {
 194       vspErrors
 195           .add(ComponentDependencyModelErrorBuilder.getcyclicDependencyComponentErrorBuilder());
 196     }
 197     if (Objects.nonNull(vspDetails.getOnboardingMethod()) &&
 198         OnboardingMethod.Manual.name().equals(vspDetails.getOnboardingMethod())) {
 199       validateManualOnboardingMethod(vspDetails, validationResponse, vspErrors);
 200     } else {
 201       if (vspDetails.getVlmVersion() != null || vspDetails.getLicenseAgreement() != null
 202           || vspDetails.getFeatureGroups() != null) {
 203         vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
 204       }
 205       OrchestrationTemplateEntity orchestrationTemplate =
 206           orchestrationTemplateDao.get(vspId, version);
 207       ToscaServiceModel serviceModel =
 208           serviceModelDao.getServiceModel(vspId, vspDetails.getVersion());
 209       if (!isOrchestrationTemplateExist(orchestrationTemplate) ||
 210           !isServiceModelExist(serviceModel)) {
 211         vspErrors.add(VendorSoftwareProductInvalidErrorBuilder
 212             .vendorSoftwareProductMissingServiceModelErrorBuilder(vspDetails.getId(),
 213                 vspDetails.getVersion()));
 214       }
 215       validationResponse.setUploadDataErrors(validateOrchestrationTemplate(orchestrationTemplate));
 216     }
 217     validationResponse
 218         .setVspErrors(vspErrors);
 219     validationResponse.setLicensingDataErrors(validateLicensingData(vspDetails));
 220     return validationResponse;
 221   }
 222
 223   private void validateManualOnboardingMethod(VspDetails vspDetails,
 224                                               ValidationResponse validationResponse,
 225                                               List<ErrorCode> vspErrors) {
 226     vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
 227
 228     Collection<DeploymentFlavorEntity> deploymentFlavors = deploymentFlavorDao
 229         .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails.getVersion(), null));
 230     if (CollectionUtils.isEmpty(deploymentFlavors)) {
 231       vspErrors
 232           .add(VendorSoftwareProductInvalidErrorBuilder.vspMissingDeploymentFlavorErrorBuilder());
 233     }
 234     vspErrors.addAll(validateDeploymentFlavors(deploymentFlavors));
 235
 236     Set<CompositionEntityValidationData> componentValidationResult =
 237         componentValidation(vspDetails.getId(), vspDetails.getVersion());
 238     if (!CollectionUtils.isEmpty(componentValidationResult)) {
 239       if (validationResponse.getQuestionnaireValidationResult() == null ||
 240           validationResponse.getQuestionnaireValidationResult().getValidationData() == null) {
 241         validationResponse.setQuestionnaireValidationResult(
 242             new QuestionnaireValidationResult(componentValidationResult));
 243       } else {
 244         validationResponse.getQuestionnaireValidationResult().getValidationData()
 245             .addAll(componentValidationResult);
 246       }
 247     }
 248   }
 249
 250   @Override
 251   public Map<String, List<ErrorMessage>> compile(String vspId, Version version) {
 252     ToscaServiceModel serviceModel =
 253         OnboardingMethod.Manual.name().equals(getValidatedVsp(vspId, version).getOnboardingMethod())
 254             //Generate Tosca service model for Manual Onboarding flow
 255             ? manualVspToscaManager
 256             .generateToscaModel(manualVspToscaManager.gatherVspInformation(vspId, version))
 257             : serviceModelDao.getServiceModel(vspId, version);
 258
 259       return compile(vspId, version, serviceModel);
 260   }
 261
 262   private boolean validateComponentDependencies(
 263       Collection<ComponentDependencyModelEntity> componentDependencies) {
 264     ComponentDependencyTracker dependencyTracker = new ComponentDependencyTracker();
 265
 266     for (ComponentDependencyModelEntity componentDependency : componentDependencies) {
 267       dependencyTracker.addDependency(componentDependency.getSourceComponentId(),
 268           componentDependency.getTargetComponentId());
 269     }
 270     return dependencyTracker.isCyclicDependencyPresent();
 271   }
 272
 273   private Collection<ErrorCode> validateDeploymentFlavors(
 274       Collection<DeploymentFlavorEntity> deploymentFlavors) {
 275
 276     Collection<ErrorCode> errorCodeList = new ArrayList<>();
 277     if (!CollectionUtils.isEmpty(deploymentFlavors)) {
 278       deploymentFlavors.forEach(deploymentFlavor -> {
 279         DeploymentFlavorEntity deployment = deploymentFlavorDao.get(deploymentFlavor);
 280         DeploymentFlavor deploymentlocalFlavor = deployment.getDeploymentFlavorCompositionData();
 281         if (deploymentlocalFlavor != null) {
 282           if (deploymentlocalFlavor.getFeatureGroupId() == null) {
 283             ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder.
 284                 getFeatureGroupMandatoryErrorBuilder(deploymentlocalFlavor.getModel());
 285             errorCodeList.add(deploymentFlavorErrorBuilder);
 286           }
 287           validateComponetComputeAssociations(errorCodeList, deploymentFlavor,
 288                   deployment, deploymentlocalFlavor);
 289         }
 290       });
 291     }
 292     return errorCodeList;
 293   }
 294
 295   private void validateComponetComputeAssociations(Collection<ErrorCode> errorCodeList,
 296                                                    DeploymentFlavorEntity deploymentFlavor,
 297                                                    DeploymentFlavorEntity deployment,
 298                                                    DeploymentFlavor deploymentlocalFlavor) {
 299     List<ComponentComputeAssociation> componetComputeAssociations =
 300         deploymentlocalFlavor.getComponentComputeAssociations();
 301     if (CollectionUtils.isEmpty(componetComputeAssociations)) {
 302       CompositionEntityValidationData compositionEntityValidationData = new
 303           CompositionEntityValidationData(CompositionEntityType.deployment, deploymentFlavor
 304           .getId());
 305       compositionEntityValidationData.setEntityName(deployment
 306           .getDeploymentFlavorCompositionData().getModel());
 307       ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 308           .getInvalidComponentComputeAssociationErrorBuilder(
 309               deploymentlocalFlavor.getModel());
 310
 311       errorCodeList.add(deploymentFlavorErrorBuilder);
 312     } else {
 313       componetComputeAssociations.forEach(componetComputeAssociation -> {
 314         if (componetComputeAssociation == null
 315             || !(componetComputeAssociation.getComponentId() != null
 316             && componetComputeAssociation.getComputeFlavorId() != null)) {
 317           CompositionEntityValidationData compositionEntityValidationData = new
 318               CompositionEntityValidationData(CompositionEntityType.deployment,
 319               deploymentFlavor.getId());
 320           compositionEntityValidationData.setEntityName(deployment
 321               .getDeploymentFlavorCompositionData().getModel());
 322           ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 323               .getInvalidComponentComputeAssociationErrorBuilder(
 324                   deploymentlocalFlavor.getModel());
 325
 326           errorCodeList.add(deploymentFlavorErrorBuilder);
 327         }
 328       });
 329     }
 330   }
 331
 332   private Set<CompositionEntityValidationData> componentValidation(String vspId, Version version) {
 333     Set<CompositionEntityValidationData> validationData = new HashSet<>();
 334     Collection<ComponentEntity> components =
 335         componentDao.list(new ComponentEntity(vspId, version, null));
 336     if (!CollectionUtils.isEmpty(components)) {
 337       components.forEach(component -> {
 338         validateImage(vspId, version, validationData, component);
 339         validateNic(vspId, version, validationData, component);
 340
 341       });
 342     }
 343
 344     return validationData;
 345   }
 346
 347   private void validateNic(String vspId, Version version,
 348                            Set<CompositionEntityValidationData> validationData,
 349                            ComponentEntity component) {
 350     Collection<NicEntity> nics =
 351         nicDao.list(new NicEntity(vspId, version, component.getId(), null));
 352     if (CollectionUtils.isNotEmpty(nics)) {
 353       nics.forEach(nicEntity -> {
 354         NicEntity nic = nicDao.get(new NicEntity(vspId, version, component.getId(),
 355             nicEntity.getId()));
 356         NetworkType networkType = nic.getNicCompositionData().getNetworkType();
 357         String networkId = nic.getNicCompositionData().getNetworkId();
 358         if (networkType.equals(NetworkType.Internal) && networkId == null) {
 359           CompositionEntityValidationData compositionEntityValidationData = new
 360               CompositionEntityValidationData(CompositionEntityType.nic, nic.getId());
 361           compositionEntityValidationData.setEntityName(nic.getNicCompositionData().getName());
 362           ErrorCode nicInternalNetworkErrorBuilder = NicInternalNetworkErrorBuilder
 363               .getNicNullNetworkIdInternalNetworkIdErrorBuilder();
 364           List<String> errors = new ArrayList<>();
 365           errors.add(nicInternalNetworkErrorBuilder.message());
 366           compositionEntityValidationData.setErrors(errors);
 367           validationData.add(compositionEntityValidationData);
 368         }
 369       });
 370     }
 371   }
 372
 373   private void validateImage(String vspId, Version version,
 374                              Set<CompositionEntityValidationData> validationData,
 375                              ComponentEntity component) {
 376     Collection<ImageEntity> images =
 377         imageDao.list(new ImageEntity(vspId, version, component.getId(), null));
 378     if (CollectionUtils.isEmpty(images)) {
 379       CompositionEntityValidationData compositionEntityValidationData = new
 380           CompositionEntityValidationData(component.getType(), component.getId());
 381       compositionEntityValidationData
 382           .setEntityName(component.getComponentCompositionData().getDisplayName());
 383       ErrorCode vfcMissingImageErrorBuilder =
 384           ComponentErrorBuilder.vfcMissingImageErrorBuilder();
 385       List<String> errors = new ArrayList<>();
 386       errors.add(vfcMissingImageErrorBuilder.message());
 387       compositionEntityValidationData.setErrors(errors);
 388       validationData.add(compositionEntityValidationData);
 389     }
 390   }
 391
 392   private List<ErrorCode> validateVspFields(VspDetails vspDetails) {
 393     List<ErrorCode> errors = new ArrayList<>();
 394
 395     if (vspDetails.getName() == null) {
 396       errors.add(createMissingMandatoryFieldError("name"));
 397     }
 398     if (vspDetails.getDescription() == null) {
 399       errors.add(createMissingMandatoryFieldError("description"));
 400     }
 401     if (vspDetails.getVendorId() == null) {
 402       errors.add(createMissingMandatoryFieldError("vendor Id"));
 403     }
 404     if (vspDetails.getCategory() == null) {
 405       errors.add(createMissingMandatoryFieldError("category"));
 406     }
 407     if (vspDetails.getSubCategory() == null) {
 408       errors.add(createMissingMandatoryFieldError("sub category"));
 409     }
 410     return errors;
 411   }
 412
 413   private List<ErrorCode> validateMandatoryLicenseFields(VspDetails vspDetails) {
 414     List<ErrorCode> errors = new ArrayList<>();
 415     if (vspDetails.getVlmVersion() == null) {
 416       errors.add(createMissingMandatoryFieldError("licensing version"));
 417     }
 418     if (vspDetails.getLicenseAgreement() == null) {
 419       errors.add(createMissingMandatoryFieldError("license agreement"));
 420     }
 421     if (CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
 422       errors.add(createMissingMandatoryFieldError("feature groups"));
 423     }
 424     return errors;
 425   }
 426
 427   private static ErrorCode createMissingMandatoryFieldError(String fieldName) {
 428     return new ValidationErrorBuilder("must be supplied", fieldName).build();
 429   }
 430
 431   private Map<String, List<ErrorMessage>> compile(String vendorSoftwareProductId, Version version,
 432                                                   ToscaServiceModel serviceModel) {
 433     if (!isServiceModelExist(serviceModel)) {
 434       return null;
 435     }
 436
 437     enrichedServiceModelDao.deleteAll(vendorSoftwareProductId, version);
 438
 439     EnrichmentManager<ToscaServiceModel> enrichmentManager =
 440         EnrichmentManagerFactory.getInstance().createInterface();
 441     enrichmentManager.init(vendorSoftwareProductId, version);
 442     enrichmentManager.setModel(serviceModel);
 443     Map<String, List<ErrorMessage>> enrichErrors = enrichmentManager.enrich();
 444
 445     enrichedServiceModelDao
 446         .storeServiceModel(vendorSoftwareProductId, version, enrichmentManager.getModel());
 447
 448     return enrichErrors;
 449   }
 450
 451   private Collection<ErrorCode> validateLicensingData(VspDetails vspDetails) {
 452     if (vspDetails.getVendorId() == null || vspDetails.getVlmVersion() == null
 453         || vspDetails.getLicenseAgreement() == null
 454         || CollectionUtils.isEmpty(vspDetails.getFeatureGroups())) {
 455       return Collections.emptyList();
 456     }
 457     return vendorLicenseFacade
 458         .validateLicensingData(vspDetails.getVendorId(), vspDetails.getVlmVersion(),
 459             vspDetails.getLicenseAgreement(), vspDetails.getFeatureGroups());
 460   }
 461
 462   @Override
 463   public VspDetails createVsp(VspDetails vspDetails) {
 464     vspInfoDao.create(vspDetails);
 465     vspInfoDao.updateQuestionnaireData(vspDetails.getId(), vspDetails.getVersion(),
 466         new JsonSchemaDataGenerator(getVspQuestionnaireSchema(null)).generateData());
 467     return vspDetails;
 468   }
 469
 470   @Override
 471   public void updateVsp(VspDetails vspDetails) {
 472     VspDetails retrieved = vspInfoDao.get(vspDetails);
 473     // TODO: 6/21/2017 remove this validation when validation will be added in the REST level
 474     if (retrieved == null) {
 475       throw new RuntimeException(String.format("Vsp with id %s and version %s does not exist.",
 476           vspDetails.getId(), vspDetails.getVersion().getId()));
 477     }
 478     vspDetails.setOnboardingMethod(retrieved.getOnboardingMethod());
 479
 480     //If any existing feature group is removed from VSP which is also associated in DF then
 481     //update DF to remove feature group associations.
 482     updateDeploymentFlavor(vspDetails);
 483
 484     updateUniqueName(retrieved.getName(), vspDetails.getName());
 485     vspInfoDao.update(vspDetails);
 486   }
 487
 488   private void updateDeploymentFlavor(VspDetails vspDetails) {
 489     final List<String> featureGroups = vspDetails.getFeatureGroups();
 490     if (featureGroups != null) {
 491       final Collection<DeploymentFlavorEntity> deploymentFlavorEntities = deploymentFlavorDao
 492           .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails
 493               .getVersion(), null));
 494       if (Objects.nonNull(deploymentFlavorEntities)) {
 495         for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 496           updateDeploymentFlavourEntity(featureGroups, deploymentFlavorEntity);
 497         }
 498       }
 499     }
 500   }
 501
 502   private void updateDeploymentFlavourEntity(List<String> featureGroups,
 503                                              DeploymentFlavorEntity deploymentFlavorEntity) {
 504     final String featureGroupId =
 505         deploymentFlavorEntity.getDeploymentFlavorCompositionData().getFeatureGroupId();
 506     if (!featureGroups.contains(featureGroupId)) {
 507       DeploymentFlavor deploymentFlavorCompositionData =
 508           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 509       deploymentFlavorCompositionData.setFeatureGroupId(null);
 510       deploymentFlavorEntity.setDeploymentFlavorCompositionData
 511           (deploymentFlavorCompositionData);
 512       deploymentFlavorDao.update(deploymentFlavorEntity);
 513     }
 514   }
 515
 516
 517   @Override
 518   public VspDetails getVsp(String vspId, Version version) {
 519       return getValidatedVsp(vspId, version);
 520   }
 521
 522   private VspDetails getValidatedVsp(String vspId, Version version) {
 523     VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
 524     if (vsp == null) {
 525       throw new CoreException(new VendorSoftwareProductNotFoundErrorBuilder(vspId).build());
 526     }
 527     return vsp;
 528   }
 529
 530   @Override
 531   public void deleteVsp(String vspId) {
 532     throw new UnsupportedOperationException(
 533         VendorSoftwareProductConstants.UNSUPPORTED_OPERATION_ERROR);
 534   }
 535
 536   @Override
 537   public List<PackageInfo> listPackages(String category, String subCategory) {
 538     return packageInfoDao.listByCategory(category, subCategory);
 539   }
 540
 541   @Override
 542   public File getTranslatedFile(String vspId, Version version) {
 543     PackageInfo packageInfo = packageInfoDao.get(new PackageInfo(vspId, version));
 544     if (packageInfo == null) {
 545       throw new CoreException(new PackageNotFoundErrorBuilder(vspId, version).build());
 546     }
 547
 548     ByteBuffer translatedFileBuffer = packageInfo.getTranslatedFile();
 549     if (translatedFileBuffer == null) {
 550       throw new CoreException(new PackageInvalidErrorBuilder(vspId, version).build());
 551     }
 552
 553     File translatedFile = new File(VendorSoftwareProductConstants.VSP_PACKAGE_ZIP);
 554
 555     try (FileOutputStream fos = new FileOutputStream(translatedFile)) {
 556       fos.write(translatedFileBuffer.array());
 557     } catch (IOException exception) {
 558       throw new CoreException(new TranslationFileCreationErrorBuilder(vspId, version).build(),
 559           exception);
 560     }
 561     return translatedFile;
 562   }
 563
 564   @Override
 565
 566   public byte[] getOrchestrationTemplateFile(String vspId, Version version) {
 567     OrchestrationTemplateEntity uploadData = orchestrationTemplateDao.get(vspId, version);
 568     ByteBuffer contentData = uploadData.getContentData();
 569     if (contentData == null) {
 570       return null;
 571     }
 572
 573     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 574
 575     try (final ZipOutputStream zos = new ZipOutputStream(baos);
 576          ZipInputStream ignored = new ZipInputStream(
 577              new ByteArrayInputStream(contentData.array()))) {
 578       zos.write(contentData.array());
 579     } catch (IOException exception) {
 580       throw new CoreException(new FileCreationErrorBuilder(vspId).build(), exception);
 581     }
 582     return baos.toByteArray();
 583   }
 584
 585   @Override
 586   public OrchestrationTemplateEntity getOrchestrationTemplateInfo(String vspId, Version version) {
 587     return orchestrationTemplateDao.getInfo(vspId, version);
 588   }
 589
 590   @Override
 591   public PackageInfo createPackage(String vspId, Version version) {
 592     ToscaServiceModel toscaServiceModel = enrichedServiceModelDao.getServiceModel(vspId, version);
 593     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 594     Version vlmVersion = vspDetails.getVlmVersion();
 595     if (vlmVersion != null) {
 596       populateVersionsForVlm(vspDetails.getVendorId(), vlmVersion);
 597     }
 598     PackageInfo packageInfo = createPackageInfo(vspDetails);
 599
 600     ToscaFileOutputServiceCsarImpl toscaServiceTemplateServiceCsar =
 601         new ToscaFileOutputServiceCsarImpl();
 602     FileContentHandler licenseArtifacts = licenseArtifactsService
 603         .createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion,
 604             vspDetails.getFeatureGroups());
 605     //todo add tosca validation here
 606     packageInfo.setTranslatedFile(ByteBuffer.wrap(
 607         toscaServiceTemplateServiceCsar.createOutputFile(toscaServiceModel, licenseArtifacts)));
 608
 609     packageInfoDao.create(packageInfo);
 610     return packageInfo;
 611   }
 612
 613   protected void populateVersionsForVlm(String vlmId, Version vlmVersion) {
 614     VersioningManager versioningManager = VersioningManagerFactory.getInstance().createInterface();
 615     versioningManager.list(vlmId).stream()
 616         .filter(version -> version.getId().equalsIgnoreCase(vlmVersion.getId()))
 617         .findAny()
 618         .ifPresent(version -> {
 619           vlmVersion.setMinor(version.getMinor());
 620           vlmVersion.setMajor(version.getMajor());
 621         });
 622   }
 623
 624   private PackageInfo createPackageInfo(VspDetails vspDetails) {
 625     PackageInfo packageInfo = new PackageInfo(vspDetails.getId(), vspDetails.getVersion());
 626     packageInfo.setVspName(vspDetails.getName());
 627     packageInfo.setVspDescription(vspDetails.getDescription());
 628     packageInfo.setCategory(vspDetails.getCategory());
 629     packageInfo.setSubCategory(vspDetails.getSubCategory());
 630     packageInfo.setVendorName(vspDetails.getVendorName());
 631     packageInfo.setPackageType(VendorSoftwareProductConstants.CSAR);
 632     packageInfo.setVendorRelease("1.0"); //todo TBD
 633     return packageInfo;
 634   }
 635
 636   @Override
 637
 638   public QuestionnaireResponse getVspQuestionnaire(String vspId, Version version) {
 639     VspQuestionnaireEntity retrieved = vspInfoDao.getQuestionnaire(vspId, version);
 640     VersioningUtil.validateEntityExistence(retrieved, new VspQuestionnaireEntity(vspId, version),
 641         VspDetails.ENTITY_TYPE);
 642
 643     String questionnaireData = retrieved.getQuestionnaireData();
 644
 645     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 646     questionnaireResponse.setData(questionnaireData);
 647     questionnaireResponse.setSchema(getVspQuestionnaireSchema(null));
 648     return questionnaireResponse;
 649   }
 650
 651   @Override
 652   public void updateVspQuestionnaire(String vspId, Version version, String questionnaireData) {
 653     vspInfoDao.updateQuestionnaireData(vspId, version, questionnaireData);
 654   }
 655
 656
 657   private Map<String, List<ErrorMessage>> validateOrchestrationTemplate(
 658       OrchestrationTemplateEntity orchestrationTemplate) throws IOException {
 659
 660     if (!isOrchestrationTemplateExist(orchestrationTemplate)) {
 661       return null;
 662     }
 663     Map<String, List<ErrorMessage>> validationErrors = new HashMap<>();
 664
 665     FileContentHandler fileContentMap = CommonUtil.validateAndUploadFileContent(
 666         OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplate.getFileSuffix()),
 667         orchestrationTemplate.getContentData().array());
 668
 669     if (CommonUtil.isFileOriginFromZip(orchestrationTemplate.getFileSuffix())) {
 670       ValidationManager validationManager =
 671           ValidationManagerUtil.initValidationManager(fileContentMap);
 672       validationErrors.putAll(validationManager.validate());
 673     }
 674
 675     return
 676         MapUtils.isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, validationErrors))
 677             ? null : validationErrors;
 678   }
 679
 680   private QuestionnaireValidationResult validateQuestionnaire(String vspId, Version version,
 681                                                               String onboardingMethod) {
 682     // The apis of CompositionEntityDataManager used here are stateful!
 683     // so, it must be re-created from scratch when it is used!
 684     CompositionEntityDataManager compositionEntityDataManager =
 685         CompositionEntityDataManagerFactory.getInstance().createInterface();
 686     compositionEntityDataManager
 687         .addEntity(vspInfoDao.getQuestionnaire(vspId, version), null);
 688
 689     Collection<NicEntity> nics = nicDao.listByVsp(vspId, version);
 690
 691     Map<String, List<String>> nicNamesByComponent = new HashMap<>();
 692     for (NicEntity nicEntity : nics) {
 693       compositionEntityDataManager.addEntity(nicEntity, null);
 694
 695       Nic nic = nicEntity.getNicCompositionData();
 696       if (nic != null && nic.getName() != null) {
 697         List<String> nicNames =
 698             nicNamesByComponent.computeIfAbsent(nicEntity.getComponentId(), k -> new ArrayList<>());
 699         nicNames.add(nic.getName());
 700       }
 701     }
 702
 703     Collection<ComponentEntity> components =
 704         componentDao.listCompositionAndQuestionnaire(vspId, version);
 705     components.forEach(component -> compositionEntityDataManager.addEntity(component,
 706         new ComponentQuestionnaireSchemaInput(nicNamesByComponent.get(component.getId()),
 707             JsonUtil.json2Object(component.getQuestionnaireData(), Map.class))));
 708
 709     Collection<ComputeEntity> computes = computeDao.listByVsp(vspId, version);
 710     computes.forEach(compute -> compositionEntityDataManager.addEntity(compute, null));
 711
 712     if (OnboardingMethod.Manual.name().equals(onboardingMethod)) {
 713       Collection<ImageEntity> images = imageDao.listByVsp(vspId, version);
 714       images.forEach(image -> compositionEntityDataManager.addEntity(image, null));
 715     }
 716
 717     Map<CompositionEntityId, Collection<String>> errorsByEntityId =
 718         compositionEntityDataManager.validateEntitiesQuestionnaire();
 719     if (MapUtils.isNotEmpty(errorsByEntityId)) {
 720       compositionEntityDataManager.buildTrees();
 721       compositionEntityDataManager.addErrorsToTrees(errorsByEntityId);
 722       return new QuestionnaireValidationResult(
 723           compositionEntityDataManager.getAllErrorsByVsp(vspId));
 724     }
 725     return null;
 726   }
 727
 728   @Override
 729   public File getInformationArtifact(String vspId, Version version) {
 730     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 731
 732     if (vspDetails == null) {
 733       return null;
 734     }
 735
 736     String vspName = vspDetails.getName();
 737     ByteBuffer infoArtifactAsByteBuffer;
 738     File infoArtifactFile;
 739     try {
 740       infoArtifactAsByteBuffer = ByteBuffer.wrap(informationArtifactGenerator.generate(vspId,
 741           version).getBytes());
 742
 743       infoArtifactFile =
 744           new File(
 745               String.format(VendorSoftwareProductConstants.INFORMATION_ARTIFACT_NAME, vspName));
 746       try (OutputStream out = new BufferedOutputStream(new FileOutputStream(infoArtifactFile))) {
 747         out.write(infoArtifactAsByteBuffer.array());
 748       }
 749
 750     } catch (IOException ex) {
 751       throw new CoreException(new InformationArtifactCreationErrorBuilder(vspId).build(), ex);
 752     }
 753     return infoArtifactFile;
 754   }
 755
 756   String getVspQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 757     return SchemaGenerator
 758         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
 759   }
 760
 761   void updateUniqueName(String oldVspName, String newVspName) {
 762     UniqueValueUtil.updateUniqueValue(
 763         VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME,
 764         oldVspName, newVspName);
 765   }
 766
 767   @Override
 768   public Collection<ComputeEntity> getComputeByVsp(String vspId, Version version) {
 769     return computeDao.listByVsp(vspId, version);
 770   }
 771
 772   private boolean isOrchestrationTemplateExist(OrchestrationTemplateEntity orchestrationTemplate) {
 773     return orchestrationTemplate != null &&
 774         orchestrationTemplate.getContentData() != null &&
 775         orchestrationTemplate.getFileSuffix() != null &&
 776         orchestrationTemplate.getFileName() != null;
 777   }
 778
 779   private boolean isServiceModelExist(ToscaServiceModel serviceModel) {
 780     return serviceModel != null && serviceModel.getEntryDefinitionServiceTemplate() != null;
 781   }
 782
 783 }