aboutsummaryrefslogtreecommitdiffstats
path: root/functest/opnfv_tests/features
diff options
context:
space:
mode:
Diffstat (limited to 'functest/opnfv_tests/features')
-rwxr-xr-xfunctest/opnfv_tests/features/copper.py84
-rwxr-xr-xfunctest/opnfv_tests/features/doctor.py90
-rwxr-xr-xfunctest/opnfv_tests/features/domino.py87
-rwxr-xr-xfunctest/opnfv_tests/features/multisite.py21
-rwxr-xr-xfunctest/opnfv_tests/features/promise.py255
-rw-r--r--functest/opnfv_tests/features/sfc/SSHUtils.py120
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/compute_presetup_CI.bash27
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/correct_classifier.bash37
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/delete.sh15
-rw-r--r--functest/opnfv_tests/features/sfc/ovs_utils.py117
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/prepare_odl_sfc.bash38
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/prepare_odl_sfc.py96
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/server_presetup_CI.bash13
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/sfc.py545
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/sfc_change_classi.bash7
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/sfc_colorado1.py596
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/sfc_tacker.bash31
-rwxr-xr-xfunctest/opnfv_tests/features/sfc/tacker_client_install.sh43
-rw-r--r--functest/opnfv_tests/features/sfc/test-vnfd1.yaml31
-rw-r--r--functest/opnfv_tests/features/sfc/test-vnfd2.yaml31
20 files changed, 2284 insertions, 0 deletions
diff --git a/functest/opnfv_tests/features/copper.py b/functest/opnfv_tests/features/copper.py
new file mode 100755
index 00000000..ab016262
--- /dev/null
+++ b/functest/opnfv_tests/features/copper.py
@@ -0,0 +1,84 @@
+#!/usr/bin/python
+#
+# Copyright 2016 AT&T Intellectual Property, Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import argparse
+import sys
+import time
+
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as functest_utils
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-r", "--report",
+ help="Create json result file",
+ action="store_true")
+args = parser.parse_args()
+
+COPPER_REPO = \
+ functest_utils.get_functest_config('general.directories.dir_repo_copper')
+RESULTS_DIR = \
+ functest_utils.get_functest_config('general.directories.dir_results')
+
+logger = ft_logger.Logger("copper").getLogger()
+
+
+def main():
+ cmd = "%s/tests/run.sh %s/tests" % (COPPER_REPO, COPPER_REPO)
+
+ start_time = time.time()
+
+ log_file = RESULTS_DIR + "/copper.log"
+ ret_val = functest_utils.execute_command(cmd,
+ output_file=log_file)
+
+ stop_time = time.time()
+ duration = round(stop_time - start_time, 1)
+ if ret_val == 0:
+ logger.info("COPPER PASSED")
+ test_status = 'PASS'
+ else:
+ logger.info("COPPER FAILED")
+ test_status = 'FAIL'
+
+ details = {
+ 'timestart': start_time,
+ 'duration': duration,
+ 'status': test_status,
+ }
+ functest_utils.logger_test_results("Copper",
+ "copper-notification",
+ details['status'], details)
+ try:
+ if args.report:
+ functest_utils.push_results_to_db("copper",
+ "copper-notification",
+ start_time,
+ stop_time,
+ details['status'],
+ details)
+ logger.info("COPPER results pushed to DB")
+ except:
+ logger.error("Error pushing results into Database '%s'"
+ % sys.exc_info()[0])
+
+ if ret_val != 0:
+ sys.exit(-1)
+
+ sys.exit(0)
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/doctor.py b/functest/opnfv_tests/features/doctor.py
new file mode 100755
index 00000000..00e5c1d6
--- /dev/null
+++ b/functest/opnfv_tests/features/doctor.py
@@ -0,0 +1,90 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2015 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
+#
+# 0.1: This script boots the VM1 and allocates IP address from Nova
+# Later, the VM2 boots then execute cloud-init to ping VM1.
+# After successful ping, both the VMs are deleted.
+# 0.2: measure test duration and publish results under json format
+#
+#
+import argparse
+import os
+import time
+
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as functest_utils
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-r", "--report",
+ help="Create json result file",
+ action="store_true")
+args = parser.parse_args()
+
+functest_yaml = functest_utils.get_functest_yaml()
+
+DOCTOR_REPO = \
+ functest_utils.get_functest_config('general.directories.dir_repo_doctor')
+RESULTS_DIR = \
+ functest_utils.get_functest_config('general.directories.dir_results')
+
+logger = ft_logger.Logger("doctor").getLogger()
+
+
+def main():
+ exit_code = -1
+
+ # if the image name is explicitly set for the doctor suite, set it as
+ # enviroment variable
+ if 'doctor' in functest_yaml and 'image_name' in functest_yaml['doctor']:
+ os.environ["IMAGE_NAME"] = functest_yaml['doctor']['image_name']
+
+ cmd = 'cd %s/tests && ./run.sh' % DOCTOR_REPO
+ log_file = RESULTS_DIR + "/doctor.log"
+
+ start_time = time.time()
+
+ ret = functest_utils.execute_command(cmd,
+ info=True,
+ output_file=log_file)
+
+ stop_time = time.time()
+ duration = round(stop_time - start_time, 1)
+ if ret == 0:
+ logger.info("Doctor test case OK")
+ test_status = 'OK'
+ exit_code = 0
+ else:
+ logger.info("Doctor test case FAILED")
+ test_status = 'NOK'
+
+ details = {
+ 'timestart': start_time,
+ 'duration': duration,
+ 'status': test_status,
+ }
+ status = "FAIL"
+ if details['status'] == "OK":
+ status = "PASS"
+ functest_utils.logger_test_results("Doctor",
+ "doctor-notification",
+ status, details)
+ if args.report:
+ functest_utils.push_results_to_db("doctor",
+ "doctor-notification",
+ start_time,
+ stop_time,
+ status,
+ details)
+ logger.info("Doctor results pushed to DB")
+
+ exit(exit_code)
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/domino.py b/functest/opnfv_tests/features/domino.py
new file mode 100755
index 00000000..7705c07b
--- /dev/null
+++ b/functest/opnfv_tests/features/domino.py
@@ -0,0 +1,87 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2015 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
+#
+# 0.1: This script boots the VM1 and allocates IP address from Nova
+# Later, the VM2 boots then execute cloud-init to ping VM1.
+# After successful ping, both the VMs are deleted.
+# 0.2: measure test duration and publish results under json format
+# 0.3: add report flag to push results when needed
+#
+
+import argparse
+import time
+
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as ft_utils
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("-r", "--report",
+ help="Create json result file",
+ action="store_true")
+args = parser.parse_args()
+
+
+DOMINO_REPO = \
+ ft_utils.get_functest_config('general.directories.dir_repo_domino')
+RESULTS_DIR = \
+ ft_utils.get_functest_config('general.directories.dir_results')
+
+logger = ft_logger.Logger("domino").getLogger()
+
+
+def main():
+ cmd = 'cd %s && ./tests/run_multinode.sh' % DOMINO_REPO
+ log_file = RESULTS_DIR + "/domino.log"
+ start_time = time.time()
+
+ ret = ft_utils.execute_command(cmd,
+ output_file=log_file)
+
+ stop_time = time.time()
+ duration = round(stop_time - start_time, 1)
+ if ret == 0 and duration > 1:
+ logger.info("domino OK")
+ test_status = 'OK'
+ elif ret == 0 and duration <= 1:
+ logger.info("domino TEST SKIPPED")
+ test_status = 'SKIPPED'
+ else:
+ logger.info("domino FAILED")
+ test_status = 'NOK'
+
+ details = {
+ 'timestart': start_time,
+ 'duration': duration,
+ 'status': test_status,
+ }
+
+ status = "FAIL"
+ if details['status'] == "OK":
+ status = "PASS"
+ elif details['status'] == "SKIPPED":
+ status = "SKIP"
+
+ ft_utils.logger_test_results("Domino",
+ "domino-multinode",
+ status,
+ details)
+ if args.report:
+ if status is not "SKIP":
+ ft_utils.push_results_to_db("domino",
+ "domino-multinode",
+ start_time,
+ stop_time,
+ status,
+ details)
+ logger.info("Domino results pushed to DB")
+
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/multisite.py b/functest/opnfv_tests/features/multisite.py
new file mode 100755
index 00000000..6d492182
--- /dev/null
+++ b/functest/opnfv_tests/features/multisite.py
@@ -0,0 +1,21 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2015 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
+#
+# Execute Multisite Tempest test cases
+#
+import functest.utils.functest_logger as ft_logger
+
+logger = ft_logger.Logger("multisite").getLogger()
+
+
+def main():
+ logger.info("multisite OK")
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/promise.py b/functest/opnfv_tests/features/promise.py
new file mode 100755
index 00000000..cce0f5dc
--- /dev/null
+++ b/functest/opnfv_tests/features/promise.py
@@ -0,0 +1,255 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2015 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
+#
+# Maintainer : jose.lausuch@ericsson.com
+#
+import argparse
+import json
+import os
+import subprocess
+import time
+
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as ft_utils
+import functest.utils.openstack_utils as openstack_utils
+import keystoneclient.v2_0.client as ksclient
+from neutronclient.v2_0 import client as ntclient
+import novaclient.client as nvclient
+
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("-d", "--debug", help="Debug mode", action="store_true")
+parser.add_argument("-r", "--report",
+ help="Create json result file",
+ action="store_true")
+args = parser.parse_args()
+
+
+dirs = ft_utils.get_functest_config('general.directories')
+PROMISE_REPO = dirs.get('dir_repo_promise')
+RESULTS_DIR = ft_utils.get_functest_config('general.directories.dir_results')
+
+TENANT_NAME = ft_utils.get_functest_config('promise.tenant_name')
+TENANT_DESCRIPTION = \
+ ft_utils.get_functest_config('promise.tenant_description')
+USER_NAME = ft_utils.get_functest_config('promise.user_name')
+USER_PWD = ft_utils.get_functest_config('promise.user_pwd')
+IMAGE_NAME = ft_utils.get_functest_config('promise.image_name')
+FLAVOR_NAME = ft_utils.get_functest_config('promise.flavor_name')
+FLAVOR_VCPUS = ft_utils.get_functest_config('promise.flavor_vcpus')
+FLAVOR_RAM = ft_utils.get_functest_config('promise.flavor_ram')
+FLAVOR_DISK = ft_utils.get_functest_config('promise.flavor_disk')
+
+
+GLANCE_IMAGE_FILENAME = \
+ ft_utils.get_functest_config('general.openstack.image_file_name')
+GLANCE_IMAGE_FORMAT = \
+ ft_utils.get_functest_config('general.openstack.image_disk_format')
+GLANCE_IMAGE_PATH = \
+ ft_utils.get_functest_config('general.directories.dir_functest_data') + \
+ "/" + GLANCE_IMAGE_FILENAME
+
+NET_NAME = ft_utils.get_functest_config('promise.network_name')
+SUBNET_NAME = ft_utils.get_functest_config('promise.subnet_name')
+SUBNET_CIDR = ft_utils.get_functest_config('promise.subnet_cidr')
+ROUTER_NAME = ft_utils.get_functest_config('promise.router_name')
+
+
+""" logging configuration """
+logger = ft_logger.Logger("promise").getLogger()
+
+
+def main():
+ exit_code = -1
+ start_time = time.time()
+ ks_creds = openstack_utils.get_credentials("keystone")
+ nv_creds = openstack_utils.get_credentials("nova")
+ nt_creds = openstack_utils.get_credentials("neutron")
+
+ keystone = ksclient.Client(**ks_creds)
+
+ user_id = openstack_utils.get_user_id(keystone, ks_creds['username'])
+ if user_id == '':
+ logger.error("Error : Failed to get id of %s user" %
+ ks_creds['username'])
+ exit(-1)
+
+ logger.info("Creating tenant '%s'..." % TENANT_NAME)
+ tenant_id = openstack_utils.create_tenant(
+ keystone, TENANT_NAME, TENANT_DESCRIPTION)
+ if not tenant_id:
+ logger.error("Error : Failed to create %s tenant" % TENANT_NAME)
+ exit(-1)
+ logger.debug("Tenant '%s' created successfully." % TENANT_NAME)
+
+ roles_name = ["admin", "Admin"]
+ role_id = ''
+ for role_name in roles_name:
+ if role_id == '':
+ role_id = openstack_utils.get_role_id(keystone, role_name)
+
+ if role_id == '':
+ logger.error("Error : Failed to get id for %s role" % role_name)
+ exit(-1)
+
+ logger.info("Adding role '%s' to tenant '%s'..." % (role_id, TENANT_NAME))
+ if not openstack_utils.add_role_user(keystone, user_id,
+ role_id, tenant_id):
+ logger.error("Error : Failed to add %s on tenant %s" %
+ (ks_creds['username'], TENANT_NAME))
+ exit(-1)
+ logger.debug("Role added successfully.")
+
+ logger.info("Creating user '%s'..." % USER_NAME)
+ user_id = openstack_utils.create_user(
+ keystone, USER_NAME, USER_PWD, None, tenant_id)
+
+ if not user_id:
+ logger.error("Error : Failed to create %s user" % USER_NAME)
+ exit(-1)
+ logger.debug("User '%s' created successfully." % USER_NAME)
+
+ logger.info("Updating OpenStack credentials...")
+ ks_creds.update({
+ "username": TENANT_NAME,
+ "password": TENANT_NAME,
+ "tenant_name": TENANT_NAME,
+ })
+
+ nt_creds.update({
+ "tenant_name": TENANT_NAME,
+ })
+
+ nv_creds.update({
+ "project_id": TENANT_NAME,
+ })
+
+ glance = openstack_utils.get_glance_client()
+ nova = nvclient.Client("2", **nv_creds)
+
+ logger.info("Creating image '%s' from '%s'..." % (IMAGE_NAME,
+ GLANCE_IMAGE_PATH))
+ image_id = openstack_utils.create_glance_image(glance,
+ IMAGE_NAME,
+ GLANCE_IMAGE_PATH)
+ if not image_id:
+ logger.error("Failed to create the Glance image...")
+ exit(-1)
+ logger.debug("Image '%s' with ID '%s' created successfully." % (IMAGE_NAME,
+ image_id))
+ flavor_id = openstack_utils.get_flavor_id(nova, FLAVOR_NAME)
+ if flavor_id == '':
+ logger.info("Creating flavor '%s'..." % FLAVOR_NAME)
+ flavor_id = openstack_utils.create_flavor(nova,
+ FLAVOR_NAME,
+ FLAVOR_RAM,
+ FLAVOR_DISK,
+ FLAVOR_VCPUS)
+ if not flavor_id:
+ logger.error("Failed to create the Flavor...")
+ exit(-1)
+ logger.debug("Flavor '%s' with ID '%s' created successfully." %
+ (FLAVOR_NAME, flavor_id))
+ else:
+ logger.debug("Using existing flavor '%s' with ID '%s'..."
+ % (FLAVOR_NAME, flavor_id))
+
+ neutron = ntclient.Client(**nt_creds)
+
+ network_dic = openstack_utils.create_network_full(neutron,
+ NET_NAME,
+ SUBNET_NAME,
+ ROUTER_NAME,
+ SUBNET_CIDR)
+ if not network_dic:
+ logger.error("Failed to create the private network...")
+ exit(-1)
+
+ logger.info("Exporting environment variables...")
+ os.environ["NODE_ENV"] = "functest"
+ os.environ["OS_TENANT_NAME"] = TENANT_NAME
+ os.environ["OS_USERNAME"] = USER_NAME
+ os.environ["OS_PASSWORD"] = USER_PWD
+ os.environ["OS_TEST_IMAGE"] = image_id
+ os.environ["OS_TEST_FLAVOR"] = flavor_id
+ os.environ["OS_TEST_NETWORK"] = network_dic["net_id"]
+
+ os.chdir(PROMISE_REPO)
+ results_file_name = RESULTS_DIR + '/' + 'promise-results.json'
+ results_file = open(results_file_name, 'w+')
+ cmd = 'npm run -s test -- --reporter json'
+
+ logger.info("Running command: %s" % cmd)
+ ret = subprocess.call(cmd, shell=True, stdout=results_file,
+ stderr=subprocess.STDOUT)
+ results_file.close()
+
+ if ret == 0:
+ logger.info("The test succeeded.")
+ # test_status = 'OK'
+ else:
+ logger.info("The command '%s' failed." % cmd)
+ # test_status = "Failed"
+
+ # Print output of file
+ with open(results_file_name, 'r') as results_file:
+ data = results_file.read()
+ logger.debug("\n%s" % data)
+ json_data = json.loads(data)
+
+ suites = json_data["stats"]["suites"]
+ tests = json_data["stats"]["tests"]
+ passes = json_data["stats"]["passes"]
+ pending = json_data["stats"]["pending"]
+ failures = json_data["stats"]["failures"]
+ start_time_json = json_data["stats"]["start"]
+ end_time = json_data["stats"]["end"]
+ duration = float(json_data["stats"]["duration"]) / float(1000)
+
+ logger.info("\n"
+ "****************************************\n"
+ " Promise test report\n\n"
+ "****************************************\n"
+ " Suites: \t%s\n"
+ " Tests: \t%s\n"
+ " Passes: \t%s\n"
+ " Pending: \t%s\n"
+ " Failures:\t%s\n"
+ " Start: \t%s\n"
+ " End: \t%s\n"
+ " Duration:\t%s\n"
+ "****************************************\n\n"
+ % (suites, tests, passes, pending, failures,
+ start_time_json, end_time, duration))
+
+ if args.report:
+ stop_time = time.time()
+ json_results = {"timestart": start_time, "duration": duration,
+ "tests": int(tests), "failures": int(failures)}
+ logger.debug("Promise Results json: " + str(json_results))
+
+ # criteria for Promise in Release B was 100% of tests OK
+ status = "FAIL"
+ if int(tests) > 32 and int(failures) < 1:
+ status = "PASS"
+ exit_code = 0
+
+ ft_utils.push_results_to_db("promise",
+ "promise",
+ start_time,
+ stop_time,
+ status,
+ json_results)
+
+ exit(exit_code)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/sfc/SSHUtils.py b/functest/opnfv_tests/features/sfc/SSHUtils.py
new file mode 100644
index 00000000..9c8c2c72
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/SSHUtils.py
@@ -0,0 +1,120 @@
+##############################################################################
+# Copyright (c) 2015 Ericsson AB and others.
+# Authors: George Paraskevopoulos (geopar@intracom-telecom.com)
+# Jose Lausuch (jose.lausuch@ericsson.com)
+# 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 paramiko
+import functest.utils.functest_logger as rl
+import os
+
+logger = rl.Logger('SSHUtils').getLogger()
+
+
+def get_ssh_client(hostname, username, password=None, proxy=None):
+ client = None
+ try:
+ if proxy is None:
+ client = paramiko.SSHClient()
+ else:
+ client = ProxyHopClient()
+ client.configure_jump_host(proxy['ip'],
+ proxy['username'],
+ proxy['password'])
+
+ if client is None:
+ raise Exception('Could not connect to client')
+
+ client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+ client.connect(hostname,
+ username=username,
+ password=password)
+ return client
+ except Exception, e:
+ logger.error(e)
+ return None
+
+
+def get_file(ssh_conn, src, dest):
+ try:
+ sftp = ssh_conn.open_sftp()
+ sftp.get(src, dest)
+ return True
+ except Exception, e:
+ logger.error("Error [get_file(ssh_conn, '%s', '%s']: %s" %
+ (src, dest, e))
+ return None
+
+
+def put_file(ssh_conn, src, dest):
+ try:
+ sftp = ssh_conn.open_sftp()
+ sftp.put(src, dest)
+ return True
+ except Exception, e:
+ logger.error("Error [put_file(ssh_conn, '%s', '%s']: %s" %
+ (src, dest, e))
+ return None
+
+
+class ProxyHopClient(paramiko.SSHClient):
+ '''
+ Connect to a remote server using a proxy hop
+ '''
+ def __init__(self, *args, **kwargs):
+ self.logger = rl.Logger("ProxyHopClient").getLogger()
+ self.proxy_ssh = None
+ self.proxy_transport = None
+ self.proxy_channel = None
+ self.proxy_ip = None
+ self.proxy_ssh_key = None
+ self.local_ssh_key = os.path.join(os.getcwd(), 'id_rsa')
+ super(ProxyHopClient, self).__init__(*args, **kwargs)
+
+ def configure_jump_host(self, jh_ip, jh_user, jh_pass,
+ jh_ssh_key='/root/.ssh/id_rsa'):
+ self.proxy_ip = jh_ip
+ self.proxy_ssh_key = jh_ssh_key
+ self.proxy_ssh = paramiko.SSHClient()
+ self.proxy_ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+ self.proxy_ssh.connect(jh_ip,
+ username=jh_user,
+ password=jh_pass)
+ self.proxy_transport = self.proxy_ssh.get_transport()
+
+ def connect(self, hostname, port=22, username='root', password=None,
+ pkey=None, key_filename=None, timeout=None, allow_agent=True,
+ look_for_keys=True, compress=False, sock=None, gss_auth=False,
+ gss_kex=False, gss_deleg_creds=True, gss_host=None,
+ banner_timeout=None):
+ try:
+ if self.proxy_ssh is None:
+ raise Exception('You must configure the jump '
+ 'host before calling connect')
+
+ get_file_res = get_file(self.proxy_ssh,
+ self.proxy_ssh_key,
+ self.local_ssh_key)
+ if get_file_res is None:
+ raise Exception('Could\'t fetch SSH key from jump host')
+ proxy_key = (paramiko.RSAKey
+ .from_private_key_file(self.local_ssh_key))
+
+ self.proxy_channel = self.proxy_transport.open_channel(
+ "direct-tcpip",
+ (hostname, 22),
+ (self.proxy_ip, 22))
+
+ self.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+ super(ProxyHopClient, self).connect(hostname,
+ username=username,
+ pkey=proxy_key,
+ sock=self.proxy_channel)
+ os.remove(self.local_ssh_key)
+ except Exception, e:
+ self.logger.error(e)
diff --git a/functest/opnfv_tests/features/sfc/compute_presetup_CI.bash b/functest/opnfv_tests/features/sfc/compute_presetup_CI.bash
new file mode 100755
index 00000000..36148aa1
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/compute_presetup_CI.bash
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# This script must be use with vxlan-gpe + nsh. Once we have eth + nsh support
+# in ODL, we will not need it anymore
+
+set -e
+ssh_options='-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
+BASEDIR=`dirname $0`
+INSTALLER_IP=${INSTALLER_IP:-10.20.0.2}
+
+pushd $BASEDIR
+#ip=`sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'fuel node'|grep compute|\
+#awk '{print $10}' | head -1`
+
+ip=$1
+echo $ip
+#sshpass -p r00tme scp $ssh_options correct_classifier.bash ${INSTALLER_IP}:/root
+#sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'scp correct_classifier.bash '"$ip"':/root'
+
+sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'ssh root@'"$ip"' ifconfig br-int up'
+output=$(sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'ssh root@'"$ip"' ip route | \
+cut -d" " -f1 | grep 11.0.0.0' ; exit 0)
+
+if [ -z "$output" ]; then
+sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'ssh root@'"$ip"' ip route add 11.0.0.0/24 \
+dev br-int'
+fi
diff --git a/functest/opnfv_tests/features/sfc/correct_classifier.bash b/functest/opnfv_tests/features/sfc/correct_classifier.bash
new file mode 100755
index 00000000..fb08af5c
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/correct_classifier.bash
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+#This scripts correct the current ODL bug which does not detect
+#when SFF and classifier are in the same swtich
+
+nsp=`ovs-ofctl -O Openflow13 dump-flows br-int table=11 | \
+grep "NXM_NX_NSP" | head -1 | cut -d',' -f13 | cut -d':' -f2 \
+| cut -d'-' -f1`
+
+ip=`ovs-ofctl -O Openflow13 dump-flows br-int table=11 | \
+grep NXM_NX_NSH_C1 | head -1 | cut -d':' -f5 | cut -d'-' -f1`
+
+output_port=`ovs-ofctl -O Openflow13 show br-int | \
+grep vxgpe | cut -d'(' -f1`
+
+output_port2=`echo $output_port`
+
+echo "This is the nsp =$(($nsp))"
+echo "This is the ip=$ip"
+echo "This is the vxlan-gpe port=$output_port2"
+
+ovs-ofctl -O Openflow13 del-flows br-int "table=11,tcp,reg0=0x1,tp_dst=80"
+ovs-ofctl -O Openflow13 del-flows br-int "table=11,tcp,reg0=0x1,tp_dst=22"
+
+ovs-ofctl -O Openflow13 add-flow br-int "table=11,tcp,reg0=0x1,tp_dst=80 \
+actions=move:NXM_NX_TUN_ID[0..31]->NXM_NX_NSH_C2[],push_nsh,\
+load:0x1->NXM_NX_NSH_MDTYPE[],load:0x3->NXM_NX_NSH_NP[],\
+load:$ip->NXM_NX_NSH_C1[],load:$nsp->NXM_NX_NSP[0..23],\
+load:0xff->NXM_NX_NSI[],load:$ip->NXM_NX_TUN_IPV4_DST[],\
+load:$nsp->NXM_NX_TUN_ID[0..31],resubmit($output_port,0)"
+
+ovs-ofctl -O Openflow13 add-flow br-int "table=11,tcp,reg0=0x1,tp_dst=22\
+ actions=move:NXM_NX_TUN_ID[0..31]->NXM_NX_NSH_C2[],push_nsh,\
+load:0x1->NXM_NX_NSH_MDTYPE[],load:0x3->NXM_NX_NSH_NP[],\
+load:$ip->NXM_NX_NSH_C1[],load:$nsp->NXM_NX_NSP[0..23],\
+load:0xff->NXM_NX_NSI[],load:$ip->NXM_NX_TUN_IPV4_DST[],\
+load:$nsp->NXM_NX_TUN_ID[0..31],resubmit($output_port,0)"
diff --git a/functest/opnfv_tests/features/sfc/delete.sh b/functest/opnfv_tests/features/sfc/delete.sh
new file mode 100755
index 00000000..c04ae637
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/delete.sh
@@ -0,0 +1,15 @@
+tacker sfc-classifier-delete red_http
+tacker sfc-classifier-delete blue_ssh
+tacker sfc-classifier-delete red_ssh
+tacker sfc-classifier-delete blue_http
+tacker sfc-delete red
+tacker sfc-delete blue
+tacker vnf-delete testVNF1
+tacker vnf-delete testVNF2
+tacker vnfd-delete test-vnfd1
+tacker vnfd-delete test-vnfd2
+openstack stack delete sfc --y
+openstack stack delete sfc_test1 --y
+openstack stack delete sfc_test2 --y
+nova delete client
+nova delete server
diff --git a/functest/opnfv_tests/features/sfc/ovs_utils.py b/functest/opnfv_tests/features/sfc/ovs_utils.py
new file mode 100644
index 00000000..20ab5a7e
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/ovs_utils.py
@@ -0,0 +1,117 @@
+##############################################################################
+# Copyright (c) 2015 Ericsson AB and others.
+# Author: George Paraskevopoulos (geopar@intracom-telecom.com)
+# 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 functest.utils.functest_logger as rl
+import os
+import time
+import shutil
+
+logger = rl.Logger('ovs_utils').getLogger()
+
+
+class OVSLogger(object):
+ def __init__(self, basedir, ft_resdir):
+ self.ovs_dir = basedir
+ self.ft_resdir = ft_resdir
+ self.__mkdir_p(self.ovs_dir)
+
+ def __mkdir_p(self, dirpath):
+ if not os.path.exists(dirpath):
+ os.makedirs(dirpath)
+
+ def __ssh_host(self, ssh_conn, host_prefix='10.20.0'):
+ try:
+ _, stdout, _ = ssh_conn.exec_command('hostname -I')
+ hosts = stdout.readline().strip().split(' ')
+ found_host = [h for h in hosts if h.startswith(host_prefix)][0]
+ return found_host
+ except Exception, e:
+ logger.error(e)
+
+ def __dump_to_file(self, operation, host, text, timestamp=None):
+ ts = (timestamp if timestamp is not None
+ else time.strftime("%Y%m%d-%H%M%S"))
+ dumpdir = os.path.join(self.ovs_dir, ts)
+ self.__mkdir_p(dumpdir)
+ fname = '{0}_{1}'.format(operation, host)
+ with open(os.path.join(dumpdir, fname), 'w') as f:
+ f.write(text)
+
+ def __remote_cmd(self, ssh_conn, cmd):
+ try:
+ _, stdout, stderr = ssh_conn.exec_command(cmd)
+ errors = stderr.readlines()
+ if len(errors) > 0:
+ host = self.__ssh_host(ssh_conn)
+ logger.error(''.join(errors))
+ raise Exception('Could not execute {0} in {1}'
+ .format(cmd, host))
+ output = ''.join(stdout.readlines())
+ return output
+ except Exception, e:
+ logger.error('[__remote_command(ssh_client, {0})]: {1}'
+ .format(cmd, e))
+ return None
+
+ def create_artifact_archive(self):
+ shutil.make_archive(self.ovs_dir,
+ 'zip',
+ root_dir=os.path.dirname(self.ovs_dir),
+ base_dir=self.ovs_dir)
+ shutil.copy2('{0}.zip'.format(self.ovs_dir), self.ft_resdir)
+
+ def ofctl_dump_flows(self, ssh_conn, br='br-int',
+ choose_table=None, timestamp=None):
+ try:
+ cmd = 'ovs-ofctl -OOpenFlow13 dump-flows {0}'.format(br)
+ if choose_table is not None:
+ cmd = '{0} table={1}'.format(cmd, choose_table)
+ output = self.__remote_cmd(ssh_conn, cmd)
+ operation = 'ofctl_dump_flows'
+ host = self.__ssh_host(ssh_conn)
+ self.__dump_to_file(operation, host, output, timestamp=timestamp)
+ return output
+ except Exception, e:
+ logger.error('[ofctl_dump_flows(ssh_client, {0}, {1})]: {2}'
+ .format(br, choose_table, e))
+ return None
+
+ def vsctl_show(self, ssh_conn, timestamp=None):
+ try:
+ cmd = 'ovs-vsctl show'
+ output = self.__remote_cmd(ssh_conn, cmd)
+ operation = 'vsctl_show'
+ host = self.__ssh_host(ssh_conn)
+ self.__dump_to_file(operation, host, output, timestamp=timestamp)
+ return output
+ except Exception, e:
+ logger.error('[vsctl_show(ssh_client)]: {0}'.format(e))
+ return None
+
+ def dump_ovs_logs(self, controller_clients, compute_clients,
+ related_error=None, timestamp=None):
+ if timestamp is None:
+ timestamp = time.strftime("%Y%m%d-%H%M%S")
+
+ for controller_client in controller_clients:
+ self.ofctl_dump_flows(controller_client,
+ timestamp=timestamp)
+ self.vsctl_show(controller_client,
+ timestamp=timestamp)
+
+ for compute_client in compute_clients:
+ self.ofctl_dump_flows(compute_client,
+ timestamp=timestamp)
+ self.vsctl_show(compute_client,
+ timestamp=timestamp)
+
+ if related_error is not None:
+ dumpdir = os.path.join(self.ovs_dir, timestamp)
+ with open(os.path.join(dumpdir, 'error'), 'w') as f:
+ f.write(related_error)
diff --git a/functest/opnfv_tests/features/sfc/prepare_odl_sfc.bash b/functest/opnfv_tests/features/sfc/prepare_odl_sfc.bash
new file mode 100755
index 00000000..c4d8f4f8
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/prepare_odl_sfc.bash
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+#
+# Author: George Paraskevopoulos (geopar@intracom-telecom.com)
+# Manuel Buil (manuel.buil@ericsson.com)
+# Prepares the controller and the compute nodes for the odl-sfc testcase
+#
+#
+# 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
+#
+
+ODL_SFC_LOG=/home/opnfv/functest/results/odl-sfc.log
+ODL_SFC_DIR=${FUNCTEST_REPO_DIR}/opnfv_tests/features/sfc
+
+# Split the output to the log file and redirect STDOUT and STDERR to /dev/null
+bash ${ODL_SFC_DIR}/server_presetup_CI.bash |& \
+ tee -a ${ODL_SFC_LOG} 1>/dev/null 2>&1
+
+# Get return value from PIPESTATUS array (bash specific feature)
+ret_val=${PIPESTATUS[0]}
+if [ $ret_val != 0 ]; then
+ echo "The tacker server deployment failed"
+ exit $ret_val
+fi
+echo "The tacker server was deployed successfully"
+
+bash ${ODL_SFC_DIR}/compute_presetup_CI.bash |& \
+ tee -a ${ODL_SFC_LOG} 1>/dev/null 2>&1
+
+ret_val=${PIPESTATUS[0]}
+if [ $ret_val != 0 ]; then
+ exit $ret_val
+fi
+
+exit 0
diff --git a/functest/opnfv_tests/features/sfc/prepare_odl_sfc.py b/functest/opnfv_tests/features/sfc/prepare_odl_sfc.py
new file mode 100755
index 00000000..3d700b8a
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/prepare_odl_sfc.py
@@ -0,0 +1,96 @@
+#
+# Author: George Paraskevopoulos (geopar@intracom-telecom.com)
+# Manuel Buil (manuel.buil@ericsson.com)
+# Prepares the controller and the compute nodes for the odl-sfc testcase
+#
+#
+# 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 os
+import sys
+import subprocess
+import paramiko
+import functest.utils.functest_logger as ft_logger
+
+logger = ft_logger.Logger("ODL_SFC").getLogger()
+
+try:
+ FUNCTEST_REPO_DIR = os.environ['FUNCTEST_REPO_DIR']
+except:
+ logger.debug("FUNCTEST_REPO_DIR does not exist!!!!!")
+
+FUNCTEST_REPO_DIR = "/home/opnfv/repos/functest"
+
+try:
+ INSTALLER_IP = os.environ['INSTALLER_IP']
+
+except:
+ logger.debug("INSTALLER_IP does not exist. We create 10.20.0.2")
+ INSTALLER_IP = "10.20.0.2"
+
+os.environ['ODL_SFC_LOG'] = "/home/opnfv/functest/results/odl-sfc.log"
+os.environ['ODL_SFC_DIR'] = FUNCTEST_REPO_DIR + "/opnfv_tests/features/sfc"
+
+command = os.environ['ODL_SFC_DIR'] + ("/server_presetup_CI.bash | "
+ "tee -a ${ODL_SFC_LOG} "
+ "1>/dev/null 2>&1")
+
+output = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
+
+# This code is for debugging purposes
+# for line in iter(output.stdout.readline, ''):
+# i = line.rstrip()
+# print(i)
+
+# Make sure the process is finished before checking the returncode
+if not output.poll():
+ output.wait()
+
+# Get return value
+if output.returncode:
+ print("The presetup of the server did not work")
+ sys.exit(output.returncode)
+
+logger.info("The presetup of the server worked ")
+
+ssh_options = "-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no"
+ssh = paramiko.SSHClient()
+ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+try:
+ ssh.connect(INSTALLER_IP, username="root",
+ password="r00tme", timeout=2)
+ command = "fuel node | grep compute | awk '{print $10}'"
+ logger.info("Executing ssh to collect the compute IPs")
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+except:
+ logger.debug("Something went wrong in the ssh to collect the computes IP")
+
+output = stdout.readlines()
+for ip in output:
+ command = os.environ['ODL_SFC_DIR'] + ("/compute_presetup_CI.bash "
+ "" + ip.rstrip() + "| tee -a "
+ "${ODL_SFC_LOG} 1>/dev/null 2>&1")
+
+ output = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
+
+# This code is for debugging purposes
+# for line in iter(output.stdout.readline, ''):
+# print(line)
+# sys.stdout.flush()
+
+ output.stdout.close()
+
+ if not (output.poll()):
+ output.wait()
+
+ # Get return value
+ if output.returncode:
+ print("The compute config did not work on compute %s" % ip)
+ sys.exit(output.returncode)
+
+sys.exit(0)
diff --git a/functest/opnfv_tests/features/sfc/server_presetup_CI.bash b/functest/opnfv_tests/features/sfc/server_presetup_CI.bash
new file mode 100755
index 00000000..240353f5
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/server_presetup_CI.bash
@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+ssh_options='-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
+BASEDIR=`dirname $0`
+INSTALLER_IP=${INSTALLER_IP:-10.20.0.2}
+
+pushd $BASEDIR
+ip=$(sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'fuel node'|grep controller|awk '{print $10}' | head -1)
+echo $ip
+
+sshpass -p r00tme scp $ssh_options delete.sh ${INSTALLER_IP}:/root
+sshpass -p r00tme ssh $ssh_options root@${INSTALLER_IP} 'scp '"$ip"':/root/tackerc .'
+sshpass -p r00tme scp $ssh_options ${INSTALLER_IP}:/root/tackerc $BASEDIR
diff --git a/functest/opnfv_tests/features/sfc/sfc.py b/functest/opnfv_tests/features/sfc/sfc.py
new file mode 100755
index 00000000..17ffef22
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/sfc.py
@@ -0,0 +1,545 @@
+import argparse
+import os
+import subprocess
+import sys
+import time
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as ft_utils
+import functest.utils.openstack_utils as os_utils
+import re
+import json
+import SSHUtils as ssh_utils
+import ovs_utils
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("-r", "--report",
+ help="Create json result file",
+ action="store_true")
+
+args = parser.parse_args()
+
+""" logging configuration """
+logger = ft_logger.Logger("ODL_SFC").getLogger()
+
+FUNCTEST_RESULTS_DIR = '/home/opnfv/functest/results/odl-sfc'
+FUNCTEST_REPO = ft_utils.FUNCTEST_REPO
+REPO_PATH = os.environ['repos_dir'] + '/functest/'
+HOME = os.environ['HOME'] + "/"
+CLIENT = "client"
+SERVER = "server"
+FLAVOR = "custom"
+IMAGE_NAME = "sf_nsh_colorado"
+IMAGE_FILENAME = "sf_nsh_colorado.qcow2"
+IMAGE_FORMAT = "qcow2"
+IMAGE_DIR = "/home/opnfv/functest/data"
+IMAGE_PATH = IMAGE_DIR + "/" + IMAGE_FILENAME
+IMAGE_URL = "http://artifacts.opnfv.org/sfc/demo/" + IMAGE_FILENAME
+
+# NEUTRON Private Network parameters
+NET_NAME = "example-net"
+SUBNET_NAME = "example-subnet"
+SUBNET_CIDR = "11.0.0.0/24"
+ROUTER_NAME = "example-router"
+SECGROUP_NAME = "example-sg"
+SECGROUP_DESCR = "Example Security group"
+SFC_TEST_DIR = REPO_PATH + "/opnfv_tests/features/sfc/"
+TACKER_SCRIPT = SFC_TEST_DIR + "sfc_tacker.bash"
+TACKER_CHANGECLASSI = SFC_TEST_DIR + "sfc_change_classi.bash"
+ssh_options = '-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
+json_results = {"tests": 4, "failures": 0}
+
+PROXY = {
+ 'ip': '10.20.0.2',
+ 'username': 'root',
+ 'password': 'r00tme'
+}
+
+# run given command locally and return commands output if success
+
+
+def run_cmd(cmd, wdir=None, ignore_stderr=False, ignore_no_output=True):
+ pipe = subprocess.Popen(cmd, shell=True,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE, cwd=wdir)
+
+ (output, errors) = pipe.communicate()
+ if output:
+ output = output.strip()
+ if pipe.returncode < 0:
+ logger.error(errors)
+ return False
+ if errors:
+ logger.error(errors)
+ if ignore_stderr:
+ return True
+ else:
+ return False
+
+ if ignore_no_output:
+ if not output:
+ return True
+
+ return output
+
+# run given command on OpenStack controller
+
+
+def run_cmd_on_cntlr(cmd):
+ ip_cntlrs = get_openstack_node_ips("controller")
+ if not ip_cntlrs:
+ return None
+
+ ssh_cmd = "ssh %s %s %s" % (ssh_options, ip_cntlrs[0], cmd)
+ return run_cmd_on_fm(ssh_cmd)
+
+# run given command on OpenStack Compute node
+
+
+def run_cmd_on_compute(cmd):
+ ip_computes = get_openstack_node_ips("compute")
+ if not ip_computes:
+ return None
+
+ ssh_cmd = "ssh %s %s %s" % (ssh_options, ip_computes[0], cmd)
+ return run_cmd_on_fm(ssh_cmd)
+
+# run given command on Fuel Master
+
+
+def run_cmd_on_fm(cmd, username="root", passwd="r00tme"):
+ ip = os.environ.get("INSTALLER_IP")
+ ssh_cmd = "sshpass -p %s ssh %s %s@%s %s" % (
+ passwd, ssh_options, username, ip, cmd)
+ return run_cmd(ssh_cmd)
+
+# run given command on Remote Machine, Can be VM
+
+
+def run_cmd_remote(ip, cmd, username="root", passwd="opnfv"):
+ ssh_opt_append = "%s -o ConnectTimeout=50 " % ssh_options
+ ssh_cmd = "sshpass -p %s ssh %s %s@%s %s" % (
+ passwd, ssh_opt_append, username, ip, cmd)
+ return run_cmd(ssh_cmd)
+
+# Get OpenStack Nodes IP Address
+
+
+def get_openstack_node_ips(role):
+ fuel_env = os.environ.get("FUEL_ENV")
+ if fuel_env is not None:
+ cmd = "fuel2 node list -f json -e %s" % fuel_env
+ else:
+ cmd = "fuel2 node list -f json"
+
+ nodes = run_cmd_on_fm(cmd)
+ ips = []
+ nodes = json.loads(nodes)
+ for node in nodes:
+ if role in node["roles"]:
+ ips.append(node["ip"])
+
+ return ips
+
+# Configures IPTABLES on OpenStack Controller
+
+
+def configure_iptables():
+ iptable_cmds = ["iptables -P INPUT ACCEPT",
+ "iptables -t nat -P INPUT ACCEPT",
+ "iptables -A INPUT -m state \
+ --state NEW,ESTABLISHED,RELATED -j ACCEPT"]
+
+ for cmd in iptable_cmds:
+ logger.info("Configuring %s on contoller" % cmd)
+ run_cmd_on_cntlr(cmd)
+
+ return
+
+
+def download_image():
+ if not os.path.isfile(IMAGE_PATH):
+ logger.info("Downloading image")
+ ft_utils.download_url(IMAGE_URL, IMAGE_DIR)
+
+ logger.info("Using old image")
+ return
+
+
+def setup_glance(glance_client):
+ image_id = os_utils.create_glance_image(glance_client,
+ IMAGE_NAME,
+ IMAGE_PATH,
+ disk=IMAGE_FORMAT,
+ container="bare",
+ public=True)
+
+ return image_id
+
+
+def setup_neutron(neutron_client):
+ n_dict = os_utils.create_network_full(neutron_client,
+ NET_NAME,
+ SUBNET_NAME,
+ ROUTER_NAME,
+ SUBNET_CIDR)
+ if not n_dict:
+ logger.error("failed to create neutron network")
+ sys.exit(-1)
+
+ network_id = n_dict["net_id"]
+ return network_id
+
+
+def setup_ingress_egress_secgroup(neutron_client, protocol,
+ min_port=None, max_port=None):
+ secgroups = os_utils.get_security_groups(neutron_client)
+ for sg in secgroups:
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'ingress', protocol,
+ port_range_min=min_port,
+ port_range_max=max_port)
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'egress', protocol,
+ port_range_min=min_port,
+ port_range_max=max_port)
+ return
+
+
+def setup_security_groups(neutron_client):
+ sg_id = os_utils.create_security_group_full(neutron_client,
+ SECGROUP_NAME, SECGROUP_DESCR)
+ setup_ingress_egress_secgroup(neutron_client, "icmp")
+ setup_ingress_egress_secgroup(neutron_client, "udp", 67, 68)
+ setup_ingress_egress_secgroup(neutron_client, "tcp", 22, 22)
+ setup_ingress_egress_secgroup(neutron_client, "tcp", 80, 80)
+ return sg_id
+
+
+def boot_instance(nova_client, name, flavor, image_id, network_id, sg_id):
+ logger.info("Creating instance '%s'..." % name)
+ logger.debug(
+ "Configuration:\n name=%s \n flavor=%s \n image=%s \n "
+ "network=%s \n" % (name, flavor, image_id, network_id))
+
+ instance = os_utils.create_instance_and_wait_for_active(flavor,
+ image_id,
+ network_id,
+ name)
+
+ if instance is None:
+ logger.error("Error while booting instance.")
+ sys.exit(-1)
+
+ instance_ip = instance.networks.get(NET_NAME)[0]
+ logger.debug("Instance '%s' got private ip '%s'." %
+ (name, instance_ip))
+
+ logger.info("Adding '%s' to security group %s" % (name, SECGROUP_NAME))
+ os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
+
+ return instance_ip
+
+
+def ping(remote, pkt_cnt=1, iface=None, retries=100, timeout=None):
+ ping_cmd = 'ping'
+
+ if timeout:
+ ping_cmd = ping_cmd + ' -w %s' % timeout
+
+ grep_cmd = "grep -e 'packet loss' -e rtt"
+
+ if iface is not None:
+ ping_cmd = ping_cmd + ' -I %s' % iface
+
+ ping_cmd = ping_cmd + ' -i 0 -c %d %s' % (pkt_cnt, remote)
+ cmd = ping_cmd + '|' + grep_cmd
+
+ while retries > 0:
+ output = run_cmd(cmd)
+ if not output:
+ return False
+
+ match = re.search('(\d*)% packet loss', output)
+ if not match:
+ return False
+
+ packet_loss = int(match.group(1))
+ if packet_loss == 0:
+ return True
+
+ retries = retries - 1
+
+ return False
+
+
+def get_floating_ips(nova_client, neutron_client):
+ ips = []
+ instances = nova_client.servers.list(search_opts={'all_tenants': 1})
+ for instance in instances:
+ floatip_dic = os_utils.create_floating_ip(neutron_client)
+ floatip = floatip_dic['fip_addr']
+ instance.add_floating_ip(floatip)
+ logger.info("Instance name and ip %s:%s " % (instance.name, floatip))
+ logger.info("Waiting for instance %s:%s to come up" %
+ (instance.name, floatip))
+ if not ping(floatip):
+ logger.info("Instance %s:%s didn't come up" %
+ (instance.name, floatip))
+ sys.exit(1)
+
+ if instance.name == "server":
+ logger.info("Server:%s is reachable" % floatip)
+ server_ip = floatip
+ elif instance.name == "client":
+ logger.info("Client:%s is reachable" % floatip)
+ client_ip = floatip
+ else:
+ logger.info("SF:%s is reachable" % floatip)
+ ips.append(floatip)
+
+ return server_ip, client_ip, ips[1], ips[0]
+
+# Start http server on a give machine, Can be VM
+
+
+def start_http_server(ip):
+ cmd = "\'python -m SimpleHTTPServer 80"
+ cmd = cmd + " > /dev/null 2>&1 &\'"
+ return run_cmd_remote(ip, cmd)
+
+# Set firewall using vxlan_tool.py on a give machine, Can be VM
+
+
+def vxlan_firewall(sf, iface="eth0", port="22", block=True):
+ cmd = "python vxlan_tool.py"
+ cmd = cmd + " -i " + iface + " -d forward -v off"
+ if block:
+ cmd = "python vxlan_tool.py -i eth0 -d forward -v off -b " + port
+
+ cmd = "sh -c 'cd /root;nohup " + cmd + " > /dev/null 2>&1 &'"
+ run_cmd_remote(sf, cmd)
+
+# Run netcat on a give machine, Can be VM
+
+
+def netcat(s_ip, c_ip, port="80", timeout=5):
+ cmd = "nc -zv "
+ cmd = cmd + " -w %s %s %s" % (timeout, s_ip, port)
+ cmd = cmd + " 2>&1"
+ output = run_cmd_remote(c_ip, cmd)
+ logger.info("%s" % output)
+ return output
+
+
+def is_ssh_blocked(srv_prv_ip, client_ip):
+ res = netcat(srv_prv_ip, client_ip, port="22")
+ match = re.search("nc:.*timed out:.*", res, re.M)
+ if match:
+ return True
+
+ return False
+
+
+def is_http_blocked(srv_prv_ip, client_ip):
+ res = netcat(srv_prv_ip, client_ip, port="80")
+ match = re.search(".* 80 port.* succeeded!", res, re.M)
+ if match:
+ return False
+
+ return True
+
+
+def capture_err_logs(controller_clients, compute_clients, error):
+ ovs_logger = ovs_utils.OVSLogger(
+ os.path.join(os.getcwd(), 'ovs-logs'),
+ FUNCTEST_RESULTS_DIR)
+
+ timestamp = time.strftime("%Y%m%d-%H%M%S")
+ ovs_logger.dump_ovs_logs(controller_clients,
+ compute_clients,
+ related_error=error,
+ timestamp=timestamp)
+ return
+
+
+def update_json_results(name, result):
+ json_results.update({name: result})
+ if result is not "Passed":
+ json_results["failures"] += 1
+
+ return
+
+
+def get_ssh_clients(role):
+ clients = []
+ for ip in get_openstack_node_ips(role):
+ s_client = ssh_utils.get_ssh_client(ip,
+ 'root',
+ proxy=PROXY)
+ clients.append(s_client)
+
+ return clients
+
+# Check SSH connectivity to VNFs
+
+
+def check_ssh(ips, retries=100):
+ check = [False, False]
+ logger.info("Checking SSH connectivity to the SFs with ips %s" % str(ips))
+ while retries and not all(check):
+ for index, ip in enumerate(ips):
+ check[index] = run_cmd_remote(ip, "exit")
+
+ if all(check):
+ logger.info("SSH connectivity to the SFs established")
+ return True
+
+ time.sleep(3)
+ retries -= 1
+
+ return False
+
+
+def main():
+ installer_type = os.environ.get("INSTALLER_TYPE")
+ if installer_type != "fuel":
+ logger.error(
+ '\033[91mCurrently supported only Fuel Installer type\033[0m')
+ sys.exit(1)
+
+ installer_ip = os.environ.get("INSTALLER_IP")
+ if not installer_ip:
+ logger.error(
+ '\033[91minstaller ip is not set\033[0m')
+ logger.error(
+ '\033[91mexport INSTALLER_IP=<ip>\033[0m')
+ sys.exit(1)
+
+ env_list = run_cmd_on_fm("fuel2 env list -f json")
+ fuel_env = os.environ.get("FUEL_ENV")
+ if len(eval(env_list)) > 1 and fuel_env is None:
+ out = run_cmd_on_fm("fuel env")
+ logger.error(
+ '\033[91mMore than one fuel env found\033[0m\n %s' % out)
+ logger.error(
+ '\033[91mexport FUEL_ENV=<env-id> to set ENV\033[0m')
+ sys.exit(1)
+
+ start_time = time.time()
+ status = "PASS"
+ configure_iptables()
+ download_image()
+ _, custom_flv_id = os_utils.get_or_create_flavor(
+ FLAVOR, 1500, 10, 1, public=True)
+ if not custom_flv_id:
+ logger.error("Failed to create custom flavor")
+ sys.exit(1)
+
+ glance_client = os_utils.get_glance_client()
+ neutron_client = os_utils.get_neutron_client()
+ nova_client = os_utils.get_nova_client()
+
+ controller_clients = get_ssh_clients("controller")
+ compute_clients = get_ssh_clients("compute")
+
+ image_id = setup_glance(glance_client)
+ network_id = setup_neutron(neutron_client)
+ sg_id = setup_security_groups(neutron_client)
+
+ boot_instance(
+ nova_client, CLIENT, FLAVOR, image_id, network_id, sg_id)
+ srv_prv_ip = boot_instance(
+ nova_client, SERVER, FLAVOR, image_id, network_id, sg_id)
+
+ subprocess.call(TACKER_SCRIPT, shell=True)
+ server_ip, client_ip, sf1, sf2 = get_floating_ips(
+ nova_client, neutron_client)
+
+ if not check_ssh([sf1, sf2]):
+ logger.error("Cannot establish SSH connection to the SFs")
+ sys.exit(1)
+
+ logger.info("Starting HTTP server on %s" % server_ip)
+ if not start_http_server(server_ip):
+ logger.error(
+ '\033[91mFailed to start HTTP server on %s\033[0m' % server_ip)
+ sys.exit(1)
+
+ logger.info("Starting HTTP firewall on %s" % sf2)
+ vxlan_firewall(sf2, port="80")
+ logger.info("Starting SSH firewall on %s" % sf1)
+ vxlan_firewall(sf1, port="22")
+
+ logger.info("Wait for ODL to update the classification rules in OVS")
+ time.sleep(120)
+
+ logger.info("Test SSH")
+ if is_ssh_blocked(srv_prv_ip, client_ip):
+ logger.info('\033[92mTEST 1 [PASSED] ==> SSH BLOCKED\033[0m')
+ update_json_results("Test 1: SSH Blocked", "Passed")
+ else:
+ error = ('\033[91mTEST 1 [FAILED] ==> SSH NOT BLOCKED\033[0m')
+ logger.error(error)
+ capture_err_logs(controller_clients, compute_clients, error)
+ update_json_results("Test 1: SSH Blocked", "Failed")
+
+ logger.info("Test HTTP")
+ if not is_http_blocked(srv_prv_ip, client_ip):
+ logger.info('\033[92mTEST 2 [PASSED] ==> HTTP WORKS\033[0m')
+ update_json_results("Test 2: HTTP works", "Passed")
+ else:
+ error = ('\033[91mTEST 2 [FAILED] ==> HTTP BLOCKED\033[0m')
+ logger.error(error)
+ capture_err_logs(controller_clients, compute_clients, error)
+ update_json_results("Test 2: HTTP works", "Failed")
+
+ logger.info("Changing the classification")
+ subprocess.call(TACKER_CHANGECLASSI, shell=True)
+ logger.info("Wait for ODL to update the classification rules in OVS")
+ time.sleep(100)
+
+ logger.info("Test HTTP")
+ if is_http_blocked(srv_prv_ip, client_ip):
+ logger.info('\033[92mTEST 3 [PASSED] ==> HTTP Blocked\033[0m')
+ update_json_results("Test 3: HTTP Blocked", "Passed")
+ else:
+ error = ('\033[91mTEST 3 [FAILED] ==> HTTP WORKS\033[0m')
+ logger.error(error)
+ capture_err_logs(controller_clients, compute_clients, error)
+ update_json_results("Test 3: HTTP Blocked", "Failed")
+
+ logger.info("Test SSH")
+ if not is_ssh_blocked(srv_prv_ip, client_ip):
+ logger.info('\033[92mTEST 4 [PASSED] ==> SSH Works\033[0m')
+ update_json_results("Test 4: SSH Works", "Passed")
+ else:
+ error = ('\033[91mTEST 4 [FAILED] ==> SSH BLOCKED\033[0m')
+ logger.error(error)
+ capture_err_logs(controller_clients, compute_clients, error)
+ update_json_results("Test 4: SSH Works", "Failed")
+
+ if json_results["failures"]:
+ status = "FAIL"
+ logger.error('\033[91mSFC TESTS: %s :( FOUND %s FAIL \033[0m' % (
+ status, json_results["failures"]))
+
+ if args.report:
+ stop_time = time.time()
+ logger.debug("Promise Results json: " + str(json_results))
+ ft_utils.push_results_to_db("sfc",
+ "functest-odl-sfc",
+ start_time,
+ stop_time,
+ status,
+ json_results)
+
+ if status == "PASS":
+ logger.info('\033[92mSFC ALL TESTS: %s :)\033[0m' % status)
+ sys.exit(0)
+
+ sys.exit(1)
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/sfc/sfc_change_classi.bash b/functest/opnfv_tests/features/sfc/sfc_change_classi.bash
new file mode 100755
index 00000000..70375ab3
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/sfc_change_classi.bash
@@ -0,0 +1,7 @@
+tacker sfc-classifier-delete red_http
+tacker sfc-classifier-delete red_ssh
+
+tacker sfc-classifier-create --name blue_http --chain blue --match source_port=0,dest_port=80,protocol=6
+tacker sfc-classifier-create --name blue_ssh --chain blue --match source_port=0,dest_port=22,protocol=6
+
+tacker sfc-classifier-list
diff --git a/functest/opnfv_tests/features/sfc/sfc_colorado1.py b/functest/opnfv_tests/features/sfc/sfc_colorado1.py
new file mode 100755
index 00000000..6965f283
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/sfc_colorado1.py
@@ -0,0 +1,596 @@
+import os
+import subprocess
+import sys
+import time
+import argparse
+import paramiko
+
+import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_utils as ft_utils
+import functest.utils.openstack_utils as os_utils
+import SSHUtils as ssh_utils
+import ovs_utils
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument("-r", "--report",
+ help="Create json result file",
+ action="store_true")
+
+args = parser.parse_args()
+
+""" logging configuration """
+logger = ft_logger.Logger("ODL_SFC").getLogger()
+
+FUNCTEST_RESULTS_DIR = '/home/opnfv/functest/results/odl-sfc'
+FUNCTEST_REPO = ft_utils.FUNCTEST_REPO
+
+HOME = os.environ['HOME'] + "/"
+
+VM_BOOT_TIMEOUT = 180
+INSTANCE_NAME = "client"
+FLAVOR = "custom"
+IMAGE_NAME = "sf_nsh_colorado"
+IMAGE_FILENAME = "sf_nsh_colorado.qcow2"
+IMAGE_FORMAT = "qcow2"
+IMAGE_PATH = "/home/opnfv/functest/data" + "/" + IMAGE_FILENAME
+
+# NEUTRON Private Network parameters
+
+NET_NAME = "example-net"
+SUBNET_NAME = "example-subnet"
+SUBNET_CIDR = "11.0.0.0/24"
+ROUTER_NAME = "example-router"
+
+SECGROUP_NAME = "example-sg"
+SECGROUP_DESCR = "Example Security group"
+
+INSTANCE_NAME_2 = "server"
+
+# TEST_DB = ft_utils.get_parameter_from_yaml("results.test_db_url")
+
+PRE_SETUP_SCRIPT = 'sfc_pre_setup.bash'
+TACKER_SCRIPT = 'sfc_tacker.bash'
+TEARDOWN_SCRIPT = "sfc_teardown.bash"
+TACKER_CHANGECLASSI = "sfc_change_classi.bash"
+
+ssh_options = '-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
+
+PROXY = {
+ 'ip': '10.20.0.2',
+ 'username': 'root',
+ 'password': 'r00tme'
+}
+
+
+def check_ssh(ip):
+ cmd = "sshpass -p opnfv ssh " + ssh_options + " -q " + ip + " exit"
+ success = subprocess.call(cmd, shell=True) == 0
+ if not success:
+ logger.debug("Wating for SSH connectivity in SF with IP: %s" % ip)
+ return success
+
+
+def main():
+
+ # Allow any port so that tacker commands reaches the server.
+ # This will be deleted when tacker is included in OPNFV installation
+
+ status = "PASS"
+ failures = 0
+ start_time = time.time()
+ json_results = {}
+
+ contr_cmd = ("sshpass -p r00tme ssh " + ssh_options + " root@10.20.0.2"
+ " 'fuel node'|grep controller|awk '{print $10}'")
+ logger.info("Executing script to get ip_server: '%s'" % contr_cmd)
+ process = subprocess.Popen(contr_cmd,
+ shell=True,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ ip_server = process.stdout.readline().rstrip()
+
+ comp_cmd = ("sshpass -p r00tme ssh " + ssh_options + " root@10.20.0.2"
+ " 'fuel node'|grep compute|awk '{print $10}'")
+ logger.info("Executing script to get compute IPs: '%s'" % comp_cmd)
+ process = subprocess.Popen(comp_cmd,
+ shell=True,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ ip_computes = [ip.strip() for ip in process.stdout.readlines()]
+
+ iptable_cmd1 = ("sshpass -p r00tme ssh " + ssh_options + " root@10.20.0.2"
+ " ssh " + ip_server + " iptables -P INPUT ACCEPT ")
+ iptable_cmd2 = ("sshpass -p r00tme ssh " + ssh_options + " root@10.20.0.2"
+ " ssh " + ip_server + " iptables -t nat -P INPUT ACCEPT ")
+ iptable_cmd3 = ("sshpass -p r00tme ssh " + ssh_options + " root@10.20.0.2"
+ " ssh " + ssh_options + " " + ip_server +
+ " iptables -A INPUT -m state"
+ " --state NEW,ESTABLISHED,RELATED -j ACCEPT")
+
+ logger.info("Changing firewall policy in controller: '%s'" % iptable_cmd1)
+ subprocess.call(iptable_cmd1, shell=True, stderr=subprocess.PIPE)
+
+ logger.info("Changing firewall policy in controller: '%s'" % iptable_cmd2)
+ subprocess.call(iptable_cmd2, shell=True, stderr=subprocess.PIPE)
+
+ logger.info("Changing firewall policy in controller: '%s'" % iptable_cmd3)
+ subprocess.call(iptable_cmd2, shell=True, stderr=subprocess.PIPE)
+
+# Getting the different clients
+
+ nova_client = os_utils.get_nova_client()
+ neutron_client = os_utils.get_neutron_client()
+ glance_client = os_utils.get_glance_client()
+
+ ovs_logger = ovs_utils.OVSLogger(
+ os.path.join(os.getcwd(), 'ovs-logs'),
+ FUNCTEST_RESULTS_DIR)
+
+ controller_clients = [ssh_utils.get_ssh_client(ip_server,
+ 'root',
+ proxy=PROXY)]
+ compute_clients = []
+ for c_ip in ip_computes:
+ c_client = ssh_utils.get_ssh_client(c_ip,
+ 'root',
+ proxy=PROXY)
+ compute_clients.append(c_client)
+
+# Download the image
+
+ if not os.path.isfile(IMAGE_PATH):
+ logger.info("Downloading image")
+ ft_utils.download_url(
+ "http://artifacts.opnfv.org/sfc/demo/sf_nsh_colorado.qcow2",
+ "/home/opnfv/functest/data/")
+ else:
+ logger.info("Using old image")
+
+# Create glance image and the neutron network
+
+ image_id = os_utils.create_glance_image(glance_client,
+ IMAGE_NAME,
+ IMAGE_PATH,
+ disk=IMAGE_FORMAT,
+ container="bare",
+ public=True)
+
+ network_dic = os_utils.create_network_full(neutron_client,
+ NET_NAME,
+ SUBNET_NAME,
+ ROUTER_NAME,
+ SUBNET_CIDR)
+ if not network_dic:
+ logger.error(
+ "There has been a problem when creating the neutron network")
+ sys.exit(-1)
+
+ network_id = network_dic["net_id"]
+
+ sg_id = os_utils.create_security_group_full(neutron_client,
+ SECGROUP_NAME, SECGROUP_DESCR)
+
+ secgroups = os_utils.get_security_groups(neutron_client)
+
+ for sg in secgroups:
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'ingress', 'udp',
+ port_range_min=67,
+ port_range_max=68)
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'egress', 'udp',
+ port_range_min=67,
+ port_range_max=68)
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'ingress', 'tcp',
+ port_range_min=22,
+ port_range_max=22)
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'egress', 'tcp',
+ port_range_min=22,
+ port_range_max=22)
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'ingress', 'tcp',
+ port_range_min=80,
+ port_range_max=80)
+ os_utils.create_secgroup_rule(neutron_client, sg['id'],
+ 'egress', 'tcp',
+ port_range_min=80,
+ port_range_max=80)
+
+ _, custom_flv_id = os_utils.get_or_create_flavor(
+ 'custom', 1500, 10, 1, public=True)
+ if not custom_flv_id:
+ logger.error("Failed to create custom flavor")
+ sys.exit(1)
+
+ iterator = 0
+ while(iterator < 6):
+ # boot INSTANCE
+ logger.info("Creating instance '%s'..." % INSTANCE_NAME)
+ logger.debug(
+ "Configuration:\n name=%s \n flavor=%s \n image=%s \n "
+ "network=%s \n" % (INSTANCE_NAME, FLAVOR, image_id, network_id))
+ instance = os_utils.create_instance_and_wait_for_active(
+ FLAVOR,
+ image_id,
+ network_id,
+ INSTANCE_NAME,
+ av_zone='nova')
+
+ if instance is None:
+ logger.error("Error while booting instance.")
+ iterator += 1
+ continue
+ # Retrieve IP of INSTANCE
+ instance_ip = instance.networks.get(NET_NAME)[0]
+ logger.debug("Instance '%s' got private ip '%s'." %
+ (INSTANCE_NAME, instance_ip))
+
+ logger.info("Adding '%s' to security group '%s'..."
+ % (INSTANCE_NAME, SECGROUP_NAME))
+ os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
+
+ logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME)
+ floatip_dic = os_utils.create_floating_ip(neutron_client)
+ floatip_client = floatip_dic['fip_addr']
+ # floatip_id = floatip_dic['fip_id']
+
+ if floatip_client is None:
+ logger.error("Cannot create floating IP.")
+ iterator += 1
+ continue
+ logger.info("Floating IP created: '%s'" % floatip_client)
+
+ logger.info("Associating floating ip: '%s' to VM '%s' "
+ % (floatip_client, INSTANCE_NAME))
+ if not os_utils.add_floating_ip(nova_client,
+ instance.id,
+ floatip_client):
+ logger.error("Cannot associate floating IP to VM.")
+ iterator += 1
+ continue
+
+ # STARTING SECOND VM (server) ###
+
+ # boot INTANCE
+ logger.info("Creating instance '%s'..." % INSTANCE_NAME_2)
+ logger.debug(
+ "Configuration:\n name=%s \n flavor=%s \n image=%s \n "
+ "network=%s \n" % (INSTANCE_NAME_2, FLAVOR, image_id, network_id))
+ instance_2 = os_utils.create_instance_and_wait_for_active(
+ FLAVOR,
+ image_id,
+ network_id,
+ INSTANCE_NAME_2,
+ av_zone='nova')
+
+ if instance_2 is None:
+ logger.error("Error while booting instance.")
+ iterator += 1
+ continue
+ # Retrieve IP of INSTANCE
+ instance_ip_2 = instance_2.networks.get(NET_NAME)[0]
+ logger.debug("Instance '%s' got private ip '%s'." %
+ (INSTANCE_NAME_2, instance_ip_2))
+
+ logger.info("Adding '%s' to security group '%s'..."
+ % (INSTANCE_NAME_2, SECGROUP_NAME))
+ os_utils.add_secgroup_to_instance(nova_client, instance_2.id, sg_id)
+
+ logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME_2)
+ floatip_dic = os_utils.create_floating_ip(neutron_client)
+ floatip_server = floatip_dic['fip_addr']
+ # floatip_id = floatip_dic['fip_id']
+
+ if floatip_server is None:
+ logger.error("Cannot create floating IP.")
+ iterator += 1
+ continue
+ logger.info("Floating IP created: '%s'" % floatip_server)
+
+ logger.info("Associating floating ip: '%s' to VM '%s' "
+ % (floatip_server, INSTANCE_NAME_2))
+
+ if not os_utils.add_floating_ip(nova_client,
+ instance_2.id,
+ floatip_server):
+ logger.error("Cannot associate floating IP to VM.")
+ iterator += 1
+ continue
+
+ # CREATION OF THE 2 SF ####
+
+ tacker_script = "%s/opnfv_tests/features/sfc/%s" % \
+ (FUNCTEST_REPO, TACKER_SCRIPT)
+ logger.info("Executing tacker script: '%s'" % tacker_script)
+ subprocess.call(tacker_script, shell=True)
+
+ # SSH CALL TO START HTTP SERVER
+ ssh = paramiko.SSHClient()
+ ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+ try:
+ ssh.connect(floatip_server, username="root",
+ password="opnfv", timeout=2)
+ command = "python -m SimpleHTTPServer 80 > /dev/null 2>&1 &"
+ logger.info("Starting HTTP server")
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+ except:
+ logger.debug("Waiting for %s..." % floatip_server)
+ time.sleep(6)
+ # timeout -= 1
+
+ instances = nova_client.servers.list(search_opts={'all_tenants': 1})
+ ips = []
+ try:
+ for instance in instances:
+ if "server" not in instance.name:
+ if "client" not in instance.name:
+ logger.debug(
+ "This is the instance name: %s " % instance.name)
+ floatip_dic = os_utils.create_floating_ip(
+ neutron_client)
+ floatip = floatip_dic['fip_addr']
+ ips.append(floatip)
+ instance.add_floating_ip(floatip)
+ except:
+ logger.debug("Problems assigning floating IP to SFs")
+
+ # If no IPs were obtained, then we cant continue
+ if not ips:
+ logger.error('Failed to obtain IPs, cant continue, exiting')
+ return
+
+ logger.debug("Floating IPs for SFs: %s..." % ips)
+
+ # Check SSH connectivity to VNFs
+ r = 0
+ retries = 100
+ check = [False, False]
+
+ logger.info("Checking SSH connectivity to the SFs with ips {0}"
+ .format(str(ips)))
+ while r < retries and not all(check):
+ try:
+ check = [check_ssh(ips[0]), check_ssh(ips[1])]
+ except Exception:
+ logger.exception("SSH check failed")
+ check = [False, False]
+ time.sleep(3)
+ r += 1
+
+ if not all(check):
+ logger.error("Cannot establish SSH connection to the SFs")
+ iterator += 1
+ continue
+
+ logger.info("SSH connectivity to the SFs established")
+
+ # SSH TO START THE VXLAN_TOOL ON SF1
+ logger.info("Configuring the SFs")
+ try:
+ ssh.connect(ips[0], username="root",
+ password="opnfv", timeout=2)
+ command = ("nohup python vxlan_tool.py -i eth0 "
+ "-d forward -v off -b 80 > /dev/null 2>&1 &")
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+ except:
+ logger.debug("Waiting for %s..." % ips[0])
+ time.sleep(6)
+ # timeout -= 1
+
+ try:
+ n = 0
+ while 1:
+ (stdin, stdout, stderr) = ssh.exec_command(
+ "ps aux | grep \"vxlan_tool.py\" | grep -v grep")
+ if len(stdout.readlines()) > 0:
+ logger.debug("HTTP firewall started")
+ break
+ else:
+ n += 1
+ if (n > 7):
+ break
+ logger.debug("HTTP firewall not started")
+ time.sleep(3)
+ except Exception:
+ logger.exception("vxlan_tool not started in SF1")
+
+ # SSH TO START THE VXLAN_TOOL ON SF2
+ try:
+ ssh.connect(ips[1], username="root",
+ password="opnfv", timeout=2)
+ command = ("nohup python vxlan_tool.py -i eth0 "
+ "-d forward -v off -b 22 > /dev/null 2>&1 &")
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+ except:
+ logger.debug("Waiting for %s..." % ips[1])
+ time.sleep(6)
+ # timeout -= 1
+
+ try:
+ n = 0
+ while 1:
+ (stdin, stdout, stderr) = ssh.exec_command(
+ "ps aux | grep \"vxlan_tool.py\" | grep -v grep")
+ if len(stdout.readlines()) > 0:
+ logger.debug("SSH firewall started")
+ break
+ else:
+ n += 1
+ if (n > 7):
+ break
+ logger.debug("SSH firewall not started")
+ time.sleep(3)
+ except Exception:
+ logger.exception("vxlan_tool not started in SF2")
+
+ i = 0
+
+ # SSH TO EXECUTE cmd_client
+ logger.info("TEST STARTED")
+ time.sleep(70)
+ try:
+ ssh.connect(floatip_client, username="root",
+ password="opnfv", timeout=2)
+ command = "nc -w 5 -zv " + instance_ip_2 + " 22 2>&1"
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+
+ # WRITE THE CORRECT WAY TO DO LOGGING
+ if "timed out" in stdout.readlines()[0]:
+ logger.info('\033[92m' + "TEST 1 [PASSED] "
+ "==> SSH BLOCKED" + '\033[0m')
+ i = i + 1
+ json_results.update({"Test 1: SSH Blocked": "Passed"})
+ else:
+ timestamp = time.strftime("%Y%m%d-%H%M%S")
+ error = ('\033[91m' + "TEST 1 [FAILED] "
+ "==> SSH NOT BLOCKED" + '\033[0m')
+ logger.error(error)
+ ovs_logger.dump_ovs_logs(controller_clients,
+ compute_clients,
+ related_error=error,
+ timestamp=timestamp)
+ status = "FAIL"
+ json_results.update({"Test 1: SSH Blocked": "Failed"})
+ failures += 1
+ except:
+ logger.debug("Waiting for %s..." % floatip_client)
+ time.sleep(6)
+ # timeout -= 1
+
+ # SSH TO EXECUTE cmd_client
+ try:
+ ssh.connect(floatip_client, username="root",
+ password="opnfv", timeout=2)
+ command = "nc -w 5 -zv " + instance_ip_2 + " 80 2>&1"
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+
+ if "succeeded" in stdout.readlines()[0]:
+ logger.info('\033[92m' + "TEST 2 [PASSED] "
+ "==> HTTP WORKS" + '\033[0m')
+ i = i + 1
+ json_results.update({"Test 2: HTTP works": "Passed"})
+ else:
+ timestamp = time.strftime("%Y%m%d-%H%M%S")
+ error = ('\033[91m' + "TEST 2 [FAILED] "
+ "==> HTTP BLOCKED" + '\033[0m')
+ logger.error(error)
+ ovs_logger.dump_ovs_logs(controller_clients,
+ compute_clients,
+ related_error=error,
+ timestamp=timestamp)
+ status = "FAIL"
+ json_results.update({"Test 2: HTTP works": "Failed"})
+ failures += 1
+ except:
+ logger.debug("Waiting for %s..." % floatip_client)
+ time.sleep(6)
+ # timeout -= 1
+
+ # CHANGE OF CLASSIFICATION #
+ logger.info("Changing the classification")
+ tacker_classi = "%s/opnfv_tests/features/sfc/%s" % \
+ (FUNCTEST_REPO, TACKER_CHANGECLASSI)
+ subprocess.call(tacker_classi, shell=True)
+
+ logger.info("Wait for ODL to update the classification rules in OVS")
+ time.sleep(100)
+
+ # SSH TO EXECUTE cmd_client
+
+ try:
+ ssh.connect(floatip_client, username="root",
+ password="opnfv", timeout=2)
+ command = "nc -w 5 -zv " + instance_ip_2 + " 80 2>&1"
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+
+ if "timed out" in stdout.readlines()[0]:
+ logger.info('\033[92m' + "TEST 3 [PASSED] "
+ "==> HTTP BLOCKED" + '\033[0m')
+ i = i + 1
+ json_results.update({"Test 3: HTTP Blocked": "Passed"})
+ else:
+ timestamp = time.strftime("%Y%m%d-%H%M%S")
+ error = ('\033[91m' + "TEST 3 [FAILED] "
+ "==> HTTP NOT BLOCKED" + '\033[0m')
+ logger.error(error)
+ ovs_logger.dump_ovs_logs(controller_clients,
+ compute_clients,
+ related_error=error,
+ timestamp=timestamp)
+ status = "FAIL"
+ json_results.update({"Test 3: HTTP Blocked": "Failed"})
+ failures += 1
+ except:
+ logger.debug("Waiting for %s..." % floatip_client)
+ time.sleep(6)
+ # timeout -= 1
+
+ # SSH TO EXECUTE cmd_client
+ try:
+ ssh.connect(floatip_client, username="root",
+ password="opnfv", timeout=2)
+ command = "nc -w 5 -zv " + instance_ip_2 + " 22 2>&1"
+ (stdin, stdout, stderr) = ssh.exec_command(command)
+
+ if "succeeded" in stdout.readlines()[0]:
+ logger.info('\033[92m' + "TEST 4 [PASSED] "
+ "==> SSH WORKS" + '\033[0m')
+ i = i + 1
+ json_results.update({"Test 4: SSH works": "Passed"})
+ else:
+ timestamp = time.strftime("%Y%m%d-%H%M%S")
+ error = ('\033[91m' + "TEST 4 [FAILED] "
+ "==> SSH BLOCKED" + '\033[0m')
+ logger.error(error)
+ ovs_logger.dump_ovs_logs(controller_clients,
+ compute_clients,
+ related_error=error,
+ timestamp=timestamp)
+ status = "FAIL"
+ json_results.update({"Test 4: SSH works": "Failed"})
+ failures += 1
+ except:
+ logger.debug("Waiting for %s..." % floatip_client)
+ time.sleep(6)
+ # timeout -= 1
+
+ ovs_logger.create_artifact_archive()
+
+ iterator += 1
+ if i == 4:
+ for x in range(0, 5):
+ logger.info('\033[92m' + "SFC TEST WORKED"
+ " :) \n" + '\033[0m')
+ break
+ else:
+ logger.info("Iterating again!")
+ delete = "bash %s/opnfv_tests/features/sfc/delete.sh" % \
+ (FUNCTEST_REPO)
+ try:
+ subprocess.call(delete, shell=True, stderr=subprocess.PIPE)
+ time.sleep(10)
+ except Exception, e:
+ logger.error("Problem when executing the delete.sh")
+ logger.error("Problem %s" % e)
+
+ if args.report:
+ stop_time = time.time()
+ json_results.update({"tests": "4", "failures": int(failures)})
+ logger.debug("Promise Results json: " + str(json_results))
+ ft_utils.push_results_to_db("sfc",
+ "functest-odl-sfc",
+ start_time,
+ stop_time,
+ status,
+ json_results)
+ if status == "PASS":
+ sys.exit(0)
+ else:
+ sys.exit(1)
+
+if __name__ == '__main__':
+ main()
diff --git a/functest/opnfv_tests/features/sfc/sfc_tacker.bash b/functest/opnfv_tests/features/sfc/sfc_tacker.bash
new file mode 100755
index 00000000..690d5f52
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/sfc_tacker.bash
@@ -0,0 +1,31 @@
+#!/bin/bash
+BASEDIR=`dirname $0`
+
+#import VNF descriptor
+tacker vnfd-create --vnfd-file ${BASEDIR}/test-vnfd1.yaml
+tacker vnfd-create --vnfd-file ${BASEDIR}/test-vnfd2.yaml
+
+#create instances of the imported VNF
+tacker vnf-create --name testVNF1 --vnfd-name test-vnfd1
+tacker vnf-create --name testVNF2 --vnfd-name test-vnfd2
+
+key=true
+while $key;do
+ sleep 3
+ active=`tacker vnf-list | grep -E 'PENDING|ERROR'`
+ echo -e "checking if SFs are up: $active"
+ if [ -z "$active" ]; then
+ key=false
+ fi
+done
+
+#create service chain
+tacker sfc-create --name red --chain testVNF1
+tacker sfc-create --name blue --chain testVNF2
+
+#create classifier
+tacker sfc-classifier-create --name red_http --chain red --match source_port=0,dest_port=80,protocol=6
+tacker sfc-classifier-create --name red_ssh --chain red --match source_port=0,dest_port=22,protocol=6
+
+tacker sfc-list
+tacker sfc-classifier-list
diff --git a/functest/opnfv_tests/features/sfc/tacker_client_install.sh b/functest/opnfv_tests/features/sfc/tacker_client_install.sh
new file mode 100755
index 00000000..adb9a44b
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/tacker_client_install.sh
@@ -0,0 +1,43 @@
+MYDIR=$(dirname $(readlink -f "$0"))
+CLIENT=$(echo python-python-tackerclient_*_all.deb)
+CLIREPO="tacker-client"
+
+# Function checks whether a python egg is available, if not, installs
+function chkPPkg() {
+ PKG="$1"
+ IPPACK=$(python - <<'____EOF'
+import pip
+from os.path import join
+for package in pip.get_installed_distributions():
+ print(package.location)
+ print(join(package.location, *package._get_metadata("top_level.txt")))
+____EOF
+)
+ echo "$IPPACK" | grep -q "$PKG"
+ if [ $? -ne 0 ];then
+ pip install "$PKG"
+ fi
+}
+
+function envSetup() {
+ apt-get install -y python-all debhelper fakeroot
+ #pip install --upgrade python-keystoneclient==1.7.4
+ chkPPkg stdeb
+}
+
+# Function installs python-tackerclient from github
+function deployTackerClient() {
+ cd $MYDIR
+ git clone -b 'SFC_refactor' https://github.com/trozet/python-tackerclient.git $CLIREPO
+ cd $CLIREPO
+ python setup.py --command-packages=stdeb.command bdist_deb
+ cd "deb_dist"
+ CLIENT=$(echo python-python-tackerclient_*_all.deb)
+ cp $CLIENT $MYDIR
+ dpkg -i "${MYDIR}/${CLIENT}"
+ apt-get -f -y install
+ dpkg -i "${MYDIR}/${CLIENT}"
+}
+
+envSetup
+deployTackerClient
diff --git a/functest/opnfv_tests/features/sfc/test-vnfd1.yaml b/functest/opnfv_tests/features/sfc/test-vnfd1.yaml
new file mode 100644
index 00000000..5c672e38
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/test-vnfd1.yaml
@@ -0,0 +1,31 @@
+template_name: test-vnfd1
+description: firewall1-example
+
+service_properties:
+ Id: firewall1-vnfd
+ vendor: tacker
+ version: 1
+ type:
+ - firewall1
+vdus:
+ vdu1:
+ id: vdu1
+ vm_image: sf_nsh_colorado
+ instance_type: custom
+ service_type: firewall1
+
+ network_interfaces:
+ management:
+ network: example-net
+ management: true
+
+ placement_policy:
+ availability_zone: nova
+
+ auto-scaling: noop
+ monitoring_policy: noop
+ failure_policy: respawn
+
+ config:
+ param0: key0
+ param1: key1
diff --git a/functest/opnfv_tests/features/sfc/test-vnfd2.yaml b/functest/opnfv_tests/features/sfc/test-vnfd2.yaml
new file mode 100644
index 00000000..8a570ab9
--- /dev/null
+++ b/functest/opnfv_tests/features/sfc/test-vnfd2.yaml
@@ -0,0 +1,31 @@
+template_name: test-vnfd2
+description: firewall2-example
+
+service_properties:
+ Id: firewall2-vnfd
+ vendor: tacker
+ version: 1
+ type:
+ - firewall2
+vdus:
+ vdu1:
+ id: vdu1
+ vm_image: sf_nsh_colorado
+ instance_type: custom
+ service_type: firewall2
+
+ network_interfaces:
+ management:
+ network: example-net
+ management: true
+
+ placement_policy:
+ availability_zone: nova
+
+ auto-scaling: noop
+ monitoring_policy: noop
+ failure_policy: respawn
+
+ config:
+ param0: key0
+ param1: key1