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