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