gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.translator.services.heattotosca.helper;
   2
   3 import org.apache.commons.collections4.CollectionUtils;
   4
   5 import java.util.ArrayList;
   6 import java.util.HashMap;
   7 import java.util.List;
   8 import java.util.Map;
   9
  10 public class ResourceTranslationNeutronPortHelper {
  11
  12     public static final String IP_COUNT_REQUIRED = "ip_count_required";
  13     public static final String FLOATING_IP_COUNT_REQUIRED = "floating_ip_count_required";
  14     public static final String NETWORK = "network";
  15     public static final String NETWORK_ROLE_TAG = "network_role_tag";
  16     public static final String FIXED_IPS = "fixed_ips";
  17     public static final String IP_VERSION = "ip_version";
  18     public static final String IP_ADDRESS = "ip_address";
  19     public static final String GET_INPUT = "get_input";
  20     public static final String ALLOWED_ADDRESS_PAIRS = "allowed_address_pairs";
  21     public static final String FLOATING_IP = "_floating_ip";
  22     public static final String FLOATING_V6_IP = "_floating_v6_ip";
  23     public static final String IPS = "_ips";
  24     public static final String V6_IPS = "_v6_ips";
  25     public static final String NET_NAME = "_net_name";
  26     public static final String NET_ID = "_net_id";
  27     public static final String NET_FQDN = "_net_fqdn";
  28     public static final String IPV4_REGEX = "\\w*_ip_\\d+";
  29     public static final String IPV6_REGEX = "\\w*_v6_ip_\\d+";
  30     public static final String MAC_COUNT_REQUIRED = "mac_count_required";
  31     public static final String MAC_ADDRESS = "mac_address";
  32     public static final String IS_REQUIRED = "is_required";
  33     public static final String IP_REQUIREMENTS = "ip_requirements";
  34     public static final String MAC_REQUIREMENTS = "mac_requirements";
  35     public static final int DEFAULT_IP_VERSION = 4;
  36
  37     public void setAdditionalProperties(Map<String, Object> properties) {
  38         setRequirements(properties);
  39         setNetworkRoleTag(properties);
  40     }
  41
  42     private void setRequirements(Map<String, Object> properties) {
  43         properties.putAll(addRequirements());
  44         setIpRequirements(properties);
  45         setMacRequirements(properties);
  46     }
  47
  48     private void setIpRequirements(Map<String, Object> properties) {
  49         setFixedIpCount(properties);
  50         setFloatingIpCount(properties);
  51         addDefaultIpRequirement(properties);
  52     }
  53
  54     private Map<String, Object> addRequirements() {
  55         Map<String, Object> properties = new HashMap<>();
  56         List<Map<String, Object>> ipRequirementsList = new ArrayList<>();
  57         properties.put(IP_REQUIREMENTS, ipRequirementsList);
  58         properties.put(MAC_REQUIREMENTS, createMacRequirement());
  59         return properties;
  60
  61     }
  62
  63     private Map<String, Object> createMacRequirement() {
  64         Map<String, Object> macRequirements = new HashMap<>();
  65         Map<String, Object> macIsRequired = new HashMap<>();
  66         macIsRequired.put(IS_REQUIRED, Boolean.FALSE);
  67         macRequirements.put(MAC_COUNT_REQUIRED, macIsRequired);
  68         return macRequirements;
  69     }
  70
  71     private void setMacRequirements(Map<String, Object> properties) {
  72             updateMacCountRequired(properties);
  73     }
  74
  75     private void updateMacCountRequired(Map<String, Object> properties) {
  76         if (properties.containsKey(MAC_ADDRESS)) {
  77             Map<String, Object> macRequirements = (Map<String, Object>) properties.get(MAC_REQUIREMENTS);
  78             Map<String, Object> macIsRequired = (Map<String, Object>) macRequirements.get(MAC_COUNT_REQUIRED);
  79             macIsRequired.put(IS_REQUIRED, Boolean.TRUE);
  80         }
  81     }
  82
  83     private void setFloatingIpCount(Map<String, Object> properties) {
  84         handleIpCountRequired(properties, ALLOWED_ADDRESS_PAIRS, FLOATING_IP_COUNT_REQUIRED );
  85     }
  86
  87     private void setFixedIpCount(Map<String, Object> properties) {
  88         handleIpCountRequired(properties, FIXED_IPS, IP_COUNT_REQUIRED );
  89     }
  90
  91
  92     private void addDefaultIpRequirement(Map<String, Object> properties) {
  93         List<Map<String, Object>> ipRequirementsList = ((List<Map<String, Object>>) properties.get(IP_REQUIREMENTS));
  94         if(ipRequirementsList.isEmpty()) {
  95             ipRequirementsList.add(createIPRequirement(DEFAULT_IP_VERSION));
  96         }
  97     }
  98
  99     private Map<String, Object> createIPRequirement(Object version) {
 100         Map<String, Object> ipRequirements = new HashMap<>();
 101         Map<String, Object> isRequired = new HashMap<>();
 102         Map<String, Object> floatingIsRequired = new HashMap<>();
 103         isRequired.put(IS_REQUIRED, Boolean.FALSE);
 104         floatingIsRequired.put(IS_REQUIRED, Boolean.FALSE);
 105         ipRequirements.put(IP_COUNT_REQUIRED, isRequired);
 106         ipRequirements.put(FLOATING_IP_COUNT_REQUIRED, floatingIsRequired);
 107         ipRequirements.put(IP_VERSION, version);
 108         return ipRequirements;
 109     }
 110
 111     private void handleIpCountRequired(Map<String, Object> properties, String ipType, String ipCountRequired ){
 112
 113         Object propertyValue = properties.get(ipType);
 114         if(propertyValue == null){
 115             return;
 116         }
 117
 118         if (propertyValue instanceof Map && !((Map) propertyValue).isEmpty()) {
 119             handleMapProperty(ipType, ipCountRequired, properties, (Map.Entry<String, Object>) ((Map) propertyValue).entrySet().iterator().next());
 120         }
 121         else if (propertyValue instanceof List && !((List) propertyValue).isEmpty()) {
 122             handleListProperty(ipType, ipCountRequired, properties,  (List) propertyValue);
 123         }
 124
 125     }
 126
 127     private void handleListProperty(String ipType, String ipCountRequired, Map<String, Object> properties,  List propertyValue) {
 128         for (int i = 0; i < propertyValue.size(); i++) {
 129             handleIpAddress(ipType, ipCountRequired, properties,  propertyValue.get(i));
 130         }
 131     }
 132
 133     private void handleMapProperty(String ipType, String ipCountRequired, Map<String, Object> properties, Map.Entry<String, Object> mapEntry) {
 134         updateIpCountRequired(ipType, ipCountRequired, properties,  mapEntry.getValue());
 135     }
 136
 137     private void handleIpAddress(String ipType, String ipCountRequired, Map<String, Object> properties, Object ipMap) {
 138         if(ipMap instanceof Map && !((Map) ipMap).isEmpty()) {
 139             Object ipAddressMap = ((Map) ipMap).get(IP_ADDRESS);
 140             if (ipAddressMap instanceof Map && !((Map) ipAddressMap).isEmpty()) {
 141                 Object ipInput = ((Map) ipAddressMap).get(GET_INPUT);
 142                 updateIpCountRequired(ipType, ipCountRequired, properties,  ipInput);
 143             }
 144         }
 145     }
 146
 147     private void updateIpCountRequired(String ipType, String ipCountRequired, Map<String, Object> properties, Object ipInput) {
 148         Object ipVersion = getVersion(ipInput, ipType);
 149         updateIpCountRequiredForVersion(ipCountRequired, properties,  ipVersion);
 150     }
 151
 152     private void updateIpCountRequiredForVersion(String ipCountRequired, Map<String, Object> properties,   Object ipVersion) {
 153         if (ipVersion != null) {
 154             HashMap<Object, Map<String, Object>> ipRequirementsMap = getIPRequirements(properties);
 155             Map<String, Object>  ipRequirement = ipRequirementsMap.get(ipVersion);
 156             if (ipRequirement == null){
 157                 ipRequirement = addIPRequirement(properties, ipVersion);
 158             }
 159             updateIpCountRequired(ipCountRequired, ipRequirement);
 160         }
 161     }
 162
 163     private Map<String, Object> addIPRequirement(Map<String, Object> properties, Object ipVersion) {
 164         List<Map<String, Object>> ipRequirementsList = ((List<Map<String,Object>>) properties.get(IP_REQUIREMENTS));
 165         Map<String, Object> newIpRequirement = createIPRequirement(ipVersion);
 166         ipRequirementsList.add(newIpRequirement);
 167         return newIpRequirement;
 168     }
 169
 170     private void updateIpCountRequired(String ipCountRequired, Map<String, Object> ipRequirement) {
 171         Map<String, Object> isIPCountRequired = (Map<String, Object>)ipRequirement.get(ipCountRequired);
 172         isIPCountRequired.put(IS_REQUIRED, Boolean.TRUE);
 173     }
 174
 175     private HashMap <Object, Map<String, Object>> getIPRequirements (Map<String, Object> properties) {
 176         HashMap<Object, Map<String, Object>> ipRequirementsMap = new HashMap<>();
 177         List<Map<String, Object>> ipRequirementsList = ((List<Map<String,Object>>) properties.get(IP_REQUIREMENTS));
 178         ipRequirementsList.stream().forEach(e->ipRequirementsMap.put(e.get(IP_VERSION),e));
 179         return ipRequirementsMap;
 180     }
 181
 182     private void setNetworkRoleTag(Map<String, Object> properties) {
 183         Object propertyValue = properties.get(NETWORK);
 184         if (propertyValue instanceof Map && !((Map) propertyValue).isEmpty()) {
 185             Map.Entry<String, String> mapEntry =
 186                     (Map.Entry<String, String>) ((Map) propertyValue).entrySet().iterator().next();
 187             if (mapEntry.getValue() instanceof String && getNetworkRole(mapEntry.getValue())!=null) {
 188                 properties.put(NETWORK_ROLE_TAG, getNetworkRole(mapEntry.getValue()));
 189             }
 190         }
 191     }
 192
 193     private Object getVersion(Object value, String type) {
 194
 195         Object version = null;
 196         if(type.equals(FIXED_IPS)){
 197             version =  getIpVersion(value);
 198         }
 199         else if(type.equals(ALLOWED_ADDRESS_PAIRS)){
 200             version =  getFloatingIpVersion(value);
 201         }
 202         return version;
 203     }
 204
 205     private Object getFloatingIpVersion(Object value) {
 206         Object ipVersion = null;
 207
 208         // Allowed ONLY String parameter
 209         if(value instanceof String) {
 210             if (((String) value).endsWith(FLOATING_V6_IP)) {
 211                 ipVersion = 6;
 212             }
 213             else if (((String) value).endsWith(FLOATING_IP)){
 214                 ipVersion = 4;
 215             }
 216         }
 217         return ipVersion;
 218     }
 219
 220     private Object getIpVersion(Object value) {
 221
 222         // Allowed List or String parameter
 223         Object ipVersion = null;
 224         if (value instanceof List && !((List) value).isEmpty()){
 225             value = ((List) value).get(0);
 226         }
 227
 228         if(value instanceof String) {
 229             if (((String) value).endsWith(V6_IPS) || ((String) value).matches(IPV6_REGEX)) {
 230                 ipVersion = 6;
 231             }
 232             else {
 233                 ipVersion = 4;
 234             }
 235         }
 236         return ipVersion;
 237     }
 238
 239     private Object getNetworkRole(String value) {
 240         Object networkRole = null;
 241         if(value.endsWith(NET_NAME)) {
 242             networkRole = value.substring(0, value.length() - NET_NAME.length());
 243         }
 244         else if(value.endsWith(NET_ID)) {
 245             networkRole = value.substring(0, value.length() - NET_ID.length());
 246         }
 247         else if(value.endsWith(NET_FQDN)) {
 248             networkRole = value.substring(0, value.length() - NET_FQDN.length());
 249         }
 250         return networkRole;
 251     }
 252 }