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.core.util.UniqueValueUtil;
   6 import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
   7 import org.openecomp.sdc.common.errors.CoreException;
   8 import org.openecomp.sdc.common.errors.ErrorCategory;
   9 import org.openecomp.sdc.common.errors.ErrorCode;
  10 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  11 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  12 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  13 import org.openecomp.sdc.logging.types.LoggerConstants;
  14 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  15 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  16 import org.openecomp.sdc.vendorsoftwareproduct.ComputeManager;
  17 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  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.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
  57   public ComputeManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
  58                             ComputeDao computeDao,
  59                             CompositionEntityDataManager compositionEntityDataManager,
  60                             DeploymentFlavorDao deploymentFlavorDao) {
  61     this.computeDao = computeDao;
  62     this.compositionEntityDataManager = compositionEntityDataManager;
  63     this.vspInfoDao = vspInfoDao;
  64     this.deploymentFlavorDao = deploymentFlavorDao;
  65   }
  66
  67   @Override
  68   public ComputeEntity createCompute(ComputeEntity compute) {
  69     mdcDataDebugMessage
  70         .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
  71
  72     if (!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
  73       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
  74           .getAddComputeNotSupportedHeatOnboardMethodErrorBuilder();
  75       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
  76           LoggerTragetServiceName.CREATE_COMPUTE, ErrorLevel.ERROR.name(),
  77           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
  78           onboardingMethodUpdateErrorCode.message());
  79       throw new CoreException(onboardingMethodUpdateErrorCode);
  80     } else {
  81       validateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
  82           compute.getComputeCompositionData().getName());
  83
  84       compute.setQuestionnaireData(
  85           new JsonSchemaDataGenerator(getComputeQuestionnaireSchema(null)).generateData());
  86       computeDao.create(compute);
  87       createUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
  88           compute.getComputeCompositionData().getName());
  89     }
  90
  91     mdcDataDebugMessage
  92         .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
  93
  94     return compute;
  95   }
  96
  97
  98   @Override
  99   public Collection<ListComputeResponse> listComputes(String vspId, Version version,
 100                                                       String componentId) {
 101     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 102     Collection<ComputeEntity> computes =
 103         computeDao.list(new ComputeEntity(vspId, version, componentId, null));
 104
 105     Collection<ListComputeResponse> computeResponse =
 106         getListComputeResponse(vspId, version, computes);
 107     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 108
 109     return computeResponse;
 110   }
 111
 112   private Collection<ListComputeResponse> getListComputeResponse(String vspId, Version version,
 113                                                                  Collection<ComputeEntity> computes) {
 114     Set<String> vspComputes = getComputeAssociatedWithDepFlavors(vspId, version);
 115     Collection<ListComputeResponse> computeResponse = new ArrayList<>();
 116     for (ComputeEntity computeEntity : computes) {
 117       ListComputeResponse response = new ListComputeResponse();
 118       response.setComputeEntity(computeEntity);
 119       if (vspComputes.contains(computeEntity.getId())) {
 120         response.setAssociatedWithDeploymentFlavor(true);
 121       } else {
 122         response.setAssociatedWithDeploymentFlavor(false);
 123       }
 124       computeResponse.add(response);
 125     }
 126     return computeResponse;
 127   }
 128
 129   private Set<String> getComputeAssociatedWithDepFlavors(String vspId, Version version) {
 130     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 131         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 132     Set<String> vspComputes = new HashSet<>();
 133     for (DeploymentFlavorEntity entity : deploymentFlavorEntities) {
 134       final List<ComponentComputeAssociation> componentComputeAssociations =
 135           entity.getDeploymentFlavorCompositionData().getComponentComputeAssociations();
 136       if (componentComputeAssociations != null && !componentComputeAssociations.isEmpty()) {
 137         for (ComponentComputeAssociation association : componentComputeAssociations) {
 138           vspComputes.add(association.getComputeFlavorId());
 139         }
 140       }
 141     }
 142     return vspComputes;
 143   }
 144
 145   @Override
 146   public CompositionEntityResponse<ComputeData> getCompute(String vspId, Version version,
 147                                                            String componentId,
 148                                                            String computeFlavorId) {
 149     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
 150         componentId, computeFlavorId);
 151
 152     ComputeEntity computeEntity = getValidatedCompute(vspId, version, componentId, computeFlavorId);
 153     ComputeData compute = computeEntity.getComputeCompositionData();
 154
 155     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
 156     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 157     schemaInput.setCompute(compute);
 158
 159     CompositionEntityResponse<ComputeData> response = new CompositionEntityResponse<>();
 160     response.setId(computeFlavorId);
 161     response.setData(compute);
 162     response.setSchema(getComputeCompositionSchema(schemaInput));
 163
 164     mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
 165         componentId, computeFlavorId);
 166
 167     return response;
 168   }
 169
 170   private ComputeEntity getValidatedCompute(String vspId, Version version, String componentId,
 171                                             String computeFlavorId) {
 172     ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
 173         computeFlavorId));
 174     VersioningUtil
 175         .validateEntityExistence(retrieved, new ComputeEntity(vspId, version, componentId,
 176             computeFlavorId), VspDetails.ENTITY_TYPE);
 177     return retrieved;
 178   }
 179
 180   @Override
 181   public QuestionnaireResponse getComputeQuestionnaire(String vspId, Version version, String
 182       componentId, String computeId) {
 183     mdcDataDebugMessage.debugEntryMessage("VSP id, componentId", vspId, componentId, computeId);
 184
 185     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
 186     ComputeEntity computeQuestionnaire =
 187         computeDao.getQuestionnaireData(vspId, version, componentId, computeId);
 188     VersioningUtil
 189         .validateEntityExistence(computeQuestionnaire,
 190             new ComputeEntity(vspId, version, componentId, computeId), VspDetails.ENTITY_TYPE);
 191     questionnaireResponse.setData(computeQuestionnaire.getQuestionnaireData());
 192     questionnaireResponse.setSchema(getComputeQuestionnaireSchema(null));
 193
 194     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId, computeId);
 195
 196     return questionnaireResponse;
 197   }
 198
 199
 200   @Override
 201   public void updateComputeQuestionnaire(String vspId, Version version, String componentId,
 202                                          String computeId, String questionnaireData) {
 203     mdcDataDebugMessage
 204         .debugEntryMessage("VSP id, component id, compute id", vspId, componentId, computeId);
 205
 206     ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
 207         computeId));
 208     VersioningUtil.validateEntityExistence(retrieved, new ComputeEntity(vspId, version,
 209         componentId, computeId), VspDetails.ENTITY_TYPE);
 210
 211     computeDao.updateQuestionnaireData(vspId, version, componentId, computeId, questionnaireData);
 212
 213     mdcDataDebugMessage
 214         .debugExitMessage("VSP id, component id, compute id", vspId, componentId, computeId);
 215   }
 216
 217   @Override
 218   public CompositionEntityValidationData updateCompute(ComputeEntity compute) {
 219     mdcDataDebugMessage
 220         .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
 221             compute.getId());
 222
 223     ComputeEntity retrieved =
 224         getComputeEntity(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
 225             compute.getId());
 226
 227     boolean manual = vspInfoDao.isManual(compute.getVspId(), compute.getVersion());
 228     if (!manual) {
 229       validateHeatVspComputeUpdate("Name",
 230           compute.getComputeCompositionData().getName(),
 231           retrieved.getComputeCompositionData().getName());
 232     }
 233
 234     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
 235     schemaInput.setCompute(compute.getComputeCompositionData());
 236
 237     CompositionEntityValidationData validationData = compositionEntityDataManager
 238         .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
 239     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 240       updateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
 241           retrieved.getComputeCompositionData().getName(),
 242           compute.getComputeCompositionData().getName());
 243       computeDao.update(compute);
 244     }
 245
 246     mdcDataDebugMessage
 247         .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
 248             compute.getId());
 249
 250     return validationData;
 251   }
 252
 253   private void validateHeatVspComputeUpdate(String name, String value, String retrivedValue) {
 254
 255     if (value != null && !value.equals(retrivedValue)) {
 256
 257       final ErrorCode updateHeatComputeErrorBuilder =
 258           DuplicateComputeInComponentErrorBuilder.getComputeHeatReadOnlyErrorBuilder(name);
 259
 260       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 261           LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
 262           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 263           updateHeatComputeErrorBuilder.message());
 264       throw new CoreException(updateHeatComputeErrorBuilder);
 265     }
 266   }
 267
 268   private ComputeEntity getComputeEntity(String vspId, Version version, String componentId,
 269                                          String computeId) {
 270     ComputeEntity computeEntity =
 271         computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
 272     VersioningUtil
 273         .validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
 274             computeId), VspDetails.ENTITY_TYPE);
 275     return computeEntity;
 276   }
 277
 278   @Override
 279   public void deleteCompute(String vspId, Version version, String componentId,
 280                             String computeFlavorId) {
 281     final String VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG =
 282         "Composition entities may not be created / deleted for Vendor Software Product "
 283             + "whose entities were uploaded";
 284     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
 285         componentId, computeFlavorId);
 286
 287     if (!vspInfoDao.isManual(vspId, version)) {
 288       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 289           LoggerTragetServiceName.DELETE_COMPUTE, ErrorLevel.ERROR.name(),
 290           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't delete compute");
 291       throw new CoreException(
 292           new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION)
 293               .withId(VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED)
 294               .withMessage(VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG).build());
 295     }
 296     ComputeEntity retrieved = getValidatedCompute(vspId, version, componentId, computeFlavorId);
 297     if (retrieved != null) {
 298       deleteComputeFromDeploymentFlavors(vspId, version, computeFlavorId);
 299       computeDao.delete(new ComputeEntity(vspId, version, componentId, computeFlavorId));
 300       deleteUniqueValue(retrieved.getVspId(), retrieved.getVersion(), retrieved.getComponentId(),
 301           retrieved.getComputeCompositionData().getName());
 302     }
 303
 304     mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
 305         componentId, computeFlavorId);
 306   }
 307
 308   private void deleteComputeFromDeploymentFlavors(String vspId, Version version,
 309                                                   String computeFlavorId) {
 310     Collection<DeploymentFlavorEntity> listDF =
 311         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 312     for (DeploymentFlavorEntity df : listDF) {
 313       DeploymentFlavorEntity deploymentFlavorEntity = removeComputeFromDF(df, computeFlavorId);
 314       if (deploymentFlavorEntity != null) {
 315         deploymentFlavorDao.update(deploymentFlavorEntity);
 316       }
 317     }
 318   }
 319
 320   private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df,
 321                                                      String computeFlavorId) {
 322     DeploymentFlavor flavor = df.getDeploymentFlavorCompositionData();
 323     List<ComponentComputeAssociation> associations = flavor.getComponentComputeAssociations();
 324     if (associations != null) {
 325       List<ComponentComputeAssociation> updatedAssociations = new ArrayList<>();
 326       for (ComponentComputeAssociation ca : associations) {
 327         if (ca.getComputeFlavorId() != null && ca.getComputeFlavorId().equals(computeFlavorId)) {
 328           ComponentComputeAssociation updateCaremoveCompute = new ComponentComputeAssociation();
 329           updateCaremoveCompute.setComponentId(ca.getComponentId());
 330           updatedAssociations.add(updateCaremoveCompute);
 331         } else {
 332           updatedAssociations.add(ca);
 333         }
 334       }
 335       flavor.setComponentComputeAssociations(updatedAssociations);
 336       df.setDeploymentFlavorCompositionData(flavor);
 337       return df;
 338     }
 339     return null;
 340   }
 341
 342   protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput) {
 343     mdcDataDebugMessage.debugEntryMessage(null);
 344     mdcDataDebugMessage.debugExitMessage(null);
 345     return SchemaGenerator
 346         .generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
 347   }
 348
 349   protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 350     mdcDataDebugMessage.debugEntryMessage(null);
 351     mdcDataDebugMessage.debugExitMessage(null);
 352     return SchemaGenerator
 353         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute, schemaInput);
 354   }
 355
 356   protected void validateUniqueName(String vspId, Version version, String componentId,
 357                                     String name) {
 358     UniqueValueUtil.validateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME,
 359         vspId, version.getId(), componentId, name);
 360   }
 361
 362   protected void createUniqueName(String vspId, Version version, String componentId, String name) {
 363     UniqueValueUtil
 364         .createUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
 365             version.getId(), componentId, name);
 366   }
 367
 368   protected void updateUniqueName(String vspId, Version version, String componentId,
 369                                   String oldName, String newName) {
 370     UniqueValueUtil
 371         .updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, oldName,
 372             newName, vspId, version.getId(), componentId);
 373   }
 374
 375   protected void deleteUniqueValue(String vspId, Version version, String componentId, String name) {
 376     if (componentId == null) {
 377       UniqueValueUtil
 378           .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
 379               version.getId(), name);
 380     }
 381     UniqueValueUtil
 382         .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
 383             version.getId(), componentId, name);
 384   }
 385 }