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)
