gerrit.onap Code Review - sdc.git/blob

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