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