catalog-be/src/main/java/org/openecomp/sdc/be/tosca/GroupExportParserImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.openecomp.sdc.be.tosca;
  21
  22 import static java.util.stream.Collectors.toList;
  23 import static java.util.stream.Collectors.toMap;
  24 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  25 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
  26 import static org.apache.commons.collections.MapUtils.isEmpty;
  27 import static org.apache.commons.collections.MapUtils.isNotEmpty;
  28 import static org.apache.commons.lang.StringUtils.isNotEmpty;
  29 import static org.openecomp.sdc.be.model.utils.ComponentUtilities.getComponentInstanceNameByInstanceId;
  30
  31 import fj.data.Either;
  32 import java.util.Collection;
  33 import java.util.HashMap;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Optional;
  37 import java.util.function.Predicate;
  38 import java.util.function.Supplier;
  39 import org.apache.commons.lang3.StringUtils;
  40 import org.openecomp.sdc.be.components.impl.exceptions.SdcResourceNotFoundException;
  41 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  42 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  43 import org.openecomp.sdc.be.model.CapabilityDefinition;
  44 import org.openecomp.sdc.be.model.Component;
  45 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  46 import org.openecomp.sdc.be.model.DataTypeDefinition;
  47 import org.openecomp.sdc.be.model.GroupDefinition;
  48 import org.openecomp.sdc.be.model.GroupInstance;
  49 import org.openecomp.sdc.be.model.GroupInstanceProperty;
  50 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  51 import org.openecomp.sdc.be.model.utils.ComponentUtilities;
  52 import org.openecomp.sdc.be.model.utils.GroupUtils;
  53 import org.openecomp.sdc.be.tosca.model.IToscaMetadata;
  54 import org.openecomp.sdc.be.tosca.model.ToscaGroupTemplate;
  55 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
  56 import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
  57 import org.openecomp.sdc.be.tosca.model.VfModuleToscaMetadata;
  58 import org.openecomp.sdc.common.api.Constants;
  59 import org.openecomp.sdc.common.log.wrappers.Logger;
  60 import org.springframework.beans.factory.annotation.Autowired;
  61 import org.springframework.context.event.EventListener;
  62
  63 @org.springframework.stereotype.Component
  64 public class GroupExportParserImpl implements GroupExportParser {
  65
  66     private static final Logger log = Logger.getLogger(GroupExportParserImpl.class);
  67     private final PropertyConvertor propertyConvertor;
  68     private Map<String, DataTypeDefinition> dataTypes;
  69     private ApplicationDataTypeCache dataTypeCache;
  70
  71     @Autowired
  72     public GroupExportParserImpl(ApplicationDataTypeCache dataTypeCache, PropertyConvertor propertyConvertor) {
  73         this.dataTypeCache = dataTypeCache;
  74         this.propertyConvertor = propertyConvertor;
  75         this.dataTypes = getDataTypes();
  76     }
  77
  78     private Map<String, DataTypeDefinition> getDataTypes() {
  79         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypesEither = dataTypeCache.getAll();
  80         if (dataTypesEither.isRight()) {
  81             log.error("Failed to retrieve all data types {}", dataTypesEither.right().value());
  82             throw new SdcResourceNotFoundException();
  83         }
  84         return dataTypesEither.left().value();
  85     }
  86
  87     @EventListener
  88     public void onDataTypesCacheChangedEvent(ApplicationDataTypeCache.DataTypesCacheChangedEvent dataTypesCacheChangedEvent) {
  89         dataTypes = dataTypesCacheChangedEvent.getNewData();
  90         log.debug("Data types cache updated.");
  91     }
  92
  93     @Override
  94     public Map<String, ToscaGroupTemplate> getGroups(Component component) {
  95         List<GroupDefinition> groups = component.getGroups();
  96         if (isEmpty(groups)) {
  97             return null;
  98         }
  99         return groups.stream().collect(toMap(GroupDefinition::getName, group -> getToscaGroupTemplate(component, group)));
 100     }
 101
 102     @Override
 103     public ToscaGroupTemplate getToscaGroupTemplate(GroupInstance groupInstance, String componentInstanceInvariantName) {
 104         String groupName = groupInstance.getName();
 105         if (StringUtils.isNotEmpty(componentInstanceInvariantName)) {
 106             String prefix = componentInstanceInvariantName + Constants.GROUP_POLICY_NAME_DELIMETER;
 107             if (groupName.startsWith(prefix)) {
 108                 groupName = groupName.substring(prefix.length());
 109             }
 110         }
 111         String invariantUUID = groupInstance.getInvariantUUID();
 112         String groupUUID = groupInstance.getGroupUUID();
 113         String version = groupInstance.getVersion();
 114         List<GroupInstanceProperty> groupInstanceProperties = groupInstance.convertToGroupInstancesProperties();
 115         String groupType = groupInstance.getType();
 116         String customizationUUID = groupInstance.getCustomizationUUID();
 117         IToscaMetadata toscaMetadata = getToscaGroupTemplateMetadata(groupName, invariantUUID, groupUUID, version, groupType, customizationUUID);
 118         Map<String, Object> properties = getToscaGroupTemplateProperties(groupInstanceProperties);
 119         return new ToscaGroupTemplate(groupType, toscaMetadata, properties);
 120     }
 121
 122     private ToscaGroupTemplate getToscaGroupTemplate(Component component, GroupDefinition groupDefinition) {
 123         String groupName = groupDefinition.getName();
 124         String invariantUUID = groupDefinition.getInvariantUUID();
 125         String groupUUID = groupDefinition.getGroupUUID();
 126         String version = groupDefinition.getVersion();
 127         String groupType = groupDefinition.getType();
 128         List<PropertyDataDefinition> groupDefinitionProperties = groupDefinition.getProperties();
 129         List<String> members = getToscaGroupTemplateMembers(component, groupDefinition.getMembers());
 130         IToscaMetadata toscaMetadata = getToscaGroupTemplateMetadata(groupName, invariantUUID, groupUUID, version, groupType, null);
 131         Map<String, Object> properties = getToscaGroupTemplateProperties(groupDefinitionProperties);
 132         Map<String, ToscaTemplateCapability> capabilities = getToscaGroupTemplateCapabilities(groupDefinition);
 133         return new ToscaGroupTemplate(groupType, members, toscaMetadata, properties, capabilities);
 134     }
 135
 136     private Map<String, ToscaTemplateCapability> getToscaGroupTemplateCapabilities(GroupDefinition group) {
 137         if (isEmpty(group.getCapabilities())) {
 138             return null;
 139         }
 140         Map<String, ToscaTemplateCapability> toscaGroupTemplateCapabilities = group.getCapabilities().values().stream().flatMap(Collection::stream)
 141             .filter(c -> isNotEmptyProperties(c.getProperties())).collect(toMap(c -> getCapabilityName(c, group), this::getToscaTemplateCapability));
 142         if (isNotEmpty(toscaGroupTemplateCapabilities)) {
 143             return toscaGroupTemplateCapabilities;
 144         } else {
 145             return null;
 146         }
 147     }
 148
 149     private String getCapabilityName(CapabilityDefinition capability, GroupDefinition group) {
 150         if (ComponentUtilities.isNotUpdatedCapReqName(group.getNormalizedName() + ".", capability.getName(), capability.getPreviousName())) {
 151             return capability.getName();
 152         }
 153         return capability.getPreviousName();
 154     }
 155
 156     private boolean isNotEmptyProperties(List<ComponentInstanceProperty> properties) {
 157         return isNotEmpty(properties) && properties.stream().filter(isComponentInstancePropertiesNotEmpty()).findFirst().isPresent();
 158     }
 159
 160     private ToscaTemplateCapability getToscaTemplateCapability(CapabilityDefinition capability) {
 161         ToscaTemplateCapability toscaTemplateCapability = new ToscaTemplateCapability();
 162         Map<String, Object> toscaCapabilityProperties = capability.getProperties().stream().filter(isComponentInstancePropertiesNotEmpty())
 163             .collect(toMap(ComponentInstanceProperty::getName, this::fetchCapabilityValue));
 164         if (isNotEmpty(toscaCapabilityProperties)) {
 165             toscaTemplateCapability.setProperties(toscaCapabilityProperties);
 166         }
 167         return toscaTemplateCapability;
 168     }
 169
 170     private Predicate<? super ComponentInstanceProperty> isComponentInstancePropertiesNotEmpty() {
 171         return c -> {
 172             return (c.getName() != null && (c.getValue() != null || c.getDefaultValue() != null));
 173         };
 174     }
 175
 176     private String fetchCapabilityValue(ComponentInstanceProperty componentInstanceProperty) {
 177         if (componentInstanceProperty.getValue() != null) {
 178             return componentInstanceProperty.getValue();
 179         } else {
 180             return componentInstanceProperty.getDefaultValue();
 181         }
 182     }
 183
 184     private List<String> getToscaGroupTemplateMembers(Component component, Map<String, String> members) {
 185         if (members == null) {
 186             return null;
 187         }
 188         return members.values().stream().map(memberId -> getMemberNameByMemberId(component, memberId)).filter(Optional::isPresent).map(Optional::get)
 189             .collect(toList());
 190     }
 191
 192     private Optional<String> getMemberNameByMemberId(Component component, String memberId) {
 193         return getComponentInstanceNameByInstanceId(component, memberId);
 194     }
 195
 196     private IToscaMetadata getToscaGroupTemplateMetadata(String groupName, String invariantUUID, String groupUUID, String version, String type,
 197                                                          String customizationUUID) {
 198         IToscaMetadata toscaMetadata = getToscaMetadataByType(type);
 199         toscaMetadata.setName(groupName);
 200         toscaMetadata.setInvariantUUID(invariantUUID);
 201         toscaMetadata.setUUID(groupUUID);
 202         toscaMetadata.setVersion(version);
 203         toscaMetadata.setCustomizationUUID(customizationUUID);
 204         return toscaMetadata;
 205     }
 206
 207     private IToscaMetadata getToscaMetadataByType(String type) {
 208         IToscaMetadata toscaMetadata;
 209         if (GroupUtils.isVfModule(type)) {
 210             toscaMetadata = new VfModuleToscaMetadata();
 211         } else {
 212             toscaMetadata = new ToscaMetadata();
 213         }
 214         return toscaMetadata;
 215     }
 216
 217     private Map<String, Object> getToscaGroupTemplateProperties(List<? extends PropertyDataDefinition> tempProperties) {
 218         if (isEmpty(tempProperties)) {
 219             return null;
 220         }
 221         Map<String, Object> props = new HashMap<>();
 222         tempProperties.forEach(input -> propertyConvertor.convertAndAddValue(dataTypes, props, input, getPropertyValue(input)));
 223         if (props.isEmpty()) {
 224             return null;
 225         } else {
 226             return props;
 227         }
 228     }
 229
 230     private Supplier<String> getPropertyValue(PropertyDataDefinition propertyDataDefinition) {
 231         return () -> {
 232             if (isNotEmpty(propertyDataDefinition.getValue())) {
 233                 return propertyDataDefinition.getValue();
 234             } else {
 235                 return propertyDataDefinition.getDefaultValue();
 236             }
 237         };
 238     }
 239 }