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         setRequirments(properties);
  39         setNetworkRoleTag(properties);
  40     }
  41
  42     private void setRequirments(Map<String, Object> properties) {
  43         properties.putAll(addRequirments());
  44         setIpRequirments(properties);
  45         setMacRequirments(properties);
  46     }
  47
  48     private void setIpRequirments(Map<String, Object> properties) {
  49         setFixedIpCount(properties);
  50         setFloatingIpCount(properties);
  51         addDefaultIpRequirment(properties);
  52     }
  53
  54     private Map<String, Object> addRequirments() {
  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, createMacRequirment());
  59         return properties;
  60
  61     }
  62
  63     private Map<String, Object> createMacRequirment() {
  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 setMacRequirments(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 addDefaultIpRequirment(Map<String, Object> properties) {
  93         List<Map<String, Object>> ipRequirmentsList = ((List<Map<String, Object>>) properties.get(IP_REQUIREMENTS));
  94
  95         if(CollectionUtils.isEmpty(ipRequirmentsList)) {
  96             ipRequirmentsList.add(createIPRequirment(DEFAULT_IP_VERSION));
  97         }
  98     }
  99
 100     private Map<String, Object> createIPRequirment(Object version) {
 101         Map<String, Object> ipRequirements = new HashMap();
 102         Map<String, Object> isRequired = new HashMap();
 103         Map<String, Object> floatingIsRequired = new HashMap();
 104         isRequired.put(IS_REQUIRED, Boolean.FALSE);
 105         floatingIsRequired.put(IS_REQUIRED, Boolean.FALSE);
 106         ipRequirements.put(IP_COUNT_REQUIRED, isRequired);
 107         ipRequirements.put(FLOATING_IP_COUNT_REQUIRED, floatingIsRequired);
 108         ipRequirements.put(IP_VERSION, version);
 109         return ipRequirements;
 110     }
 111
 112     private void handleIpCountRequired(Map<String, Object> properties, String ipType, String ipCountRequired ){
 113
 114         Object propertyValue = properties.get(ipType);
 115         if(propertyValue == null){
 116             return;
 117         }
 118
 119         if (propertyValue instanceof Map && !((Map) propertyValue).isEmpty()) {
 120             handleMapProperty(ipType, ipCountRequired, properties, (Map.Entry<String, Object>) ((Map) propertyValue).entrySet().iterator().next());
 121         }
 122         else if (propertyValue instanceof List && !((List) propertyValue).isEmpty()) {
 123             handleListProperty(ipType, ipCountRequired, properties,  (List) propertyValue);
 124         }
 125
 126     }
 127
 128     private void handleListProperty(String ipType, String ipCountRequired, Map<String, Object> properties,  List propertyValue) {
 129         for (int i = 0; i < propertyValue.size(); i++) {
 130             handleIpAddress(ipType, ipCountRequired, properties,  propertyValue.get(i));
 131         }
 132     }
 133
 134     private void handleMapProperty(String ipType, String ipCountRequired, Map<String, Object> properties, Map.Entry<String, Object> mapEntry) {
 135         updateIpCountRequired(ipType, ipCountRequired, properties,  mapEntry.getValue());
 136     }
 137
 138     private void handleIpAddress(String ipType, String ipCountRequired, Map<String, Object> properties, Object ipMap) {
 139         if(ipMap instanceof Map && !((Map) ipMap).isEmpty()) {
 140             Object ipAddressMap = ((Map) ipMap).get(IP_ADDRESS);
 141             if (ipAddressMap instanceof Map && !((Map) ipAddressMap).isEmpty()) {
 142                 Object ipInput = ((Map) ipAddressMap).get(GET_INPUT);
 143                 updateIpCountRequired(ipType, ipCountRequired, properties,  ipInput);
 144             }
 145         }
 146     }
 147
 148     private void updateIpCountRequired(String ipType, String ipCountRequired, Map<String, Object> properties, Object ipInput) {
 149         Object ipVersion = getVersion(ipInput, ipType);
 150         updateIpCountRequiredForVersion(ipCountRequired, properties,  ipVersion);
 151     }
 152
 153     private void updateIpCountRequiredForVersion(String ipCountRequired, Map<String, Object> properties,   Object ipVersion) {
 154         if (ipVersion != null) {
 155             HashMap<Object, Map<String, Object>> ipRequirmentsMap = getIPRequirments(properties);
 156             Map<String, Object>  ipRequirement = ipRequirmentsMap.get(ipVersion);
 157             if (ipRequirement == null){
 158                 ipRequirement = addIPRequirment(properties, ipVersion);
 159             }
 160             updateIpCountRequired(ipCountRequired, ipRequirement);
 161         }
 162     }
 163
 164     private Map<String, Object> addIPRequirment(Map<String, Object> properties, Object ipVersion) {
 165         List<Map<String, Object>> ipRequirmentsList = ((List<Map<String,Object>>) properties.get(IP_REQUIREMENTS));
 166         Map<String, Object> newIpRequirment = createIPRequirment(ipVersion);
 167         ipRequirmentsList.add(newIpRequirment);
 168         return newIpRequirment;
 169     }
 170
 171     private void updateIpCountRequired(String ipCountRequired, Map<String, Object> ipRequirement) {
 172         Map<String, Object> isIPCountRequired = (Map<String, Object>)ipRequirement.get(ipCountRequired);
 173         isIPCountRequired.put(IS_REQUIRED, Boolean.TRUE);
 174     }
 175
 176     private HashMap <Object, Map<String, Object>> getIPRequirments (Map<String, Object> properties) {
 177         HashMap<Object, Map<String, Object>> ipRequirmentsMap = new HashMap();
 178         List<Map<String, Object>> ipRequirmentsList = ((List<Map<String,Object>>) properties.get(IP_REQUIREMENTS));
 179         ipRequirmentsList.stream().forEach(e->ipRequirmentsMap.put(e.get(IP_VERSION),e));
 180         return ipRequirmentsMap;
 181     }
 182
 183     private void setNetworkRoleTag(Map<String, Object> properties) {
 184         Object propertyValue = properties.get(NETWORK);
 185         if (propertyValue instanceof Map && !((Map) propertyValue).isEmpty()) {
 186             Map.Entry<String, String> mapEntry =
 187                     (Map.Entry<String, String>) ((Map) propertyValue).entrySet().iterator().next();
 188             if (mapEntry.getValue() instanceof String && getNetworkRole(mapEntry.getValue())!=null) {
 189                 properties.put(NETWORK_ROLE_TAG, getNetworkRole(mapEntry.getValue()));
 190             }
 191         }
 192     }
 193
 194     private Object getVersion(Object value, String type) {
 195
 196         Object version = null;
 197         if(type.equals(FIXED_IPS)){
 198             version =  getIpVersion(value);
 199         }
 200         else if(type.equals(ALLOWED_ADDRESS_PAIRS)){
 201             version =  getFloatingIpVersion(value);
 202         }
 203         return version;
 204     }
 205
 206     private Object getFloatingIpVersion(Object value) {
 207         Object ipVersion = null;
 208
 209         // Allowed ONLY String parameter
 210         if(value instanceof String) {
 211             if (((String) value).endsWith(FLOATING_V6_IP)) {
 212                 ipVersion = 6;
 213             }
 214             else if (((String) value).endsWith(FLOATING_IP)){
 215                 ipVersion = 4;
 216             }
 217         }
 218         return ipVersion;
 219     }
 220
 221     private Object getIpVersion(Object value) {
 222
 223         // Allowed List or String parameter
 224         Object ipVersion = null;
 225         if (value instanceof List && !((List) value).isEmpty()){
 226             value = ((List) value).get(0);
 227         }
 228
 229         if(value instanceof String) {
 230             if (((String) value).endsWith(V6_IPS) || ((String) value).matches(IPV6_REGEX)) {
 231                 ipVersion = 6;
 232             }
 233             else {
 234                 ipVersion = 4;
 235             }
 236         }
 237         return ipVersion;
 238     }
 239
 240     private Object getNetworkRole(String value) {
 241         Object networkRole = null;
 242         if(value.endsWith(NET_NAME)) {
 243             networkRole = value.substring(0, value.length() - NET_NAME.length());
 244         }
 245         else if(value.endsWith(NET_ID)) {
 246             networkRole = value.substring(0, value.length() - NET_ID.length());
 247         }
 248         else if(value.endsWith(NET_FQDN)) {
 249             networkRole = value.substring(0, value.length() - NET_FQDN.length());
 250         }
 251         return networkRole;
 252     }
 253 }