openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImpl.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import org.apache.commons.collections4.CollectionUtils;
   4 import org.openecomp.sdc.common.errors.CoreException;
   5 import org.openecomp.sdc.common.errors.ErrorCode;
   6 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   7 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
   8 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
   9 import org.openecomp.sdc.logging.types.LoggerConstants;
  10 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  11 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  12 import org.openecomp.sdc.vendorsoftwareproduct.DeploymentFlavorManager;
  13 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  21 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
  22 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  23 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  24 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  25 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  26 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  27 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  28 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  29 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  30 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.DeploymentFlavorCompositionSchemaInput;
  31 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  32 import org.openecomp.sdc.versioning.VersioningUtil;
  33 import org.openecomp.sdc.versioning.dao.types.Version;
  34
  35 import java.util.ArrayList;
  36 import java.util.Collection;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40
  41 public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
  42
  43   private static final MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  44   private VendorSoftwareProductInfoDao vspInfoDao;
  45   private DeploymentFlavorDao deploymentFlavorDao;
  46   private CompositionEntityDataManager compositionEntityDataManager;
  47   private ComponentDao componentDao;
  48   private ComputeDao computeDao;
  49
  50   public DeploymentFlavorManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
  51                                      DeploymentFlavorDao deploymentFlavorDao,
  52                                      CompositionEntityDataManager compositionEntityDataManager,
  53                                      ComponentDao componentDao,
  54                                      ComputeDao computeDao) {
  55     this.vspInfoDao = vspInfoDao;
  56     this.deploymentFlavorDao = deploymentFlavorDao;
  57     this.compositionEntityDataManager = compositionEntityDataManager;
  58     this.componentDao = componentDao;
  59     this.computeDao = computeDao;
  60
  61   }
  62
  63   @Override
  64   public Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version) {
  65     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
  66     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
  67     return deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
  68   }
  69
  70   @Override
  71   public DeploymentFlavorEntity createDeploymentFlavor(
  72       DeploymentFlavorEntity deploymentFlavorEntity) {
  73     DeploymentFlavorEntity createDeploymentFlavor;
  74     mdcDataDebugMessage.debugEntryMessage("VSP id ", deploymentFlavorEntity.getVspId());
  75
  76     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
  77         deploymentFlavorEntity.getVersion())) {
  78       ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
  79           .getAddDeploymentNotSupportedHeatOnboardErrorBuilder();
  80       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
  81           LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
  82           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), deploymentFlavorErrorBuilder.message());
  83       throw new CoreException(deploymentFlavorErrorBuilder);
  84     } else {
  85       validateDeploymentFlavor(deploymentFlavorEntity, deploymentFlavorEntity.getVersion());
  86       createDeploymentFlavor =
  87           compositionEntityDataManager.createDeploymentFlavor(deploymentFlavorEntity);
  88     }
  89     return createDeploymentFlavor;
  90   }
  91
  92   private void validateDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity,
  93                                         Version version) {
  94     //Validation for unique model.
  95     Collection<DeploymentFlavorEntity> listDeploymentFlavors =
  96         listDeploymentFlavors(deploymentFlavorEntity.getVspId(),
  97             version);
  98     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
  99
 100     List<String> featureGroups =
 101         getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), version);
 102     String featureGroup = deploymentFlavorEntity.getDeploymentFlavorCompositionData()
 103         .getFeatureGroupId();
 104     if (featureGroup != null && featureGroup.trim().length() > 0) {
 105       if (isEmpty(featureGroups) || (!(validFeatureGroup(featureGroups, featureGroup)))) {
 106         ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 107             .getFeatureGroupNotexistErrorBuilder(featureGroup, deploymentFlavorEntity.getVspId(),
 108                 version);
 109         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 110             LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 111             LoggerErrorCode.DATA_ERROR.getErrorCode(), deploymentFlavorErrorBuilder.message());
 112         throw new CoreException(deploymentFlavorErrorBuilder);
 113       }
 114     }
 115
 116     validateComponentComputeAssociation(deploymentFlavorEntity, version);
 117   }
 118
 119   private void isDeploymentFlavorModelDuplicate(DeploymentFlavorEntity deploymentFlavorEntity,
 120                                                 Collection<DeploymentFlavorEntity> listDeploymentFlavors) {
 121     listDeploymentFlavors.forEach(deploymentFlavor -> {
 122       if (deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel().equalsIgnoreCase(
 123           deploymentFlavor.getDeploymentFlavorCompositionData().getModel())) {
 124         ErrorCode deploymentFlavorModelErrorBuilder = DeploymentFlavorErrorBuilder
 125             .getDuplicateDeploymentFlavorModelErrorBuilder(
 126                 deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel(),
 127                 deploymentFlavorEntity.getVspId());
 128         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 129             LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 130             LoggerErrorCode.DATA_ERROR.getErrorCode(), deploymentFlavorModelErrorBuilder.message());
 131         throw new CoreException(deploymentFlavorModelErrorBuilder);
 132       }
 133     });
 134   }
 135
 136   private List<String> getFeatureGroupListForVsp(String vspId, Version version) {
 137     final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 138     return vspDetails.getFeatureGroups();
 139   }
 140
 141   private boolean isEmpty(Collection coll) {
 142     return (coll == null || coll.isEmpty());
 143   }
 144
 145   private boolean validFeatureGroup(List<String> featureGroups, String featureGroupId) {
 146     Iterator<String> iterator = featureGroups.iterator();
 147     boolean valid = false;
 148     while (iterator.hasNext()) {
 149       String fgId = iterator.next().trim();
 150       if (fgId.equals(featureGroupId)) {
 151         valid = true;
 152         break;
 153       } else {
 154         valid = false;
 155       }
 156     }
 157     return valid;
 158   }
 159
 160   private void validateComponentComputeAssociation(DeploymentFlavorEntity deploymentFlavorEntity,
 161                                                    Version version) {
 162     List<ComponentComputeAssociation> componentComputeAssociationList = deploymentFlavorEntity
 163         .getDeploymentFlavorCompositionData().getComponentComputeAssociations();
 164     List<String> vfcList = new ArrayList<>();
 165     if (!isEmpty(componentComputeAssociationList)) {
 166       componentComputeAssociationList.forEach(componentComputeAssociation -> {
 167         if ((componentComputeAssociation.getComponentId() == null || componentComputeAssociation
 168             .getComponentId().trim().length() == 0) &&
 169             (componentComputeAssociation
 170                 .getComputeFlavorId() != null && componentComputeAssociation
 171                 .getComputeFlavorId().trim().length() > 0)) {
 172           ErrorCode invalidAssociationErrorBuilder = DeploymentFlavorErrorBuilder
 173               .getInvalidAssociationErrorBuilder();
 174           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 175               LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 176               LoggerErrorCode.DATA_ERROR.getErrorCode(), invalidAssociationErrorBuilder.message());
 177           throw new CoreException(invalidAssociationErrorBuilder);
 178         } else if (componentComputeAssociation.getComponentId() != null &&
 179             componentComputeAssociation.getComponentId().trim().length() > 0) {
 180           ComponentEntity component = getComponent(deploymentFlavorEntity.getVspId(), version,
 181               componentComputeAssociation.getComponentId());
 182           if (componentComputeAssociation
 183               .getComputeFlavorId() != null && componentComputeAssociation
 184               .getComputeFlavorId().trim().length() > 0) {
 185             ComputeEntity computeFlavor = computeDao.get(new ComputeEntity(deploymentFlavorEntity
 186                 .getVspId(), version, componentComputeAssociation.getComponentId(),
 187                 componentComputeAssociation.getComputeFlavorId()));
 188             if (computeFlavor == null) {
 189               ErrorCode invalidComputeIdErrorBuilder = DeploymentFlavorErrorBuilder
 190                   .getInvalidComputeIdErrorBuilder(componentComputeAssociation.getComputeFlavorId(),
 191                       componentComputeAssociation.getComponentId());
 192               MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 193                   LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 194                   LoggerErrorCode.DATA_ERROR.getErrorCode(),
 195                   invalidComputeIdErrorBuilder.message());
 196               throw new CoreException(invalidComputeIdErrorBuilder);
 197             }
 198           }
 199           vfcList.add(componentComputeAssociation.getComponentId());
 200         }
 201       });
 202       Map<String, Integer> frequencyMapping = CollectionUtils.getCardinalityMap(vfcList);
 203
 204       for (Integer vfcCount : frequencyMapping.values()) {
 205         if (vfcCount != 1) {
 206           ErrorCode duplicateVfcAssociationErrorBuilder = DeploymentFlavorErrorBuilder
 207               .getDuplicateVfcAssociationErrorBuilder();
 208           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 209               LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 210               LoggerErrorCode.DATA_ERROR.getErrorCode(),
 211               duplicateVfcAssociationErrorBuilder.message());
 212           throw new CoreException(duplicateVfcAssociationErrorBuilder);
 213         }
 214       }
 215     }
 216   }
 217
 218   private ComponentEntity getComponent(String vspId, Version version, String componentId) {
 219     ComponentEntity retrieved = componentDao.get(new ComponentEntity(vspId, version, componentId));
 220     VersioningUtil
 221         .validateEntityExistence(retrieved, new ComponentEntity(vspId, version, componentId),
 222             VspDetails.ENTITY_TYPE);
 223     return retrieved;
 224   }
 225
 226   @Override
 227   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavor(String vspId,
 228                                                                          Version version,
 229                                                                          String deploymentFlavorId) {
 230     mdcDataDebugMessage
 231         .debugEntryMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 232
 233     DeploymentFlavorEntity deploymentFlavorEntity =
 234         getValidatedDeploymentFlavor(vspId, version, deploymentFlavorId);
 235     DeploymentFlavor deploymentFlavor = deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 236     DeploymentFlavorCompositionSchemaInput schemaInput = new
 237         DeploymentFlavorCompositionSchemaInput();
 238     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 239     schemaInput.setDeploymentFlavor(deploymentFlavor);
 240     List<String> featureGroups =
 241         getFeatureGroupListForVsp(vspId, version);
 242     schemaInput.setFeatureGroupIds(featureGroups);
 243     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
 244     response.setId(deploymentFlavorId);
 245     response.setSchema((SchemaGenerator
 246         .generate(SchemaTemplateContext.composition, CompositionEntityType.deployment,
 247             schemaInput)));
 248     response.setData(deploymentFlavor);
 249     mdcDataDebugMessage
 250         .debugExitMessage("VSP id, deployment flavor id ", vspId, deploymentFlavorId);
 251
 252     return response;
 253   }
 254
 255   private DeploymentFlavorEntity getValidatedDeploymentFlavor(String vspId, Version version, String
 256       deploymentFlavorId) {
 257     DeploymentFlavorEntity retrieved = deploymentFlavorDao.get(new DeploymentFlavorEntity(vspId,
 258         version, deploymentFlavorId));
 259     VersioningUtil
 260         .validateEntityExistence(retrieved, new DeploymentFlavorEntity(vspId, version,
 261             deploymentFlavorId), VspDetails.ENTITY_TYPE);
 262     return retrieved;
 263   }
 264
 265   @Override
 266   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavorSchema(String vspId,
 267                                                                                Version version) {
 268     DeploymentFlavorCompositionSchemaInput schemaInput =
 269         new DeploymentFlavorCompositionSchemaInput();
 270     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 271     List<String> featureGroups =
 272         getFeatureGroupListForVsp(vspId, version);
 273     schemaInput.setFeatureGroupIds(featureGroups);
 274     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
 275     response.setSchema((SchemaGenerator
 276         .generate(SchemaTemplateContext.composition, CompositionEntityType.deployment,
 277             schemaInput)));
 278     return response;
 279   }
 280
 281   @Override
 282   public void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId) {
 283     mdcDataDebugMessage
 284         .debugEntryMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 285     /*Version activeVersion =
 286         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();*/
 287     DeploymentFlavorEntity deploymentFlavorEntity =
 288         getValidatedDeploymentFlavor(vspId, version, deploymentFlavorId);
 289     if (!vspInfoDao.isManual(vspId, version)) {
 290       final ErrorCode deleteDeploymentFlavorErrorBuilder =
 291           NotSupportedHeatOnboardMethodErrorBuilder
 292               .getDelDeploymentFlavorNotSupportedHeatOnboardMethodErrorBuilder();
 293       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 294           LoggerTragetServiceName.DELETE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 295           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 296           deleteDeploymentFlavorErrorBuilder.message());
 297       throw new CoreException(deleteDeploymentFlavorErrorBuilder);
 298     }
 299     if (deploymentFlavorEntity != null) {
 300       deploymentFlavorDao.delete(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
 301
 302     }
 303     mdcDataDebugMessage
 304         .debugExitMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 305   }
 306
 307   public CompositionEntityValidationData updateDeploymentFlavor(
 308       DeploymentFlavorEntity deploymentFlavorEntity) {
 309     mdcDataDebugMessage.debugEntryMessage("VSP id, deploymentFlavor id", deploymentFlavorEntity
 310         .getVspId(), deploymentFlavorEntity.getId());
 311     /*Version activeVersion =
 312         getVersionInfo(deploymentFlavorEntity.getVspId(), VersionableEntityAction.Write, user)
 313             .getActiveVersion();*/
 314
 315     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
 316         deploymentFlavorEntity.getVersion())) {
 317       final ErrorCode updateDeploymentFlavorErrorBuilder =
 318           NotSupportedHeatOnboardMethodErrorBuilder
 319               .getUpdateDfNotSupportedHeatOnboardMethodErrorBuilder();
 320       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 321           LoggerTragetServiceName.UPDATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 322           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 323           updateDeploymentFlavorErrorBuilder.message());
 324       throw new CoreException(updateDeploymentFlavorErrorBuilder);
 325     }
 326     DeploymentFlavorEntity retrieved =
 327         getValidatedDeploymentFlavor(deploymentFlavorEntity.getVspId(),
 328             deploymentFlavorEntity.getVersion(),
 329             deploymentFlavorEntity.getId());
 330
 331
 332     Collection<DeploymentFlavorEntity> listDeploymentFlavors = listDeploymentFlavors
 333         (deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getVersion());
 334     listDeploymentFlavors.remove(retrieved);
 335     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 336
 337     //validateComponentComputeAssociation(deploymentFlavorEntity, activeVersion);
 338     validateComponentComputeAssociation(deploymentFlavorEntity,
 339         deploymentFlavorEntity.getVersion());
 340
 341     DeploymentFlavorCompositionSchemaInput schemaInput = new
 342         DeploymentFlavorCompositionSchemaInput();
 343     schemaInput.setManual(vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
 344         deploymentFlavorEntity.getVersion()));
 345     schemaInput.setDeploymentFlavor(retrieved.getDeploymentFlavorCompositionData());
 346
 347     List<String> featureGroups =
 348         getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(),
 349             deploymentFlavorEntity.getVersion());
 350     schemaInput.setFeatureGroupIds(featureGroups);
 351
 352     CompositionEntityValidationData validationData = compositionEntityDataManager
 353         .validateEntity(deploymentFlavorEntity, SchemaTemplateContext.composition, schemaInput);
 354     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 355       deploymentFlavorDao.update(deploymentFlavorEntity);
 356     }
 357
 358     mdcDataDebugMessage.debugExitMessage("VSP id, deploymentFlavor id",
 359         deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getId());
 360     return validationData;
 361   }
 362
 363 }