openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImpl.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 import java.util.ArrayList;
  20 import java.util.Collection;
  21 import java.util.Iterator;
  22 import java.util.List;
  23 import java.util.Map;
  24
  25 import org.apache.commons.collections4.CollectionUtils;
  26 import org.apache.commons.lang.StringUtils;
  27 import org.openecomp.sdc.common.errors.CoreException;
  28 import org.openecomp.sdc.common.errors.ErrorCode;
  29 import org.openecomp.sdc.vendorsoftwareproduct.CompositionEntityDataManager;
  30 import org.openecomp.sdc.vendorsoftwareproduct.DeploymentFlavorManager;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  32 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  35 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  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.DeploymentFlavorErrorBuilder;
  40 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  41 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  42 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  43 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  44 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  45 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  46 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  47 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.DeploymentFlavorCompositionSchemaInput;
  48 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  49 import org.openecomp.sdc.versioning.VersioningUtil;
  50 import org.openecomp.sdc.versioning.dao.types.Version;
  51
  52 import java.util.*;
  53
  54 public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
  55   private final VendorSoftwareProductInfoDao vspInfoDao;
  56   private final DeploymentFlavorDao deploymentFlavorDao;
  57   private final CompositionEntityDataManager compositionEntityDataManager;
  58   private final ComputeDao computeDao;
  59   private final ComponentDao componentDao;
  60
  61   public DeploymentFlavorManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
  62                                      DeploymentFlavorDao deploymentFlavorDao,
  63                                      CompositionEntityDataManager compositionEntityDataManager,
  64                                      ComputeDao computeDao, ComponentDao componentDao) {
  65     this.vspInfoDao = vspInfoDao;
  66     this.deploymentFlavorDao = deploymentFlavorDao;
  67     this.compositionEntityDataManager = compositionEntityDataManager;
  68     this.computeDao = computeDao;
  69     this.componentDao = componentDao;
  70
  71   }
  72
  73   @Override
  74   public Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version) {
  75     return deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
  76   }
  77
  78   @Override
  79   public DeploymentFlavorEntity createDeploymentFlavor(
  80       DeploymentFlavorEntity deploymentFlavorEntity) {
  81     DeploymentFlavorEntity createDeploymentFlavor;
  82     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getVersion())) {
  83       ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
  84           .getAddDeploymentNotSupportedHeatOnboardErrorBuilder();
  85       throw new CoreException(deploymentFlavorErrorBuilder);
  86     } else {
  87       validateDeploymentFlavor(deploymentFlavorEntity, deploymentFlavorEntity.getVersion());
  88       createDeploymentFlavor =
  89           compositionEntityDataManager.createDeploymentFlavor(deploymentFlavorEntity);
  90     }
  91     return createDeploymentFlavor;
  92   }
  93
  94   private void validateDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity,
  95                                         Version version) {
  96     //Validation for unique model.
  97     Collection<DeploymentFlavorEntity> listDeploymentFlavors =
  98         listDeploymentFlavors(deploymentFlavorEntity.getVspId(),
  99             version);
 100     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 101
 102     List<String> featureGroups =
 103         getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), version);
 104     String featureGroup = deploymentFlavorEntity.getDeploymentFlavorCompositionData()
 105         .getFeatureGroupId();
 106     if (featureGroup != null && featureGroup.trim().length() > 0
 107           && (isEmpty(featureGroups) || (!(validFeatureGroup(featureGroups, featureGroup))))) {
 108         ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 109             .getFeatureGroupNotexistErrorBuilder();
 110         throw new CoreException(deploymentFlavorErrorBuilder);
 111     }
 112     validateComponentComputeAssociation(deploymentFlavorEntity, version);
 113   }
 114
 115   private void isDeploymentFlavorModelDuplicate(DeploymentFlavorEntity deploymentFlavorEntity,
 116                     Collection<DeploymentFlavorEntity> listDeploymentFlavors) {
 117     listDeploymentFlavors.forEach(deploymentFlavor -> {
 118       if (deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel().equalsIgnoreCase(
 119           deploymentFlavor.getDeploymentFlavorCompositionData().getModel())) {
 120         ErrorCode deploymentFlavorModelErrorBuilder = DeploymentFlavorErrorBuilder
 121             .getDuplicateDeploymentFlavorModelErrorBuilder(
 122                 deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel(),
 123                 deploymentFlavorEntity.getVspId());
 124         throw new CoreException(deploymentFlavorModelErrorBuilder);
 125       }
 126     });
 127   }
 128
 129   private List<String> getFeatureGroupListForVsp(String vspId, Version version) {
 130     final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 131     return vspDetails.getFeatureGroups();
 132   }
 133
 134   private boolean isEmpty(Collection coll) {
 135     return coll == null || coll.isEmpty();
 136   }
 137
 138   private boolean validFeatureGroup(List<String> featureGroups, String featureGroupId) {
 139     Iterator<String> iterator = featureGroups.iterator();
 140     boolean valid = false;
 141     while (iterator.hasNext()) {
 142       String fgId = iterator.next().trim();
 143       if (fgId.equals(featureGroupId)) {
 144         valid = true;
 145         break;
 146       } else {
 147         valid = false;
 148       }
 149     }
 150     return valid;
 151   }
 152
 153     private void validateComponentComputeAssociation(DeploymentFlavorEntity deploymentFlavorEntity,
 154                                                      Version version) {
 155         List<ComponentComputeAssociation> componentComputeAssociationList =
 156                 deploymentFlavorEntity.getDeploymentFlavorCompositionData().getComponentComputeAssociations();
 157         List<String> vfcList = new ArrayList<>();
 158         if (!isEmpty(componentComputeAssociationList)) {
 159             componentComputeAssociationList.forEach(
 160                     componentComputeAssociation -> validateComponentComputeAssocoationList(deploymentFlavorEntity,
 161                             version,
 162                             vfcList, componentComputeAssociation));
 163             Map<String, Integer> frequencyMapping = CollectionUtils.getCardinalityMap(vfcList);
 164
 165             for (Integer vfcCount : frequencyMapping.values()) {
 166                 if (vfcCount != 1) {
 167                     ErrorCode duplicateVfcAssociationErrorBuilder =
 168                             DeploymentFlavorErrorBuilder.getDuplicateVfcAssociationErrorBuilder();
 169                     throw new CoreException(duplicateVfcAssociationErrorBuilder);
 170                 }
 171             }
 172         }
 173     }
 174
 175     private void validateComponentComputeAssocoationList(
 176             DeploymentFlavorEntity deploymentFlavorEntity,
 177             Version version,
 178             List<String> vfcList,
 179             ComponentComputeAssociation componentComputeAssociation) {
 180         if ((componentComputeAssociation.getComponentId() == null || componentComputeAssociation
 181                 .getComponentId().trim().length() == 0)
 182                 && (componentComputeAssociation
 183                 .getComputeFlavorId() != null && componentComputeAssociation
 184                 .getComputeFlavorId().trim().length() > 0)) {
 185             ErrorCode invalidAssociationErrorBuilder = DeploymentFlavorErrorBuilder
 186                     .getInvalidAssociationErrorBuilder();
 187             throw new CoreException(invalidAssociationErrorBuilder);
 188         } else if (componentComputeAssociation.getComponentId() != null
 189                 && componentComputeAssociation.getComponentId().trim().length() > 0) {
 190             validateComponentAssociation(deploymentFlavorEntity,
 191                     version, componentComputeAssociation);
 192
 193             validateComponentComputeAssociationFlavour(deploymentFlavorEntity,
 194                     version, componentComputeAssociation);
 195             vfcList.add(componentComputeAssociation.getComponentId());
 196         }
 197     }
 198
 199     private void validateComponentAssociation(DeploymentFlavorEntity deploymentFlavorEntity, Version version,
 200                                               ComponentComputeAssociation componentComputeAssociation) {
 201
 202         if (StringUtils.isNotBlank(componentComputeAssociation.getComponentId())) {
 203             ComponentEntity componentEntity =
 204                     componentDao.get(new ComponentEntity(deploymentFlavorEntity.getVspId(), version,
 205                             componentComputeAssociation.getComponentId()));
 206             if (componentEntity == null) {
 207                 ErrorCode invalidComputeIdErrorBuilder =
 208                         DeploymentFlavorErrorBuilder.getInvalidComponentIdErrorBuilder();
 209                 throw new CoreException(invalidComputeIdErrorBuilder);
 210             }
 211         }
 212     }
 213
 214   private void validateComponentComputeAssociationFlavour(
 215           DeploymentFlavorEntity deploymentFlavorEntity,
 216                           Version version,
 217                           ComponentComputeAssociation componentComputeAssociation) {
 218     if (componentComputeAssociation
 219         .getComputeFlavorId() != null && componentComputeAssociation
 220         .getComputeFlavorId().trim().length() > 0) {
 221       ComputeEntity computeFlavor = computeDao.get(new ComputeEntity(deploymentFlavorEntity
 222           .getVspId(), version, componentComputeAssociation.getComponentId(),
 223           componentComputeAssociation.getComputeFlavorId()));
 224       if (computeFlavor == null) {
 225         ErrorCode invalidComputeIdErrorBuilder = DeploymentFlavorErrorBuilder
 226             .getInvalidComputeIdErrorBuilder();
 227         throw new CoreException(invalidComputeIdErrorBuilder);
 228       }
 229     }
 230   }
 231
 232   @Override
 233   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavor(String vspId,
 234                                                         Version version,
 235                                                         String deploymentFlavorId) {
 236     DeploymentFlavorEntity deploymentFlavorEntity =
 237         getValidatedDeploymentFlavor(vspId, version, deploymentFlavorId);
 238     DeploymentFlavor deploymentFlavor = deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 239     DeploymentFlavorCompositionSchemaInput schemaInput = new
 240         DeploymentFlavorCompositionSchemaInput();
 241     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 242     schemaInput.setDeploymentFlavor(deploymentFlavor);
 243     List<String> featureGroups =
 244         getFeatureGroupListForVsp(vspId, version);
 245     schemaInput.setFeatureGroupIds(featureGroups);
 246     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
 247     response.setId(deploymentFlavorId);
 248     response.setSchema(SchemaGenerator
 249         .generate(SchemaTemplateContext.composition, CompositionEntityType.deployment,
 250             schemaInput));
 251     response.setData(deploymentFlavor);
 252     return response;
 253   }
 254
 255   private DeploymentFlavorEntity getValidatedDeploymentFlavor(String vspId, Version version, String
 256       deploymentFlavorId) {
 257     DeploymentFlavorEntity retrieved = deploymentFlavorDao.get(new DeploymentFlavorEntity(vspId,
 258         version, deploymentFlavorId));
 259     VersioningUtil
 260         .validateEntityExistence(retrieved, new DeploymentFlavorEntity(vspId, version,
 261             deploymentFlavorId), VspDetails.ENTITY_TYPE);
 262     return retrieved;
 263   }
 264
 265   @Override
 266   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavorSchema(String vspId,
 267                                                                                Version version) {
 268     DeploymentFlavorCompositionSchemaInput schemaInput =
 269         new DeploymentFlavorCompositionSchemaInput();
 270     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 271     List<String> featureGroups =
 272         getFeatureGroupListForVsp(vspId, version);
 273     schemaInput.setFeatureGroupIds(featureGroups);
 274     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
 275     response.setSchema(SchemaGenerator
 276         .generate(SchemaTemplateContext.composition, CompositionEntityType.deployment,
 277             schemaInput));
 278     return response;
 279   }
 280
 281   @Override
 282   public void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId) {
 283     DeploymentFlavorEntity deploymentFlavorEntity =
 284         getValidatedDeploymentFlavor(vspId, version, deploymentFlavorId);
 285     if (!vspInfoDao.isManual(vspId, version)) {
 286       final ErrorCode deleteDeploymentFlavorErrorBuilder =
 287           NotSupportedHeatOnboardMethodErrorBuilder
 288               .getDelDeploymentFlavorNotSupportedHeatOnboardMethodErrorBuilder();
 289       throw new CoreException(deleteDeploymentFlavorErrorBuilder);
 290     }
 291     if (deploymentFlavorEntity != null) {
 292       deploymentFlavorDao.delete(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
 293
 294     }
 295   }
 296
 297   @Override
 298   public CompositionEntityValidationData updateDeploymentFlavor(
 299       DeploymentFlavorEntity deploymentFlavorEntity) {
 300     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
 301         deploymentFlavorEntity.getVersion())) {
 302       final ErrorCode updateDeploymentFlavorErrorBuilder =
 303           NotSupportedHeatOnboardMethodErrorBuilder
 304               .getUpdateDfNotSupportedHeatOnboardMethodErrorBuilder();
 305       throw new CoreException(updateDeploymentFlavorErrorBuilder);
 306     }
 307     DeploymentFlavorEntity retrieved =
 308         getValidatedDeploymentFlavor(deploymentFlavorEntity.getVspId(),
 309             deploymentFlavorEntity.getVersion(),
 310             deploymentFlavorEntity.getId());
 311
 312
 313     Collection<DeploymentFlavorEntity> listDeploymentFlavors = listDeploymentFlavors(
 314             deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getVersion());
 315     listDeploymentFlavors.remove(retrieved);
 316     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 317
 318     validateComponentComputeAssociation(deploymentFlavorEntity,
 319         deploymentFlavorEntity.getVersion());
 320
 321     DeploymentFlavorCompositionSchemaInput schemaInput = new
 322         DeploymentFlavorCompositionSchemaInput();
 323     schemaInput.setManual(vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
 324         deploymentFlavorEntity.getVersion()));
 325     schemaInput.setDeploymentFlavor(retrieved.getDeploymentFlavorCompositionData());
 326
 327     List<String> featureGroups =
 328         getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(),
 329             deploymentFlavorEntity.getVersion());
 330     schemaInput.setFeatureGroupIds(featureGroups);
 331
 332     CompositionEntityValidationData validationData = compositionEntityDataManager
 333         .validateEntity(deploymentFlavorEntity, SchemaTemplateContext.composition, schemaInput);
 334     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 335       deploymentFlavorDao.update(deploymentFlavorEntity);
 336     }
 337     return validationData;
 338   }
 339
 340 }