gerrit.onap Code Review - sdc.git/blob

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