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]
def assign_floating_ip(nova_client, neutron_client, instance_id): instance = nova_client.servers.get(instance_id) floating_ip = os_utils.create_floating_ip(neutron_client)['fip_addr'] instance.add_floating_ip(floating_ip) logger.info("Assigned floating ip [%s] to instance [%s]" % (floating_ip, instance.name)) return floating_ip
def add_float_ip(self, vm): self.logger.info("Creating floating IP for VM '%s'..." % self.vm2_name) floatip_dic = os_utils.create_floating_ip(self.neutron_client) floatip = floatip_dic['fip_addr'] if floatip is None: self.logger.error("Cannot create floating IP.") return None self.logger.info("Floating IP created: '%s'" % floatip) self.logger.info("Associating floating ip: '%s' to VM '%s' " % (floatip, self.vm2_name)) if not os_utils.add_floating_ip(self.nova_client, vm.id, floatip): self.logger.error("Cannot associate floating IP to VM.") return None return floatip
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, "=") 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, TESTCASE_CONFIG.image_name, COMMON_CONFIG.image_path, disk=COMMON_CONFIG.image_format, container="bare", public='public') network_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) network_2_id = test_utils.create_net(neutron_client, TESTCASE_CONFIG.net_2_name) test_utils.create_subnet(neutron_client, TESTCASE_CONFIG.subnet_2_name, TESTCASE_CONFIG.subnet_2_cidr, network_2_id) sg_id = os_utils.create_security_group_full(neutron_client, TESTCASE_CONFIG.secgroup_name, TESTCASE_CONFIG.secgroup_descr) test_utils.open_icmp_ssh(neutron_client, sg_id) vm_2 = test_utils.create_instance( nova_client, TESTCASE_CONFIG.instance_2_name, image_id, network_2_id, sg_id, secgroup_name=TESTCASE_CONFIG.secgroup_name) vm_2_ip = test_utils.get_instance_ip(vm_2) u1 = test_utils.generate_ping_userdata([vm_2_ip]) vm_1 = test_utils.create_instance( nova_client, TESTCASE_CONFIG.instance_1_name, image_id, network_1_id, sg_id, secgroup_name=TESTCASE_CONFIG.secgroup_name, userdata=u1) results.record_action("Create VPN with eRT==iRT") vpn_name = "sdnvpn-7" kwargs = { "import_targets": TESTCASE_CONFIG.targets, "export_targets": TESTCASE_CONFIG.targets, "route_distinguishers": TESTCASE_CONFIG.route_distinguishers, "name": vpn_name } bgpvpn = os_utils.create_bgpvpn(neutron_client, **kwargs) bgpvpn_id = bgpvpn['bgpvpn']['id'] logger.debug("VPN created details: %s" % bgpvpn) msg = ("Associate router '%s' and net '%s' to the VPN." % (TESTCASE_CONFIG.router_1_name, TESTCASE_CONFIG.net_2_name)) results.record_action(msg) results.add_to_summary(0, "-") os_utils.create_router_association(neutron_client, bgpvpn_id, router_1_id) os_utils.create_network_association(neutron_client, bgpvpn_id, network_2_id) test_utils.wait_for_bgp_router_assoc(neutron_client, bgpvpn_id, router_1_id) test_utils.wait_for_bgp_net_assoc(neutron_client, bgpvpn_id, network_2_id) instances_up = test_utils.wait_for_instances_up(vm_1, vm_2) if not instances_up: logger.error("One or more instances is down") logger.info("Waiting for the VMs to connect to each other using the" " updated network configuration") test_utils.wait_before_subtest() results.get_ping_status(vm_1, vm_2, expected="PASS", timeout=200) results.add_to_summary(0, "=") msg = "Assign a Floating IP to %s" % vm_1.name results.record_action(msg) fip = os_utils.create_floating_ip(neutron_client) fip_added = os_utils.add_floating_ip(nova_client, vm_1.id, fip['fip_addr']) if fip_added: results.add_success(msg) else: results.add_failure(msg) results.record_action("Ping %s via Floating IP" % vm_1.name) results.add_to_summary(0, "-") results.ping_ip_test(fip['fip_addr']) return results.compile_summary()
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(): 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(): 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()
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)