Add serial failover tests.
diff --git a/tests/serial_failover.py b/tests/serial_failover.py
new file mode 100644
index 0000000..8fb7064
--- /dev/null
+++ b/tests/serial_failover.py
@@ -0,0 +1,218 @@
+"""
+Serial failover test cases
+
+"""
+
+import time
+import signal
+import sys
+import logging
+
+import unittest
+import random
+
+import oftest.controller as controller
+import oftest.cstruct as ofp
+import oftest.message as message
+import oftest.dataplane as dataplane
+import oftest.action as action
+
+from testutils import *
+
+#@var serial_failover_port_map Local copy of the configuration map from OF port
+# numbers to OS interfaces
+serial_failover_port_map = None
+#@var serial_failover_logger Local logger object
+serial_failover_logger = None
+#@var serial_failover_config Local copy of global configuration data
+serial_failover_config = None
+
+test_prio = {}
+
+def test_set_init(config):
+ """
+ Set up function for serial failover test classes
+
+ @param config The configuration dictionary; see oft
+ """
+
+ global serial_failover_port_map
+ global serial_failover_logger
+ global serial_failover_config
+
+ serial_failover_logger = logging.getLogger("serial_failover")
+ serial_failover_logger.info("Initializing test set")
+ serial_failover_port_map = config["port_map"]
+ serial_failover_config = config
+
+class SerialFailover(unittest.TestCase):
+ """
+ Opens a connection that the switch should use as its only controller,
+ as specified by controller_host and controller_port.
+ Then cause the connection to fail [fail method should be configurable].
+ Ultimately, the switch should connect to the next controller port,
+ as specified by
+ --test-params="controller_list=['ip2:port2','ip3:port3']".
+ Multiple test params are specified by
+ --test-params="param1=val1;param2=val2"
+ """
+
+ # populated by buildControllerList()
+ controller_list = []
+ controller_idx = 0
+ # populated by setUp()
+ test_timeout = 0
+ test_iterations = 0
+
+ def sig_handler(self, v1, v2):
+ serial_failover_logger.critical("Received interrupt signal; exiting")
+ print "Received interrupt signal; exiting"
+ self.clean_shutdown = False
+ self.tearDown()
+ sys.exit(1)
+
+ def controllerSetup(self, host, port):
+ self.controller = controller.Controller(host=host,port=port)
+
+ # clean_shutdown should be set to False to force quit app
+ self.clean_shutdown = True
+
+ self.controller.start()
+ #@todo Add an option to wait for a pkt transaction to ensure version
+ # compatibilty?
+ self.controller.connect(timeout=self.test_timeout)
+ self.assertTrue(self.controller.active,
+ "Controller startup failed, not active")
+ self.assertTrue(self.controller.switch_addr is not None,
+ "Controller startup failed, no switch addr")
+ serial_failover_logger.info("Connected " +
+ str(self.controller.switch_addr))
+
+ # send echo request and wait for reply
+ request = message.echo_request()
+ response, pkt = self.controller.transact(request)
+ self.assertEqual(response.header.type, ofp.OFPT_ECHO_REPLY,
+ 'response is not echo_reply')
+ self.assertEqual(request.header.xid, response.header.xid,
+ 'response xid != request xid')
+ self.assertEqual(len(response.data), 0, 'response data non-empty')
+
+ def connectionKill(self, kill_method):
+ if kill_method == 'controller_shutdown':
+ serial_failover_logger.info("Shutting down controller")
+ self.controller.shutdown()
+ elif kill_method == 'no_echo':
+ serial_failover_logger.info("Disabling controller keep alive")
+ self.controller.keep_alive = False
+
+ # wait for controller to die
+ count = 0
+ while self.controller.active and count < self.test_timeout:
+ time.sleep(1)
+ count = count + 1
+ else:
+ self.assertTrue(false, "Unknown controller kill method")
+
+ def buildControllerList(self):
+ # controller_list is list of ip/port tuples
+ partial_list = test_param_get(serial_failover_config,
+ 'controller_list')
+ serial_failover_logger.debug(str(partial_list))
+ self.controller_list = [(serial_failover_config["controller_host"],
+ serial_failover_config["controller_port"])]
+ if partial_list is not None:
+ for controller in partial_list:
+ ip,portstr = controller.split(':')
+ try:
+ port = int(portstr)
+ except:
+ self.assertTrue(0, "failure converting port " +
+ portstr + " to integer")
+ self.controller_list.append( (ip, int(port)) )
+
+ def getController(self):
+ return self.controller_list[self.controller_idx]
+
+ def getNextController(self):
+ self.controller_idx = (self.controller_idx + 1) \
+ % len(self.controller_list)
+ return self.controller_list[self.controller_idx]
+
+ def setUp(self):
+ self.logger = serial_failover_logger
+ self.config = serial_failover_config
+ signal.signal(signal.SIGINT, self.sig_handler)
+ serial_failover_logger.info("** START TEST CASE " + str(self))
+
+ self.test_timeout = test_param_get(serial_failover_config,
+ 'failover_timeout') or 60
+ self.test_iterations = test_param_get(serial_failover_config,
+ 'failover_iterations') or 4
+
+ self.buildControllerList()
+ self.controller_idx = 0
+ controller = self.getController()
+ self.controllerSetup(controller[0], controller[1])
+
+ def inheritSetup(self, parent):
+ """
+ Inherit the setup of a parent
+
+ This allows running at test from within another test. Do the
+ following:
+
+ sub_test = SomeTestClass() # Create an instance of the test class
+ sub_test.inheritSetup(self) # Inherit setup of parent
+ sub_test.runTest() # Run the test
+
+ Normally, only the parent's setUp and tearDown are called and
+ the state after the sub_test is run must be taken into account
+ by subsequent operations.
+ """
+ self.logger = parent.logger
+ self.config = parent.config
+ serial_failover_logger.info("** Setup " + str(self) +
+ " inheriting from " + str(parent))
+ self.controller = parent.controller
+
+ def tearDown(self):
+ serial_failover_logger.info("** END TEST CASE " + str(self))
+ self.controller.shutdown()
+ if self.clean_shutdown:
+ self.controller.join()
+
+ def doFailover(self, killmethod):
+ serial_failover_logger.info("Starting serial failover test")
+ self.assertTrue(self.controller.switch_socket is not None,
+ str(self) + 'No connection to switch')
+ # kill controller connection
+ self.connectionKill(killmethod)
+ # establish new controller connection
+ controller = self.getNextController()
+ serial_failover_logger.debug("** Next controller (%u/%u)%s:%u" %
+ (self.controller_idx,
+ len(self.controller_list),
+ controller[0],
+ controller[1]))
+ self.controllerSetup(controller[0], controller[1])
+
+ def runTest(self):
+ for i in range(0,self.test_iterations):
+ self.doFailover('controller_shutdown')
+
+ def assertTrue(self, cond, msg):
+ if not cond:
+ serial_failover_logger.error("** FAILED ASSERTION: " + msg)
+ unittest.TestCase.assertTrue(self, cond, msg)
+
+test_prio["SerialFailover"] = -1
+
+
+class SerialFailoverNoEcho(SerialFailover):
+
+ def runTest(self):
+ for i in range(0,self.test_iterations):
+ self.doFailover('no_echo')
+
+test_prio["SerialFailoverNoEcho"] = -1
+