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