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