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

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3
   4 import org.apache.commons.collections4.CollectionUtils;
   5 import org.openecomp.sdc.common.errors.CoreException;
   6 import org.openecomp.sdc.common.errors.ErrorCategory;
   7 import org.openecomp.sdc.common.errors.ErrorCode;
   8 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   9 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  10 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  11 import org.openecomp.sdc.logging.types.LoggerConstants;
  12 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  13 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  14 import org.openecomp.sdc.vendorsoftwareproduct.ComputeManager;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  21 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  22 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  23 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  24 import org.openecomp.sdc.vendorsoftwareproduct.errors.DuplicateComputeInComponentErrorBuilder;
  25 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  26 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
  27 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  28 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  29 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  30 import org.openecomp.sdc.vendorsoftwareproduct.types.ListComputeResponse;
  31 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
  32 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  33 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  34 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  35 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
  36 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  37 import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.compute.Compute;
  38 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComputeCompositionSchemaInput;
  39 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
  41 import org.openecomp.sdc.vendorsoftwareproduct.utils.VendorSoftwareProductUtils;
  42 import org.openecomp.sdc.versioning.VersioningUtil;
  43 import org.openecomp.sdc.versioning.dao.types.Version;
  44 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  45
  46 import java.util.ArrayList;
  47 import java.util.Collection;
  48 import java.util.HashSet;
  49 import java.util.List;
  50 import java.util.Set;
  51
  52 public class ComputeManagerImpl implements ComputeManager {
  53
  54   private static final MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  55   private ComputeDao computeDao;
  56   private CompositionEntityDataManager compositionEntityDataManager;
  57   private VendorSoftwareProductInfoDao vspInfoDao;
  58   private DeploymentFlavorDao deploymentFlavorDao;
  59   private ComponentDao componentDao;
  60   private static final String MANUAL = "Manual";
  61
  62   public ComputeManagerImpl(
  63       VendorSoftwareProductInfoDao vspInfoDao,
  64       ComputeDao computeDao,
  65       CompositionEntityDataManager compositionEntityDataManager,
  66       DeploymentFlavorDao deploymentFlavorDao,
  67       ComponentDao componentDao
  68      ) {
  69     this.computeDao = computeDao;
  70     this.compositionEntityDataManager = compositionEntityDataManager;
  71     this.vspInfoDao = vspInfoDao;
  72     this.deploymentFlavorDao = deploymentFlavorDao;
  73     this.componentDao = componentDao;
  74   }
  75
  76   @Override
  77   public ComputeEntity createCompute(ComputeEntity compute, String user) {
  78     ComputeEntity createdCompute = null;
  79     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", compute.getVspId(),
  80         compute.getComponentId());
  81
  82     /*Version activeVersion =
  83         getVersionInfo(compute.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
  84     compute.setVersion(activeVersion);*/
  85     //if (!isManual(compute.getVspId(), activeVersion)) {
  86     if (!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
  87       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
  88           .getAddComputeNotSupportedHeatOnboardMethodErrorBuilder();
  89       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
  90           LoggerTragetServiceName.CREATE_COMPUTE, ErrorLevel.ERROR.name(),
  91           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
  92           onboardingMethodUpdateErrorCode.message());
  93       throw new CoreException(onboardingMethodUpdateErrorCode);
  94     } else {
  95       //validateComponentId(compute.getVspId(),compute.getVersion(),compute.getComponentId());
  96       validateCompute(compute);
  97       createdCompute = createCompute(compute);
  98     }
  99
 100     mdcDataDebugMessage
 101         .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
 102
 103     return createdCompute;
 104   }
 105
 106   private ComputeEntity createCompute(ComputeEntity compute) {
 107
 108     return compositionEntityDataManager.createCompute(compute);
 109   }
 110
 111   private void validateCompute(ComputeEntity compute) {
 112     Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
 113         (),compute.getComponentId());
 114
 115     if (!isComputeNameUnique(vfcComputeList,compute.getComputeCompositionData().getName())) {
 116       final ErrorCode duplicateComputeInComponentErrorBuilder =
 117           new DuplicateComputeInComponentErrorBuilder(compute.getComputeCompositionData().getName(),
 118               compute.getComponentId()).build();
 119       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 120           LoggerTragetServiceName.CREATE_COMPUTE, ErrorLevel.ERROR.name(),
 121           LoggerErrorCode.DATA_ERROR.getErrorCode(),
 122           duplicateComputeInComponentErrorBuilder.message());
 123       throw new CoreException(duplicateComputeInComponentErrorBuilder);
 124     }
 125
 126   }
 127
 128   private void validateComputeUpdate(ComputeEntity compute) {
 129     Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
 130         (),compute.getComponentId());
 131
 132     for (ComputeEntity ce : vfcComputeList) {
 133       if (ce.getId().equals(compute.getId())) {
 134         vfcComputeList.remove(ce);
 135         break;
 136       }
 137     }
 138
 139     if (!isComputeNameUnique(vfcComputeList,compute.getComputeCompositionData().getName())) {
 140       final ErrorCode duplicateComputeInComponentErrorBuilder =
 141           new DuplicateComputeInComponentErrorBuilder(compute.getComputeCompositionData().getName(),
 142               compute.getComponentId()).build();
 143       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 144           LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
 145           LoggerErrorCode.DATA_ERROR.getErrorCode(),
 146           duplicateComputeInComponentErrorBuilder.message());
 147       throw new CoreException(duplicateComputeInComponentErrorBuilder);
 148     }
 149
 150   }
 151
 152   @Override
 153   public Collection<ListComputeResponse> listCompute(String vspId, Version version,
 154                                                      String componentId, String user) {
 155
 156     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 157     //validateComponentId(vspId, version, componentId);
 158     ComputeEntity entity = new ComputeEntity(vspId, version, componentId, null);
 159     Collection<ComputeEntity> computes = computeDao.list(entity);
 160
 161     Collection<ListComputeResponse> computeResponse =
 162         getListComputeResponse(vspId, version, user, computes);
 163     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 164
 165     return computeResponse;
 166   }
 167
 168   private Collection<ListComputeResponse> getListComputeResponse(String vspId, Version version,
 169                                                                  String user,
 170                                                                  Collection<ComputeEntity> computes) {
 171     Set<String> vspComputes = getComputeAssociatedWithDepFlavors(vspId, version, user);
 172     Collection<ListComputeResponse> computeResponse = new ArrayList<ListComputeResponse>();
 173     for(ComputeEntity computeEntity : computes) {
 174       ListComputeResponse response = new ListComputeResponse();
 175       response.setComputeEntity(computeEntity);
 176       if(vspComputes.contains(computeEntity.getId())) {
 177         response.setAssociatedWithDeploymentFlavor(true);
 178       } else {
 179         response.setAssociatedWithDeploymentFlavor(false);
 180       }
 181       computeResponse.add(response);
 182     }
 183     return computeResponse;
 184   }
 185
 186   private Set<String> getComputeAssociatedWithDepFlavors(String vspId, Version version,
 187                                                          String user) {
 188     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 189         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 190     Set<String> vspComputes = new HashSet<String>();
 191     for(DeploymentFlavorEntity entity : deploymentFlavorEntities) {
 192       final List<ComponentComputeAssociation> componentComputeAssociations =
 193           entity.getDeploymentFlavorCompositionData().getComponentComputeAssociations();
 194       if(componentComputeAssociations != null  && !componentComputeAssociations.isEmpty()) {
 195         for(ComponentComputeAssociation association : componentComputeAssociations) {
 196           vspComputes.add(association.getComputeFlavorId());
 197         }
 198       }
 199     }
 200     return vspComputes;
 201   }
 202
 203   private boolean isComputeNameUnique(Collection<ComputeEntity> vfcComputeList, String name) {
 204     for (ComputeEntity compute : vfcComputeList) {
 205       if (compute.getComputeCompositionData().getName().equalsIgnoreCase(name)) {
 206         return false;
 207       }
 208     }
 209     return true;
 210   }
 211
 212   private Collection<ComputeEntity> listCompute(String vspId, Version version,String componentId) {
 213     Collection<ComputeEntity> computeEntities =
 214         computeDao.list(new ComputeEntity(vspId, version, componentId, null));
 215
 216     return computeEntities;
 217   }
 218
 219   @Override
 220   public CompositionEntityResponse<ComputeData> getCompute(String vspId, Version version,
 221                                                            String componentId,
 222                                                            String computeFlavorId, String user) {
 223     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
 224         componentId, computeFlavorId);
 225
 226     /*version = VersioningUtil
 227         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
 228     ComputeEntity computeEntity = getCompute(vspId, version, componentId, computeFlavorId);
 229     ComputeData compute = computeEntity.getComputeCompositionData();
 230
 231     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
 232     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 233     schemaInput.setCompute(compute);
 234
 235     CompositionEntityResponse<ComputeData> response = new CompositionEntityResponse<>();
 236     response.setId(computeFlavorId);
 237     response.setData(compute);
 238     response.setSchema(getComputeCompositionSchema(schemaInput));
 239
 240     mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
 241         componentId, computeFlavorId);
 242
 243     return response;
 244   }
 245
 246   private ComputeEntity getCompute(String vspId, Version version, String componentId, String
 247       computeFlavorId) {
 248     //validateComponentId(vspId,version,componentId);
 249     ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
 250         computeFlavorId));
 251     VersioningUtil
 252         .validateEntityExistence(retrieved, new ComputeEntity(vspId, version, componentId,
 253             computeFlavorId), VspDetails.ENTITY_TYPE);
 254     return retrieved;
 255   }
 256
 257   /*private void validateComponentId(String vspId, Version version, String componentId) {
 258     ComponentEntity retrivedComponent = componentDao.get(new ComponentEntity(vspId, version,
 259         componentId));
 260     VersioningUtil
 261         .validateEntityExistence(retrivedComponent, new ComponentEntity(vspId, version,
 262             componentId),VspDetails.ENTITY_TYPE);
 263   }*/
 264
 265   @Override
 266   public QuestionnaireResponse getComputeQuestionnaire(String vspId, Version version, String
 267           componentId, String computeId, String user) {
 268     mdcDataDebugMessage.debugEntryMessage("VSP id, componentId", vspId, componentId, computeId);
 269
 270     /*version = VersioningUtil
 271         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
 272     //validateComponentId(vspId,version,componentId);
 273     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 274     //validateComponentId(vspId,version,componentId);
 275     ComputeEntity computeQuestionnaire = computeDao.getQuestionnaireData(vspId, version, componentId, computeId);
 276     VersioningUtil
 277             .validateEntityExistence(computeQuestionnaire, new ComputeEntity(vspId, version, componentId,
 278                     computeId), VspDetails.ENTITY_TYPE);
 279     questionnaireResponse.setData(computeQuestionnaire.getQuestionnaireData());
 280     questionnaireResponse.setSchema(getComputeQuestionnaireSchema(null));
 281
 282     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId,
 283             componentId, computeId);
 284
 285     return questionnaireResponse;
 286   }
 287
 288
 289   protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 290     mdcDataDebugMessage.debugEntryMessage(null, null);
 291
 292     mdcDataDebugMessage.debugExitMessage(null, null);
 293     return SchemaGenerator
 294         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute,
 295             schemaInput);
 296   }
 297
 298
 299   @Override
 300   public void updateComputeQuestionnaire(String vspId, Version version, String componentId, String
 301       computeId,
 302                                          String questionnaireData, String user) {
 303     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
 304         componentId, computeId);
 305
 306     /*Version activeVersion =
 307         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
 308     getComponent(vspId, activeVersion, componentId);*/
 309     ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId,version,componentId,
 310         computeId));
 311     VersioningUtil.validateEntityExistence(retrieved, new ComputeEntity(vspId, version,
 312         componentId, computeId), VspDetails.ENTITY_TYPE);
 313
 314     computeDao.updateQuestionnaireData(vspId, version, componentId, computeId, questionnaireData);
 315
 316     mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
 317         componentId, computeId);
 318   }
 319
 320   @Override
 321   public CompositionEntityValidationData updateCompute(ComputeEntity compute, String user) {
 322     mdcDataDebugMessage
 323             .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
 324                     compute.getId());
 325
 326     /*Version activeVersion =
 327         getVersionInfo(image.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
 328     image.setVersion(activeVersion);*/
 329
 330     ComputeEntity retrieved = getComputeEntity(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
 331             compute.getId());
 332
 333     if(!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
 334       final ComputeData computeCompositionData = compute.getComputeCompositionData();
 335       final String name = computeCompositionData.getName();
 336       //final String format = computeCompositionData.getFormat();
 337       validateHeatVspComputeUpdate("Name", name, retrieved.getComputeCompositionData()
 338               .getName());
 339       /*validateHeatVspComputeUpdate("format", format, retrieved.getComputeCompositionData()
 340           .getFormat());*/
 341     }
 342
 343     Collection<ComputeEntity> vfcComputeList = listComputes(compute.getVspId() ,
 344             compute.getVersion(), compute.getComponentId());
 345
 346     //Set to null so that retrieved object is equal to one in list and gets removed.
 347     retrieved.setQuestionnaireData(null);
 348     vfcComputeList.remove(retrieved);
 349     if(vspInfoDao.isManual(compute.getVspId(), compute.getVersion()))
 350       validateVfcCompute(compute, vfcComputeList);
 351
 352     //Set format to default value in order to handle FTL validation when compute format is null
 353     /*if(compute.getComputeCompositionData().getFormat() == null)
 354       compute.getComputeCompositionData().setFormat(ComputeFormat.qcow2.name());*/
 355
 356     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
 357     schemaInput.setCompute(compute.getComputeCompositionData());
 358
 359     CompositionEntityValidationData validationData = compositionEntityDataManager
 360             .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
 361     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 362       computeDao.update(compute);
 363     }
 364
 365     mdcDataDebugMessage
 366             .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
 367                     compute.getId());
 368
 369     return validationData;
 370   }
 371
 372   private void validateHeatVspComputeUpdate(String name, String value, String retrivedValue) {
 373
 374     if(value != null && !value.equals(retrivedValue)) {
 375
 376       final ErrorCode updateHeatComputeErrorBuilder =
 377               DuplicateComputeInComponentErrorBuilder.getComputeHeatReadOnlyErrorBuilder(name);
 378
 379       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 380               LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
 381               LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 382               updateHeatComputeErrorBuilder.message());
 383       throw new CoreException(updateHeatComputeErrorBuilder);
 384     }
 385   }
 386
 387   private void validateVfcCompute(ComputeEntity compute, Collection<ComputeEntity> vfcComputeList) {
 388     if (isComputeNameDuplicate(vfcComputeList,compute.getComputeCompositionData().getName(), compute.getId())) {
 389       ErrorCode errorCode = DuplicateComputeInComponentErrorBuilder.getDuplicateComputeNameErrorBuilder(compute
 390               .getComputeCompositionData().getName(), compute.getComponentId());
 391
 392       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 393               LoggerTragetServiceName.CREATE_COMPONENT, ErrorLevel.ERROR.name(),
 394               errorCode.id(),errorCode.message());
 395
 396       throw new CoreException(errorCode);
 397     }
 398   }
 399
 400   private boolean isComputeNameDuplicate(Collection<ComputeEntity> computes, String name, String computeId) {
 401     for (ComputeEntity compute : computes) {
 402       if (compute.getComputeCompositionData().getName().equals(name) && !compute.getId().equals(computeId)) {
 403         return true;
 404       }
 405     }
 406     return false;
 407   }
 408
 409
 410   private ComputeEntity getComputeEntity(String vspId, Version version, String componentId,
 411   String computeId) {
 412       //validateComponentId(vspId,version,componentId);
 413       ComputeEntity computeEntity = computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
 414       VersioningUtil.validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
 415       computeId), VspDetails.ENTITY_TYPE);
 416       return computeEntity;
 417       }
 418
 419   private Collection<ComputeEntity> listComputes(String vspId, Version version, String componentId) {
 420     return computeDao.list(new ComputeEntity(vspId, version, componentId, null));
 421   }
 422
 423   @Override
 424   public void deleteCompute(String vspId, Version version, String componentId, String
 425       computeFlavorId, String user) {
 426     final String VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG =
 427         "Composition entities may not be created / deleted for Vendor Software Product "
 428             + "whose entities were uploaded";
 429     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
 430         componentId, computeFlavorId);
 431
 432     /*Version activeVersion =
 433         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();*/
 434     if (!vspInfoDao.isManual(vspId, version)) {
 435       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 436           LoggerTragetServiceName.DELETE_COMPUTE, ErrorLevel.ERROR.name(),
 437           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't delete compute");
 438       throw new CoreException(
 439           new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION)
 440               .withId(VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED)
 441               .withMessage(VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG).build());
 442     }
 443     ComputeEntity retrived = getCompute(vspId,version,componentId,computeFlavorId);
 444     if (retrived != null){
 445       deleteComputeFromDeploymentFlavors(vspId,version,computeFlavorId);
 446       computeDao.delete(new ComputeEntity(vspId, version, componentId, computeFlavorId));
 447     }
 448
 449     mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
 450         componentId, computeFlavorId);
 451   }
 452
 453   private void deleteComputeFromDeploymentFlavors(String vspId, Version activeVersion,
 454                                                   String computeFlavorId) {
 455     //Collection<DeploymentFlavorEntity> listDF = listDeploymentFlavors(vspId, activeVersion);
 456     Collection<DeploymentFlavorEntity> listDF = deploymentFlavorDao.list(new DeploymentFlavorEntity
 457         (vspId, activeVersion, null));
 458     for(DeploymentFlavorEntity df : listDF) {
 459       DeploymentFlavorEntity deploymentFlavorEntity=removeComputeFromDF(df, computeFlavorId);
 460       if(deploymentFlavorEntity!=null)
 461         deploymentFlavorDao.update(deploymentFlavorEntity);
 462     }
 463   }
 464
 465   private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df, String
 466       computeFlavorId) {
 467     DeploymentFlavor flavor = df.getDeploymentFlavorCompositionData();
 468     List<ComponentComputeAssociation> associations = flavor.getComponentComputeAssociations();
 469     if (associations != null) {
 470       List<ComponentComputeAssociation> updatedAssociations = new ArrayList<>();
 471       for (ComponentComputeAssociation ca : associations) {
 472         if (ca.getComputeFlavorId() != null && ca.getComputeFlavorId().equals(computeFlavorId)) {
 473           ComponentComputeAssociation updateCaremoveCompute = new ComponentComputeAssociation();
 474           updateCaremoveCompute.setComponentId(ca.getComponentId());
 475           updatedAssociations.add(updateCaremoveCompute);
 476         } else {
 477           updatedAssociations.add(ca);
 478         }
 479       }
 480       flavor.setComponentComputeAssociations(updatedAssociations);
 481       df.setDeploymentFlavorCompositionData(flavor);
 482       return df;
 483     }
 484     return null;
 485   }
 486
 487   protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput){
 488     mdcDataDebugMessage.debugEntryMessage(null, null);
 489     mdcDataDebugMessage.debugExitMessage(null, null);
 490     return SchemaGenerator.generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
 491   }
 492
 493    /*boolean isManual(String vspId, Version version) {
 494
 495     VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
 496     String onboardingMethod = vsp.getOnboardingMethod();
 497     if (MANUAL.equals(onboardingMethod)) {
 498       return true;
 499     }
 500     return false;
 501   }*/
 502
 503 }