Add suport for fuel installer

JIRA: SDNVPN-238
JIRA: FUEL-393

This patch adds support for fuel installer by modifying relevant
pieces of code.

Change-Id: I5245e84022dd258c96648b0985660e093ca98b52
Signed-off-by: Stamatis Katsaounis <mokats@intracom-telecom.com>
(cherry picked from commit b17b3d80849b9c9989fb4deeb6001a6ff78261c1)

6 files changed, 199 insertions, 159 deletions

diff --git a/sdnvpn/artifacts/quagga_setup.sh b/sdnvpn/artifacts/quagga_setup.sh
index b3bf786..c6e6a9c 100644
--- a/sdnvpn/artifacts/quagga_setup.sh
+++ b/sdnvpn/artifacts/quagga_setup.sh
@@ -35,10 +35,10 @@ done
 if [ -z "$quagga_int" ]
 then
 echo 'No available network interface'
-fi
-
+else
 ip link set $quagga_int up
 ip addr add $OWN_IP/$EXT_NET_MASK dev $quagga_int
+fi
 
 # Download quagga/zrpc rpms
 cd /root
diff --git a/sdnvpn/lib/quagga.py b/sdnvpn/lib/quagga.py
index f11e188..6efd6a9 100644
--- a/sdnvpn/lib/quagga.py
+++ b/sdnvpn/lib/quagga.py
@@ -22,12 +22,12 @@ logger = logging.getLogger('sdnvpn-quagga')
 COMMON_CONFIG = config.CommonConfig()
 
 
-def odl_add_neighbor(neighbor_ip, controller_ip, controller):
-    # Explicitly pass controller_ip because controller.ip
+def odl_add_neighbor(neighbor_ip, odl_ip, odl_node):
+    # Explicitly pass odl_ip because odl_node.ip
     # Might not be accessible from the Quagga instance
     command = 'configure-bgp -op add-neighbor --as-num 200'
-    command += ' --ip %s --use-source-ip %s' % (neighbor_ip, controller_ip)
-    success = run_odl_cmd(controller, command)
+    command += ' --ip %s --use-source-ip %s' % (neighbor_ip, odl_ip)
+    success = run_odl_cmd(odl_node, command)
     # The run_cmd api is really whimsical
     logger.info("Maybe stdout of %s: %s", command, success)
     return success
@@ -42,20 +42,20 @@ def bootstrap_quagga(fip_addr, controller_ip):
     return rc == 0
 
 
