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