openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImpl.java

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