-def gen_quagga_setup_script(controller_ip,
+def gen_quagga_setup_script(odl_ip,
                             fake_floating_ip,
                             ext_net_mask,
                             ip_prefix, rd, irt, ert):
     with open(COMMON_CONFIG.quagga_setup_script_path) as f:
         template = f.read()
-    script = template.format(controller_ip,
+    script = template.format(odl_ip,
                              fake_floating_ip,
                              ext_net_mask,
                              ip_prefix, rd, irt, ert)
     return script
 
 
-def check_for_peering(controller):
+def check_for_peering(odl_node):
     cmd = 'show-bgp --cmd \\"ip bgp neighbors\\"'
     tries = 20
     neighbors = None
@@ -64,7 +64,7 @@ def check_for_peering(controller):
     while tries > 0:
         if neighbors and 'Established' in neighbors:
             break
-        neighbors = run_odl_cmd(controller, cmd)
+        neighbors = run_odl_cmd(odl_node, cmd)
         logger.info("Output of %s: %s", cmd, neighbors)
         if neighbors:
             opens = opens_regex.search(neighbors)
diff --git a/sdnvpn/lib/utils.py b/sdnvpn/lib/utils.py
index 1b39c31..0d77c40 100644
--- a/sdnvpn/lib/utils.py
+++ b/sdnvpn/lib/utils.py
@@ -19,6 +19,7 @@ from concurrent.futures import ThreadPoolExecutor
 from openstack.exceptions import ResourceNotFound
 from requests.auth import HTTPBasicAuth
 
+from functest.utils import env
 from opnfv.deployment.factory import Factory as DeploymentFactory
 
 from sdnvpn.lib import config as sdnvpn_config
@@ -28,8 +29,10 @@ logger = logging.getLogger('sdnvpn_test_utils')
 
 common_config = sdnvpn_config.CommonConfig()
 
-ODL_USER = 'admin'
-ODL_PASS = 'admin'
+ODL_USER = env.get('SDN_CONTROLLER_USER')
+ODL_PASSWORD = env.get('SDN_CONTROLLER_PASSWORD')
+ODL_IP = env.get('SDN_CONTROLLER_IP')
+ODL_PORT = env.get('SDN_CONTROLLER_RESTCONFPORT')
 
 executor = ThreadPoolExecutor(5)
 
@@ -297,18 +300,16 @@ def get_installerHandler():
         return None
     else:
         if installer_type in ["apex"]:
-            developHandler = DeploymentFactory.get_handler(
-                installer_type,
-                installer_ip,
-                'root',
-                pkey_file="/root/.ssh/id_rsa")
-
-        if installer_type in ["fuel"]:
-            developHandler = DeploymentFactory.get_handler(
-                installer_type,
-                installer_ip,
-                'root',
-                'r00tme')
+            installer_user = "root"
+        elif installer_type in ["fuel"]:
+            installer_user = "ubuntu"
+
+        developHandler = DeploymentFactory.get_handler(
+            installer_type,
+            installer_ip,
+            installer_user,
+            pkey_file="/root/.ssh/id_rsa")
+
         return developHandler
 
 
@@ -536,17 +537,19 @@ def exec_cmd(cmd, verbose):
     return output, success
 
 
-def check_odl_fib(ip, controller_ip):
+def check_odl_fib(ip):
     """Check that there is an entry in the ODL Fib for `ip`"""
-    url = "http://" + controller_ip + \
-          ":8181/restconf/config/odl-fib:fibEntries/"
+    url = ("http://{user}:{password}@{ip}:{port}/restconf/config/"
+           "odl-fib:fibEntries/".format(user=ODL_USER,
+                                        password=ODL_PASSWORD, ip=ODL_IP,
+                                        port=ODL_PORT))
     logger.debug("Querring '%s' for FIB entries", url)
-    res = requests.get(url, auth=(ODL_USER, ODL_PASS))
+    res = requests.get(url, auth=(ODL_USER, ODL_PASSWORD))
     if res.status_code != 200:
         logger.error("OpenDaylight response status code: %s", res.status_code)
         return False
     logger.debug("Checking whether '%s' is in the OpenDaylight FIB"
-                 % controller_ip)
+                 % ODL_IP)
     logger.debug("OpenDaylight FIB: \n%s" % res.text)
     return ip in res.text
 
@@ -598,34 +601,50 @@ def wait_for_cloud_init(conn, instance):
 def attach_instance_to_ext_br(instance, compute_node):
     libvirt_instance_name = instance.instance_name
     installer_type = str(os.environ['INSTALLER_TYPE'].lower())
-    if installer_type == "fuel":
+    # In Apex, br-ex (or br-floating for Fuel) is an ovs bridge and virsh
+    # attach-interface won't just work. We work around it by creating a linux
+    # bridge, attaching that to br-ex (or br-floating for Fuel) with a
+    # veth pair and virsh-attaching the instance to the linux-bridge
+    if installer_type in ["fuel"]:
+        bridge = "br-floating"
+    elif installer_type in ["apex"]:
         bridge = "br-ex"
-    elif installer_type == "apex":
-        # In Apex, br-ex is an ovs bridge and virsh attach-interface
-        # won't just work. We work around it by creating a linux
-        # bridge, attaching that to br-ex with a veth pair
-        # and virsh-attaching the instance to the linux-bridge
-        bridge = "br-quagga"
-        cmd = """
-        set -e
-        if ! sudo brctl show |grep -q ^{bridge};then
-          sudo brctl addbr {bridge}
-          sudo ip link set {bridge} up
-          sudo ip link add quagga-tap type veth peer name ovs-quagga-tap
-          sudo ip link set dev ovs-quagga-tap up
-          sudo ip link set dev quagga-tap up
-          sudo ovs-vsctl add-port br-ex ovs-quagga-tap
-          sudo brctl addif {bridge} quagga-tap
-        fi
-        """
-        compute_node.run_cmd(cmd.format(bridge=bridge))
+    else:
+        logger.warn("installer type %s is neither fuel nor apex."
+                    % installer_type)
+        return
+
+    cmd = """
+    set -e
+    if ! sudo brctl show |grep -q ^br-quagga;then
+      sudo brctl addbr br-quagga
+      sudo ip link set br-quagga up
+      sudo ip link add quagga-tap type veth peer name ovs-quagga-tap
+      sudo ip link set dev ovs-quagga-tap up
+      sudo ip link set dev quagga-tap up
+      sudo ovs-vsctl add-port {bridge} ovs-quagga-tap
+      sudo brctl addif br-quagga quagga-tap
+    fi
+    """
+    compute_node.run_cmd(cmd.format(bridge=bridge))
 
     compute_node.run_cmd("sudo virsh attach-interface %s"
-                         " bridge %s" % (libvirt_instance_name, bridge))
+                         " bridge br-quagga" % (libvirt_instance_name))
 
 
 def detach_instance_from_ext_br(instance, compute_node):
     libvirt_instance_name = instance.instance_name
