support rfc2544 test using spirent virtual test center

1. support rfc2544 throughput and latency test with different packet size
2. support vswitch performance test based on STCv affinity deployment

Change-Id: I597de973ab95039dcbcd2da8473a3a5c87a10c14
Signed-off-by: Qiang Dai <Qiang.Dai@spirent.com>

1 files changed, 157 insertions, 0 deletions

diff --git a/contrib/nettest/nettest/nettest.py b/contrib/nettest/nettest/nettest.py
new file mode 100644
index 00000000..c5a203e0
--- /dev/null
+++ b/contrib/nettest/nettest/nettest.py
@@ -0,0 +1,157 @@
+##############################################################################
+# Copyright (c) 2018 Spirent Communications and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import logging
+from time import sleep
+
+from rfc2544test import StcRfc2544Test
+from stcv_stack import StcvStack
+
+
+class NetTestMaster(object):
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+        self.stacks = []
+        self.testcases = []
+
+        self.stack_created = False
+        self.status_reason = ''
+
+    def get_stack_by_id(self, id):
+        for stack in self.stacks:
+            if id == stack.stack_id:
+                return stack
+        return None
+
+    def get_stack_by_name(self, name):
+        for stack in self.stacks:
+            if name == stack.name:
+                return stack
+        return None
+
+    def create_stack(self, name, stack_type, pub_net_name, **kwargs):
+        if stack_type != 'stcv':
+            raise Exception('only support stcv stack type currently')
+
+        try:
+            stack = StcvStack(name=name,
+                              pub_net_name=pub_net_name,
+                              ntp_server_ip=kwargs.get('license_server_ip'),
+                              lab_server_ip=kwargs.get('lab_server_ip'),
+                              stcv_image=kwargs.get('stcv_image'),
+                              stcv_flavor=kwargs.get('stcv_flavor'),
+                              stcv_affinity=kwargs.get('stcv_affinity'))
+            stack.create_stack()
+            self.stacks.append(stack)
+
+        except Exception as err:
+            self.logger.error('create stack fail. err = %s', str(err))
+            raise err
+
+        return stack
+
+    def delete_stack(self, stack_id):
+        stack = self.get_stack_by_id(stack_id)
+        if stack is None:
+            raise Exception('stack does not exist, stack_id = %s', stack_id)
+
+        self.stacks.remove(stack)
+        stack.delete_stack()
+
+    def get_tc_result(self, tc_id):
+        tc = self.get_tc_by_id(tc_id)
+        return tc.get_result()
+
+    def get_tc_status(self, tc_id):
+        tc = self.get_tc_by_id(tc_id)
+        return tc.get_status()
+
+    def execute_testcase(self, name, category, stack_id, **kwargs):
+        if category != 'rfc2544':
+            raise Exception("currently only support rfc2544 test")
+
+        stack = self.get_stack_by_id(stack_id)
+        if stack is None:
+            raise Exception("defined stack not exist, stack_id = %s", stack_id)
+
+        tc = StcRfc2544Test(name=name,
+                            lab_server_ip=stack.lab_server_ip,
+                            license_server_ip=stack.ntp_server_ip,
+                            west_stcv_admin_ip=stack.get_west_stcv_ip(),
+                            west_stcv_tst_ip=stack.get_west_stcv_tst_ip(),
+                            east_stcv_admin_ip=stack.get_east_stcv_ip(),
+                            east_stcv_tst_ip=stack.get_east_stcv_tst_ip(),
+                            stack_id=stack_id,
+                            **kwargs)
+        self.testcases.append(tc)
+        tc.execute()
+
+        return tc.tc_id
+
+    def get_tc_by_id(self, id):
+        for tc in self.testcases:
+            if id == tc.tc_id:
+                return tc
+        return None
+
+    def delete_testcase(self, tc_id):
+        tc = self.get_tc_by_id(tc_id)
+
+        if tc.status == 'finished':
+            tc.delete_result()
+
+        if tc.status == 'running':
+            tc.cancel_run()
+
+        self.testcases.remove(tc)
+
+
+if __name__ == "__main__":
+    try:
+        nettest = NetTestMaster()
+        stack_params = {
+            "stcv_affinity": True,
+            "stcv_image": "stcv-4.79",
+            "stcv_flavor": "m1.tiny",
+            "lab_server_ip": "192.168.37.122",
+            "license_server_ip": "192.168.37.251"
+        }
+
+        stack = nettest.create_stack(name='stack1',
+                                     stack_type='stcv',
+                                     pub_net_name='external',
+                                     **stack_params)
+        tc_params = {
+            'metric': 'throughput',
+            'framesizes': [64, 128]
+        }
+        tc = nettest.execute_testcase(name='tc1',
+                                      category='rfc2544',
+                                      stack_id=stack.stack_id,
+                                      **tc_params)
+
+        print "test case id is %s" % tc.id
+
+        status = tc.get_status()
+        while (status != tc.TC_STATUS_FINISHED):
+            if status == tc.TC_STATUS_ERROR:
+                print "tc exectue fail, reason %s" % tc.get_err_reason()
+                break
+            sleep(2)
+        if status == tc.TC_STATUS_FINISHED:
+            print tc.get_result()
+
+        nettest.delete_testcase(tc.id)
+
+        nettest.delete_stack(stack.stack_id)
+
+    except Exception as err:
+        print err