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