+    installer_type = str(os.environ['INSTALLER_TYPE'].lower())
+    # This function undoes all the actions performed by
+    # attach_instance_to_ext_br on Fuel and Apex installers.
+    if installer_type in ["fuel"]:
+        bridge = "br-floating"
+    elif installer_type in ["apex"]:
+        bridge = "br-ex"
+    else:
+        logger.warn("installer type %s is neither fuel nor apex."
+                    % installer_type)
+        return
     mac = compute_node.run_cmd("for vm in $(sudo virsh list | "
                                "grep running | awk '{print $2}'); "
                                "do echo -n ; sudo virsh dumpxml $vm| "
@@ -634,25 +653,16 @@ def detach_instance_from_ext_br(instance, compute_node):
                          " --type bridge --mac %s"
                          % (libvirt_instance_name, mac))
 
-    installer_type = str(os.environ['INSTALLER_TYPE'].lower())
-    if installer_type == "fuel":
-        bridge = "br-ex"
-    elif installer_type == "apex":
-        # In Apex, br-ex is an ovs bridge and virsh attach-interface
-        # won't just work. We work around it by creating a linux
-        # bridge, attaching that to br-ex with a veth pair
-        # and virsh-attaching the instance to the linux-bridge
-        bridge = "br-quagga"
-        cmd = """
-            sudo brctl delif {bridge} quagga-tap &&
-            sudo ovs-vsctl del-port br-ex ovs-quagga-tap &&
-            sudo ip link set dev quagga-tap down &&
-            sudo ip link set dev ovs-quagga-tap down &&
-            sudo ip link del quagga-tap type veth peer name ovs-quagga-tap &&
-            sudo ip link set {bridge} down &&
-            sudo brctl delbr {bridge}
-        """
-        compute_node.run_cmd(cmd.format(bridge=bridge))
+    cmd = """
+        sudo brctl delif br-quagga quagga-tap &&
+        sudo ovs-vsctl del-port {bridge} ovs-quagga-tap &&
+        sudo ip link set dev quagga-tap down &&
+        sudo ip link set dev ovs-quagga-tap down &&
+        sudo ip link del quagga-tap type veth peer name ovs-quagga-tap &&
+        sudo ip link set br-quagga down &&
+        sudo brctl delbr br-quagga
+    """
+    compute_node.run_cmd(cmd.format(bridge=bridge))
 
 
 def cleanup_neutron(conn, neutron_client, floatingip_ids, bgpvpn_ids,
@@ -791,6 +801,15 @@ def is_fail_mode_secure():
         if not openstack_node.is_active():
             continue
 
+        installer_type = str(os.environ['INSTALLER_TYPE'].lower())
+        if installer_type in ['fuel']:
+            if (
+                'controller' in openstack_node.roles or
+                'opendaylight' in openstack_node.roles or
+                'installer' in openstack_node.roles
+            ):
+                continue
+
         ovs_int_list = (openstack_node.run_cmd(get_ovs_int_cmd).
                         strip().split('\n'))
         if 'br-int' in ovs_int_list:
@@ -920,34 +939,32 @@ def get_node_ip_and_netmask(node, iface):
     return mgmt_ip, mgmt_netmask
 
 
-def get_odl_bgp_entity_owner(controllers):
+def get_odl_bgp_entity_owner(odl_nodes):
     """ Finds the ODL owner of the BGP entity in the cluster.
 
     When ODL runs in clustering mode we need to execute the BGP speaker
     related commands to that ODL which is the owner of the BGP entity.
 
-    :param controllers: list of OS controllers
-    :return controller: OS controller in which ODL BGP entity owner runs
+    :param odl_nodes: list of Opendaylight nodes
+    :return odl_node: Opendaylight node in which ODL BGP entity owner runs
     """
-    if len(controllers) == 1:
-        return controllers[0]
+    if len(odl_nodes) == 1:
+        return odl_nodes[0]
     else:
-        installer_type = str(os.environ['INSTALLER_TYPE'].lower())
-        if installer_type in ['fuel']:
-            ip, _ = get_node_ip_and_netmask(controllers[0], 'br-ctl')
-            port = 8282
-            odl_pass = 'admin'
-        else:
-            ip = controllers[0].ip
-            port = 8081
-            odl_pass = os.environ['SDN_CONTROLLER_PASSWORD']
         url = ('http://{user}:{password}@{ip}:{port}/restconf/'
                'operational/entity-owners:entity-owners/entity-type/bgp'
-               .format(user='admin', password=odl_pass, ip=ip, port=port))
+               .format(user=ODL_USER, password=ODL_PASSWORD, ip=ODL_IP,
+                       port=ODL_PORT))
+
+        installer_type = str(os.environ['INSTALLER_TYPE'].lower())
+        if installer_type in ['apex']:
+            node_user = 'heat-admin'
+        elif installer_type in ['fuel']:
+            node_user = 'ubuntu'
 
         remote_odl_akka_conf = ('/opt/opendaylight/configuration/'
                                 'initial/akka.conf')
