openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/utils/ManualVspDataCollectionService.java

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