gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.vendorsoftwareproduct.impl;
   2
   3 import org.apache.commons.collections4.CollectionUtils;
   4 import org.openecomp.sdc.common.errors.CoreException;
   5 import org.openecomp.sdc.common.errors.ErrorCode;
   6 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   7 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
   8 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
   9 import org.openecomp.sdc.logging.types.LoggerConstants;
  10 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  11 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  12 import org.openecomp.sdc.vendorsoftwareproduct.DeploymentFlavorManager;
  13 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
  14 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  15 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  16 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
  17 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  18 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  19 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  20 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  21 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  22 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
  23 import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
  24 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
  25 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
  26 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
  27 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  28 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
  29 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
  30 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  31 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.DeploymentFlavorCompositionSchemaInput;
  32 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  33 import org.openecomp.sdc.versioning.VersioningUtil;
  34 import org.openecomp.sdc.versioning.dao.types.Version;
  35
  36 import java.util.ArrayList;
  37 import java.util.Collection;
  38 import java.util.Iterator;
  39 import java.util.List;
  40 import java.util.Map;
  41
  42 public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
  43
  44   private static final MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  45   private VendorSoftwareProductInfoDao vspInfoDao;
  46   private DeploymentFlavorDao deploymentFlavorDao;
  47   private CompositionEntityDataManager compositionEntityDataManager;
  48   private  ComponentDao componentDao;
  49   private ComputeDao computeDao;
  50
  51   public DeploymentFlavorManagerImpl(
  52       VendorSoftwareProductInfoDao vspInfoDao,
  53       DeploymentFlavorDao deploymentFlavorDao,
  54       CompositionEntityDataManager compositionEntityDataManager,
  55       ComponentDao componentDao,
  56       ComputeDao computeDao
  57
  58   ) {
  59
  60     this.vspInfoDao = vspInfoDao;
  61     this.deploymentFlavorDao = deploymentFlavorDao;
  62     this.compositionEntityDataManager = compositionEntityDataManager;
  63     this.componentDao = componentDao;
  64     this.computeDao = computeDao;
  65
  66   }
  67
  68   @Override
  69   public Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version,
  70                                                                   String user) {
  71     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
  72     /*version = VersioningUtil
  73         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
  74
  75     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
  76     return listDeploymentFlavors(vspId, version);
  77   }
  78
  79   private Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version) {
  80     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
  81         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
  82     return deploymentFlavorEntities;
  83   }
  84
  85   @Override
  86   public DeploymentFlavorEntity createDeploymentFlavor(
  87       DeploymentFlavorEntity deploymentFlavorEntity, String user) {
  88     DeploymentFlavorEntity createDeploymentFlavor = null;
  89     mdcDataDebugMessage.debugEntryMessage("VSP id ", deploymentFlavorEntity.getVspId());
  90     /*Version activeVersion =
  91         getVersionInfo(deploymentFlavorEntity.getVspId(), VersionableEntityAction.Write, user)
  92             .getActiveVersion();
  93     deploymentFlavorEntity.setVersion(activeVersion);*/
  94
  95     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
  96         deploymentFlavorEntity.getVersion())) {
  97       ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
  98           .getAddDeploymentNotSupportedHeatOnboardErrorBuilder();
  99       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 100           LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 101           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), deploymentFlavorErrorBuilder.message());
 102       throw new CoreException(deploymentFlavorErrorBuilder);
 103     } else {
 104       validateDeploymentFlavor(deploymentFlavorEntity, user, deploymentFlavorEntity.getVersion());
 105       createDeploymentFlavor =
 106           compositionEntityDataManager.createDeploymentFlavor(deploymentFlavorEntity);
 107     }
 108     return createDeploymentFlavor;
 109   }
 110
 111   private void validateDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity, String
 112       user, Version activeVersion) {
 113
 114     //Validation for unique model.
 115     Collection<DeploymentFlavorEntity> listDeploymentFlavors =
 116         listDeploymentFlavors(deploymentFlavorEntity.getVspId(),
 117             activeVersion);
 118     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 119
 120     List<String> featureGroups =
 121         getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), user, activeVersion);
 122     String featureGroup = deploymentFlavorEntity.getDeploymentFlavorCompositionData()
 123         .getFeatureGroupId();
 124     if (featureGroup != null && featureGroup.trim().length()>0) {
 125       if (isEmpty(featureGroups) || (!(validFeatureGroup(featureGroups, featureGroup)))) {
 126         ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
 127             .getFeatureGroupNotexistErrorBuilder(featureGroup, deploymentFlavorEntity.getVspId(),
 128                 activeVersion);
 129         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 130             LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 131             LoggerErrorCode.DATA_ERROR.getErrorCode(), deploymentFlavorErrorBuilder.message());
 132         throw new CoreException(deploymentFlavorErrorBuilder);
 133       }
 134     }
 135
 136     validateComponentComputeAssociation(deploymentFlavorEntity, activeVersion);
 137   }
 138
 139   private void isDeploymentFlavorModelDuplicate(DeploymentFlavorEntity deploymentFlavorEntity,
 140                                                 Collection<DeploymentFlavorEntity> listDeploymentFlavors) {
 141     listDeploymentFlavors.forEach(deploymentFlavor -> {
 142       if (deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel().equalsIgnoreCase(
 143           deploymentFlavor.getDeploymentFlavorCompositionData().getModel())) {
 144         ErrorCode deploymentFlavorModelErrorBuilder = DeploymentFlavorErrorBuilder
 145             .getDuplicateDeploymentFlavorModelErrorBuilder(
 146                 deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel(),
 147                 deploymentFlavorEntity.getVspId());
 148         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 149             LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 150             LoggerErrorCode.DATA_ERROR.getErrorCode(), deploymentFlavorModelErrorBuilder.message());
 151         throw new CoreException(deploymentFlavorModelErrorBuilder);
 152       }
 153     });
 154   }
 155
 156   private List<String> getFeatureGroupListForVsp(String vspId,
 157                                                  String user, Version activeVersion) {
 158     /*VersionedVendorSoftwareProductInfo versionedVendorSoftwareProductInfo = getVspDetails(
 159         vspId,activeVersion, user);
 160     return versionedVendorSoftwareProductInfo.getVspDetails()
 161         .getFeatureGroups();*/
 162
 163     final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, activeVersion));
 164     return vspDetails.getFeatureGroups();
 165   }
 166
 167   private boolean isEmpty(Collection coll) {
 168     return (coll == null || coll.isEmpty());
 169   }
 170
 171   private boolean validFeatureGroup(List<String> featureGroups, String featureGroupId) {
 172     Iterator<String> iterator = featureGroups.iterator();
 173     boolean valid = false;
 174     while (iterator.hasNext()) {
 175       String fgId = iterator.next().trim();
 176       if (fgId.equals(featureGroupId)) {
 177         valid = true;
 178         break;
 179       } else {
 180         valid = false;
 181       }
 182     }
 183     return valid;
 184   }
 185
 186   private void validateComponentComputeAssociation(DeploymentFlavorEntity deploymentFlavorEntity,
 187                                                    Version activeVersion) {
 188     List<ComponentComputeAssociation> componentComputeAssociationList = deploymentFlavorEntity
 189         .getDeploymentFlavorCompositionData().getComponentComputeAssociations();
 190     List<String> vfcList = new ArrayList<>();
 191     if (!isEmpty(componentComputeAssociationList)) {
 192       componentComputeAssociationList.forEach(componentComputeAssociation -> {
 193         if ((componentComputeAssociation.getComponentId() == null || componentComputeAssociation
 194             .getComponentId().trim().length() == 0) &&
 195             (componentComputeAssociation
 196                 .getComputeFlavorId() != null && componentComputeAssociation
 197                 .getComputeFlavorId().trim().length() > 0)) {
 198           ErrorCode invalidAssociationErrorBuilder = DeploymentFlavorErrorBuilder
 199               .getInvalidAssociationErrorBuilder();
 200           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 201               LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 202               LoggerErrorCode.DATA_ERROR.getErrorCode(), invalidAssociationErrorBuilder.message());
 203           throw new CoreException(invalidAssociationErrorBuilder);
 204         } else if (componentComputeAssociation.getComponentId() != null &&
 205             componentComputeAssociation.getComponentId().trim().length() > 0 ) {
 206           ComponentEntity component = getComponent(deploymentFlavorEntity.getVspId(), activeVersion,
 207               componentComputeAssociation.getComponentId());
 208           if (componentComputeAssociation
 209               .getComputeFlavorId() != null && componentComputeAssociation
 210               .getComputeFlavorId().trim().length() > 0 ) {
 211             ComputeEntity computeFlavor = computeDao.get(new ComputeEntity(deploymentFlavorEntity
 212                     .getVspId(), activeVersion, componentComputeAssociation.getComponentId(),
 213                 componentComputeAssociation.getComputeFlavorId()));
 214             if (computeFlavor == null) {
 215               ErrorCode invalidComputeIdErrorBuilder = DeploymentFlavorErrorBuilder
 216                   .getInvalidComputeIdErrorBuilder(componentComputeAssociation.getComputeFlavorId(),
 217                       componentComputeAssociation.getComponentId());
 218               MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 219                   LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 220                   LoggerErrorCode.DATA_ERROR.getErrorCode(),
 221                   invalidComputeIdErrorBuilder.message());
 222               throw new CoreException(invalidComputeIdErrorBuilder);
 223             }
 224           }
 225           vfcList.add(componentComputeAssociation.getComponentId());
 226         }
 227       });
 228       Map<String, Integer> frequencyMapping = CollectionUtils.getCardinalityMap(vfcList);
 229
 230       for (Integer vfcCount : frequencyMapping.values()) {
 231         if (vfcCount != 1) {
 232           ErrorCode duplicateVfcAssociationErrorBuilder = DeploymentFlavorErrorBuilder
 233               .getDuplicateVfcAssociationErrorBuilder();
 234           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 235               LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 236               LoggerErrorCode.DATA_ERROR.getErrorCode(),
 237               duplicateVfcAssociationErrorBuilder.message());
 238           throw new CoreException(duplicateVfcAssociationErrorBuilder);
 239         }
 240       }
 241     }
 242   }
 243
 244   private ComponentEntity getComponent(String vspId, Version version, String componentId) {
 245     ComponentEntity retrieved = componentDao.get(new ComponentEntity(vspId, version, componentId));
 246     VersioningUtil
 247         .validateEntityExistence(retrieved, new ComponentEntity(vspId, version, componentId),
 248             VspDetails.ENTITY_TYPE);
 249     return retrieved;
 250   }
 251
 252   @Override
 253   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavor(String vspId,
 254                                                                          Version version,
 255                                                                          String deploymentFlavorId,
 256                                                                          String user) {
 257     mdcDataDebugMessage
 258         .debugEntryMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 259
 260     /*version = VersioningUtil
 261         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
 262     DeploymentFlavorEntity deploymentFlavorEntity = getDeploymentFlavor(vspId,version,
 263         deploymentFlavorId);
 264     DeploymentFlavor deploymentFlavor = deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 265     DeploymentFlavorCompositionSchemaInput schemaInput = new
 266         DeploymentFlavorCompositionSchemaInput();
 267     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 268     schemaInput.setDeploymentFlavor(deploymentFlavor);
 269     List<String> featureGroups =
 270         getFeatureGroupListForVsp(vspId, user, version);
 271     schemaInput.setFeatureGroupIds(featureGroups);
 272     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
 273     response.setId(deploymentFlavorId);
 274     response.setSchema((SchemaGenerator
 275         .generate(SchemaTemplateContext.composition, CompositionEntityType.deployment,
 276             schemaInput)));
 277     response.setData(deploymentFlavor);
 278     mdcDataDebugMessage
 279         .debugExitMessage("VSP id, deployment flavor id ", vspId, deploymentFlavorId);
 280
 281     return response;
 282   }
 283
 284   private DeploymentFlavorEntity getDeploymentFlavor(String vspId, Version version, String
 285       deploymentFlavorId) {
 286     DeploymentFlavorEntity retrieved = deploymentFlavorDao.get(new DeploymentFlavorEntity(vspId,
 287         version, deploymentFlavorId));
 288     VersioningUtil
 289         .validateEntityExistence(retrieved, new DeploymentFlavorEntity(vspId, version,
 290             deploymentFlavorId ), VspDetails.ENTITY_TYPE);
 291     return retrieved;
 292   }
 293
 294   @Override
 295   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavorSchema(String vspId,
 296                                                                                Version version,
 297                                                                                String user) {
 298     /*version = VersioningUtil
 299         .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
 300     DeploymentFlavorCompositionSchemaInput schemaInput= new
 301         DeploymentFlavorCompositionSchemaInput();
 302     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
 303     List<String> featureGroups =
 304         getFeatureGroupListForVsp(vspId, user, version);
 305     schemaInput.setFeatureGroupIds(featureGroups);
 306     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
 307     response.setSchema((SchemaGenerator
 308         .generate(SchemaTemplateContext.composition, CompositionEntityType.deployment,
 309             schemaInput)));
 310     return response;
 311   }
 312
 313   @Override
 314   public void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId,
 315                                      String user) {
 316     mdcDataDebugMessage
 317         .debugEntryMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 318     /*Version activeVersion =
 319         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();*/
 320     DeploymentFlavorEntity deploymentFlavorEntity = getDeploymentFlavor(vspId,version,
 321         deploymentFlavorId);
 322     if (!vspInfoDao.isManual(vspId, version)) {
 323       final ErrorCode deleteDeploymentFlavorErrorBuilder =
 324           NotSupportedHeatOnboardMethodErrorBuilder
 325               .getDelDeploymentFlavorNotSupportedHeatOnboardMethodErrorBuilder();
 326       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 327           LoggerTragetServiceName.DELETE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 328           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 329           deleteDeploymentFlavorErrorBuilder.message());
 330       throw new CoreException(deleteDeploymentFlavorErrorBuilder);
 331     }
 332     if(deploymentFlavorEntity != null) {
 333       deploymentFlavorDao.delete(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
 334
 335     }
 336     mdcDataDebugMessage
 337         .debugExitMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 338   }
 339
 340   public CompositionEntityValidationData updateDeploymentFlavor(DeploymentFlavorEntity
 341                                                                     deploymentFlavorEntity, String user) {
 342     mdcDataDebugMessage.debugEntryMessage("VSP id, deploymentFlavor id", deploymentFlavorEntity
 343         .getVspId(), deploymentFlavorEntity.getId());
 344     /*Version activeVersion =
 345         getVersionInfo(deploymentFlavorEntity.getVspId(), VersionableEntityAction.Write, user)
 346             .getActiveVersion();*/
 347
 348     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
 349         deploymentFlavorEntity.getVersion())) {
 350       final ErrorCode updateDeploymentFlavorErrorBuilder =
 351           NotSupportedHeatOnboardMethodErrorBuilder
 352               .getUpdateDfNotSupportedHeatOnboardMethodErrorBuilder();
 353       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 354           LoggerTragetServiceName.UPDATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
 355           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
 356           updateDeploymentFlavorErrorBuilder.message());
 357       throw new CoreException(updateDeploymentFlavorErrorBuilder);
 358     }
 359     //deploymentFlavorEntity.setVersion(activeVersion);
 360     DeploymentFlavorEntity retrieved =
 361         getDeploymentFlavor(deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getVersion(),
 362             deploymentFlavorEntity.getId());
 363
 364
 365     Collection<DeploymentFlavorEntity> listDeploymentFlavors = listDeploymentFlavors
 366         (deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getVersion());
 367     listDeploymentFlavors.remove(retrieved);
 368     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 369
 370     //validateComponentComputeAssociation(deploymentFlavorEntity, activeVersion);
 371     validateComponentComputeAssociation(deploymentFlavorEntity, deploymentFlavorEntity.getVersion());
 372
 373     DeploymentFlavorCompositionSchemaInput schemaInput = new
 374         DeploymentFlavorCompositionSchemaInput();
 375     schemaInput.setManual(vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
 376         deploymentFlavorEntity.getVersion()));
 377     schemaInput.setDeploymentFlavor(retrieved.getDeploymentFlavorCompositionData());
 378
 379     List<String> featureGroups =
 380         getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), user,
 381             deploymentFlavorEntity.getVersion());
 382     schemaInput.setFeatureGroupIds(featureGroups);
 383
 384     CompositionEntityValidationData validationData = compositionEntityDataManager
 385         .validateEntity(deploymentFlavorEntity, SchemaTemplateContext.composition, schemaInput);
 386     if (CollectionUtils.isEmpty(validationData.getErrors())) {
 387       deploymentFlavorDao.update(deploymentFlavorEntity);
 388     }
 389
 390     mdcDataDebugMessage.debugExitMessage("VSP id, deploymentFlavor id",
 391         deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getId());
 392     return validationData;
 393   }
 394
 395 }