-        remote_odl_home_akka_conf = '/home/heat-admin/akka.conf'
+        remote_odl_home_akka_conf = '/home/{0}/akka.conf'.format(node_user)
         local_tmp_akka_conf = '/tmp/akka.conf'
         try:
             json_output = requests.get(url).json()
@@ -957,36 +974,43 @@ def get_odl_bgp_entity_owner(controllers):
             return None
         odl_bgp_owner = json_output['entity-type'][0]['entity'][0]['owner']
 
-        get_odl_id_cmd = "sudo docker ps -qf name=opendaylight_api"
-        for controller in controllers:
-            odl_id = controller.run_cmd(get_odl_id_cmd)
-            controller.run_cmd('sudo docker cp {container_id}:{odl_akka_conf} '
-                               '/home/heat-admin/'
-                               .format(container_id=odl_id,
-                                       odl_akka_conf=remote_odl_akka_conf))
-            controller.run_cmd('sudo chmod 777 {0}'
-                               .format(remote_odl_home_akka_conf))
-            controller.get_file(remote_odl_home_akka_conf, local_tmp_akka_conf)
+        for odl_node in odl_nodes:
+            if installer_type in ['apex']:
+                get_odl_id_cmd = 'sudo docker ps -qf name=opendaylight_api'
+                odl_id = odl_node.run_cmd(get_odl_id_cmd)
+                odl_node.run_cmd('sudo docker cp '
+                                 '{container_id}:{odl_akka_conf} '
+                                 '/home/{user}/'
+                                 .format(container_id=odl_id,
+                                         odl_akka_conf=remote_odl_akka_conf,
+                                         user=node_user))
+            elif installer_type in ['fuel']:
+                odl_node.run_cmd('sudo cp {0} /home/{1}/'
+                                 .format(remote_odl_akka_conf, node_user))
+            odl_node.run_cmd('sudo chmod 777 {0}'
+                             .format(remote_odl_home_akka_conf))
+            odl_node.get_file(remote_odl_home_akka_conf, local_tmp_akka_conf)
 
             for line in open(local_tmp_akka_conf):
                 if re.search(odl_bgp_owner, line):
-                    return controller
+                    return odl_node
         return None
 
 
-def add_quagga_external_gre_end_point(controllers, remote_tep_ip):
+def add_quagga_external_gre_end_point(odl_nodes, remote_tep_ip):
     json_body = {'input':
                  {'destination-ip': remote_tep_ip,
                   'tunnel-type': "odl-interface:tunnel-type-mpls-over-gre"}
                  }
