openecomp-be/lib/openecomp-sdc-vendor-software-product-lib/openecomp-sdc-vendor-software-product-core/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/services/ManualVspDataCollectionService.java

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