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