-    url = ('http://{ip}:8081/restconf/operations/'
-           'itm-rpc:add-external-tunnel-endpoint'.format(ip=controllers[0].ip))
+    url = ('http://{ip}:{port}/restconf/operations/'
+           'itm-rpc:add-external-tunnel-endpoint'.format(ip=ODL_IP,
+                                                         port=ODL_PORT))
     headers = {'Content-type': 'application/yang.data+json',
                'Accept': 'application/yang.data+json'}
     try:
         requests.post(url, data=json.dumps(json_body),
                       headers=headers,
-                      auth=HTTPBasicAuth('admin', 'admin'))
+                      auth=HTTPBasicAuth(ODL_USER, ODL_PASSWORD))
     except Exception as e:
         logger.error("Failed to create external tunnel endpoint on"
                      " ODL for external tep ip %s with error %s"
@@ -994,9 +1018,11 @@ def add_quagga_external_gre_end_point(controllers, remote_tep_ip):
     return None
 
 
-def is_fib_entry_present_on_odl(controllers, ip_prefix, vrf_id):
-    url = ('http://admin:admin@{ip}:8081/restconf/config/odl-fib:fibEntries/'
-           'vrfTables/{vrf}/'.format(ip=controllers[0].ip, vrf=vrf_id))
+def is_fib_entry_present_on_odl(odl_nodes, ip_prefix, vrf_id):
+    url = ('http://{user}:{password}@{ip}:{port}/restconf/config/'
+           'odl-fib:fibEntries/vrfTables/{vrf}/'
+           .format(user=ODL_USER, password=ODL_PASSWORD, ip=ODL_IP,
+                   port=ODL_PORT, vrf=vrf_id))
     logger.error("url is %s" % url)
     try:
         vrf_table = requests.get(url).json()
diff --git a/sdnvpn/sh_utils/fetch-log-script.sh b/sdnvpn/sh_utils/fetch-log-script.sh
index c3c037d..9b0dc74 100755
--- a/sdnvpn/sh_utils/fetch-log-script.sh
+++ b/sdnvpn/sh_utils/fetch-log-script.sh
@@ -107,7 +107,11 @@ node(){
    fi
  done
  # not all messages only tail the last 10k lines
- tail -n 10000 /var/log/messages > messages
+ if [ -f /var/log/messages ]; then
+   tail -n 10000 /var/log/messages > messages
+ elif [ -f /var/log/syslog ]; then
+   tail -n 10000 /var/log/syslog > messages
+ fi
 }
 
 _curl_data_store(){
@@ -137,7 +141,11 @@ datastore()
   dump=$tmp_folder/dump-$HOSTNAME.txt
   operational=$tmp_folder/Operational-Inventory-$HOSTNAME.txt
   karaf_output=$tmp_folder/Karaf_out-$HOSTNAME.txt
-  odl_ip_port=$(grep ^url= /etc/neutron/plugins/ml2/ml2_conf.ini |cut -d '/' -f3)
+  if [ -f /etc/neutron/plugins/ml2/ml2_conf.ini ]; then
+    odl_ip_port=$(grep ^url= /etc/neutron/plugins/ml2/ml2_conf.ini |cut -d '/' -f3)
+  else
+    odl_ip_port=$(netstat -tln | grep '8080\|8081\|8181\|8282' | awk 'NR==1 {print $4}')
+  fi
 
   config_urls=( restconf/config/neutron:neutron/networks/ restconf/config/neutron:neutron/subnets/ restconf/config/neutron:neutron/ports/ restconf/config/neutron:neutron/routers/ restconf/config/itm:transport-zones/ restconf/config/itm-state:tunnels_state/ restconf/config/itm-state:external-tunnel-list/ restconf/config/itm-state:dpn-endpoints/ restconf/config/itm-config:vtep-config-schemas/ restconf/config/itm-config:tunnel-monitor-enabled/ restconf/config/itm-config:tunnel-monitor-interval/ restconf/config/interface-service-bindings:service-bindings/ restconf/config/l3vpn:vpn-instances/ restconf/config/ietf-interfaces:interfaces/ restconf/config/l3vpn:vpn-interfaces/ restconf/config/odl-fib:fibEntries restconf/config/neutronvpn:networkMaps restconf/config/neutronvpn:subnetmaps restconf/config/neutronvpn:vpnMaps restconf/config/neutronvpn:neutron-port-data restconf/config/id-manager:id-pools/ restconf/config/elan:elan-instances/ restconf/config/elan:elan-interfaces/ restconf/config/elan:elan-state/ restconf/config/elan:elan-forwarding-tables/ restconf/config/elan:elan-interface-forwarding-entries/ restconf/config/elan:elan-dpn-interfaces/ restconf/config/elan:elan-tag-name-map/  restconf/config/odl-nat:external-networks/ restconf/config/odl-nat:ext-routers/ restconf/config/odl-nat:intext-ip-port-map/ restconf/config/odl-nat:snatint-ip-port-map/ restconf/config/odl-l3vpn:vpn-instance-to-vpn-id/ restconf/config/neutronvpn:neutron-router-dpns/ restconf/operational/itm-config:tunnel-monitor-interval/ restconf/config/itm-config:tunnel-monitor-interval/ restconf/operational/itm-config:tunnel-monitor-params/ restconf/config/itm-config:tunnel-monitor-params/ restconf/config/vpnservice-dhcp:designated-switches-for-external-tunnels/ restconf/config/neutron:neutron/security-groups/ restconf/config/neutron:neutron/security-rules/ restconf/config/network-topology:network-topology/topology/hwvtep:1 restconf/config/network-topology:network-topology/topology/ovsdb:1 )
 
diff --git a/sdnvpn/test/functest/testcase_1bis.py b/sdnvpn/test/functest/testcase_1bis.py
index f33d247..b39c58e 100644
--- a/sdnvpn/test/functest/testcase_1bis.py
+++ b/sdnvpn/test/functest/testcase_1bis.py
@@ -54,7 +54,7 @@ def main():
         az_2 = "nova:" + compute_nodes[1]
 
         file_path = pkg_resources.resource_filename(
-                    'sdnvpn', TESTCASE_CONFIG.hot_file_name)
+            'sdnvpn', TESTCASE_CONFIG.hot_file_name)
         templ = open(file_path, 'r').read()
         logger.debug("Template is read: '%s'" % templ)
         env = test_utils.get_heat_environment(TESTCASE_CONFIG, COMMON_CONFIG)
@@ -206,7 +206,7 @@ def main():
             test_utils.delete_stack_and_wait(heat_client, stack_id)
         except Exception as e:
             logger.error(
-                   "exception occurred while executing testcase_1bis: %s", e)
+                "exception occurred while executing testcase_1bis: %s", e)
 
     return results.compile_summary()
 
