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