Test VIRL connection.

Change-Id: I812ff9c8c9669b63907469c643c839e8bd3b419a
Signed-off-by: Stefan Kobza <skobza@cisco.com>

9 files changed, 81 insertions, 31 deletions

diff --git a/resources/libraries/bash/dut_setup.sh b/resources/libraries/bash/dut_setup.sh
index 0309228067..077fdcc8c9 100644
--- a/resources/libraries/bash/dut_setup.sh
+++ b/resources/libraries/bash/dut_setup.sh
@@ -37,3 +37,8 @@ echo See free memory
 echo
 free -m
 
+echo UUID
+sudo dmidecode | grep UUID
+
+echo Add dpdk-input trace
+sudo vpp_api_test <<< "exec trace add dpdk-input 100"
diff --git a/resources/libraries/python/DUTSetup.py b/resources/libraries/python/DUTSetup.py
index 76f76aef7e..e5e56784d5 100644
--- a/resources/libraries/python/DUTSetup.py
+++ b/resources/libraries/python/DUTSetup.py
@@ -20,6 +20,20 @@ class DUTSetup(object):
     def __init__(self):
         pass
 
+    def start_vpp_service_on_all_duts(self, nodes):
+        """Start up the VPP service on all nodes."""
+        ssh = SSH()
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                ssh.connect(node)
+                (ret_code, stdout, stderr) = \
+                        ssh.exec_command_sudo('service vpp restart')
+                if 0 != int(ret_code):
+                    logger.debug('stdout: {0}'.format(stdout))
+                    logger.debug('stderr: {0}'.format(stderr))
+                    raise Exception('DUT {0} failed to start VPP service'.
+                            format(node['host']))
+
     def setup_all_duts(self, nodes):
         """Prepare all DUTs in given topology for test execution."""
         for node in nodes.values():
@@ -35,7 +49,7 @@ class DUTSetup(object):
                 Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH))
         logger.trace(stdout)
         if 0 != int(ret_code):