diff --git a/sdnvpn/test/functest/testcase_3.py b/sdnvpn/test/functest/testcase_3.py
index a4e9121..1a13eb7 100644
--- a/sdnvpn/test/functest/testcase_3.py
+++ b/sdnvpn/test/functest/testcase_3.py
@@ -51,45 +51,47 @@ def main():
     health_cmd = "sudo docker ps -f name=opendaylight_api -f " \
                  "health=healthy -q"
     if installer_type in ["fuel"]:
-        controllers = [node for node in openstack_nodes
-                       if "running" in node.run_cmd(fuel_cmd)]
+        odl_nodes = [node for node in openstack_nodes
+                     if "running" in node.run_cmd(fuel_cmd)]
     elif installer_type in ["apex"]:
-        controllers = [node for node in openstack_nodes
-                       if node.run_cmd(health_cmd)
-                       if "Running" in node.run_cmd(apex_cmd)]
+        odl_nodes = [node for node in openstack_nodes
+                     if node.run_cmd(health_cmd)
+                     if "Running" in node.run_cmd(apex_cmd)]
+    else:
+        logger.error("Incompatible installer type")
 
     computes = [node for node in openstack_nodes if node.is_compute()]
 
     msg = ("Verify that OpenDaylight can start/communicate with zrpcd/Quagga")
     results.record_action(msg)
     results.add_to_summary(0, "-")
-    if not controllers:
-        msg = ("Controller (ODL) list is empty. Skipping rest of tests.")
+    if not odl_nodes:
+        msg = ("ODL node list is empty. Skipping rest of tests.")
         logger.info(msg)
         results.add_failure(msg)
         return results.compile_summary()
     else:
-        msg = ("Controller (ODL) list is ready")
+        msg = ("ODL node list is ready")
         logger.info(msg)
         results.add_success(msg)
 
     logger.info("Checking if zrpcd is "
-                "running on the controller nodes")
+                "running on the opendaylight nodes")
 
