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