-            logger.error('DUT {0} setup script failed: "{1}"'.
+            logger.debug('DUT {0} setup script failed: "{1}"'.
                     format(node['host'], stdout + stderr))
             raise Exception('DUT test setup script failed at node {}'.
                     format(node['host']))
diff --git a/resources/libraries/python/IPv6Setup.py b/resources/libraries/python/IPv6Setup.py
index db497757bc..edd5d2cc6e 100644
--- a/resources/libraries/python/IPv6Setup.py
+++ b/resources/libraries/python/IPv6Setup.py
@@ -18,6 +18,7 @@ from ipaddress import IPv6Network
 from topology import NodeType
 from topology import Topology
 from constants import Constants
+from robot.api import logger
 
 
 class IPv6Networks(object):
@@ -177,6 +178,12 @@ class IPv6Setup(object):
             raise Exception('VPP sw_interface_set_flags failed on {h}'.format(
                 h=node['host']))
 
+        cmd_input = 'exec show int'
+        (ret_code, stdout, stderr) = ssh.exec_command_sudo(cmd, cmd_input)
+        logger.debug('ret: {0}'.format(ret_code))
+        logger.debug('stdout: {0}'.format(stdout))
+        logger.debug('stderr: {0}'.format(stderr))
+
     @staticmethod
     def vpp_del_if_ipv6_addr(node, interface, addr, prefix):
         """Delete IPv6 address on VPP.
diff --git a/resources/libraries/python/PacketVerifier.py b/resources/libraries/python/PacketVerifier.py
index 566ea95c25..19d6aaf53f 100644
--- a/resources/libraries/python/PacketVerifier.py
+++ b/resources/libraries/python/PacketVerifier.py
@@ -232,6 +232,7 @@ class RxQueue(PacketVerifier):
             return None
 
         pkt = self._sock.recv(0x7fff)
+        pkt_pad = auto_pad(pkt)
         print 'Received packet on {0} of len {1}'.format(self._ifname, len(pkt))
         Ether(pkt).show2()
         print
@@ -241,7 +242,7 @@ class RxQueue(PacketVerifier):
                 # Auto pad all packets in ignore list
                 ignore[i] = auto_pad(ig_pkt)
             for ig_pkt in ignore:
-                if ig_pkt == pkt:
+                if ig_pkt == pkt_pad:
                     # Found the packet in ignore list, get another one
                     # TODO: subtract timeout - time_spent in here
                     ignore.remove(ig_pkt)
diff --git a/resources/libraries/python/ssh.py b/resources/libraries/python/ssh.py
index 385619ce42..a2bb9b1dc4 100644
--- a/resources/libraries/python/ssh.py
+++ b/resources/libraries/python/ssh.py
@@ -11,6 +11,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import paramiko
+from paramiko import RSAKey
+import StringIO
 from scp import SCPClient
 from time import time
 from robot.api import logger
@@ -28,9 +30,7 @@ class SSH(object):
     __existing_connections = {}
 
     def __init__(self):
-        self._ssh = paramiko.SSHClient()
-        self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        self._hostname = None
+        pass
 
     def _node_hash(self, node):
         return hash(frozenset([node['host'], node['port']]))
@@ -40,31 +40,47 @@ class SSH(object):
 
         If there already is a connection to the node, this method reuses it.
         """
-        self._hostname = node['host']
         node_hash = self._node_hash(node)
-        if node_hash in self.__existing_connections:
-            self._ssh = self.__existing_connections[node_hash]
+        if node_hash in SSH.__existing_connections:
+            self._ssh = SSH.__existing_connections[node_hash]
+            logger.debug('reusing ssh: {0}'.format(self._ssh))
         else:
             start = time()
+            pkey = None
+            if 'priv_key' in node:
+                pkey = RSAKey.from_private_key(
+                        StringIO.StringIO(node['priv_key']))
+
+            self._ssh = paramiko.SSHClient()
+            self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
             self._ssh.connect(node['host'], username=node['username'],
-                              password=node['password'])
-            self.__existing_connections[node_hash] = self._ssh
+                              password=node.get('password'), pkey=pkey)
+
+            SSH.__existing_connections[node_hash] = self._ssh
+
             logger.trace('connect took {} seconds'.format(time() - start))
+            logger.debug('new ssh: {0}'.format(self._ssh))
+
+        logger.debug('Connect peer: {0}'.
+                format(self._ssh.get_transport().getpeername()))
+        logger.debug('Connections: {0}'.format(str(SSH.__existing_connections)))
 
     def exec_command(self, cmd, timeout=10):
         """Execute SSH command on a new channel on the connected Node.
 
         Returns (return_code, stdout, stderr).
         """
-        logger.trace('exec_command on {0}: {1}'.format(self._hostname, cmd))
+        logger.trace('exec_command on {0}: {1}'
+                .format(self._ssh.get_transport().getpeername(), cmd))
         start = time()
         chan = self._ssh.get_transport().open_session()
         if timeout is not None:
             chan.settimeout(int(timeout))
         chan.exec_command(cmd)
         end = time()
-        logger.trace('exec_command "{0}" on {1} took {2} seconds'.format(
-            cmd, self._hostname, end-start))
+        logger.trace('exec_command on {0} took {1} seconds'.format(
+            self._ssh.get_transport().getpeername(), end-start))
 
         stdout = ""
         while True:
@@ -99,9 +115,9 @@ class SSH(object):
             >>> ssh = SSH()
             >>> ssh.connect(node)
             >>> #Execute command without input (sudo -S cmd)
-            >>> ssh.exex_command_sudo("ifconfig eth0 down")
+            >>> ssh.exec_command_sudo("ifconfig eth0 down")
             >>> #Execute command with input (sudo -S cmd <<< "input")
