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