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 download_image(url, image_path):
image_filename = os.path.basename(image_path)
image_url = "%s/%s" % (url, image_filename)
image_dir = os.path.dirname(image_path)
if not os.path.isfile(image_path):
logger.info("Downloading image")
ft_utils.download_url(image_url, image_dir)
else:
logger.info("Using old image")
def test_download_url_default(self, mock_url):
with mock.patch("six.moves.builtins.open", mock.mock_open()) as m, \
mock.patch('functest.utils.functest_utils.shutil.copyfileobj')\
as mock_sh:
name = self.url.rsplit('/')[-1]
dest = self.dest_path + "/" + name
self.assertTrue(
functest_utils.download_url(self.url, self.dest_path))
m.assert_called_once_with(dest, 'wb')
self.assertTrue(mock_sh.called)
def download_and_add_image_on_glance(glance, image_name,
image_url, data_dir):
dest_path = data_dir
if not os.path.exists(dest_path):
os.makedirs(dest_path)
file_name = image_url.rsplit('/')[-1]
if not ft_utils.download_url(image_url, dest_path):
return False
image = os_utils.create_glance_image(
glance, image_name, dest_path + file_name)
if not image:
return False
return image
def download_and_add_image_on_glance(glance, image_name, image_url):
dest_path = vHello_DATA_DIR + "tmp/"
if not os.path.exists(dest_path):
os.makedirs(dest_path)
file_name = image_url.rsplit('/')[-1]
if not functest_utils.download_url(image_url, dest_path):
logger.error("Failed to download image %s" % file_name)
return False
image = os_utils.create_glance_image(
glance, image_name, dest_path + file_name)
if not image:
logger.error("Failed to upload image on glance")
return False
return image
def download_and_add_image_on_glance(glance, image_name, image_url):
dest_path = VIMS_DATA_DIR + "tmp/"
if not os.path.exists(dest_path):
os.makedirs(dest_path)
file_name = image_url.rsplit('/')[-1]
if not functest_utils.download_url(image_url, dest_path):
logger.error("Failed to download image %s" % file_name)
return False
image = os_utils.create_glance_image(
glance, image_name, dest_path + file_name)
if not image:
logger.error("Failed to upload image on glance")
return False
return image
def download_and_add_image_on_glance(glance, image_name, image_url, data_dir):
try:
dest_path = data_dir
if not os.path.exists(dest_path):
os.makedirs(dest_path)
file_name = image_url.rsplit('/')[-1]
if not ft_utils.download_url(image_url, dest_path):
return False
except Exception:
raise Exception(
"Impossible to download image from {}".format(image_url))
try:
image = create_glance_image(glance, image_name, dest_path + file_name)
if not image:
return False
else:
return image
except Exception:
raise Exception(
"Impossible to put image {} in glance".format(image_name))
def test_download_url_failed(self, mock_url):
self.assertFalse(functest_utils.download_url(self.url, self.dest_path))
def main():
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_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_summit2016.qcow2",
"/home/opnfv/functest/data/")
else:
logger.info("Using old image")
# Allow any port so that tacker commands reaches the server.
# CHECK IF THIS STILL MAKES SENSE WHEN TACKER IS INCLUDED IN OPNFV INSTALATION
controller_command = ("sshpass -p r00tme ssh [email protected]"
" 'fuel node'|grep controller|awk '{print $10}'")
logger.info("Executing tacker script: '%s'" % controller_command)
process = subprocess.Popen(controller_command,
shell=True,
stdout=subprocess.PIPE)
ip = process.stdout.readline()
iptable_command1 = ("sshpass -p r00tme ssh [email protected] ssh"
" " + ip + " iptables -P INPUT ACCEPT ")
iptable_command2 = ("sshpass -p r00tme ssh [email protected] ssh"
" " + ip + "iptables -t nat -P INPUT ACCEPT ")
subprocess.call(iptable_command1, shell=True)
subprocess.call(iptable_command2, shell=True)
# 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,
logger=logger)
network_dic = os_utils.create_network_full(logger,
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(logger, neutron_client,
SECGROUP_NAME, SECGROUP_DESCR)
# boot INTANCE
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)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# 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.")
sys.exit(-1)
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.")
sys.exit(-1)
# STARTING SECOND VM (server) ###
# boot INTANCE
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_2 = os_utils.create_instance_and_wait_for_active(FLAVOR,
image_id,
network_id,
INSTANCE_NAME_2)
if instance_2 is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# 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.")
sys.exit(-1)
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.")
sys.exit(-1)
# CREATION OF THE 2 SF ####
tacker_script = "/home/opnfv/repos/functest/testcases/features/sfc/" + \
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="******",
password="******", 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")
logger.debug("Floating IPs for SFs: %s..." % ips)
# SSH TO START THE VXLAN_TOOL ON SF1
logger.info("Configuring the SFs")
try:
ssh.connect(ips[0], username="******",
password="******", timeout=2)
command = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -f -b 80 &")
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % ips[0])
time.sleep(6)
# timeout -= 1
# SSH TO START THE VXLAN_TOOL ON SF2
try:
ssh.connect(ips[1], username="******",
password="******", timeout=2)
command = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -f -b 22 &")
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % ips[1])
time.sleep(6)
# timeout -= 1
# SSH TO EXECUTE cmd_client
logger.info("TEST STARTED")
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 22 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
# WRITE THE CORRECT WAY TO DO LOGGING
i = 0
logger.info("First output: %s" % stdout.readlines())
if "timed out" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 1 [PASSED] "
"==> SSH BLOCKED" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 1 [FAILED] "
"==> SSH NOT BLOCKED" + '\033[0m')
return
# SSH TO EXECUTE cmd_client
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 80 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
if "succeeded" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 2 [PASSED] "
"==> HTTP WORKS" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 2 [FAILED] "
"==> HTTP BLOCKED" + '\033[0m')
return
# CHANGE OF CLASSIFICATION #
logger.info("Changing the classification")
tacker_classi = "/home/opnfv/repos/functest/testcases/features/sfc/" + \
TACKER_CHANGECLASSI
subprocess.call(tacker_classi, shell=True)
# SSH TO EXECUTE cmd_client
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 80 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
if "timed out" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 3 [WORKS] "
"==> HTTP BLOCKED" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 3 [FAILED] "
"==> HTTP NOT BLOCKED" + '\033[0m')
return
# SSH TO EXECUTE cmd_client
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 22 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
if "succeeded" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 4 [WORKS] "
"==> SSH WORKS" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 4 [FAILED] "
"==> SSH BLOCKED" + '\033[0m')
return
if i == 4:
for x in range(0, 5):
logger.info('\033[92m' + "SFC TEST WORKED"
" :) \n" + '\033[0m')
sys.exit(0)
def main():
results = Results(COMMON_CONFIG.line_length)
results.add_to_summary(0, "=")
results.add_to_summary(2, "STATUS", "SUBTEST")
results.add_to_summary(0, "=")
openstack_nodes = test_utils.get_nodes()
# node.is_odl() doesn't work in Apex
# https://jira.opnfv.org/browse/RELENG-192
controllers = [
node for node in openstack_nodes
if "running" in node.run_cmd("sudo systemctl status opendaylight")
]
computes = [node for node in openstack_nodes if node.is_compute()]
msg = ("Verify that OpenDaylight can start/communicate with zrpcd/Quagga")
results.record_action(msg)
results.add_to_summary(0, "-")
if not controllers:
msg = ("Controller (ODL) list is empty. Skipping rest of tests.")
logger.info(msg)
results.add_failure(msg)
return results.compile_summary()
else:
msg = ("Controller (ODL) list is ready")
logger.info(msg)
results.add_success(msg)
controller = controllers[0] # We don't handle HA well
get_ext_ip_cmd = "sudo ip a | grep br-ex | grep inet | awk '{print $2}'"
ext_net_cidr = controller.run_cmd(get_ext_ip_cmd).strip().split('\n')
ext_net_mask = ext_net_cidr[0].split('/')[1]
controller_ext_ip = ext_net_cidr[0].split('/')[0]
logger.info("Starting bgp speaker of controller at IP %s " %
controller_ext_ip)
logger.info("Checking if zrpcd is " "running on the controller node")
output_zrpcd = controller.run_cmd("ps --no-headers -C " "zrpcd -o state")
states = output_zrpcd.split()
running = any([s != 'Z' for s in states])
msg = ("zrpcd is running")
if not running:
logger.info("zrpcd is not running on the controller node")
results.add_failure(msg)
else:
logger.info("zrpcd is running on the controller node")
results.add_success(msg)
results.add_to_summary(0, "-")
# Ensure that ZRPCD ip & port are well configured within ODL
add_client_conn_to_bgp = "bgp-connect -p 7644 -h 127.0.0.1 add"
test_utils.run_odl_cmd(controller, add_client_conn_to_bgp)
# Start bgp daemon
start_quagga = "odl:configure-bgp -op start-bgp-server " \
"--as-num 100 --router-id {0}".format(controller_ext_ip)
test_utils.run_odl_cmd(controller, start_quagga)
logger.info("Checking if bgpd is running" " on the controller node")
# Check if there is a non-zombie bgpd process
output_bgpd = controller.run_cmd("ps --no-headers -C " "bgpd -o state")
states = output_bgpd.split()
running = any([s != 'Z' for s in states])
msg = ("bgpd is running")
if not running:
logger.info("bgpd is not running on the controller node")
results.add_failure(msg)
else:
logger.info("bgpd is running on the controller node")
results.add_success(msg)
results.add_to_summary(0, "-")
# We should be able to restart the speaker
# but the test is disabled because of buggy upstream
# https://github.com/6WIND/zrpcd/issues/15
# stop_quagga = 'odl:configure-bgp -op stop-bgp-server'
# test_utils.run_odl_cmd(controller, stop_quagga)
# logger.info("Checking if bgpd is still running"
# " on the controller node")
# output_bgpd = controller.run_cmd("ps --no-headers -C " \
# "bgpd -o state")
# states = output_bgpd.split()
# running = any([s != 'Z' for s in states])
# msg = ("bgpd is stopped")
# if not running:
# logger.info("bgpd is not running on the controller node")
# results.add_success(msg)
# else:
# logger.info("bgpd is still running on the controller node")
# results.add_failure(msg)
# Taken from the sfc tests
if not os.path.isfile(COMMON_CONFIG.ubuntu_image_path):
logger.info("Downloading image")
ft_utils.download_url(
"http://artifacts.opnfv.org/sdnvpn/"
"ubuntu-16.04-server-cloudimg-amd64-disk1.img",
"/home/opnfv/functest/data/")
else:
logger.info("Using old image")
glance_client = os_utils.get_glance_client()
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
(floatingip_ids, instance_ids, router_ids, network_ids, image_ids,
subnet_ids, interfaces, bgpvpn_ids, flavor_ids) = ([] for i in range(9))
try:
sg_id = os_utils.create_security_group_full(
neutron_client, TESTCASE_CONFIG.secgroup_name,
TESTCASE_CONFIG.secgroup_descr)
test_utils.open_icmp(neutron_client, sg_id)
test_utils.open_http_port(neutron_client, sg_id)
test_utils.open_bgp_port(neutron_client, sg_id)
net_id, subnet_1_id, router_1_id = test_utils.create_network(
neutron_client, TESTCASE_CONFIG.net_1_name,
TESTCASE_CONFIG.subnet_1_name, TESTCASE_CONFIG.subnet_1_cidr,
TESTCASE_CONFIG.router_1_name)
quagga_net_id, subnet_quagga_id, \
router_quagga_id = test_utils.create_network(
neutron_client,
TESTCASE_CONFIG.quagga_net_name,
TESTCASE_CONFIG.quagga_subnet_name,
TESTCASE_CONFIG.quagga_subnet_cidr,
TESTCASE_CONFIG.quagga_router_name)
interfaces.append(tuple((router_1_id, subnet_1_id)))
interfaces.append(tuple((router_quagga_id, subnet_quagga_id)))
network_ids.extend([net_id, quagga_net_id])
router_ids.extend([router_1_id, router_quagga_id])
subnet_ids.extend([subnet_1_id, subnet_quagga_id])
installer_type = str(os.environ['INSTALLER_TYPE'].lower())
if installer_type == "fuel":
disk = 'raw'
elif installer_type == "apex":
disk = 'qcow2'
else:
logger.error("Incompatible installer type")
ubuntu_image_id = os_utils.create_glance_image(
glance_client,
COMMON_CONFIG.ubuntu_image_name,
COMMON_CONFIG.ubuntu_image_path,
disk,
container="bare",
public="public")
image_ids.append(ubuntu_image_id)
# NOTE(rski) The order of this seems a bit weird but
# there is a reason for this, namely
# https://jira.opnfv.org/projects/SDNVPN/issues/SDNVPN-99
# so we create the quagga instance using cloud-init
# and immediately give it a floating IP.
# The cloud-init script should contain a small sleep for
# this to work.
# We also create the FIP first because it is used in the
# cloud-init script.
fip = os_utils.create_floating_ip(neutron_client)
# fake_fip is needed to bypass NAT
# see below for the reason why.
fake_fip = os_utils.create_floating_ip(neutron_client)
floatingip_ids.extend([fip['fip_id'], fake_fip['fip_id']])
# pin quagga to some compute
compute_node = nova_client.hypervisors.list()[0]
quagga_compute_node = "nova:" + compute_node.hypervisor_hostname
# Map the hypervisor used above to a compute handle
# returned by releng's manager
for comp in computes:
if compute_node.host_ip in comp.run_cmd("sudo ip a"):
compute = comp
break
quagga_bootstrap_script = quagga.gen_quagga_setup_script(
controller_ext_ip, fake_fip['fip_addr'], ext_net_mask)
_, flavor_id = test_utils.create_custom_flavor()
flavor_ids.append(flavor_id)
quagga_vm = test_utils.create_instance(
nova_client,
TESTCASE_CONFIG.quagga_instance_name,
ubuntu_image_id,
quagga_net_id,
sg_id,
fixed_ip=TESTCASE_CONFIG.quagga_instance_ip,
flavor=COMMON_CONFIG.custom_flavor_name,
userdata=quagga_bootstrap_script,
compute_node=quagga_compute_node)
instance_ids.append(quagga_vm)
fip_added = os_utils.add_floating_ip(nova_client, quagga_vm.id,
fip['fip_addr'])
msg = ("Assign a Floating IP to %s " %
TESTCASE_CONFIG.quagga_instance_name)
if fip_added:
results.add_success(msg)
else:
results.add_failure(msg)
test_utils.attach_instance_to_ext_br(quagga_vm, compute)
try:
testcase = "Bootstrap quagga inside an OpenStack instance"
cloud_init_success = test_utils.wait_for_cloud_init(quagga_vm)
if cloud_init_success:
results.add_success(testcase)
else:
results.add_failure(testcase)
results.add_to_summary(0, "=")
results.add_to_summary(0, '-')
results.add_to_summary(1, "Peer Quagga with OpenDaylight")
results.add_to_summary(0, '-')
neighbor = quagga.odl_add_neighbor(fake_fip['fip_addr'],
controller_ext_ip, controller)
peer = quagga.check_for_peering(controller)
finally:
test_utils.detach_instance_from_ext_br(quagga_vm, compute)
if neighbor and peer:
results.add_success("Peering with quagga")
else:
results.add_failure("Peering with quagga")
except Exception as e:
logger.error("exception occurred while executing testcase_3: %s", e)
raise
finally:
test_utils.cleanup_nova(nova_client, instance_ids, flavor_ids)
test_utils.cleanup_glance(glance_client, image_ids)
test_utils.cleanup_neutron(neutron_client, floatingip_ids, bgpvpn_ids,
interfaces, subnet_ids, router_ids,
network_ids)
return results.compile_summary()