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