-    for controller in controllers:
-        output_zrpcd = controller.run_cmd("ps --no-headers -C "
-                                          "zrpcd -o state")
+    for odl_node in odl_nodes:
+        output_zrpcd = odl_node.run_cmd("ps --no-headers -C "
+                                        "zrpcd -o state")
         states = output_zrpcd.split()
         running = any([s != 'Z' for s in states])
-        msg = ("zrpcd is running in {name}".format(name=controller.name))
+        msg = ("zrpcd is running in {name}".format(name=odl_node.name))
 
         if not running:
-            logger.info("zrpcd is not running on the controller node {name}"
-                        .format(name=controller.name))
+            logger.info("zrpcd is not running on the opendaylight node {name}"
+                        .format(name=odl_node.name))
             results.add_failure(msg)
         else:
-            logger.info("zrpcd is running on the controller node {name}"
-                        .format(name=controller.name))
+            logger.info("zrpcd is running on the opendaylight node {name}"
+                        .format(name=odl_node.name))
             results.add_success(msg)
 
         results.add_to_summary(0, "-")
@@ -97,51 +99,55 @@ def main():
     # Find the BGP entity owner in ODL because of this bug:
     # https://jira.opendaylight.org/browse/NETVIRT-1308
     msg = ("Found BGP entity owner")
-    controller = test_utils.get_odl_bgp_entity_owner(controllers)
-    if controller is None:
+    odl_node = test_utils.get_odl_bgp_entity_owner(odl_nodes)
+    if odl_node is None:
         logger.error("Failed to find the BGP entity owner")
         results.add_failure(msg)
     else:
         logger.info('BGP entity owner is {name}'
-                    .format(name=controller.name))
+                    .format(name=odl_node.name))
         results.add_success(msg)
     results.add_to_summary(0, "-")
 
-    get_ext_ip_cmd = "sudo ip a | grep br-ex | grep inet | awk '{print $2}'"
-    ext_net_cidr = controller.run_cmd(get_ext_ip_cmd).strip().split('\n')
-    ext_net_mask = ext_net_cidr[0].split('/')[1]
-    controller_ext_ip = ext_net_cidr[0].split('/')[0]
+    installer_type = str(os.environ['INSTALLER_TYPE'].lower())
+    if installer_type in ['apex']:
+        odl_interface = 'br-ex'
+    elif installer_type in ['fuel']:
+        odl_interface = 'ens6'
+    else:
+        logger.error("Incompatible installer type")
+    odl_ip, odl_netmask = test_utils.get_node_ip_and_netmask(
+        odl_node, odl_interface)
 
-    logger.info("Starting bgp speaker of controller at IP %s "
-                % controller_ext_ip)
+    logger.info("Starting bgp speaker of opendaylight node at IP %s "
+                % odl_ip)
 
     # Ensure that ZRPCD ip & port are well configured within ODL
     add_client_conn_to_bgp = "bgp-connect -p 7644 -h 127.0.0.1 add"
-    test_utils.run_odl_cmd(controller, add_client_conn_to_bgp)
+    test_utils.run_odl_cmd(odl_node, add_client_conn_to_bgp)
 
     # Start bgp daemon
     start_quagga = "odl:configure-bgp -op start-bgp-server " \
-                   "--as-num 100 --router-id {0}".format(controller_ext_ip)
-    test_utils.run_odl_cmd(controller, start_quagga)
+                   "--as-num 100 --router-id {0}".format(odl_ip)
+    test_utils.run_odl_cmd(odl_node, start_quagga)
 
     # we need to wait a bit until the bgpd is up
     time.sleep(5)
 
-    logger.info("Checking if bgpd is running"
-                " on the controller node")
+    logger.info("Checking if bgpd is running on the opendaylight node")
 
     # Check if there is a non-zombie bgpd process
-    output_bgpd = controller.run_cmd("ps --no-headers -C "
-                                     "bgpd -o state")
+    output_bgpd = odl_node.run_cmd("ps --no-headers -C "
+                                   "bgpd -o state")
     states = output_bgpd.split()
     running = any([s != 'Z' for s in states])
 
     msg = ("bgpd is running")
     if not running:
