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

   1 package org.openecomp.sdc.be.tosca;
   2
   3 import fj.data.Either;
   4 import org.apache.commons.lang.StringUtils;
   5 import org.openecomp.sdc.be.components.impl.exceptions.SdcResourceNotFoundException;
   6 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
   7 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
   8 import org.openecomp.sdc.be.model.*;
   9 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  10 import org.openecomp.sdc.be.model.utils.ComponentUtilities;
  11 import org.openecomp.sdc.be.model.utils.GroupUtils;
  12 import org.openecomp.sdc.be.tosca.model.*;
  13 import org.openecomp.sdc.common.api.Constants;
  14 import org.openecomp.sdc.common.log.wrappers.Logger;
  15 import org.springframework.beans.factory.annotation.Autowired;
  16 import org.springframework.stereotype.Service;
  17
  18 import java.util.*;
  19 import java.util.function.Predicate;
  20 import java.util.function.Supplier;
  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 @Service
  32 public class GroupExportParserImpl implements GroupExportParser {
  33
  34     private static final Logger log = Logger.getLogger(GroupExportParserImpl.class);
  35
  36     private Map<String, DataTypeDefinition> dataTypes;
  37     private ApplicationDataTypeCache dataTypeCache;
  38     private PropertyConvertor propertyConvertor = PropertyConvertor.getInstance();
  39
  40     @Autowired
  41         public GroupExportParserImpl(ApplicationDataTypeCache dataTypeCache) {
  42                 this.dataTypeCache = dataTypeCache;
  43                 this.dataTypes = getDataTypes();
  44         }
  45
  46     private Map<String, DataTypeDefinition> getDataTypes()  {
  47                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> dataTypesEither = dataTypeCache.getAll();
  48                 if (dataTypesEither.isRight()) {
  49                         log.error("Failed to retrieve all data types {}", dataTypesEither.right().value());
  50                         throw new SdcResourceNotFoundException();
  51                 }
  52
  53                 return dataTypesEither.left().value();
  54         }
  55
  56         @Override
  57         public Map<String, ToscaGroupTemplate> getGroups(Component component) {
  58                 List<GroupDefinition> groups = component.getGroups();
  59
  60                 if (isEmpty(groups)) {
  61                         return null;
  62                 }
  63
  64                 return groups.stream()
  65                                 .collect(toMap(GroupDefinition::getName,
  66                                                   group -> getToscaGroupTemplate(component, group)));
  67         }
  68
  69         @Override
  70         public ToscaGroupTemplate getToscaGroupTemplate(GroupInstance groupInstance, String componentInstanceInvariantName) {
  71
  72                 String groupName = groupInstance.getName();
  73                 if (StringUtils.isNotEmpty(componentInstanceInvariantName)) {
  74                         String prefix = componentInstanceInvariantName + Constants.GROUP_POLICY_NAME_DELIMETER;
  75                         if (groupName.startsWith(prefix)) {
  76                                 groupName = groupName.substring(prefix.length());
  77                         }
  78                 }
  79                 String invariantUUID = groupInstance.getInvariantUUID();
  80                 String groupUUID = groupInstance.getGroupUUID();
  81                 String version = groupInstance.getVersion();
  82                 List<GroupInstanceProperty> groupInstanceProperties = groupInstance.convertToGroupInstancesProperties();
  83                 String groupType = groupInstance.getType();
  84                 String customizationUUID = groupInstance.getCustomizationUUID();
  85
  86                 IToscaMetadata toscaMetadata = getToscaGroupTemplateMetadata(groupName, invariantUUID, groupUUID, version, groupType, customizationUUID);
  87                 Map<String, Object> properties = getToscaGroupTemplateProperties(groupInstanceProperties);
  88
  89         return new ToscaGroupTemplate(groupType, toscaMetadata, properties);
  90         }
  91
  92         private ToscaGroupTemplate getToscaGroupTemplate(Component component, GroupDefinition groupDefinition) {
  93
  94                 String groupName = groupDefinition.getName();
  95                 String invariantUUID = groupDefinition.getInvariantUUID();
  96                 String groupUUID = groupDefinition.getGroupUUID();
  97                 String version = groupDefinition.getVersion();
  98                 String groupType = groupDefinition.getType();
  99                 List<PropertyDataDefinition> groupDefinitionProperties = groupDefinition.getProperties();
 100
 101                 List<String> members = getToscaGroupTemplateMembers(component, groupDefinition.getMembers());
 102                 IToscaMetadata toscaMetadata = getToscaGroupTemplateMetadata(groupName, invariantUUID, groupUUID, version,groupType, null);
 103                 Map<String, Object> properties = getToscaGroupTemplateProperties(groupDefinitionProperties);
 104                 Map<String, ToscaTemplateCapability> capabilities = getToscaGroupTemplateCapabilities(groupDefinition);
 105
 106                 return new ToscaGroupTemplate(groupType, members, toscaMetadata, properties, capabilities);
 107         }
 108
 109         private Map<String, ToscaTemplateCapability> getToscaGroupTemplateCapabilities(GroupDefinition group) {
 110                 if (isEmpty(group.getCapabilities())) {
 111                         return null;
 112                 }
 113
 114                 Map<String, ToscaTemplateCapability> toscaGroupTemplateCapabilities = group.getCapabilities().values()
 115                                 .stream()
 116                                 .flatMap(Collection::stream)
 117                                 .filter(c -> isNotEmptyProperties(c.getProperties()))
 118                                 .collect(toMap(c-> getCapabilityName(c, group), this::getToscaTemplateCapability));
 119
 120                 if (isNotEmpty(toscaGroupTemplateCapabilities)) {
 121                         return toscaGroupTemplateCapabilities;
 122                 } else {
 123                         return null;
 124                 }
 125         }
 126
 127         private String getCapabilityName(CapabilityDefinition capability, GroupDefinition group) {
 128         if(ComponentUtilities.isNotUpdatedCapReqName(group.getNormalizedName() + ".", capability.getName(), capability.getPreviousName())){
 129                 return capability.getName();
 130                 }
 131                 return capability.getPreviousName();
 132         }
 133
 134         private boolean isNotEmptyProperties(List<ComponentInstanceProperty> properties) {
 135         return isNotEmpty(properties) && properties.stream()
 136                                 .filter(isComponentInstancePropertiesNotEmpty())
 137                                 .findFirst()
 138                                 .isPresent();
 139         }
 140
 141         private ToscaTemplateCapability getToscaTemplateCapability(CapabilityDefinition capability) {
 142                 ToscaTemplateCapability toscaTemplateCapability = new ToscaTemplateCapability();
 143                 Map<String, Object> toscaCapabilityProperties = capability.getProperties().stream()
 144                                 .filter(isComponentInstancePropertiesNotEmpty())
 145                                 .collect(toMap(ComponentInstanceProperty::getName,
 146                                                                                   this::fetchCapabilityValue));
 147                 if(isNotEmpty(toscaCapabilityProperties)) {
 148                         toscaTemplateCapability.setProperties(toscaCapabilityProperties);
 149                 }
 150                 return toscaTemplateCapability;
 151         }
 152
 153         private Predicate<? super ComponentInstanceProperty> isComponentInstancePropertiesNotEmpty() {
 154                 return c -> {
 155                         return (c.getName() != null && (c.getValue() != null || c.getDefaultValue() != null));
 156                 };
 157         }
 158
 159         private String fetchCapabilityValue(ComponentInstanceProperty componentInstanceProperty) {
 160                 if(componentInstanceProperty.getValue() != null) {
 161                         return componentInstanceProperty.getValue();
 162                 }else {
 163                         return componentInstanceProperty.getDefaultValue();
 164                 }
 165         }
 166
 167         private List<String> getToscaGroupTemplateMembers(Component component, Map<String, String> members) {
 168                 if (members == null) {
 169                         return null;
 170                 }
 171                 return members.values()
 172                                 .stream()
 173                                 .map(memberId -> getMemberNameByMemberId(component, memberId))
 174                                 .filter(Optional::isPresent)
 175                                 .map(Optional::get)
 176                                 .collect(toList());
 177         }
 178
 179         private Optional<String> getMemberNameByMemberId(Component component, String memberId) {
 180         return getComponentInstanceNameByInstanceId(component, memberId);
 181         }
 182
 183         private IToscaMetadata getToscaGroupTemplateMetadata(String groupName,String invariantUUID,
 184                                                                      String groupUUID,String version,String type, String customizationUUID) {
 185
 186                 IToscaMetadata toscaMetadata = getToscaMetadataByType(type);
 187
 188                 toscaMetadata.setName(groupName);
 189                 toscaMetadata.setInvariantUUID(invariantUUID);
 190                 toscaMetadata.setUUID(groupUUID);
 191                 toscaMetadata.setVersion(version);
 192                 toscaMetadata.setCustomizationUUID(customizationUUID);
 193                 return toscaMetadata;
 194         }
 195
 196         private IToscaMetadata getToscaMetadataByType(String type) {
 197                 IToscaMetadata toscaMetadata;
 198                 if (GroupUtils.isVfModule(type)) {
 199                         toscaMetadata = new VfModuleToscaMetadata();
 200                 } else {
 201                         toscaMetadata = new ToscaMetadata();
 202                 }
 203                 return toscaMetadata;
 204         }
 205
 206         private Map<String, Object> getToscaGroupTemplateProperties(List<? extends PropertyDataDefinition> tempProperties) {
 207
 208                 if (isEmpty(tempProperties)) {
 209                         return null;
 210                 }
 211
 212                 Map<String, Object> props = new HashMap<>();
 213
 214                 tempProperties.forEach(input ->
 215                         propertyConvertor.convertAndAddValue(dataTypes, props, input, getPropertyValue(input))
 216                 );
 217
 218                 if (props.isEmpty()) {
 219                         return null;
 220                 } else {
 221                         return props;
 222                 }
 223         }
 224
 225         private Supplier<String> getPropertyValue(PropertyDataDefinition propertyDataDefinition) {
 226                 return () -> {
 227                         if (isNotEmpty(propertyDataDefinition.getValue())) {
 228                                 return propertyDataDefinition.getValue();
 229                         } else {
 230                                 return propertyDataDefinition.getDefaultValue();
 231                         }
 232                 };
 233         }
 234 }