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