gerrit.onap Code Review - sdc.git/blob

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