Adds some network parsing for baremetal deployments and other fixes

Changes include:
 - Fixes Intel Pod 2 inventory file
 - Check for DHCP server on the host and disable
 - Adds realistic+common network-settings file
 - Modifies baremetal deployments to bridge to correct interface
 - Adds private/storage network OVS bridges
 - Parses network-settings into valid network-environment variables
 - If certain network-settings are missing they will be auto-detected

Note: The actual settings set forth for deployment only include
admin/external networks at the moment.  Private/storage networks will be
handled in an upcoming patch.

JIRA: APEX-50

Change-Id: I0a1a86f37c08702a93fe167688c3149ba5573db4
Signed-off-by: Tim Rozet <trozet@redhat.com>

1 files changed, 314 insertions, 0 deletions

diff --git a/lib/common-functions.sh b/lib/common-functions.sh
new file mode 100644
index 00000000..9aa97e87
--- /dev/null
+++ b/lib/common-functions.sh
@@ -0,0 +1,314 @@
+#!/usr/bin/env bash
+# Common Functions used by  OPNFV Apex
+# author: Tim Rozet (trozet@redhat.com)
+
+##find ip of interface
+##params: interface name
+function find_ip {
+  ip addr show $1 | grep -Eo '^\s+inet\s+[\.0-9]+' | awk '{print $2}'
+}
+
+##finds subnet of ip and netmask
+##params: ip, netmask
+function find_subnet {
+  IFS=. read -r i1 i2 i3 i4 <<< "$1"
+  IFS=. read -r m1 m2 m3 m4 <<< "$2"
+  printf "%d.%d.%d.%d\n" "$((i1 & m1))" "$((i2 & m2))" "$((i3 & m3))" "$((i4 & m4))"
+}
+
+##verify subnet has at least n IPs
+##params: subnet mask, n IPs
+function verify_subnet_size {
+  IFS=. read -r i1 i2 i3 i4 <<< "$1"
+  num_ips_required=$2
+
+  ##this function assumes you would never need more than 254
+  ##we check here to make sure
+  if [ "$num_ips_required" -ge 254 ]; then
+    echo -e "\n\n${red}ERROR: allocating more than 254 IPs is unsupported...Exiting${reset}\n\n"
+    return 1
+  fi
+
+  ##we just return if 3rd octet is not 255
+  ##because we know the subnet is big enough
+  if [ "$i3" -ne 255 ]; then
+    return 0
+  elif [ $((254-$i4)) -ge "$num_ips_required" ]; then
+    return 0
+  else
+    echo -e "\n\n${red}ERROR: Subnet is too small${reset}\n\n"
+    return 1
+  fi
+}
+
+##finds last usable ip (broadcast minus 1) of a subnet from an IP and netmask
+## Warning: This function only works for IPv4 at the moment.
+##params: ip, netmask
+function find_last_ip_subnet {
+  IFS=. read -r i1 i2 i3 i4 <<< "$1"
+  IFS=. read -r m1 m2 m3 m4 <<< "$2"
+  IFS=. read -r s1 s2 s3 s4 <<< "$((i1 & m1)).$((i2 & m2)).$((i3 & m3)).$((i4 & m4))"
+  printf "%d.%d.%d.%d\n" "$((255 - $m1 + $s1))" "$((255 - $m2 + $s2))" "$((255 - $m3 + $s3))" "$((255 - $m4 + $s4 - 1))"
+}
+
+##increments subnet by a value
+##params: ip, value
+##assumes low value
+function increment_subnet {
+  IFS=. read -r i1 i2 i3 i4 <<< "$1"
+  printf "%d.%d.%d.%d\n" "$i1" "$i2" "$i3" "$((i4 | $2))"
+}
+
+##finds netmask of interface
+##params: interface
+##returns long format 255.255.x.x
+function find_netmask {
+  ifconfig $1 | grep -Eo 'netmask\s+[\.0-9]+' | awk '{print $2}'
+}
+
+##finds short netmask of interface
+##params: interface
+##returns short format, ex: /21
+function find_short_netmask {
+  echo "/$(ip addr show $1 | grep -Eo '^\s+inet\s+[\/\.0-9]+' | awk '{print $2}' | cut -d / -f2)"
+}
+
+##increments next IP
+##params: ip
+##assumes a /24 subnet
+function next_ip {
+  baseaddr="$(echo $1 | cut -d. -f1-3)"
+  lsv="$(echo $1 | cut -d. -f4)"
+  if [ "$lsv" -ge 254 ]; then
+    return 1
+  fi
+  ((lsv++))
+  echo $baseaddr.$lsv
+}
+
+##subtracts a value from an IP address
+##params: last ip, ip_count
+##assumes ip_count is less than the last octect of the address
+subtract_ip() {
+  IFS=. read -r i1 i2 i3 i4 <<< "$1"
+  ip_count=$2
+  if [ $i4 -lt $ip_count ]; then
+    echo -e "\n\n${red}ERROR: Can't subtract $ip_count from IP address $1  Exiting${reset}\n\n"
+    exit 1
+  fi
+  printf "%d.%d.%d.%d\n" "$i1" "$i2" "$i3" "$((i4 - $ip_count ))"
+}
+
+##check if IP is in use
+##params: ip
+##ping ip to get arp entry, then check arp
+function is_ip_used {
+  ping -c 5 $1 > /dev/null 2>&1
+  arp -n | grep "$1 " | grep -iv incomplete > /dev/null 2>&1
+}
+
+##find next usable IP
+##params: ip
+function next_usable_ip {
+  new_ip=$(next_ip $1)
+  while [ "$new_ip" ]; do
+    if ! is_ip_used $new_ip; then
+      echo $new_ip
+      return 0
+    fi
+    new_ip=$(next_ip $new_ip)
+  done
+  return 1
+}
+
+##increment ip by value
+##params: ip, amount to increment by
+##increment_ip $next_private_ip 10
+function increment_ip {
+  baseaddr="$(echo $1 | cut -d. -f1-3)"
+  lsv="$(echo $1 | cut -d. -f4)"
+  incrval=$2
+  lsv=$((lsv+incrval))
+  if [ "$lsv" -ge 254 ]; then
+    return 1
+  fi
+  echo $baseaddr.$lsv
+}
+
+##finds gateway on system
+##params: interface to validate gateway on (optional)
+##find_gateway em1
+function find_gateway {
+  local gw gw_interface
+  gw=$(ip route | grep default | awk '{print $3}')
+  gw_interface=$(ip route get $gw | awk '{print $3}')
+  if [ -n "$1" ]; then
+    if [ "$gw_interface" == "$1" ]; then
+      echo ${gw}
+    fi
+  fi
+}
+
+##finds subnet in CIDR notation for interface
+##params: interface to find CIDR
+function find_cidr {
+  local cidr network ip netmask short_mask
+  ip=$(find_ip $1)
+  netmask=$(find_netmask $1)
+  if [[ -z "$ip" || -z "$netmask" ]]; then
+    return 1
+  fi
+  network=$(find_subnet ${ip} ${netamsk})
+  short_mask=$(find_short_netmask $1)
+  if [[ -z "$network" || -z "$short_mask" ]]; then
+    return 1
+  fi
+  cidr="${subnet}'\'${short_mask}"
+  echo ${cidr}
+}
+
+##finds block of usable IP addresses for an interface
+##simply returns at the moment the correct format
+##after first 20 IPs, and leave 20 IPs at end of subnet (for floating ips, etc)
+##params: interface to find IP
+function find_usable_ip_range {
+  local interface_ip subnet_mask first_block_ip last_block_ip
+  interface_ip=$(find_ip $1)
+  subnet_mask=$(find_netmask $1)
+  if [[ -z "$interface_ip" || -z "$subnet_mask" ]]; then
+    return 1
+  fi
+  interface_ip=$(increment_ip ${interface_ip} 20)
+  first_block_ip=$(next_usable_ip ${interface_ip})
+  if [ -z "$first_block_ip" ]; then
+    return 1
+  fi
+  last_block_ip=$(find_last_ip_subnet ${interface_ip} ${subnet_mask})
+  if [ -z "$last_block_ip" ]; then
+    return 1
+  else
+    last_block_ip=$(subtract_ip ${last_block_ip} 20)
+    echo "${first_block_ip},${last_block_ip}"
+  fi
+
+}
+
+##generates usable IP range in correct format based on CIDR
+##assumes the first 20 IPs are used (by instack or otherwise)
+##params: cidr
+function generate_usable_ip_range {
+  local first_ip first_block_ip last_block_ip
+  first_ip=$(ipcalc  -nb $1 | grep HostMin: | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+")
+  first_block_ip=$(increment_ip ${first_ip} 20)
+  last_block_ip=$(ipcalc  -nb $1 | grep HostMax: | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+")
+  if [[ -z "$first_block_ip" || -z "$last_block_ip" ]]; then
+    return 1
+  else
+    last_block_ip=$(subtract_ip ${last_block_ip} 20)
+    echo "${first_block_ip},${last_block_ip}"
+  fi
+}
+
+##find the instack IP address
+##finds first usable IP on subnet
+##params: interface
+function find_provisioner_ip {
+  local interface_ip
+  interface_ip=$(find_ip $1)
+  if [ -z "$interface_ip" ]; then
+    return 1
+  fi
+  echo $(increment_ip ${interface_ip} 1)
+}
+
+##generates instack IP address based on CIDR
+##params: cidr
+function generate_provisioner_ip {
+  local provisioner_ip
+  provisioner_ip=$(ipcalc  -nb $1 | grep HostMin: | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+")
+}
+
+##finds the dhcp range available via interface
+##uses first 8 IPs, after 2nd IP
+##params: interface
+function find_dhcp_range {
+  local dhcp_range_start dhcp_range_end interface_ip
+  interface_ip=$(find_ip $1)
+  if [ -z "$interface_ip" ]; then
+    return 1
+  fi
+  dhcp_range_start=$(increment_ip ${interface_ip} 2)
+  dhcp_range_end=$(increment_ip ${dhcp_range_start} 8)
+  echo "${dhcp_range_start},${dhcp_range_end}"
+}
+
+##generates the dhcp range available via CIDR
+##uses first 8 IPs, after 1st IP
+##params: cidr
+function generate_dhcp_range {
+  local dhcp_range_start dhcp_range_end first_ip
+  first_ip=$(ipcalc  -nb $1 | grep HostMin: | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+")
+  if [ -z "$first_ip" ]; then
+    return 1
+  fi
+  dhcp_range_start=$(increment_ip ${first_ip} 1)
+  dhcp_range_end=$(increment_ip ${dhcp_range_start} 8)
+  echo "${dhcp_range_start},${dhcp_range_end}"
+}
+
+##finds the introspection range available via interface
+##uses 8 IPs, after the first 10 IPs
+##params: interface
+function find_introspection_range {
+  local inspect_range_start inspect_range_end interface_ip
+  interface_ip=$(find_ip $1)
+  if [ -z "$interface_ip" ]; then
+    return 1
+  fi
+  inspect_range_start=$(increment_ip ${interface_ip} 10)
+  inspect_range_end=$(increment_ip ${inspect_range_start} 8)
+  echo "${inspect_range_start},${inspect_range_end}"
+}
+
+##generate the introspection range available via CIDR
+##uses 8 IPs, after the first 10 IPs
+##params: cidr
+function generate_introspection_range {
+  local inspect_range_start inspect_range_end first_ip
+  first_ip=$(ipcalc  -nb $1 | grep HostMin: | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+")
+  if [ -z "$first_ip" ]; then
+    return 1
+  fi
+  inspect_range_start=$(increment_ip ${first_ip} 10)
+  inspect_range_end=$(increment_ip ${inspect_range_start} 8)
+  echo "${inspect_range_start},${inspect_range_end}"
+}
+
+##finds the floating ip range available via interface
+##uses last 20 IPs of a subnet
+##params: interface
+function find_floating_ip_range {
+  local float_range_start float_range_end interface_ip subnet_mask
+  interface_ip=$(find_ip $1)
+  subnet_mask=$(find_netmask $1)
+  if [[ -z "$interface_ip" || -z "$subnet_mask" ]]; then
+    return 1
+  fi
+  float_range_end=$(find_last_ip_subnet ${interface_ip} ${subnet_mask})
+  float_range_start=$(subtract_ip ${float_range_end} 19)
+  echo "${float_range_start},${float_range_end}"
+}
+
+##generate the floating range available via CIDR
+##uses last 20 IPs of subnet
+##params: cidr
+function generate_floating_ip_range {
+  local float_range_start float_range_end last_ip
+  last_ip=$(ipcalc  -nb $1 | grep HostMax: | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+")
+  if [ -z "$last_ip" ]; then
+    return 1
+  fi
+  float_range_start=$(subtract_ip ${last_ip} 19)
+  float_range_end=${last_ip}
+  echo "${float_range_start},${float_range_end}"
+}