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.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.DeploymentFlavorDao;
  27 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDaoFactory;
  28 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
  29 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDaoFactory;
  30 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
  31 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDaoFactory;
  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 VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao =
  61       VendorSoftwareProductInfoDaoFactory.getInstance().createInterface();
  62   private static final DeploymentFlavorDao deploymentFlavorDao =
  63       DeploymentFlavorDaoFactory.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    * Gets vendor name for the vsp.
  80    *
  81    * @param vspId   the vsp id
  82    * @param version the version
  83    * @return the release vendor name
  84    */
  85   public Optional<String> getReleaseVendor(String vspId, Version version) {
  86     String vendorName = null;
  87     VspDetails vspDetails = vendorSoftwareProductInfoDao.get(new VspDetails(vspId, version));
  88     if (Objects.nonNull(vspDetails)) {
  89       vendorName = vspDetails.getVendorName();
  90     }
  91     return Optional.ofNullable(vendorName);
  92   }
  93
  94   /**
  95    * Gets the deployment flavor data for manually onboarded VSPs.
  96    *
  97    * @param vspId   the vsp id
  98    * @param version the version
  99    * @return the allowed flavors
 100    */
 101   public Map<String, DeploymentFlavorModel> getAllowedFlavors(String vspId, Version version) {
 102     Map<String, DeploymentFlavorModel> allowedFlavors = new HashMap<>();
 103     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 104         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 105     if (CollectionUtils.isNotEmpty(deploymentFlavorEntities)) {
 106       for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 107         DeploymentFlavor deploymentFlavorCompositionData =
 108             deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 109
 110         VspDetails vspDetails = vendorSoftwareProductInfoDao.get(new VspDetails(vspId, version));
 111         String vspVlmId;
 112         Version vlmVersion;
 113         if (Objects.nonNull(vspDetails)) {
 114           vspVlmId = vspDetails.getVendorId();
 115           vlmVersion = vspDetails.getVlmVersion();
 116           if (StringUtils.isNotEmpty(vspVlmId)) {
 117             DeploymentFlavorModel deploymentFlavorModel = new DeploymentFlavorModel();
 118             String featureGroupId = deploymentFlavorCompositionData.getFeatureGroupId();
 119             if (Objects.isNull(featureGroupId)) {
 120               //No feature group associated with deployment flavor. So excluding this deployment
 121               // flavor for Tosca model
 122               continue;
 123             }
 124             //Gather and set License flavor info
 125             LicenseFlavor licenseFlavor = getLicenseFlavor(featureGroupId);
 126             deploymentFlavorModel.setLicense_flavor(licenseFlavor);
 127             //Get sp_part_number
 128             Optional<String> partNumber = getPartNumber(vspVlmId, vlmVersion, featureGroupId);
 129             partNumber.ifPresent(deploymentFlavorModel::setSp_part_number);
 130             //Gather and set Vendor Info
 131             String vendorModel = deploymentFlavorCompositionData.getModel();
 132             Optional<VendorInfo> vendorInfo = getVendorInfo(vspVlmId, vendorModel, vlmVersion,
 133                 featureGroupId);
 134             vendorInfo.ifPresent(deploymentFlavorModel::setVendor_info);
 135             //Gather and set Compute info
 136             List<ComponentComputeAssociation> componentComputeAssociations =
 137                 deploymentFlavorCompositionData.getComponentComputeAssociations();
 138             if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 139               for (ComponentComputeAssociation componentComputeAssociation :
 140                   componentComputeAssociations) {
 141                 String componentId = componentComputeAssociation.getComponentId();
 142                 String computeFlavorId = componentComputeAssociation.getComputeFlavorId();
 143                 Optional<ComputeFlavor> computeFlavor =
 144                     getComputeFlavor(vspId, version, componentId, computeFlavorId);
 145                 computeFlavor.ifPresent(deploymentFlavorModel::setCompute_flavor);
 146               }
 147             }
 148             partNumber.ifPresent(spPartNumber -> allowedFlavors.put(spPartNumber,
 149                 deploymentFlavorModel));
 150           }
 151         }
 152       }
 153     }
 154     return allowedFlavors;
 155   }
 156
 157   /**
 158    * Gets the component image data for manually onboarded VSPs.
 159    *
 160    * @param vspId   the vsp id
 161    * @param version the version
 162    * @return the vsp component images
 163    */
 164   public Map<String, List<MultiFlavorVfcImage>> getVspComponentImages(String vspId,
 165                                                                       Version version) {
 166     Map<String, List<MultiFlavorVfcImage>> vspComponentImages = new HashMap<>();
 167     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 168         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 169     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 170       DeploymentFlavor deploymentFlavorCompositionData =
 171           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 172
 173       List<ComponentComputeAssociation> componentComputeAssociations =
 174           deploymentFlavorCompositionData.getComponentComputeAssociations();
 175       if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 176         for (ComponentComputeAssociation componentComputeAssociation :
 177             componentComputeAssociations) {
 178           String componentId = componentComputeAssociation.getComponentId();
 179           List<MultiFlavorVfcImage> componentImages =
 180               getComponentImages(vspId, version, componentId);
 181           if (CollectionUtils.isNotEmpty(componentImages)) {
 182             vspComponentImages.put(componentId, componentImages);
 183           }
 184         }
 185       }
 186     }
 187     return vspComponentImages;
 188   }
 189
 190   /**
 191    * Gets the component data for manually onboarded VSPs.
 192    *
 193    * @param vspId   the vsp id
 194    * @param version the version
 195    * @return the vsp components
 196    */
 197   public Map<String, String> getVspComponents(String vspId, Version version) {
 198     Map<String, String> componentIdNameMap = new HashMap<>();
 199     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 200         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 201     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 202       DeploymentFlavor deploymentFlavorCompositionData =
 203           deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 204
 205       List<ComponentComputeAssociation> componentComputeAssociations =
 206           deploymentFlavorCompositionData.getComponentComputeAssociations();
 207       if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 208         for (ComponentComputeAssociation componentComputeAssociation :
 209             componentComputeAssociations) {
 210           String componentId = componentComputeAssociation.getComponentId();
 211           Optional<String> componentName = getComponentName(vspId, version, componentId);
 212           componentName.ifPresent(name -> componentIdNameMap.put(componentId, name));
 213         }
 214       }
 215     }
 216     return componentIdNameMap;
 217   }
 218
 219   /**
 220    * Gets the NIC data for manually onboarded VSPs.
 221    *
 222    * @param vspId   the vsp id
 223    * @param version the version
 224    * @return the vsp component nics
 225    */
 226   public Map<String, List<Nic>> getVspComponentNics(String vspId, Version version) {
 227     Map<String, List<Nic>> vspComponentNics = new HashMap<>();
 228     Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
 229         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
 230     if (CollectionUtils.isNotEmpty(deploymentFlavorEntities)) {
 231       for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
 232         DeploymentFlavor deploymentFlavorCompositionData =
 233             deploymentFlavorEntity.getDeploymentFlavorCompositionData();
 234         if (Objects.nonNull(deploymentFlavorCompositionData)) {
 235           List<ComponentComputeAssociation> componentComputeAssociations =
 236               deploymentFlavorCompositionData.getComponentComputeAssociations();
 237           if (CollectionUtils.isNotEmpty(componentComputeAssociations)) {
 238             for (ComponentComputeAssociation componentComputeAssociation :
 239                 componentComputeAssociations) {
 240               String componentId = componentComputeAssociation.getComponentId();
 241               List<Nic> componentNics = getComponentNics(vspId, version, componentId);
 242               if (CollectionUtils.isNotEmpty(componentNics)) {
 243                 vspComponentNics.put(componentId, componentNics);
 244               }
 245             }
 246           }
 247         }
 248       }
 249     }
 250     return vspComponentNics;
 251   }
 252
 253   private List<Nic> getComponentNics(String vspId, Version version, String componentId) {
 254     List<Nic> componentNics = new ArrayList<>();
 255     Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
 256     if (Objects.nonNull(nics)) {
 257       for (NicEntity nic : nics) {
 258         String nicId = nic.getId();
 259         NicEntity nicEntity = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
 260         if (Objects.nonNull(nicEntity)
 261             && Objects.nonNull(nicEntity.getCompositionData())) {
 262           componentNics.add(nicEntity.getNicCompositionData());
 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) {
 277     FeatureGroupModel featureGroup = getFeatureGroup(vlmId, version, featureGroupId);
 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, String vendorModel, Version version,
 285                                              String featureGroupId) {
 286     VendorInfo vendorInfo = null;
 287     FeatureGroupModel featureGroup = getFeatureGroup(vlmId, version, featureGroupId);
 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(vendorModel);
 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     ComputeFlavor computeFlavor = null;
 303     ComputeEntity computeQuestionnaire = null;
 304     try {
 305       computeQuestionnaire = computeDao.getQuestionnaireData(vspId, version, componentId,
 306           computeFlavorId);
 307     } catch (Exception ex) {
 308       log.debug("", ex);
 309       computeQuestionnaire = null;
 310       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 311           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
 312           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Failed to get compute questionnaire : "
 313               + ex.getMessage());
 314     }
 315     if (Objects.nonNull(computeQuestionnaire)) {
 316       String computeQuestionnaireData = computeQuestionnaire.getQuestionnaireData();
 317       if (Objects.nonNull(computeQuestionnaireData)) {
 318         Compute compute;
 319         try {
 320           compute = JsonUtil.json2Object(computeQuestionnaireData, Compute.class);
 321         } catch (Exception ex) {
 322           log.debug("", ex);
 323           compute = null;
 324           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 325               LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
 326               LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to parse compute questionnaire : "
 327                   + ex.getMessage());
 328         }
 329         if (compute != null && Objects.nonNull(compute.getVmSizing())) {
 330           computeFlavor = new ComputeFlavor();
 331           if (Objects.nonNull(compute.getVmSizing().getNumOfCPUs())) {
 332             computeFlavor.setNum_cpus(compute.getVmSizing().getNumOfCPUs());
 333           }
 334           if (Objects.nonNull(compute.getVmSizing().getFileSystemSizeGB())) {
 335             computeFlavor.setDisk_size(compute.getVmSizing().getFileSystemSizeGB() + " GB");
 336           }
 337           if (Objects.nonNull(compute.getVmSizing().getMemoryRAM())) {
 338             computeFlavor.setMem_size(compute.getVmSizing().getMemoryRAM());
 339           }
 340         }
 341       }
 342     }
 343     return Optional.ofNullable(computeFlavor);
 344   }
 345
 346   private FeatureGroupModel getFeatureGroup(String vlmId, Version version, String featureGroupId) {
 347     FeatureGroupEntity fgInput = new FeatureGroupEntity();
 348     fgInput.setVendorLicenseModelId(vlmId);
 349     fgInput.setVersion(version);
 350     fgInput.setId(featureGroupId);
 351     return vendorLicenseFacade.getFeatureGroupModel(fgInput);
 352   }
 353
 354   private Optional<String> getComponentName(String vspId, Version version, String componentId) {
 355
 356     ComponentEntity componentEntity =
 357         componentDao.get(new ComponentEntity(vspId, version, componentId));
 358     if (Objects.nonNull(componentEntity)
 359         && Objects.nonNull(componentEntity.getComponentCompositionData())) {
 360       ComponentData componentCompositionData = componentEntity.getComponentCompositionData();
 361       return Optional.ofNullable(componentCompositionData.getDisplayName());
 362     }
 363     return Optional.empty();
 364   }
 365
 366   private List<MultiFlavorVfcImage> getComponentImages(String vspId, Version version,
 367                                                        String componentId) {
 368     List<MultiFlavorVfcImage> multiFlavorVfcImages = new ArrayList<>();
 369     MultiFlavorVfcImage multiFlavorVfcImage;
 370     Collection<ImageEntity> componentImages =
 371         imageDao.list(new ImageEntity(vspId, version, componentId, null));
 372     if (Objects.nonNull(componentImages)) {
 373       for (ImageEntity componentImage : componentImages) {
 374         ImageEntity imageEntity = imageDao.get(componentImage);
 375         ImageEntity imageQuestionnaireDataEntity = imageDao.getQuestionnaireData(vspId, version,
 376             componentId, componentImage.getId());
 377         Image imageCompositionData = imageEntity.getImageCompositionData();
 378         if (Objects.nonNull(imageEntity)
 379             && Objects.nonNull(imageQuestionnaireDataEntity)
 380             && Objects.nonNull(imageCompositionData)) {
 381           ImageDetails imageDetails;
 382           try {
 383             imageDetails = JsonUtil.json2Object(imageQuestionnaireDataEntity
 384                 .getQuestionnaireData(), ImageDetails.class);
 385           } catch (Exception ex) {
 386             log.debug("", ex);
 387             imageDetails = null;
 388             MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 389                 LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
 390                 LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to parse image questionnaire : "
 391                     + ex.getMessage());
 392           }
 393           if (Objects.nonNull(imageDetails)
 394               && Objects.nonNull(imageDetails.getVersion())) {
 395             //Image version is used as a key for the image block
 396             //So excluding the population if questionnaire data is absent or invalid
 397             multiFlavorVfcImage = new MultiFlavorVfcImage();
 398             multiFlavorVfcImage.setSoftware_version(imageDetails.getVersion());
 399             if (Objects.nonNull(imageCompositionData.getFileName())) {
 400               multiFlavorVfcImage.setFile_name(imageCompositionData.getFileName());
 401             }
 402             if (Objects.nonNull(imageDetails.getMd5())) {
 403               multiFlavorVfcImage.setFile_hash(imageDetails.getMd5());
 404             }
 405             multiFlavorVfcImage.setFile_hash_type("md5");
 406             multiFlavorVfcImages.add(multiFlavorVfcImage);
 407           }
 408         }
 409       }
 410     }
 411     return multiFlavorVfcImages;
 412   }
 413 }