gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.vendorsoftwareproduct.services;
   2
   3 import org.apache.commons.collections4.CollectionUtils;
   4 import org.apache.commons.lang.StringUtils;
   5 import org.openecomp.core.utilities.json.JsonUtil;
   6 import org.openecomp.sdc.datatypes.error.ErrorLevel;
   7 import org.openecomp.sdc.generator.datatypes.tosca.ComputeFlavor;
   8 import org.openecomp.sdc.generator.datatypes.tosca.DeploymentFlavorModel;
   9 import org.openecomp.sdc.generator.datatypes.tosca.LicenseFlavor;
  10 import org.openecomp.sdc.generator.datatypes.tosca.MultiFlavorVfcImage;
  11 import org.openecomp.sdc.generator.datatypes.tosca.VendorInfo;
  12 import org.openecomp.sdc.logging.api.Logger;
  13 import org.openecomp.sdc.logging.api.LoggerFactory;
  14 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  15 import org.openecomp.sdc.logging.types.LoggerConstants;
  16 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  17 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  18 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  19 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
  20 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
  21 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
  22 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  23 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDaoFactory;
  24 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
  25 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDaoFactory;
  26 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  27 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDaoFactory;
  28 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  29 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDaoFactory;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
  32 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
  33 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
  34 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  35 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
  36 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
  37 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
  38 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
  39 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
  40 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
  41 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
  42 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
  43 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  44 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  45 import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.compute.Compute;
  46 import org.openecomp.sdc.vendorsoftwareproduct.types.questionnaire.component.image.ImageDetails;
  47 import org.openecomp.sdc.versioning.dao.types.Version;
  48
  49 import java.util.ArrayList;
  50 import java.util.Collection;
  51 import java.util.HashMap;
  52 import java.util.List;
  53 import java.util.Map;
  54 import java.util.Objects;
  55 import java.util.Optional;
  56
  57
  58 public class ManualVspDataCollectionService {
  59
  60   private static final VendorSoftwareProductDao vendorSoftwareProductDao =
  61       VendorSoftwareProductDaoFactory.getInstance().createInterface();
  62   private static final VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao =
  63       VendorSoftwareProductInfoDaoFactory.getInstance().createInterface();
  64   private static final ComputeDao computeDao =
  65       ComputeDaoFactory.getInstance().createInterface();
  66   private static final ImageDao imageDao =
  67       ImageDaoFactory.getInstance().createInterface();
  68   private static final ComponentDao componentDao =
  69       ComponentDaoFactory.getInstance().createInterface();
  70
  71   private static final NicDao nicDao =
  72       NicDaoFactory.getInstance().createInterface();
  73   private static final VendorLicenseFacade vendorLicenseFacade =
  74       VendorLicenseFacadeFactory.getInstance().createInterface();
  75
  76   private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
  77
  78
  79   /**
  80    * Gets vendor name for the vsp.
  81    *
  82    * @param vspId   the vsp id
  83    * @param version the version
  84    * @param user    the user
  85    * @return the release vendor name
  86    */
  87   public Optional<String> getReleaseVendor(String vspId, Version version, String user) {
  88     String vendorName = null;
  89     VspDetails vspDetails = vendorSoftwareProductInfoDao.get(new VspDetails(vspId, version));
  90     if (Objects.nonNull(vspDetails)) {
  91       vendorName = vspDetails.getVendorName();
  92     }
  93     return Optional.ofNullable(vendorName);
  94   }
  95
  96   /**
  97    * Gets the deployment flavor data for manually onboarded VSPs.
  98    *
  99    * @param vspId   the vsp id
 100    * @param version the version
 101    * @param user    the user
 102    * @return the allowed flavors
 103    */
 104   public Map<String, DeploymentFlavorModel> getAllowedFlavors(String vspId, Version version,
 105                                                               String user) {
 106     Map<String, DeploymentFlavorModel> allowedFlavors = new HashMap<>();
 107     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 108         vendorSoftwareProductDao.listDeploymentFlavors(vspId, version);
 109     if (CollectionUtils.isNotEmpty(deploymentFlavorEntities)) {
 110       for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 111         DeploymentFlavor deploymentFlavorCompositionData =
 112             deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 113
 114         VspDetails vspDetails = vendorSoftwareProductInfoDao.get(new VspDetails(vspId, version));
 115         String vspVlmId;
 116         Version vlmVersion;
 117         if (Objects.nonNull(vspDetails)) {
 118           vspVlmId = vspDetails.getVendorId();
 119           vlmVersion = vspDetails.getVlmVersion();
 120           if (StringUtils.isNotEmpty(vspVlmId)) {
 121             DeploymentFlavorModel deploymentFlavorModel = new DeploymentFlavorModel();
 122             String featureGroupId = deploymentFlavorCompositionData.getFeatureGroupId();
 123             if (Objects.isNull(featureGroupId)) {
 124               //No feature group associated with deployment flavor. So excluding this deployment
 125               // flavor for Tosca model
 126               continue;
 127             }
 128             //Gather and set License flavor info
 129             LicenseFlavor licenseFlavor = getLicenseFlavor(featureGroupId);
 130             deploymentFlavorModel.setLicense_flavor(licenseFlavor);
 131             //Get sp_part_number
 132             Optional<String> partNumber = getPartNumber(vspVlmId, vlmVersion, featureGroupId,
 133                 user);
 134             partNumber.ifPresent(deploymentFlavorModel::setSp_part_number);
 135             //Gather and set Vendor Info
 136             String vendorModel = deploymentFlavorCompositionData.getModel();
 137             Optional<VendorInfo> vendorInfo = getVendorInfo(vspVlmId, vendorModel, vlmVersion,
 138                 featureGroupId, user);
 139             vendorInfo.ifPresent(deploymentFlavorModel::setVendor_info);
 140             //Gather and set Compute info
 141             List<ComponentComputeAssociation> componentComputeAssociations =
 142                 deploymentFlavorCompositionData.getComponentComputeAssociations();
 143             if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 144               for (ComponentComputeAssociation componentComputeAssociation :
 145                   componentComputeAssociations) {
 146                 String componentId = componentComputeAssociation.getComponentId();
 147                 String computeFlavorId = componentComputeAssociation.getComputeFlavorId();
 148                 Optional<ComputeFlavor> computeFlavor =
 149                     getComputeFlavor(vspId, version, componentId, computeFlavorId, user);
 150                 computeFlavor.ifPresent(deploymentFlavorModel::setCompute_flavor);
 151               }
 152             }
 153             partNumber.ifPresent(spPartNumber -> allowedFlavors.put(spPartNumber,
 154                 deploymentFlavorModel));
 155           }
 156         }
 157       }
 158     }
 159     return allowedFlavors;
 160   }
 161
 162   /**
 163    * Gets the component image data for manually onboarded VSPs.
 164    *
 165    * @param vspId   the vsp id
 166    * @param version the version
 167    * @param user    the user
 168    * @return the vsp component images
 169    */
 170   public Map<String, List<MultiFlavorVfcImage>> getVspComponentImages(String vspId,
 171                                                                       Version version,
 172                                                                       String user) {
 173     Map<String, List<MultiFlavorVfcImage>> vspComponentImages = new HashMap<>();
 174     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 175         vendorSoftwareProductDao.listDeploymentFlavors(vspId, version);
 176     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 177       DeploymentFlavor deploymentFlavorCompositionData =
 178           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 179
 180       List<ComponentComputeAssociation> componentComputeAssociations =
 181           deploymentFlavorCompositionData.getComponentComputeAssociations();
 182       if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 183         for (ComponentComputeAssociation componentComputeAssociation :
 184             componentComputeAssociations) {
 185           String componentId = componentComputeAssociation.getComponentId();
 186           List<MultiFlavorVfcImage> componentImages =
 187               getComponentImages(vspId, version, componentId, user);
 188           if (CollectionUtils.isNotEmpty(componentImages)) {
 189             vspComponentImages.put(componentId, componentImages);
 190           }
 191         }
 192       }
 193     }
 194     return vspComponentImages;
 195   }
 196
 197   /**
 198    * Gets the component data for manually onboarded VSPs.
 199    *
 200    * @param vspId   the vsp id
 201    * @param version the version
 202    * @param user    the user
 203    * @return the vsp components
 204    */
 205   public Map<String, String> getVspComponents(String vspId, Version version, String user) {
 206     Map<String, String> componentIdNameMap = new HashMap<>();
 207     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 208         vendorSoftwareProductDao.listDeploymentFlavors(vspId, version);
 209     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 210       DeploymentFlavor deploymentFlavorCompositionData =
 211           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 212
 213       List<ComponentComputeAssociation> componentComputeAssociations =
 214           deploymentFlavorCompositionData.getComponentComputeAssociations();
 215       if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 216         for (ComponentComputeAssociation componentComputeAssociation :
 217             componentComputeAssociations) {
 218           String componentId = componentComputeAssociation.getComponentId();
 219           Optional<String> componentName = getComponentName(vspId, version, componentId, user);
 220           componentName.ifPresent(name -> componentIdNameMap.put(componentId, name));
 221         }
 222       }
 223     }
 224     return componentIdNameMap;
 225   }
 226
 227   /**
 228    * Gets the NIC data for manually onboarded VSPs.
 229    *
 230    * @param vspId   the vsp id
 231    * @param version the version
 232    * @param user    the user
 233    * @return the vsp component nics
 234    */
 235   public Map<String, List<Nic>> getVspComponentNics(String vspId, Version version, String user) {
 236     Map<String, List<Nic>> vspComponentNics = new HashMap<>();
 237     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 238         vendorSoftwareProductDao.listDeploymentFlavors(vspId, version);
 239     if (CollectionUtils.isNotEmpty(deploymentFlavorEntities)) {
 240       for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 241         DeploymentFlavor deploymentFlavorCompositionData =
 242             deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 243         if (Objects.nonNull(deploymentFlavorCompositionData)) {
 244           List<ComponentComputeAssociation> componentComputeAssociations =
 245               deploymentFlavorCompositionData.getComponentComputeAssociations();
 246           if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 247             for (ComponentComputeAssociation componentComputeAssociation :
 248                 componentComputeAssociations) {
 249               String componentId = componentComputeAssociation.getComponentId();
 250               List<Nic> componentNics = getComponentNics(vspId, version, componentId, user);
 251               if (CollectionUtils.isNotEmpty(componentNics)) {
 252                 vspComponentNics.put(componentId, componentNics);
 253               }
 254             }
 255           }
 256         }
 257       }
 258     }
 259     return vspComponentNics;
 260   }
 261
 262   private List<Nic> getComponentNics(String vspId, Version version, String componentId,
 263                                      String user) {
 264     List<Nic> componentNics = new ArrayList<>();
 265     Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
 266     if (Objects.nonNull(nics)) {
 267       for (NicEntity nic : nics) {
 268         String nicId = nic.getId();
 269         NicEntity nicEntity = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
 270         if (Objects.nonNull(nicEntity)
 271             && Objects.nonNull(nicEntity.getCompositionData())) {
 272           componentNics.add(nicEntity.getNicCompositionData());
 273         }
 274       }
 275     }
 276     return componentNics;
 277   }
 278
 279   private LicenseFlavor getLicenseFlavor(String featureGroupId) {
 280     LicenseFlavor licenseFlavor = new LicenseFlavor();
 281     licenseFlavor.setFeature_group_uuid(featureGroupId);
 282     return licenseFlavor;
 283   }
 284
 285   private Optional<String> getPartNumber(String vlmId, Version version,
 286                                          String featureGroupId, String user) {
 287     FeatureGroupModel featureGroup = getFeatureGroup(vlmId, version, featureGroupId, user);
 288     if (Objects.nonNull(featureGroup)) {
 289       return Optional.ofNullable(featureGroup.getFeatureGroup().getPartNumber());
 290     }
 291     return Optional.empty();
 292   }
 293
 294   private Optional<VendorInfo> getVendorInfo(String vlmId, String vendorModel, Version version,
 295                                              String featureGroupId, String user) {
 296     VendorInfo vendorInfo = null;
 297     FeatureGroupModel featureGroup = getFeatureGroup(vlmId, version, featureGroupId, user);
 298     if (Objects.nonNull(featureGroup)) {
 299       //Process Feature group to get Manufacturer ref no.
 300       String manufacturerReferenceNumber = featureGroup.getEntityManufacturerReferenceNumber();
 301       vendorInfo = new VendorInfo();
 302       vendorInfo.setVendor_model(vendorModel);
 303       if (Objects.nonNull(manufacturerReferenceNumber)) {
 304         vendorInfo.setManufacturer_reference_number(manufacturerReferenceNumber);
 305       }
 306     }
 307     return Optional.ofNullable(vendorInfo);
 308   }
 309
 310   private Optional<ComputeFlavor> getComputeFlavor(String vspId, Version version,
 311                                                    String componentId, String computeFlavorId,
 312                                                    String user) {
 313     ComputeFlavor computeFlavor = null;
 314     ComputeEntity computeQuestionnaire = null;
 315     try {
 316       computeQuestionnaire = computeDao.getQuestionnaireData(vspId, version, componentId,
 317           computeFlavorId);
 318     } catch (Exception ex) {
 319       log.debug("",ex);
 320       computeQuestionnaire = null;
 321       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 322           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
 323           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Failed to get compute questionnaire : "
 324               + ex.getMessage());
 325     }
 326     if (computeQuestionnaire != null && Objects.nonNull(computeQuestionnaire)) {
 327       String computeQuestionnaireData = computeQuestionnaire.getQuestionnaireData();
 328       if (Objects.nonNull(computeQuestionnaireData)) {
 329         Compute compute;
 330         try {
 331           compute = JsonUtil.json2Object(computeQuestionnaireData, Compute.class);
 332         } catch (Exception ex) {
 333           log.debug("",ex);
 334           compute = null;
 335           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 336               LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
 337               LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to parse compute questionnaire : "
 338                   + ex.getMessage());
 339         }
 340         if (compute != null && Objects.nonNull(compute.getVmSizing())) {
 341           computeFlavor = new ComputeFlavor();
 342           if (Objects.nonNull(compute.getVmSizing().getNumOfCPUs())) {
 343             computeFlavor.setNum_cpus(compute.getVmSizing().getNumOfCPUs());
 344           }
 345           if (Objects.nonNull(compute.getVmSizing().getFileSystemSizeGB())) {
 346             computeFlavor.setDisk_size(compute.getVmSizing().getFileSystemSizeGB() + " GB");
 347           }
 348           if (Objects.nonNull(compute.getVmSizing().getMemoryRAM())) {
 349             computeFlavor.setMem_size(compute.getVmSizing().getMemoryRAM());
 350           }
 351         }
 352       }
 353     }
 354     return Optional.ofNullable(computeFlavor);
 355   }
 356
 357   private FeatureGroupModel getFeatureGroup(String vlmId, Version version, String featureGroupId,
 358                                             String user) {
 359     FeatureGroupEntity fgInput = new FeatureGroupEntity();
 360     fgInput.setVendorLicenseModelId(vlmId);
 361     fgInput.setVersion(version);
 362     fgInput.setId(featureGroupId);
 363     return vendorLicenseFacade.getFeatureGroupModel(fgInput, user);
 364   }
 365
 366   private Optional<String> getComponentName(String vspId, Version version, String componentId,
 367                                             String user) {
 368
 369     ComponentEntity componentEntity =
 370         componentDao.get(new ComponentEntity(vspId, version, componentId));
 371     if (Objects.nonNull(componentEntity)
 372         && Objects.nonNull(componentEntity.getComponentCompositionData())) {
 373       ComponentData componentCompositionData = componentEntity.getComponentCompositionData();
 374       return Optional.ofNullable(componentCompositionData.getDisplayName());
 375     }
 376     return Optional.empty();
 377   }
 378
 379   private List<MultiFlavorVfcImage> getComponentImages(String vspId, Version version,
 380                                                        String componentId, String user) {
 381     List<MultiFlavorVfcImage> multiFlavorVfcImages = new ArrayList<>();
 382     MultiFlavorVfcImage multiFlavorVfcImage = null;
 383     Collection<ImageEntity> componentImages =
 384         vendorSoftwareProductDao.listImages(vspId, version, componentId);
 385     if (Objects.nonNull(componentImages)) {
 386       for (ImageEntity componentImage : componentImages) {
 387         String imageId = componentImage.getId();
 388         ImageEntity imageEntity = vendorSoftwareProductDao.getImage(vspId, version, componentId,
 389             imageId);
 390         ImageEntity imageQuestionnaireDataEntity = imageDao.getQuestionnaireData(vspId, version,
 391             componentId, imageId);
 392         Image imageCompositionData = imageEntity.getImageCompositionData();
 393         if (Objects.nonNull(imageEntity)
 394             && Objects.nonNull(imageQuestionnaireDataEntity)
 395             && Objects.nonNull(imageCompositionData)) {
 396           ImageDetails imageDetails;
 397           try {
 398             imageDetails = JsonUtil.json2Object(imageQuestionnaireDataEntity
 399                 .getQuestionnaireData(), ImageDetails.class);
 400           } catch (Exception ex) {
 401             log.debug("",ex);
 402             imageDetails = null;
 403             MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 404                 LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
 405                 LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to parse image questionnaire : "
 406                     + ex.getMessage());
 407           }
 408           if (imageDetails != null && Objects.nonNull(imageDetails)
 409               && Objects.nonNull(imageDetails.getVersion())) {
 410             //Image version is used as a key for the image block
 411             //So excluding the population if questionnaire data is absent or invalid
 412             multiFlavorVfcImage = new MultiFlavorVfcImage();
 413             multiFlavorVfcImage.setSoftware_version(imageDetails.getVersion());
 414             if (Objects.nonNull(imageCompositionData.getFileName())) {
 415               multiFlavorVfcImage.setFile_name(imageCompositionData.getFileName());
 416             }
 417             if (Objects.nonNull(imageDetails.getMd5())) {
 418               multiFlavorVfcImage.setFile_hash(imageDetails.getMd5());
 419             }
 420             multiFlavorVfcImage.setFile_hash_type("md5");
 421             multiFlavorVfcImages.add(multiFlavorVfcImage);
 422           }
 423         }
 424       }
 425     }
 426     return multiFlavorVfcImages;
 427   }
 428 }