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