-        logger.info("bgpd is not running on the controller node")
+        logger.info("bgpd is not running on the opendaylight node")
         results.add_failure(msg)
     else:
-        logger.info("bgpd is running on the controller node")
+        logger.info("bgpd is running on the opendaylight node")
         results.add_success(msg)
 
     results.add_to_summary(0, "-")
@@ -150,22 +156,22 @@ def main():
     # but the test is disabled because of buggy upstream
     # https://github.com/6WIND/zrpcd/issues/15
     # stop_quagga = 'odl:configure-bgp -op stop-bgp-server'
-    # test_utils.run_odl_cmd(controller, stop_quagga)
+    # test_utils.run_odl_cmd(odl_node, stop_quagga)
 
     # logger.info("Checking if bgpd is still running"
-    #             " on the controller node")
+    #             " on the opendaylight node")
 
-    # output_bgpd = controller.run_cmd("ps --no-headers -C " \
-    #                                  "bgpd -o state")
+    # output_bgpd = odl_node.run_cmd("ps --no-headers -C " \
+    #                                "bgpd -o state")
     # states = output_bgpd.split()
     # running = any([s != 'Z' for s in states])
 
     # msg = ("bgpd is stopped")
     # if not running:
-    #     logger.info("bgpd is not running on the controller node")
+    #     logger.info("bgpd is not running on the opendaylight node")
     #     results.add_success(msg)
     # else:
-    #     logger.info("bgpd is still running on the controller node")
+    #     logger.info("bgpd is still running on the opendaylight node")
     #     results.add_failure(msg)
 
     # Taken from the sfc tests
@@ -268,9 +274,9 @@ def main():
                 compute = comp
                 break
         quagga_bootstrap_script = quagga.gen_quagga_setup_script(
-            controller_ext_ip,
+            odl_ip,
             fake_fip['fip_addr'],
-            ext_net_mask,
+            odl_netmask,
             TESTCASE_CONFIG.external_network_ip_prefix,
             TESTCASE_CONFIG.route_distinguishers,
             TESTCASE_CONFIG.import_targets,
@@ -317,16 +323,16 @@ def main():
         results.add_to_summary(0, '-')
 
         neighbor = quagga.odl_add_neighbor(fake_fip['fip_addr'],
-                                           controller_ext_ip,
-                                           controller)
-        peer = quagga.check_for_peering(controller)
+                                           odl_ip,
+                                           odl_node)
+        peer = quagga.check_for_peering(odl_node)
 
         if neighbor and peer:
             results.add_success("Peering with quagga")
         else:
             results.add_failure("Peering with quagga")
 
-        test_utils.add_quagga_external_gre_end_point(controllers,
+        test_utils.add_quagga_external_gre_end_point(odl_nodes,
                                                      fake_fip['fip_addr'])
         test_utils.wait_before_subtest()
 
@@ -382,7 +388,7 @@ def main():
         msg = ("External IP prefix %s is exchanged with ODL"
                % TESTCASE_CONFIG.external_network_ip_prefix)
         fib_added = test_utils.is_fib_entry_present_on_odl(
-            controllers,
+            odl_nodes,
             TESTCASE_CONFIG.external_network_ip_prefix,
             TESTCASE_CONFIG.route_distinguishers)
         if fib_added:
@@ -417,12 +423,12 @@ def main():
         if fake_fip is not None:
             bgp_nbr_disconnect_cmd = ("bgp-nbr -i %s -a 200 del"
                                       % fake_fip['fip_addr'])
-            test_utils.run_odl_cmd(controller, bgp_nbr_disconnect_cmd)
+            test_utils.run_odl_cmd(odl_node, bgp_nbr_disconnect_cmd)
         bgp_server_stop_cmd = ("bgp-rtr -r %s -a 100 del"
-                               % controller_ext_ip)
+                               % odl_ip)
         odl_zrpc_disconnect_cmd = "bgp-connect -p 7644 -h 127.0.0.1 del"
-        test_utils.run_odl_cmd(controller, bgp_server_stop_cmd)
-        test_utils.run_odl_cmd(controller, odl_zrpc_disconnect_cmd)
+        test_utils.run_odl_cmd(odl_node, bgp_server_stop_cmd)
+        test_utils.run_odl_cmd(odl_node, odl_zrpc_disconnect_cmd)
 
     return results.compile_summary()