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