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.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
 197     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
 198     schemaInput.setManual(manual);
 199     schemaInput.setCompute(retrieved.getComputeCompositionData());
 200
 201     CompositionEntityValidationData validationData = compositionEntityDataManager
 202         .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
 203     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 204       updateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
 205           retrieved.getComputeCompositionData().getName(),
 206           compute.getComputeCompositionData().getName());
 207       computeDao.update(compute);
 208     }
 209     return validationData;
 210   }
 211
 212   private ComputeEntity getComputeEntity(String vspId, Version version, String componentId,
 213                                          String computeId) {
 214     ComputeEntity computeEntity =
 215         computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
 216     VersioningUtil
 217         .validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
 218             computeId), VspDetails.ENTITY_TYPE);
 219     return computeEntity;
 220   }
 221
 222   @Override
 223   public void deleteCompute(String vspId, Version version, String componentId,
 224                             String computeFlavorId) {
 225     final String vspCompositionEditNotAllowedMsg =
 226         "Composition entities may not be created / deleted for Vendor Software Product "
 227             + "whose entities were uploaded";
 228     if (!vspInfoDao.isManual(vspId, version)) {
 229       throw new CoreException(
 230           new ErrorCode.ErrorCodeBuilder()
 231               .withId(VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED)
 232               .withMessage(vspCompositionEditNotAllowedMsg).build());
 233     }
 234     ComputeEntity retrieved = getValidatedCompute(vspId, version, componentId, computeFlavorId);
 235     if (retrieved != null) {
 236       deleteComputeFromDeploymentFlavors(vspId, version, computeFlavorId);
 237       computeDao.delete(new ComputeEntity(vspId, version, componentId, computeFlavorId));
 238       deleteUniqueValue(retrieved.getVspId(), retrieved.getVersion(), retrieved.getComponentId(),
 239           retrieved.getComputeCompositionData().getName());
 240     }
 241   }
 242
 243   private void deleteComputeFromDeploymentFlavors(String vspId, Version version,
 244                                                   String computeFlavorId) {
 245     Collection<DeploymentFlavorEntity> listDF =
 246         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 247     for (DeploymentFlavorEntity df : listDF) {
 248       DeploymentFlavorEntity deploymentFlavorEntity = removeComputeFromDF(df, computeFlavorId);
 249       if (deploymentFlavorEntity != null) {
 250         deploymentFlavorDao.update(deploymentFlavorEntity);
 251       }
 252     }
 253   }
 254
 255   private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df,
 256                                                      String computeFlavorId) {
 257     DeploymentFlavor flavor = df.getDeploymentFlavorCompositionData();
 258     List<ComponentComputeAssociation> associations = flavor.getComponentComputeAssociations();
 259     if (associations != null) {
 260       List<ComponentComputeAssociation> updatedAssociations = new ArrayList<>();
 261       for (ComponentComputeAssociation ca : associations) {
 262         if (ca.getComputeFlavorId() != null && ca.getComputeFlavorId().equals(computeFlavorId)) {
 263           ComponentComputeAssociation updateCaremoveCompute = new ComponentComputeAssociation();
 264           updateCaremoveCompute.setComponentId(ca.getComponentId());
 265           updatedAssociations.add(updateCaremoveCompute);
 266         } else {
 267           updatedAssociations.add(ca);
 268         }
 269       }
 270       flavor.setComponentComputeAssociations(updatedAssociations);
 271       df.setDeploymentFlavorCompositionData(flavor);
 272       return df;
 273     }
 274     return null;
 275   }
 276
 277   protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput) {
 278     return SchemaGenerator
 279         .generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
 280   }
 281
 282   protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
 283     return SchemaGenerator
 284         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute, schemaInput);
 285   }
 286
 287   protected void validateUniqueName(String vspId, Version version, String componentId,
 288                                     String name) {
 289     UniqueValueUtil uniqueValueUtil =
 290         new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
 291     uniqueValueUtil.validateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME,
 292         vspId, version.getId(), componentId, name);
 293   }
 294
 295   protected void createUniqueName(String vspId, Version version, String componentId, String name) {
 296     UniqueValueUtil uniqueValueUtil =
 297         new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
 298     uniqueValueUtil
 299         .createUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
 300             version.getId(), componentId, name);
 301   }
 302
 303   protected void updateUniqueName(String vspId, Version version, String componentId,
 304                                   String oldName, String newName) {
 305     UniqueValueUtil uniqueValueUtil =
 306         new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
 307     uniqueValueUtil
 308         .updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, oldName,
 309             newName, vspId, version.getId(), componentId);
 310   }
 311
 312   protected void deleteUniqueValue(String vspId, Version version, String componentId, String name) {
 313     UniqueValueUtil uniqueValueUtil =
 314         new UniqueValueUtil(UniqueValueDaoFactory.getInstance().createInterface());
 315     if (componentId == null) {
 316       uniqueValueUtil
 317           .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
 318               version.getId(), name);
 319     }
 320     uniqueValueUtil
 321         .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
 322             version.getId(), componentId, name);
 323   }
 324 }