gerrit.onap Code Review - sdc.git/blob

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