-            >>> ssh.exex_command_sudo("vpp_api_test", "dump_interface_table")
+            >>> ssh.exec_command_sudo("vpp_api_test", "dump_interface_table")
         """
         if cmd_input is None:
             command = 'sudo -S {c}'.format(c=cmd)
@@ -182,7 +198,7 @@ class SSH(object):
         connect() method has to be called first!
         """
         logger.trace('SCP {0} to {1}:{2}'.format(
-            local_path, self._hostname, remote_path))
+            local_path, self._ssh.get_transport().getpeername(), remote_path))
         # SCPCLient takes a paramiko transport as its only argument
         scp = SCPClient(self._ssh.get_transport())
         start = time()
@@ -229,7 +245,7 @@ def exec_cmd_no_error(node, cmd, timeout=None, sudo=False):
 
     Returns (stdout, stderr).
     """
-    (rc, stdout, stderr) = exec_cmd(node,cmd, timeout=timeout, sudo=sudo)
+    (rc, stdout, stderr) = exec_cmd(node, cmd, timeout=timeout, sudo=sudo)
     assert_equal(rc, 0, 'Command execution failed: "{}"\n{}'.
                  format(cmd, stderr))
     return (stdout, stderr)
diff --git a/resources/libraries/python/topology.py b/resources/libraries/python/topology.py
index 8b6905d7e1..103416078a 100644
--- a/resources/libraries/python/topology.py
+++ b/resources/libraries/python/topology.py
@@ -195,7 +195,7 @@ class Topology(object):
 
         interface_dict = {}
         list_mac_address = self.convert_mac_to_number_list(mac_address)
-        logger.trace(list_mac_address.__str__())
+        logger.trace(str(list_mac_address))
         for interface in interfaces_list:
             # TODO: create vat json integrity checking and move there
             if "l2_address" not in interface:
@@ -254,6 +254,9 @@ class Topology(object):
             if_mac = ifc['mac_address']
             interface_dict = self._extract_vpp_interface_by_mac(interface_list,
                                                                 if_mac)
+            if not interface_dict:
+                raise Exception('Interface {0} not found by MAC {1}'.
+                        format(ifc, if_mac))
             ifc['name'] = interface_dict["interface_name"]
             ifc['vpp_sw_index'] = interface_dict["sw_if_index"]
 
diff --git a/resources/libraries/robot/ipv4.robot b/resources/libraries/robot/ipv4.robot
index a5745a8ce0..c271de5693 100644
--- a/resources/libraries/robot/ipv4.robot
+++ b/resources/libraries/robot/ipv4.robot
@@ -45,6 +45,7 @@
 | | Setup IPv4 adresses on all DUT nodes in topology | ${nodes} | ${nodes_ipv4_addr}
 | | Setup ARP on all DUTs | ${nodes} | ${nodes_ipv4_addr}
 | | Routes are set up for IPv4 testing
+| | Sleep | 10
 
 | TG interface "${tg_port}" can route to node "${node}" interface "${port}" "${hops}" hops away using IPv4
 | | Node "${nodes['TG']}" interface "${tg_port}" can route to node "${node}" interface "${port}" "${hops}" hops away using IPv4
@@ -74,7 +75,7 @@
 | # TODO: end_size is currently minimum MTU size for Ethernet minus IPv4 and
 | # ICMP echo header size (1500 - 20 - 8),
 | # MTU info is not in VAT sw_interface_dump output
-| | ${args}= | Set Variable | ${args} --start_size 0 --end_size 1472 --step 1
+| | ${args}= | Set Variable | ${args} --start_size 1 --end_size 1472 --step 1
 | | Run Traffic Script On Node | ipv4_sweep_ping.py | ${src_node} | ${args}
 
 | Send ARP request and validate response
diff --git a/resources/libraries/robot/ipv6.robot b/resources/libraries/robot/ipv6.robot
index 3d8a2ea82d..6cd6640b0a 100644
--- a/resources/libraries/robot/ipv6.robot
+++ b/resources/libraries/robot/ipv6.robot
@@ -152,6 +152,7 @@
 | | [Arguments] | ${nodes} | ${nodes_addr}
 | | Setup all DUTs before test
 | | Nodes Setup Ipv6 Addresses | ${nodes} | ${nodes_addr}
+| | Sleep | 10
 
 | Clear ipv6 on all dut in topology
 | | [Documentation] | Remove IPv6 address on all DUTs
diff --git a/resources/traffic_scripts/ipv4_ping_ttl_check.py b/resources/traffic_scripts/ipv4_ping_ttl_check.py
index 2fd9d552ea..54b6aa1ef5 100755
--- a/resources/traffic_scripts/ipv4_ping_ttl_check.py
+++ b/resources/traffic_scripts/ipv4_ping_ttl_check.py
@@ -30,8 +30,8 @@ def check_ttl(ttl_begin, ttl_end, ttl_diff):
 
 
 def ckeck_packets_equal(pkt_send, pkt_recv):
-    pkt_send_raw = str(pkt_send)
-    pkt_recv_raw = str(pkt_recv)
+    pkt_send_raw = auto_pad(pkt_send)
+    pkt_recv_raw = auto_pad(pkt_recv)
     if pkt_send_raw != pkt_recv_raw:
         print "Sent:     {}".format(pkt_send_raw.encode('hex'))
         print "Received: {}".format(pkt_recv_raw.encode('hex'))
@@ -63,20 +63,21 @@ if dst_if_defined and (src_if_name == dst_if_name):
     raise Exception("Source interface name equals destination interface name")
 
 src_if = Interface(src_if_name)
-src_if.send_pkt(create_gratuitous_arp_request(src_mac, src_ip))
+src_if.send_pkt(str(create_gratuitous_arp_request(src_mac, src_ip)))
 if dst_if_defined:
     dst_if = Interface(dst_if_name)
-    dst_if.send_pkt(create_gratuitous_arp_request(dst_mac, dst_ip))
+    dst_if.send_pkt(str(create_gratuitous_arp_request(dst_mac, dst_ip)))
 
-pkt_req_send = auto_pad(Ether(src=src_mac, dst=first_hop_mac) /
-                        IP(src=src_ip, dst=dst_ip) /
-                        ICMP())
-pkt_req_send = Ether(pkt_req_send)
+pkt_req_send = (Ether(src=src_mac, dst=first_hop_mac) /
+                      IP(src=src_ip, dst=dst_ip) /
+                      ICMP())
 src_if.send_pkt(pkt_req_send)
 
 if dst_if_defined:
     try:
         pkt_req_recv = dst_if.recv_pkt()
+        if pkt_req_recv is None:
+            raise Exception('Timeout waiting for packet')
     except:
         src_if.close()
         if dst_if_defined:
@@ -89,14 +90,15 @@ if dst_if_defined:
     del pkt_req_send_mod[IP].chksum  # update checksum
     ckeck_packets_equal(pkt_req_send_mod[IP], pkt_req_recv[IP])
 
-    pkt_resp_send = auto_pad(Ether(src=dst_mac, dst=pkt_req_recv.src) /
-                             IP(src=dst_ip, dst=src_ip) /
-                             ICMP(type=0))  # echo-reply
-    pkt_resp_send = Ether(pkt_resp_send)
+    pkt_resp_send = (Ether(src=dst_mac, dst=pkt_req_recv.src) /
+                           IP(src=dst_ip, dst=src_ip) /
+                           ICMP(type=0))  # echo-reply
     dst_if.send_pkt(pkt_resp_send)
 
 try:
     pkt_resp_recv = src_if.recv_pkt()
+    if pkt_resp_recv is None:
+        raise Exception('Timeout waiting for packet')
 except:
     src_if.close()
     if dst_if_defined: