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