def test_ping_dscp(self): capture_file = sh.execute('mktemp', sudo=True).stdout.strip() interface = ip.get_network_main_route_device( self.server.floating_ip_address) # IPv4 tcpdump DSCP filters explanation: # ip[1] refers to the byte 1 (the TOS byte) of the IP header # 0xfc = 11111100 is the mask to get only DSCP value from the ToS # As DSCP mark is most significant 6 bits we do right shift (>>) # twice in order to divide by 4 and compare with the decimal value # See details at http://darenmatthews.com/blog/?p=1199 dscp_mark = CONF.tobiko.neutron.dscp_mark capture_filter = (f"'(ip src {self.server.floating_ip_address} and " f"(ip[1] & 0xfc) >> 2 == {dscp_mark})'") # start a capture process = tcpdump.start_capture(capture_file=capture_file, interface=interface, capture_filter=capture_filter, capture_timeout=60) time.sleep(1) # send a ping to the server ping.assert_reachable_hosts([self.server.floating_ip_address], ) # stop tcpdump and get the pcap capture pcap = tcpdump.get_pcap(process, capture_file=capture_file) # check the capture is not empty tcpdump.assert_pcap_is_not_empty(pcap=pcap)
def assert_is_reachable(self): self.stack.assert_is_reachable() ping.assert_reachable_hosts(self.stack.list_fixed_ips(), timeout=300., ssh_client=self.peer_stack.ssh_client) if self.stack.has_vlan: self.stack.assert_vlan_is_reachable()
def assert_reachable_nodes( nodes: typing.Iterable[_topology.OpenStackTopologyNode], **ping_params): node_ips = {node.name: str(node.public_ip) for node in nodes} LOG.debug(f"Test nodes are reachable: " f"{json.dumps(node_ips, sort_keys=True, indent=4)}") ping.assert_reachable_hosts(node_ips.values(), **ping_params)
def test_ping_subnet_gateways(self): network_id = self.stack.network_stack.network_id subnets = neutron.list_subnets(network_id=network_id) gateway_ips = [ netaddr.IPAddress(subnet['gateway_ip']) for subnet in subnets ] ping.assert_reachable_hosts(gateway_ips, ssh_client=self.stack.ssh_client)
def test_ping_port(self, network_id=None, device_id=None): network_id = network_id or self.stack.network_stack.network_id device_id = device_id or self.stack.server_id ports = neutron.list_ports(network_id=network_id, device_id=device_id) port_ips = set() for port in ports: self.assertEqual(network_id, port['network_id']) self.assertEqual(device_id, port['device_id']) port_ips.update(neutron.list_port_ip_addresses(port=port)) ping.assert_reachable_hosts(port_ips, ssh_client=self.stack.ssh_client)
def test_ping_subnet_gateways(self): """Checks server can ping its gateway IPs""" network_id = self.stack.network_stack.network_id subnets = neutron.list_subnets(network_id=network_id) LOG.debug("Subnets enabled are:\n" f"{json.dumps(subnets, indent=4, sort_keys=True)}") gateway_ips = [ netaddr.IPAddress(subnet['gateway_ip']) for subnet in subnets ] LOG.debug(f"Gateway IPs are: {gateway_ips}") ping.assert_reachable_hosts(gateway_ips, ssh_client=self.stack.ssh_client)
def test_controllers_shutdown(): test_case = tobiko.get_test_case() all_nodes = topology.list_openstack_nodes(group='controller') if len(all_nodes) < 3: tobiko.skip_test('It requires at least three controller nodes') all_node_names = [node.name for node in all_nodes] LOG.info("Ensure all controller nodes are running: " f"{all_node_names}") for node in all_nodes: node.power_on_overcloud_node() topology.assert_reachable_nodes(all_nodes) LOG.debug('Check VM is running while all controllers nodes are on') nova_server = tobiko.setup_fixture(stacks.CirrosServerStackFixture) nova_server_ip = nova_server.ip_address ping.assert_reachable_hosts([nova_server_ip]) quorum_level = math.ceil(0.5 * len(all_nodes)) assert quorum_level >= len(all_nodes) - quorum_level nodes = random.sample(all_nodes, quorum_level) node_names = [node.name for node in nodes] LOG.info(f"Power off {quorum_level} random controller nodes: " f"{node_names}") for node in nodes: node.power_off_overcloud_node() test_case.addCleanup(node.power_on_overcloud_node) topology.assert_unreachable_nodes(nodes, retry_count=1) topology.assert_reachable_nodes(node for node in all_nodes if node not in nodes) LOG.debug('Check whenever VM is still running while some "' '"controllers nodes are off') reachable, unreachable = ping.ping_hosts([nova_server_ip], count=1) if reachable: LOG.debug(f"VM ips are reachable: {reachable}") if unreachable: LOG.debug(f"VM is are unreachable: {unreachable}") # TODO what do we expect here: VM reachable or unreachable? random.shuffle(nodes) LOG.info(f"Power on controller nodes: {node_names}") for node in nodes: node.power_on_overcloud_node() LOG.debug("Check all controller nodes are running again: " f"{all_node_names}") topology.assert_reachable_nodes(all_nodes, retry_timeout=600.) LOG.debug('Check VM is running while all controllers nodes are on') ping.assert_reachable_hosts([nova_server_ip])
def assert_vlan_is_reachable(self, ip_version: int = None, timeout: tobiko.Seconds = None, ssh_client: ssh.SSHClientType = None): fixed_ips = self.list_vlan_fixed_ips(ip_version=ip_version) if fixed_ips: if timeout is None: timeout = self.is_reachable_timeout if ssh_client is None: ssh_client = self.vlan_ssh_proxy_client ping.assert_reachable_hosts(fixed_ips, ssh_client=ssh_client, timeout=timeout) else: tobiko.fail(f'Server {self.stack_name} has any IP on VLAN port')
def test_ping_port(self, network_id=None, device_id=None, ip_version=None): """Checks server can ping its own port""" port_ips = neutron.list_device_ip_addresses( device_id=device_id or self.stack.server_id, network_id=network_id or self.stack.network_stack.network_id, need_dhcp=self.stack.need_dhcp, ip_version=ip_version) if port_ips: ping.assert_reachable_hosts(port_ips, timeout=600., ssh_client=self.stack.peer_ssh_client) elif ip_version: self.skipTest(f"Server has any port IPv{ip_version} address to be" " tested") else: self.skipTest("Server has any port IP address to be tested")
def test_servers_creation(stack=TestServerCreationStack, number_of_servers=2) -> \ tobiko.Selection[_nova.ServerStackFixture]: initial_servers_ids = {server.id for server in nova.list_servers()} pid = os.getpid() fixture_obj = tobiko.get_fixture_class(stack) # Get list of server stack instances fixtures: tobiko.Selection[_nova.ServerStackFixture] = tobiko.select( tobiko.get_fixture(fixture_obj, fixture_id=f'{pid}-{i}') for i in range(number_of_servers or 1)) test_case = tobiko.get_test_case() # Check fixtures types for fixture in fixtures: test_case.assertIsInstance(fixture, _nova.ServerStackFixture) # Delete all servers stacks for fixture in fixtures: tobiko.cleanup_fixture(fixture) # Create all servers stacks for fixture in fixtures: tobiko.use_fixture(fixture) # Check every server ID is unique and new server_ids = {fixture.server_id for fixture in fixtures} test_case.assertEqual(number_of_servers or 1, len(server_ids)) test_case.assertFalse(server_ids & initial_servers_ids) # sleep for 20 sec , ensure no race condition with ssh time.sleep(20) # Test SSH connectivity to floating IP address for fixture in fixtures: test_case.assertTrue(sh.get_hostname(ssh_client=fixture.ssh_client)) # Test pinging to floating IP address ping.assert_reachable_hosts(fixture.floating_ip_address for fixture in fixtures) return fixtures
def test_activate_server(self, initial_status='SHUTOFF'): self.stack.ensure_server_status(initial_status) server = nova.activate_server(self.stack.server_id) self.assertEqual('ACTIVE', server.status) ping.assert_reachable_hosts([self.stack.ip_address])
def test_assert_reachable_hosts(self): ping.assert_reachable_hosts(['127.0.0.1'], count=3, **self.execute_params)
def test_internal_router_ipv6_interface_is_reachable(self): ping.assert_reachable_hosts([self.ipv6_subnet_gateway_ip], ssh_client=self.stack.ssh_client)
def test_ping_fixed_ipv6(self): ping.assert_reachable_hosts([self.get_fixed_ip(ip_version=6)], ssh_client=self.peer_ssh_client)
def test_ping_floating_ip(self): """Test connectivity to floating IP address""" ping.assert_reachable_hosts([self.stack.floating_ip_address])
def test_ping(self): """Test ICMP connectivity to from VM to VM""" ping.assert_reachable_hosts( [self.stack.ip_address], ssh_client=self.stack.peer_stack.ssh_client)