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