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