gerrit.onap Code Review - sdc.git/blob

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