def create_instance(nova_client, name, flavor, image_id, network_id, sg_id,
secgroup_name=None, fixed_ip=None,
av_zone='', userdata=None, files=None):
logger.info("Creating instance '%s'..." % name)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n"
" network=%s\n secgroup=%s \n hypervisor=%s \n"
" fixed_ip=%s\n files=%s\n userdata=\n%s\n"
% (name, flavor, image_id, network_id, sg_id,
av_zone, fixed_ip, files, userdata))
instance = os_utils.create_instance_and_wait_for_active(
flavor,
image_id,
network_id,
name,
config_drive=True,
userdata=userdata,
av_zone=av_zone,
fixed_ip=fixed_ip,
files=files)
if instance is None:
logger.error("Error while booting instance.")
return None
if secgroup_name:
logger.debug("Adding '%s' to security group '%s'..."
% (name, secgroup_name))
else:
logger.debug("Adding '%s' to security group '%s'..."
% (name, sg_id))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
return instance
def create_instance(nova_client,
name,
image_id,
network_id,
sg_id,
secgroup_name=None,
fixed_ip=None,
compute_node='',
userdata=None,
files=None,
**kwargs
):
if 'flavor' not in kwargs:
kwargs['flavor'] = common_config.default_flavor
logger.info("Creating instance '%s'..." % name)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n"
" network=%s\n secgroup=%s \n hypervisor=%s \n"
" fixed_ip=%s\n files=%s\n userdata=\n%s\n"
% (name, kwargs['flavor'], image_id, network_id, sg_id,
compute_node, fixed_ip, files, userdata))
instance = os_utils.create_instance_and_wait_for_active(
kwargs['flavor'],
image_id,
network_id,
name,
config_drive=True,
userdata=userdata,
av_zone=compute_node,
fixed_ip=fixed_ip,
files=files)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
else:
logger.debug("Instance '%s' booted successfully. IP='%s'." %
(name, instance.networks.itervalues().next()[0]))
# Retrieve IP of INSTANCE
# instance_ip = instance.networks.get(network_id)[0]
if secgroup_name:
logger.debug("Adding '%s' to security group '%s'..."
% (name, secgroup_name))
else:
logger.debug("Adding '%s' to security group '%s'..."
% (name, sg_id))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
return instance
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 add_secgroup(self, vmname, vm_id, sg_id):
self.logger.info("Adding '%s' to security group '%s'..." %
(vmname, self.sg_name))
os_utils.add_secgroup_to_instance(self.nova_client, vm_id, sg_id)
def deploy_orchestrator(self):
self.logger.info("Additional pre-configuration steps")
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
# Import images if needed
# needs some images
self.logger.info("Upload some OS images if it doesn't exist")
temp_dir = os.path.join(self.data_dir, "tmp/")
for image_name, image_url in self.images.iteritems():
self.logger.info("image: %s, url: %s", image_name, image_url)
try:
image_id = os_utils.get_image_id(glance_client, image_name)
self.logger.info("image_id: %s", image_id)
except BaseException:
self.logger.error("Unexpected error: %s", sys.exc_info()[0])
if image_id == '':
self.logger.info("""%s image doesn't exist on glance
repository. Try downloading this image
and upload on glance !""" % image_name)
image_id = os_utils.download_and_add_image_on_glance(
glance_client, image_name, image_url, temp_dir)
if image_id == '':
self.logger.error("Failed to find or upload required OS "
"image for this deployment")
return False
network_dic = os_utils.create_network_full(neutron_client,
"openbaton_mgmt",
"openbaton_mgmt_subnet",
"openbaton_router",
"192.168.100.0/24")
# orchestrator VM flavor
self.logger.info(
"Check if orchestra Flavor is available, if not create one")
flavor_exist, flavor_id = os_utils.get_or_create_flavor("orchestra",
"4096",
'20',
'2',
public=True)
self.logger.debug("Flavor id: %s" % flavor_id)
if not network_dic:
self.logger.error("There has been a problem when creating the "
"neutron network")
network_id = network_dic["net_id"]
self.logger.info("Creating floating IP for VM in advance...")
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
if floatip is None:
self.logger.error("Cannot create floating IP.")
return False
userdata = "#!/bin/bash\n"
userdata += "echo \"Executing userdata...\"\n"
userdata += "set -x\n"
userdata += "set -e\n"
userdata += "echo \"Set nameserver to '8.8.8.8'...\"\n"
userdata += "echo \"nameserver 8.8.8.8\" >> /etc/resolv.conf\n"
userdata += "echo \"Install curl...\"\n"
userdata += "apt-get install curl\n"
userdata += "echo \"Inject public key...\"\n"
userdata += ("echo \"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCuPXrV3"
"geeHc6QUdyUr/1Z+yQiqLcOskiEGBiXr4z76MK4abiFmDZ18OMQlc"
"fl0p3kS0WynVgyaOHwZkgy/DIoIplONVr2CKBKHtPK+Qcme2PVnCtv"
"EqItl/FcD+1h5XSQGoa+A1TSGgCod/DPo+pes0piLVXP8Ph6QS1k7S"
"ic7JDeRQ4oT1bXYpJ2eWBDMfxIWKZqcZRiGPgMIbJ1iEkxbpeaAd9O"
"4MiM9nGCPESmed+p54uYFjwEDlAJZShcAZziiZYAvMZhvAhe6USljc"
"7YAdalAnyD/jwCHuwIrUw/lxo7UdNCmaUxeobEYyyFA1YVXzpNFZya"
"XPGAAYIJwEq/ openbaton@opnfv\" >> /home/ubuntu/.ssh/aut"
"horized_keys\n")
userdata += "echo \"Download bootstrap...\"\n"
userdata += ("curl -s %s " "> ./bootstrap\n" % self.bootstrap_link)
userdata += ("curl -s %s"
"> ./config_file\n" % self.bootstrap_config_link)
userdata += ("echo \"Disable usage of mysql...\"\n")
userdata += "sed -i s/mysql=.*/mysql=no/g /config_file\n"
userdata += ("echo \"Setting 'rabbitmq_broker_ip' to '%s'\"\n" %
floatip)
userdata += ("sed -i s/rabbitmq_broker_ip=localhost/rabbitmq_broker_ip"
"=%s/g /config_file\n" % floatip)
userdata += "echo \"Set autostart of components to 'false'\"\n"
userdata += "export OPENBATON_COMPONENT_AUTOSTART=false\n"
userdata += "echo \"Execute bootstrap...\"\n"
bootstrap = "sh ./bootstrap release -configFile=./config_file"
userdata += bootstrap + "\n"
userdata += "echo \"Setting 'nfvo.plugin.timeout' to '300000'\"\n"
userdata += ("echo \"nfvo.plugin.timeout=600000\" >> "
"/etc/openbaton/openbaton-nfvo.properties\n")
userdata += (
"wget %s -O /etc/openbaton/openbaton-vnfm-generic-user-data.sh\n" %
self.userdata_file)
userdata += "sed -i '113i\ \ \ \ sleep 60' " \
"/etc/openbaton/openbaton-vnfm-generic-user-data.sh\n"
userdata += "echo \"Starting NFVO\"\n"
userdata += "service openbaton-nfvo restart\n"
userdata += "echo \"Starting Generic VNFM\"\n"
userdata += "service openbaton-vnfm-generic restart\n"
userdata += "echo \"...end of userdata...\"\n"
sg_id = os_utils.create_security_group_full(neutron_client,
"orchestra-sec-group",
"allowall")
os_utils.create_secgroup_rule(neutron_client, sg_id, "ingress", "icmp",
0, 255)
os_utils.create_secgroup_rule(neutron_client, sg_id, "egress", "icmp",
0, 255)
os_utils.create_secgroup_rule(neutron_client, sg_id, "ingress", "tcp",
1, 65535)
os_utils.create_secgroup_rule(neutron_client, sg_id, "ingress", "udp",
1, 65535)
os_utils.create_secgroup_rule(neutron_client, sg_id, "egress", "tcp",
1, 65535)
os_utils.create_secgroup_rule(neutron_client, sg_id, "egress", "udp",
1, 65535)
self.logger.info("Security group set")
self.logger.info("Create instance....")
self.logger.info(
"flavor: m1.medium\n"
"image: %s\n"
"network_id: %s\n"
"userdata: %s\n", self.imagename, network_id, userdata)
instance = os_utils.create_instance_and_wait_for_active(
"orchestra",
os_utils.get_image_id(glance_client, self.imagename),
network_id,
"orchestra-openbaton",
config_drive=False,
userdata=userdata)
self.ob_instance_id = instance.id
self.logger.info("Adding sec group to orchestra instance")
os_utils.add_secgroup_to_instance(nova_client, self.ob_instance_id,
sg_id)
self.logger.info("Associating floating ip: '%s' to VM '%s' ", floatip,
"orchestra-openbaton")
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
self.logger.error("Cannot associate floating IP to VM.")
return False
self.logger.info("Waiting for Open Baton NFVO to be up and running...")
x = 0
while x < 200:
if servertest(floatip, "8080"):
break
else:
self.logger.debug("Open Baton NFVO is not started yet (%ss)" %
(x * 5))
time.sleep(5)
x += 1
if x == 200:
self.logger.error("Open Baton is not started correctly")
self.ob_ip = floatip
self.ob_password = "******"
self.ob_username = "******"
self.ob_https = False
self.ob_port = "8080"
self.logger.info("Waiting for all components up and running...")
time.sleep(60)
self.details["orchestrator"] = {
'status': "PASS",
'result': "Deploy Open Baton NFVO: OK"
}
self.logger.info("Deploy Open Baton NFVO: OK")
return True
def main():
deploymentHandler = DeploymentFactory.get_handler(
COMMON_CONFIG.installer_type,
COMMON_CONFIG.installer_ip,
COMMON_CONFIG.installer_user,
installer_pwd=COMMON_CONFIG.installer_password)
cluster = COMMON_CONFIG.installer_cluster
openstack_nodes = (deploymentHandler.get_nodes({'cluster': cluster})
if cluster is not None
else deploymentHandler.get_nodes())
controller_nodes = [node for node in openstack_nodes
if node.is_controller()]
compute_nodes = [node for node in openstack_nodes
if node.is_compute()]
odl_ip, odl_port = test_utils.get_odl_ip_port(openstack_nodes)
for compute in compute_nodes:
logger.info("This is a compute: %s" % compute.info)
results = Results(COMMON_CONFIG.line_length)
results.add_to_summary(0, "=")
results.add_to_summary(2, "STATUS", "SUBTEST")
results.add_to_summary(0, "=")
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)
test_utils.setup_compute_node(TESTCASE_CONFIG.subnet_cidr, compute_nodes)
test_utils.configure_iptables(controller_nodes)
test_utils.download_image(COMMON_CONFIG.url,
COMMON_CONFIG.image_path)
_, custom_flv_id = os_utils.get_or_create_flavor(
COMMON_CONFIG.flavor,
COMMON_CONFIG.ram_size_in_mb,
COMMON_CONFIG.disk_size_in_gb,
COMMON_CONFIG.vcpu_count, 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()
tacker_client = os_tacker.get_tacker_client()
controller_clients = test_utils.get_ssh_clients(controller_nodes)
compute_clients = test_utils.get_ssh_clients(compute_nodes)
ovs_logger = ovs_log.OVSLogger(
os.path.join(COMMON_CONFIG.sfc_test_dir, 'ovs-logs'),
COMMON_CONFIG.functest_results_dir)
image_id = os_utils.create_glance_image(glance_client,
COMMON_CONFIG.image_name,
COMMON_CONFIG.image_path,
COMMON_CONFIG.image_format,
public='public')
network_id = test_utils.setup_neutron(neutron_client,
TESTCASE_CONFIG.net_name,
TESTCASE_CONFIG.subnet_name,
TESTCASE_CONFIG.router_name,
TESTCASE_CONFIG.subnet_cidr)
sg_id = test_utils.create_security_groups(neutron_client,
TESTCASE_CONFIG.secgroup_name,
TESTCASE_CONFIG.secgroup_descr)
vnf_names = ['testVNF1', 'testVNF2']
topo_seed = topo_shuffler.get_seed() # change to None for nova av zone
testTopology = topo_shuffler.topology(vnf_names, seed=topo_seed)
logger.info('This test is run with the topology {0}'
.format(testTopology['id']))
logger.info('Topology description: {0}'
.format(testTopology['description']))
client_instance = test_utils.create_instance(
nova_client, CLIENT, COMMON_CONFIG.flavor, image_id,
network_id, sg_id, av_zone=testTopology['client'])
server_instance = test_utils.create_instance(
nova_client, SERVER, COMMON_CONFIG.flavor, image_id,
network_id, sg_id, av_zone=testTopology['server'])
server_ip = server_instance.networks.get(TESTCASE_CONFIG.net_name)[0]
tosca_red = os.path.join(COMMON_CONFIG.sfc_test_dir,
COMMON_CONFIG.vnfd_dir,
TESTCASE_CONFIG.test_vnfd_red)
os_tacker.create_vnfd(tacker_client, tosca_file=tosca_red)
tosca_blue = os.path.join(COMMON_CONFIG.sfc_test_dir,
COMMON_CONFIG.vnfd_dir,
TESTCASE_CONFIG.test_vnfd_blue)
os_tacker.create_vnfd(tacker_client, tosca_file=tosca_blue)
default_param_file = os.path.join(
COMMON_CONFIG.sfc_test_dir,
COMMON_CONFIG.vnfd_dir,
COMMON_CONFIG.vnfd_default_params_file)
test_utils.create_vnf_in_av_zone(
tacker_client, vnf_names[0], 'test-vnfd1',
default_param_file, testTopology[vnf_names[0]])
test_utils.create_vnf_in_av_zone(
tacker_client, vnf_names[1], 'test-vnfd2',
default_param_file, testTopology[vnf_names[1]])
vnf1_id = os_tacker.wait_for_vnf(tacker_client, vnf_name=vnf_names[0])
vnf2_id = os_tacker.wait_for_vnf(tacker_client, vnf_name=vnf_names[1])
if vnf1_id is None or vnf2_id is None:
logger.error('ERROR while booting vnfs')
sys.exit(1)
vnf1_instance_id = test_utils.get_nova_id(tacker_client, 'vdu1', vnf1_id)
os_utils.add_secgroup_to_instance(nova_client, vnf1_instance_id, sg_id)
vnf2_instance_id = test_utils.get_nova_id(tacker_client, 'vdu1', vnf2_id)
os_utils.add_secgroup_to_instance(nova_client, vnf2_instance_id, sg_id)
os_tacker.create_sfc(tacker_client, 'red', chain_vnf_names=['testVNF1'])
os_tacker.create_sfc(tacker_client, 'blue', chain_vnf_names=['testVNF2'])
os_tacker.create_sfc_classifier(
tacker_client, 'red_http', sfc_name='red',
match={
'source_port': 0,
'dest_port': 80,
'protocol': 6
})
os_tacker.create_sfc_classifier(
tacker_client, 'red_ssh', sfc_name='red',
match={
'source_port': 0,
'dest_port': 22,
'protocol': 6
})
logger.info(test_utils.run_cmd('tacker sfc-list')[1])
logger.info(test_utils.run_cmd('tacker sfc-classifier-list')[1])
# Start measuring the time it takes to implement the classification rules
t1 = threading.Thread(target=test_utils.wait_for_classification_rules,
args=(ovs_logger, compute_nodes, odl_ip, odl_port,
testTopology,))
try:
t1.start()
except Exception as e:
logger.error("Unable to start the thread that counts time %s" % e)
logger.info("Assigning floating IPs to instances")
server_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, server_instance.id)
client_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, client_instance.id)
sf1_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, vnf1_instance_id)
sf2_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, vnf2_instance_id)
for ip in (server_floating_ip,
client_floating_ip,
sf1_floating_ip,
sf2_floating_ip):
logger.info("Checking connectivity towards floating IP [%s]" % ip)
if not test_utils.ping(ip, retries=50, retry_timeout=1):
logger.error("Cannot ping floating IP [%s]" % ip)
sys.exit(1)
logger.info("Successful ping to floating IP [%s]" % ip)
if not test_utils.check_ssh([sf1_floating_ip, sf2_floating_ip]):
logger.error("Cannot establish SSH connection to the SFs")
sys.exit(1)
logger.info("Starting HTTP server on %s" % server_floating_ip)
if not test_utils.start_http_server(server_floating_ip):
logger.error('\033[91mFailed to start HTTP server on %s\033[0m'
% server_floating_ip)
sys.exit(1)
logger.info("Starting SSH firewall on %s" % sf1_floating_ip)
test_utils.start_vxlan_tool(sf1_floating_ip, block="22")
logger.info("Starting HTTP firewall on %s" % sf2_floating_ip)
test_utils.start_vxlan_tool(sf2_floating_ip, block="80")
logger.info("Wait for ODL to update the classification rules in OVS")
t1.join()
logger.info("Test SSH")
if test_utils.is_ssh_blocked(client_floating_ip, server_ip):
results.add_to_summary(2, "PASS", "SSH Blocked")
else:
error = ('\033[91mTEST 1 [FAILED] ==> SSH NOT BLOCKED\033[0m')
logger.error(error)
test_utils.capture_ovs_logs(
ovs_logger, controller_clients, compute_clients, error)
results.add_to_summary(2, "FAIL", "SSH Blocked")
logger.info("Test HTTP")
if not test_utils.is_http_blocked(client_floating_ip, server_ip):
results.add_to_summary(2, "PASS", "HTTP works")
else:
error = ('\033[91mTEST 2 [FAILED] ==> HTTP BLOCKED\033[0m')
logger.error(error)
test_utils.capture_ovs_logs(
ovs_logger, controller_clients, compute_clients, error)
results.add_to_summary(2, "FAIL", "HTTP works")
logger.info("Changing the classification")
test_utils.delete_classifier_and_acl(
tacker_client, 'red_http', odl_ip, odl_port)
test_utils.delete_classifier_and_acl(
tacker_client, 'red_ssh', odl_ip, odl_port)
os_tacker.create_sfc_classifier(
tacker_client, 'blue_http', sfc_name='blue',
match={
'source_port': 0,
'dest_port': 80,
'protocol': 6
})
os_tacker.create_sfc_classifier(
tacker_client, 'blue_ssh', sfc_name='blue',
match={
'source_port': 0,
'dest_port': 22,
'protocol': 6
})
logger.info(test_utils.run_cmd('tacker sfc-classifier-list')[1])
# Start measuring the time it takes to implement the classification rules
t2 = threading.Thread(target=test_utils.wait_for_classification_rules,
args=(ovs_logger, compute_nodes, odl_ip, odl_port,
testTopology,))
try:
t2.start()
except Exception as e:
logger.error("Unable to start the thread that counts time %s" % e)
logger.info("Wait for ODL to update the classification rules in OVS")
t2.join()
logger.info("Test HTTP")
if test_utils.is_http_blocked(client_floating_ip, server_ip):
results.add_to_summary(2, "PASS", "HTTP Blocked")
else:
error = ('\033[91mTEST 3 [FAILED] ==> HTTP WORKS\033[0m')
logger.error(error)
test_utils.capture_ovs_logs(
ovs_logger, controller_clients, compute_clients, error)
results.add_to_summary(2, "FAIL", "HTTP Blocked")
logger.info("Test SSH")
if not test_utils.is_ssh_blocked(client_floating_ip, server_ip):
results.add_to_summary(2, "PASS", "SSH works")
else:
error = ('\033[91mTEST 4 [FAILED] ==> SSH BLOCKED\033[0m')
logger.error(error)
test_utils.capture_ovs_logs(
ovs_logger, controller_clients, compute_clients, error)
results.add_to_summary(2, "FAIL", "SSH works")
return results.compile_summary()
def main():
deploymentHandler = DeploymentFactory.get_handler(
INSTALLER["type"],
INSTALLER["ip"],
INSTALLER["user"],
installer_pwd=INSTALLER["password"])
cluster = INSTALLER["cluster"]
openstack_nodes = (deploymentHandler.get_nodes({'cluster': cluster})
if cluster is not None
else deploymentHandler.get_nodes())
compute_nodes = [node for node in openstack_nodes
if node.is_compute()]
odl_ip, odl_port = test_utils.get_odl_ip_port(openstack_nodes)
neutron_client = os_utils.get_neutron_client()
nova_client = os_utils.get_nova_client()
tacker_client = os_tacker.get_tacker_client()
ovs_logger = ovs_log.OVSLogger(
os.path.join(DEMO_DIR, 'ovs-logs'), RESULTS_DIR)
sg_id = os_utils.get_security_group_id(neutron_client, SECGROUP_NAME)
vnfs = ['testVNF1', 'testVNF2']
topo_seed = 0
testTopology = topo_shuffler.topology(vnfs, seed=topo_seed)
logger.info('This test is run with the topology {0}'
.format(testTopology['id']))
logger.info('Topology description: {0}'
.format(testTopology['description']))
tosca_red = os.path.join(DEMO_DIR, VNFD_DIR, TEST_VNFD)
os_tacker.create_vnfd(tacker_client, tosca_file=tosca_red)
default_param_file = os.path.join(
DEMO_DIR, VNFD_DIR, VNFD_DEFAULT_PARAMS_FILE)
test_utils.create_vnf_in_av_zone(
tacker_client, vnfs[0], 'test-vnfd1',
default_param_file, testTopology[vnfs[0]])
vnf_id = os_tacker.wait_for_vnf(tacker_client, vnf_name='testVNF1')
if vnf_id is None:
logger.error('ERROR while booting vnf')
sys.exit(1)
vnf_instance_id = test_utils.get_nova_id(tacker_client, 'vdu1', vnf_id)
instances = os_utils.get_instances(nova_client)
for instance in instances:
if ('client' not in instance.name) and ('server' not in instance.name):
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
os_tacker.create_sfc(tacker_client, 'red', chain_vnf_names=['testVNF1'], symmetrical=True)
os_tacker.create_sfc_classifier(
tacker_client, 'red_http', sfc_name='red',
match={
'source_port': 0,
'dest_port': 80,
'protocol': 6
})
os_tacker.create_sfc_classifier(
tacker_client, 'red_http_reverse', sfc_name='red',
match={
'source_port': 80,
'dest_port': 0,
'protocol': 6
})
logger.info(test_utils.run_cmd('tacker sfc-list')[1])
logger.info(test_utils.run_cmd('tacker sfc-classifier-list')[1])
sf_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, vnf_instance_id)
for ip in [sf_floating_ip]:
logger.info("Checking connectivity towards floating IP [%s]" % ip)
if not test_utils.ping(ip, retries=50, retry_timeout=1):
logger.error("Cannot ping floating IP [%s]" % ip)
sys.exit(1)
logger.info("Successful ping to floating IP [%s]" % ip)
if not test_utils.check_ssh([sf_floating_ip]):
logger.error("Cannot establish SSH connection to the SFs")
sys.exit(1)
logger.info("Firewall started, blocking traffic port 80")
test_utils.vxlan_firewall(sf_floating_ip, port=80)
cmd = "python vxlan_tool.py --metadata -i eth0 -d forward -v off -b 80"
cmd = "sh -c 'cd /root;nohup " + cmd + " > /dev/null 2>&1 &'"
test_utils.run_cmd_remote(sf_floating_ip, cmd)
time.sleep(7)
logger.info("Wait for ODL to update the classification rules in OVS")
time.sleep(10)
rsps = test_utils.get_odl_resource_list(
odl_ip, odl_port, 'rendered-service-path', datastore='operational')
reverse_path_id = next(
rsp['path-id']
for rsp in rsps['rendered-service-paths']['rendered-service-path']
if rsp['name'].endswith('Reverse'))
hex_path_id = hex(int(reverse_path_id))
reverse_path_action = "load:{0}->NXM_NX_NSH_C3[]".format(hex_path_id)
for compute_node in compute_nodes:
compute_ssh = compute_node.ssh_client
match_rsp = re.compile(
r'.+tp_dst=80.+load:(0x[0-9a-f]+)->NXM_NX_NSP\[0\.\.23\].+')
# First line is OFPST_FLOW reply (OF1.3) (xid=0x2):
# This is not a flow so ignore
flows = (ovs_logger.ofctl_dump_flows(compute_ssh, 'br-int', '11')
.strip().split('\n')[1:])
matching_flows = [match_rsp.match(f) for f in flows]
if all(m is None for m in matching_flows):
break
uplink_flow = [f.group(0) for f in matching_flows if f is not None][0]
actions = uplink_flow.split("actions=")[1]
actions_c3 = "{0},{1}".format(reverse_path_action, actions)
cmd = "ovs-ofctl -OOpenflow13 mod-flows br-int \"table=11,tcp,reg0=0x1,tp_dst=80,actions={0}\"".format(actions_c3)
#compute_node.run_cmd(cmd)
logger.info("Running: {0}".format(cmd))
match_port = re.compile(
r'.+table=158.+output:([0-9]+)')
flows = (ovs_logger.ofctl_dump_flows(compute_ssh, 'br-int', '158').strip().split('\n')[1:])
matching_flows = [match_port.match(f) for f in flows]
sf_port = [f.group(1) for f in matching_flows if f is not None][0]
cmd = "ovs-ofctl -O Openflow13 add-flow br-int \"table=11,nsi=254,nsp={0} actions=load:0x1->NXM_NX_REG0[],move:NXM_NX_NSH_C2[]->NXM_NX_TUN_ID[0..31],resubmit({1},1)\"".format(reverse_path_id, sf_port)
#compute_node.run_cmd(cmd)
logger.info("Running: {0}".format(cmd))
cmd = "ovs-ofctl -O Openflow13 add-flow br-int \"table=1, priority=40000,nsi=254,nsp={0},reg0=0x1,in_port={1} actions=pop_nsh,goto_table:21\"".format(reverse_path_id, sf_port)
logger.info("Running: {0}".format(cmd))
logger.info("HTTP traffic from client to server should be blocked")
logger.info("When trying to send HTTP traffic to server it should respond with TCP RESET")
def main():
deploymentHandler = DeploymentFactory.get_handler(
COMMON_CONFIG.installer_type,
COMMON_CONFIG.installer_ip,
COMMON_CONFIG.installer_user,
installer_pwd=COMMON_CONFIG.installer_password)
cluster = COMMON_CONFIG.installer_cluster
all_nodes = (deploymentHandler.get_nodes({'cluster': cluster})
if cluster is not None
else deploymentHandler.get_nodes())
controller_nodes = [node for node in all_nodes if node.is_controller()]
compute_nodes = [node for node in all_nodes if node.is_compute()]
odl_ip, odl_port = test_utils.get_odl_ip_port(all_nodes)
results = Results(COMMON_CONFIG.line_length)
results.add_to_summary(0, "=")
results.add_to_summary(2, "STATUS", "SUBTEST")
results.add_to_summary(0, "=")
test_utils.setup_compute_node(TESTCASE_CONFIG.subnet_cidr, compute_nodes)
test_utils.configure_iptables(controller_nodes)
test_utils.download_image(COMMON_CONFIG.url, COMMON_CONFIG.image_path)
neutron_client = os_utils.get_neutron_client()
nova_client = os_utils.get_nova_client()
tacker_client = os_tacker.get_tacker_client()
_, custom_flavor_id = os_utils.get_or_create_flavor(
COMMON_CONFIG.flavor,
COMMON_CONFIG.ram_size_in_mb,
COMMON_CONFIG.disk_size_in_gb,
COMMON_CONFIG.vcpu_count,
public=True)
if custom_flavor_id is None:
logger.error("Failed to create custom flavor")
sys.exit(1)
controller_clients = test_utils.get_ssh_clients(controller_nodes)
compute_clients = test_utils.get_ssh_clients(compute_nodes)
ovs_logger = ovs_log.OVSLogger(
os.path.join(COMMON_CONFIG.sfc_test_dir, 'ovs-logs'),
COMMON_CONFIG.functest_results_dir)
image_id = os_utils.create_glance_image(
os_utils.get_glance_client(),
COMMON_CONFIG.image_name,
COMMON_CONFIG.image_path,
COMMON_CONFIG.image_format,
public='public')
network_id = test_utils.setup_neutron(
neutron_client,
TESTCASE_CONFIG.net_name,
TESTCASE_CONFIG.subnet_name,
TESTCASE_CONFIG.router_name,
TESTCASE_CONFIG.subnet_cidr)
sg_id = test_utils.create_security_groups(
neutron_client,
TESTCASE_CONFIG.secgroup_name,
TESTCASE_CONFIG.secgroup_descr)
vnf_name = 'testVNF1'
# Using seed=0 uses the baseline topology: everything in the same host
testTopology = topo_shuffler.topology([vnf_name], seed=0)
logger.info('This test is run with the topology {0}'
.format(testTopology['id']))
logger.info('Topology description: {0}'
.format(testTopology['description']))
client_instance = test_utils.create_instance(
nova_client,
CLIENT,
COMMON_CONFIG.flavor,
image_id,
network_id,
sg_id,
av_zone=testTopology[CLIENT])
server_instance = test_utils.create_instance(
nova_client,
SERVER,
COMMON_CONFIG.flavor,
image_id,
network_id,
sg_id,
av_zone=testTopology[SERVER])
server_ip = server_instance.networks.get(TESTCASE_CONFIG.net_name)[0]
tosca_file = os.path.join(
COMMON_CONFIG.sfc_test_dir,
COMMON_CONFIG.vnfd_dir,
TESTCASE_CONFIG.test_vnfd)
default_param_file = os.path.join(
COMMON_CONFIG.sfc_test_dir,
COMMON_CONFIG.vnfd_dir,
COMMON_CONFIG.vnfd_default_params_file)
os_tacker.create_vnfd(tacker_client, tosca_file=tosca_file)
test_utils.create_vnf_in_av_zone(
tacker_client,
vnf_name,
'test-vnfd1',
default_param_file,
testTopology[vnf_name])
vnf_id = os_tacker.wait_for_vnf(tacker_client, vnf_name=vnf_name)
if vnf_id is None:
logger.error('ERROR while booting VNF')
sys.exit(1)
vnf_instance_id = test_utils.get_nova_id(tacker_client, 'vdu1', vnf_id)
os_utils.add_secgroup_to_instance(nova_client, vnf_instance_id, sg_id)
os_tacker.create_sfc(
tacker_client,
sfc_name='red',
chain_vnf_names=[vnf_name],
symmetrical=True)
os_tacker.create_sfc_classifier(
tacker_client, 'red_http', sfc_name='red',
match={
'source_port': 0,
'dest_port': 80,
'protocol': 6
})
# FIXME: JIRA SFC-86
# Tacker does not allow to specify the direction of the chain to be used,
# only references the SFP (which for symmetric chains results in two RSPs)
os_tacker.create_sfc_classifier(
tacker_client, 'red_http_reverse', sfc_name='red',
match={
'source_port': 80,
'dest_port': 0,
'protocol': 6
})
logger.info(test_utils.run_cmd('tacker sfc-list'))
logger.info(test_utils.run_cmd('tacker sfc-classifier-list'))
# Start measuring the time it takes to implement the classification rules
t1 = threading.Thread(target=test_utils.wait_for_classification_rules,
args=(ovs_logger, compute_nodes, odl_ip, odl_port,
testTopology,))
try:
t1.start()
except Exception as e:
logger.error("Unable to start the thread that counts time %s" % e)
logger.info("Assigning floating IPs to instances")
server_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, server_instance.id)
client_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, client_instance.id)
sf_floating_ip = test_utils.assign_floating_ip(
nova_client, neutron_client, vnf_instance_id)
for ip in (server_floating_ip, client_floating_ip, sf_floating_ip):
logger.info("Checking connectivity towards floating IP [%s]" % ip)
if not test_utils.ping(ip, retries=50, retry_timeout=1):
logger.error("Cannot ping floating IP [%s]" % ip)
sys.exit(1)
logger.info("Successful ping to floating IP [%s]" % ip)
if not test_utils.check_ssh([sf_floating_ip]):
logger.error("Cannot establish SSH connection to the SFs")
sys.exit(1)
logger.info("Starting HTTP server on %s" % server_floating_ip)
if not test_utils.start_http_server(server_floating_ip):
logger.error('\033[91mFailed to start the HTTP server\033[0m')
sys.exit(1)
blocked_port = TESTCASE_CONFIG.blocked_source_port
logger.info("Firewall started, blocking traffic port %d" % blocked_port)
test_utils.start_vxlan_tool(sf_floating_ip, block=blocked_port)
logger.info("Wait for ODL to update the classification rules in OVS")
t1.join()
allowed_port = TESTCASE_CONFIG.allowed_source_port
logger.info("Test if HTTP from port %s works" % allowed_port)
if not test_utils.is_http_blocked(
client_floating_ip, server_ip, allowed_port):
results.add_to_summary(2, "PASS", "HTTP works")
else:
error = ('\033[91mTEST 1 [FAILED] ==> HTTP BLOCKED\033[0m')
logger.error(error)
test_utils.capture_ovs_logs(
ovs_logger, controller_clients, compute_clients, error)
results.add_to_summary(2, "FAIL", "HTTP works")
logger.info("Test if HTTP from port %s is blocked" % blocked_port)
if test_utils.is_http_blocked(
client_floating_ip, server_ip, blocked_port):
results.add_to_summary(2, "PASS", "HTTP Blocked")
else:
error = ('\033[91mTEST 2 [FAILED] ==> HTTP WORKS\033[0m')
logger.error(error)
test_utils.capture_ovs_logs(
ovs_logger, controller_clients, compute_clients, error)
results.add_to_summary(2, "FAIL", "HTTP Blocked")
return results.compile_summary()
def main():
creds_nova = openstack_utils.get_credentials("nova")
nova_client = novaclient.Client('2', **creds_nova)
creds_neutron = openstack_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
creds_keystone = openstack_utils.get_credentials("keystone")
keystone_client = keystoneclient.Client(**creds_keystone)
glance_endpoint = keystone_client.service_catalog.url_for(
service_type='image', endpoint_type='publicURL')
glance_client = glanceclient.Client(1, glance_endpoint,
token=keystone_client.auth_token)
EXIT_CODE = -1
image_id = None
flavor = None
# Check if the given image exists
image_id = openstack_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME)
if image_id != '':
logger.info("Using existing image '%s'..." % GLANCE_IMAGE_NAME)
global image_exists
image_exists = True
else:
logger.info("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = openstack_utils.create_glance_image(glance_client,
GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create a Glance image...")
return(EXIT_CODE)
logger.debug("Image '%s' with ID=%s created successfully."
% (GLANCE_IMAGE_NAME, image_id))
network_dic = openstack_utils.create_network_full(logger,
neutron_client,
PRIVATE_NET_NAME,
PRIVATE_SUBNET_NAME,
ROUTER_NAME,
PRIVATE_SUBNET_CIDR)
if not network_dic:
logger.error(
"There has been a problem when creating the neutron network")
return(EXIT_CODE)
network_id = network_dic["net_id"]
sg_id = create_security_group(neutron_client)
# Check if the given flavor exists
try:
flavor = nova_client.flavors.find(name=FLAVOR)
logger.info("Using existing Flavor '%s'..." % FLAVOR)
except:
logger.error("Flavor '%s' not found." % FLAVOR)
logger.info("Available flavors are: ")
pMsg(nova_client.flavor.list())
return(EXIT_CODE)
# Deleting instances if they exist
servers = nova_client.servers.list()
for server in servers:
if server.name == NAME_VM_1 or server.name == NAME_VM_2:
logger.info("Instance %s found. Deleting..." % server.name)
server.delete()
# boot VM 1
start_time = time.time()
stop_time = start_time
logger.info("vPing Start Time:'%s'" % (
datetime.datetime.fromtimestamp(start_time).strftime(
'%Y-%m-%d %H:%M:%S')))
logger.info("Creating instance '%s'..." % NAME_VM_1)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (NAME_VM_1, flavor, image_id, network_id))
vm1 = nova_client.servers.create(
name=NAME_VM_1,
flavor=flavor,
image=image_id,
nics=[{"net-id": network_id}]
)
# wait until VM status is active
if not waitVmActive(nova_client, vm1):
logger.error("Instance '%s' cannot be booted. Status is '%s'" % (
NAME_VM_1, openstack_utils.get_instance_status(nova_client, vm1)))
return (EXIT_CODE)
else:
logger.info("Instance '%s' is ACTIVE." % NAME_VM_1)
# Retrieve IP of first VM
test_ip = vm1.networks.get(PRIVATE_NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." % (NAME_VM_1, test_ip))
logger.info("Adding '%s' to security group '%s'..."
% (NAME_VM_1, SECGROUP_NAME))
openstack_utils.add_secgroup_to_instance(nova_client, vm1.id, sg_id)
# boot VM 2
logger.info("Creating instance '%s'..." % NAME_VM_2)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (NAME_VM_2, flavor, image_id, network_id))
vm2 = nova_client.servers.create(
name=NAME_VM_2,
flavor=flavor,
image=image_id,
nics=[{"net-id": network_id}]
)
if not waitVmActive(nova_client, vm2):
logger.error("Instance '%s' cannot be booted. Status is '%s'" % (
NAME_VM_2, openstack_utils.get_instance_status(nova_client, vm2)))
return (EXIT_CODE)
else:
logger.info("Instance '%s' is ACTIVE." % NAME_VM_2)
logger.info("Adding '%s' to security group '%s'..." % (NAME_VM_2,
SECGROUP_NAME))
openstack_utils.add_secgroup_to_instance(nova_client, vm2.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % NAME_VM_2)
floatip_dic = openstack_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip is None:
logger.error("Cannot create floating IP.")
return (EXIT_CODE)
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip, NAME_VM_2))
if not openstack_utils.add_floating_ip(nova_client, vm2.id, floatip):
logger.error("Cannot associate floating IP to VM.")
return (EXIT_CODE)
logger.info("Trying to establish SSH connection to %s..." % floatip)
username = '******'
password = '******'
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
timeout = 50
nolease = False
got_ip = False
discover_count = 0
cidr_first_octet = PRIVATE_SUBNET_CIDR.split('.')[0]
while timeout > 0:
try:
ssh.connect(floatip, username=username,
password=password, timeout=2)
logger.debug("SSH connection established to %s." % floatip)
break
except:
logger.debug("Waiting for %s..." % floatip)
time.sleep(6)
timeout -= 1
console_log = vm2.get_console_output()
# print each "Sending discover" captured on the console log
if (len(re.findall("Sending discover", console_log)) >
discover_count and not got_ip):
discover_count += 1
logger.debug("Console-log '%s': Sending discover..."
% NAME_VM_2)
# check if eth0 got an ip,the line looks like this:
# "inet addr:192.168."....
# if the dhcp agent fails to assing ip, this line will not appear
if "inet addr:" + cidr_first_octet in console_log and not got_ip:
got_ip = True
logger.debug("The instance '%s' succeeded to get the IP "
"from the dhcp agent.")
# if dhcp doesnt work,it shows "No lease, failing".The test will fail
if "No lease, failing" in console_log and not nolease and not got_ip:
nolease = True
logger.debug("Console-log '%s': No lease, failing..."
% NAME_VM_2)
logger.info("The instance failed to get an IP from the "
"DHCP agent. The test will probably timeout...")
if timeout == 0: # 300 sec timeout (5 min)
logger.error("Cannot establish connection to IP '%s'. Aborting"
% floatip)
return (EXIT_CODE)
scp = SCPClient(ssh.get_transport())
ping_script = REPO_PATH + "testcases/OpenStack/vPing/ping.sh"
try:
scp.put(ping_script, "~/")
except:
logger.error("Cannot SCP the file '%s' to VM '%s'"
% (ping_script, floatip))
return (EXIT_CODE)
cmd = 'chmod 755 ~/ping.sh'
(stdin, stdout, stderr) = ssh.exec_command(cmd)
for line in stdout.readlines():
print line
logger.info("Waiting for ping...")
sec = 0
stop_time = time.time()
duration = 0
cmd = '~/ping.sh ' + test_ip
flag = False
status = "FAIL"
while True:
time.sleep(1)
(stdin, stdout, stderr) = ssh.exec_command(cmd)
output = stdout.readlines()
for line in output:
if "vPing OK" in line:
logger.info("vPing detected!")
status = "PASS"
# we consider start time at VM1 booting
stop_time = time.time()
duration = round(stop_time - start_time, 1)
logger.info("vPing duration:'%s' s." % duration)
EXIT_CODE = 0
flag = True
break
elif sec == PING_TIMEOUT:
logger.info("Timeout reached.")
flag = True
break
if flag:
break
logger.debug("Pinging %s. Waiting for response..." % test_ip)
sec += 1
if status == "PASS":
logger.info("vPing OK")
else:
duration = 0
logger.error("vPing FAILED")
if args.report:
try:
logger.debug("Pushing vPing SSH results into DB...")
functest_utils.push_results_to_db("functest",
"vping_ssh",
logger,
start_time,
stop_time,
status,
details={'timestart': start_time,
'duration': duration,
'status': status})
except:
logger.error("Error pushing results into Database '%s'"
% sys.exc_info()[0])
exit(EXIT_CODE)
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():
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
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 = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip is None:
logger.error("Cannot create floating IP.")
sys.exit(-1)
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip, INSTANCE_NAME))
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
sys.exit(0)
def main():
deploymentHandler = DeploymentFactory.get_handler(
INSTALLER["type"],
INSTALLER["ip"],
INSTALLER["user"],
installer_pwd=INSTALLER["password"])
cluster = INSTALLER["cluster"]
openstack_nodes = (deploymentHandler.get_nodes({'cluster': cluster}) if
cluster is not None else deploymentHandler.get_nodes())
compute_nodes = [node for node in openstack_nodes if node.is_compute()]
odl_ip, odl_port = test_utils.get_odl_ip_port(openstack_nodes)
neutron_client = os_utils.get_neutron_client()
nova_client = os_utils.get_nova_client()
tacker_client = os_tacker.get_tacker_client()
compute_clients = test_utils.get_ssh_clients(compute_nodes)
ovs_logger = ovs_log.OVSLogger(os.path.join(DEMO_DIR, 'ovs-logs'),
RESULTS_DIR)
sg_id = os_utils.get_security_group_id(neutron_client, SECGROUP_NAME)
vnfs = ['testVNF1', 'testVNF2']
topo_seed = 0
testTopology = topo_shuffler.topology(vnfs, seed=topo_seed)
logger.info('This test is run with the topology {0}'.format(
testTopology['id']))
logger.info('Topology description: {0}'.format(
testTopology['description']))
tosca_red = os.path.join(DEMO_DIR, VNFD_DIR, TEST_VNFD_RED)
os_tacker.create_vnfd(tacker_client, tosca_file=tosca_red)
tosca_blue = os.path.join(DEMO_DIR, VNFD_DIR, TEST_VNFD_BLUE)
os_tacker.create_vnfd(tacker_client, tosca_file=tosca_blue)
default_param_file = os.path.join(DEMO_DIR, VNFD_DIR,
VNFD_DEFAULT_PARAMS_FILE)
test_utils.create_vnf_in_av_zone(tacker_client, vnfs[0], 'test-vnfd1',
default_param_file, testTopology[vnfs[0]])
test_utils.create_vnf_in_av_zone(tacker_client, vnfs[1], 'test-vnfd2',
default_param_file, testTopology[vnfs[1]])
vnf1_id = os_tacker.wait_for_vnf(tacker_client, vnf_name='testVNF1')
vnf2_id = os_tacker.wait_for_vnf(tacker_client, vnf_name='testVNF2')
if vnf1_id is None or vnf2_id is None:
logger.error('ERROR while booting vnfs')
sys.exit(1)
instances = os_utils.get_instances(nova_client)
for instance in instances:
if ('client' not in instance.name) and ('server' not in instance.name):
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
os_tacker.create_sfc(tacker_client, 'red', chain_vnf_names=['testVNF1'])
os_tacker.create_sfc(tacker_client, 'blue', chain_vnf_names=['testVNF2'])
os_tacker.create_sfc_classifier(tacker_client,
'red_http',
sfc_name='red',
match={
'source_port': 0,
'dest_port': 80,
'protocol': 6
})
os_tacker.create_sfc_classifier(tacker_client,
'red_ssh',
sfc_name='red',
match={
'source_port': 0,
'dest_port': 22,
'protocol': 6
})
logger.info(test_utils.run_cmd('tacker sfc-list')[1])
logger.info(test_utils.run_cmd('tacker sfc-classifier-list')[1])
num_chains = 2
# Start measuring the time it takes to implement the classification rules
t1 = threading.Thread(target=test_utils.wait_for_classification_rules,
args=(
ovs_logger,
compute_nodes,
odl_ip,
odl_port,
testTopology,
))
try:
t1.start()
except Exception, e:
logger.error("Unable to start the thread that counts time %s" % e)
def main():
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
image_id = os_utils.create_glance_image(glance_client,
EXAMPLE_IMAGE_NAME,
IMAGE_PATH,
disk=IMAGE_FORMAT,
container="bare",
public=True)
network_dic = os_utils.create_network_full(
neutron_client,
EXAMPLE_PRIVATE_NET_NAME,
EXAMPLE_PRIVATE_SUBNET_NAME,
EXAMPLE_ROUTER_NAME,
EXAMPLE_PRIVATE_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,
EXAMPLE_SECGROUP_NAME,
EXAMPLE_SECGROUP_DESCR)
# boot INTANCE
logger.info("Creating instance '%s'..." % EXAMPLE_INSTANCE_NAME)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n"
% (EXAMPLE_INSTANCE_NAME, EXAMPLE_FLAVOR, image_id, network_id))
instance = os_utils.create_instance_and_wait_for_active(
EXAMPLE_FLAVOR,
image_id,
network_id,
EXAMPLE_INSTANCE_NAME)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# Retrieve IP of INSTANCE
instance_ip = instance.networks.get(EXAMPLE_PRIVATE_NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." %
(EXAMPLE_INSTANCE_NAME, instance_ip))
logger.info("Adding '%s' to security group '%s'..."
% (EXAMPLE_INSTANCE_NAME, EXAMPLE_SECGROUP_NAME))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % EXAMPLE_INSTANCE_NAME)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip is None:
logger.error("Cannot create floating IP.")
sys.exit(-1)
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip, EXAMPLE_INSTANCE_NAME))
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
sys.exit(0)