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

   1 package org.openecomp.sdc.be.tosca;
   2
   3
   4 import fj.data.Either;
   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.PolicyTargetType;
   8 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
   9 import org.openecomp.sdc.be.model.*;
  10 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  11 import org.openecomp.sdc.be.tosca.model.IToscaMetadata;
  12 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
  13 import org.openecomp.sdc.be.tosca.model.ToscaPolicyTemplate;
  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.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.function.Supplier;
  23 import java.util.stream.Collectors;
  24
  25 import static org.apache.commons.collections.CollectionUtils.isEmpty;
  26 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
  27 import static org.apache.commons.collections.MapUtils.isNotEmpty;
  28 import static org.apache.commons.lang.StringUtils.isNotEmpty;
  29
  30 @Service
  31 public class PolicyExportParserImpl implements PolicyExportParser {
  32
  33         private static final Logger log = Logger.getLogger(PolicyExportParserImpl.class);
  34
  35         private ApplicationDataTypeCache dataTypeCache;
  36         private Map<String, DataTypeDefinition> dataTypes;
  37         private PropertyConvertor propertyConvertor = PropertyConvertor.getInstance();
  38
  39         @Autowired
  40         public PolicyExportParserImpl(ApplicationDataTypeCache dataTypeCache) {
  41                 this.dataTypeCache = dataTypeCache;
  42                 this.dataTypes = getDataTypes();
  43         }
  44
  45         private Map<String, DataTypeDefinition> getDataTypes()  {
  46                 Either<Map<String, DataTypeDefinition>, TitanOperationStatus> dataTypesEither = dataTypeCache.getAll();
  47                 if (dataTypesEither.isRight()) {
  48                         log.error("Failed to retrieve all data types {}", dataTypesEither.right().value());
  49                         throw new SdcResourceNotFoundException();
  50                 }
  51
  52                 return dataTypesEither.left().value();
  53         }
  54
  55         @Override
  56         public Map<String, ToscaPolicyTemplate> getPolicies(Component component) {
  57                 Map<String, ToscaPolicyTemplate> toscaPolicies = null;
  58                 Map<String, PolicyDefinition> policies = component.getPolicies();
  59                 if (isNotEmpty(policies)) {
  60
  61                          toscaPolicies = policies.values().stream().collect(
  62                                          Collectors.toMap(
  63                                                          PolicyDefinition::getName,
  64                                                          policy->getToscaPolicyTemplate(policy,component)));
  65                         log.debug("policies converted");
  66                 }
  67                 return toscaPolicies;
  68         }
  69
  70         private ToscaPolicyTemplate getToscaPolicyTemplate(PolicyDefinition policyDefinition,Component component) {
  71
  72                  String type = policyDefinition.getPolicyTypeName();
  73              IToscaMetadata metadata = getToscaPolicyTemplateMetadata(policyDefinition);
  74              Map<String, Object> properties = getToscaPolicyTemplateProperties(policyDefinition);
  75              List<String> targets = getToscaPolicyTemplateTargets(
  76                          policyDefinition,component.getComponentInstances(),component.getGroups());
  77
  78                 return new ToscaPolicyTemplate(type, metadata, properties, targets);
  79         }
  80
  81         private List<String> getToscaPolicyTemplateTargets(PolicyDefinition policyDefinition,
  82                         List<ComponentInstance> componentInstances, List<GroupDefinition> groups) {
  83
  84                 Map<PolicyTargetType, List<String>> targets = policyDefinition.getTargets();
  85                 List<String> targetNames = null;
  86
  87                 if (targets == null || targets.isEmpty()) {
  88                         return null;
  89                 }
  90
  91                 List<String> componentInstancesTargets = targets.get(PolicyTargetType.COMPONENT_INSTANCES);
  92                 List<String> groupTargets = targets.get(PolicyTargetType.GROUPS);
  93
  94                 if (isNotEmpty(componentInstancesTargets) && isNotEmpty(componentInstances)) {
  95                         // get target names by Id from component instances
  96                         Map<String, String> targetNamesByIdFromComponentInstances =
  97                                         getTargetNamesByIdFromComponentInstances(componentInstances);
  98                         targetNames = targetNamesLazyInstantiation(targetNames);
  99                         addTargetNames(componentInstancesTargets, targetNames, targetNamesByIdFromComponentInstances);
 100
 101                 }
 102
 103                 if (isNotEmpty(groupTargets) && isNotEmpty(groups)) {
 104                         // get target names by id from group definitions
 105                         Map<String, String> targetNamesByIdFromGroupDefinitions = getTargetNamesByIdFromGroupDefinitions(groups);
 106                         targetNames = targetNamesLazyInstantiation(targetNames);
 107                         addTargetNames(groupTargets, targetNames, targetNamesByIdFromGroupDefinitions);
 108
 109                 }
 110
 111                 return targetNames;
 112         }
 113
 114         private List<String> targetNamesLazyInstantiation(List<String> targetNames) {
 115                 if (targetNames == null) {
 116                         targetNames = new ArrayList<>();
 117                 }
 118                 return targetNames;
 119         }
 120
 121         private void addTargetNames(List<String> targets, List<String> targetNames,
 122                         Map<String, String> targetNamesById) {
 123
 124                 if (!targetNamesById.isEmpty()) {
 125
 126                         for (String id : targets) {
 127                                 String name = targetNamesById.get(id);
 128                                 if (name != null) {
 129                                         targetNames.add(name);
 130                                 }
 131                         }
 132                 }
 133         }
 134
 135         private Map<String, String> getTargetNamesByIdFromGroupDefinitions(List<GroupDefinition> groups) {
 136                 return groups.stream().collect(
 137                                 Collectors.toMap(GroupDefinition::getUniqueId, GroupDefinition::getName));
 138         }
 139
 140         private Map<String, String> getTargetNamesByIdFromComponentInstances(List<ComponentInstance> componentInstances) {
 141                 return componentInstances.stream().collect(
 142                                 Collectors.toMap(ComponentInstance::getUniqueId,ComponentInstance::getName));
 143         }
 144
 145         private Map<String, Object> getToscaPolicyTemplateProperties(PolicyDefinition policyDefinition) {
 146
 147                 List<PropertyDataDefinition> tempProperties = policyDefinition.getProperties();
 148
 149                 if (isEmpty(tempProperties)) {
 150                         return null;
 151                 }
 152
 153                 Map<String, Object> props = new HashMap<>();
 154
 155                 tempProperties.forEach(input ->
 156                         propertyConvertor.convertAndAddValue(dataTypes, props, input, getPropertyValue(input))
 157                 );
 158
 159                 if (props.isEmpty()) {
 160                         return null;
 161                 } else {
 162                         return props;
 163                 }
 164         }
 165
 166         private Supplier<String> getPropertyValue(PropertyDataDefinition propertyDataDefinition) {
 167                 return () -> {
 168                         if (isNotEmpty(propertyDataDefinition.getValue())) {
 169                                 return propertyDataDefinition.getValue();
 170                         } else {
 171                                 return propertyDataDefinition.getDefaultValue();
 172                         }
 173                 };
 174         }
 175
 176         private IToscaMetadata getToscaPolicyTemplateMetadata(PolicyDefinition policyDefinition) {
 177                 IToscaMetadata metadata = new ToscaMetadata();
 178                 metadata.setInvariantUUID(policyDefinition.getInvariantUUID());
 179                 metadata.setUUID(policyDefinition.getPolicyUUID());
 180                 metadata.setName(policyDefinition.getName());
 181                 metadata.setVersion(policyDefinition.getVersion());
 182                 return metadata;
 183         }
 184
 185 }