def test_assert_file_size(self): file_name = os.path.join(sh.make_temp_dir(), self.id()) sh.execute(f'echo "{self.id()}" > "{file_name}"') sh.assert_file_size(len(self.id()) + 1, file_name)
def test_assert_file_size_when_empty(self): file_name = os.path.join(sh.make_temp_dir(), self.id()) sh.execute(f'touch "{file_name}"') sh.assert_file_size(0, file_name)
def test_get_file_size(self): file_name = os.path.join(sh.make_temp_dir(), self.id()) sh.execute(f'echo "{self.id()}" > "{file_name}"') file_size = sh.get_file_size(file_name) self.assertEqual(len(self.id()) + 1, file_size)
def test_get_file_size_when_empty(self): file_name = os.path.join(sh.make_temp_dir(), self.id()) sh.execute(f'touch "{file_name}"') file_size = sh.get_file_size(file_name) self.assertEqual(0, file_size)
def test_python(self): python_version = sh.execute(['python', '--version'], ssh_client=self.stack.ssh_client).stderr self.assertTrue(python_version.startswith('Python 2.7'), python_version)
def execute(self, **kwargs): return sh.execute(**kwargs)
def _create_bridge(self, hostname, bridges): for br_name in bridges: agent_host = topology.get_openstack_node(hostname=hostname) sh.execute("sudo ovs-vsctl --may-exist add-br %s" % br_name, ssh_client=agent_host.ssh_client)
def get_rhosp_version(): ssh_client = list_openstack_nodes(group='controller')[0].ssh_client rhosp_release = sh.execute('cat /etc/rhosp-release', ssh_client=ssh_client).stdout rhosp_version = re.search(r"[0-9]*\.[0-9]*\.[0-9]*", rhosp_release)[0] return rhosp_version
def kill_ovn_controller(self, hosts: typing.Optional[typing.List[str]] = None, timeout=60, interval=5): '''Stop OVN controller container by killing ovn-controller process running into it Docker/Podman service should restart it automatically :parm hosts: List of hostnames to stop agent on :type hosts: list of strings :param timeout: Time to wait OVN controller is recovered :type timeout: int :param interval: Time to wait between attempts :type interval: int ''' hosts = hosts or self.hosts self.assertNotEqual([], hosts, "Host list is empty") if self.container_name == '': self.container_name = self.get_agent_container_name( self.agent_name) if not self.container_name: self.skipTest(f"Missing container(s): '{self.container_name}'") for host in hosts: ssh_client = topology.get_openstack_node(hostname=host).ssh_client pid = None for directory in ('ovn', 'openvswitch'): try: pid = sh.execute(f'{self.container_runtime_name} exec ' f'-uroot {self.container_name} cat ' f'/run/{directory}/ovn-controller.pid', ssh_client=ssh_client, sudo=True).stdout.splitlines()[0] except sh.ShellCommandFailed: LOG.debug(f'/run/{directory}/ovn-controller.pid cannot ' f'be accessed') else: LOG.debug(f'/run/{directory}/ovn-controller.pid returned ' f'pid {pid}') break self.assertIsNotNone(pid) LOG.debug(f'Killing process {pid} from container ' f'{self.container_name} on host {host}') sh.execute(f'{self.container_runtime_name} exec -uroot ' f'{self.container_name} kill {pid}', ssh_client=ssh_client, sudo=True) LOG.debug(f'Container {self.container_name} has been killed ' f"on host '{host}'...") # Schedule auto-restart of service at the end of this test case self.addCleanup(self.start_agent, hosts=[host, ]) # Verify the container is restarted automatically for attempt in tobiko.retry(timeout=timeout, interval=interval): search_running_ovn_cont = (f"{self.container_runtime_name} ps " "--format '{{.Names}}'" f" -f name={self.container_name}") output = sh.execute(search_running_ovn_cont, ssh_client=ssh_client, sudo=True).stdout.splitlines() if self.container_name in output: LOG.debug(f'{self.container_name} successfully restarted') break attempt.check_limits()
def test_stdout(self): fixture = self.fixture sh.execute(f"echo some text > '{fixture.temp_filename}'", ssh_client=fixture.ssh_client) line = self.fixture.process.stdout.readline() self.assertEqual(b'some text\n', line)
def stop_process(pid_list): """Stop (kill) a process from a list""" for pid in pid_list: LOG.info(f'stopping process with pid: {pid}') sh.execute(f'sudo kill -9 {pid}')
def test_make_temp_dir(self): temp_dir = sh.make_temp_dir() files = sh.execute(f'ls "{temp_dir}"').stdout.splitlines() self.assertEqual([], files)
def test_ncat_command(self): output = sh.execute('ncat --version', ssh_client=self.stack.ssh_client).stderr.strip() self.assertIn('Ncat: Version', output) self.assertIn('https://nmap.org/ncat', output)
def execute(self, **kwargs): kwargs.setdefault('shell', self.shell) kwargs.setdefault('ssh_client', self.ssh_client) return sh.execute(**kwargs)
def _delete_bridges(self, hostname, bridges): for br_name in bridges: agent_host = topology.get_openstack_node(hostname=hostname) sh.execute("sudo ovs-vsctl del-br %s" % br_name, ssh_client=agent_host.ssh_client) self.deleted_bridges[hostname].add(br_name)
def test_execute_command(self): result = sh.execute('hostname', ssh_client=self.ssh_client) self.assertTrue(result.stdout.startswith('undercloud-0'))
def ovn_dbs_are_synchronized(test_case): from tobiko.tripleo import containers # declare commands runtime_name = containers.get_container_runtime_name() search_container_cmd = ( "%s ps --format '{{.Names}}' -f name=ovn-dbs-bundle" % runtime_name) container_cmd_prefix = ('%s exec -uroot {container}' % runtime_name) ovndb_sync_cmd = ('ovs-appctl -t /var/run/openvswitch/{ovndb_ctl_file} ' 'ovsdb-server/sync-status') ovndb_show_cmd = '{ovndb} show' ovndb_ctl_file_dict = {'nb': 'ovnnb_db.ctl', 'sb': 'ovnsb_db.ctl'} ovndb_dict = {'nb': 'ovn-nbctl', 'sb': 'ovn-sbctl'} expected_state_active_str = 'state: active' expected_state_backup_str = 'state: backup' # use ovn master db as a reference ovn_master_node_name = pacemaker.get_ovn_db_master_node() test_case.assertEqual(1, len(ovn_master_node_name)) ovn_master_node = topology.get_openstack_node(ovn_master_node_name[0]) ovn_master_dbs_show_dict = {} # obtained the container name container_name = sh.execute(search_container_cmd, ssh_client=ovn_master_node.ssh_client, sudo=True).stdout.splitlines()[0] for db in ('nb', 'sb'): # check its synchronization is active sync_cmd = (' '.join( (container_cmd_prefix, ovndb_sync_cmd)).format(container=container_name, ovndb_ctl_file=ovndb_ctl_file_dict[db])) sync_status = sh.execute(sync_cmd, ssh_client=ovn_master_node.ssh_client, sudo=True).stdout test_case.assertIn(expected_state_active_str, sync_status) # obtain nb and sb show output show_cmd = (' '.join((container_cmd_prefix, ovndb_show_cmd)).format(container=container_name, ovndb=ovndb_dict[db])) ovn_db_show = sh.execute(show_cmd, ssh_client=ovn_master_node.ssh_client, sudo=True).stdout ovn_master_dbs_show_dict[db] = build_ovn_db_show_dict(ovn_db_show) # ovn dbs are located on the controller nodes for node in topology.list_openstack_nodes(group='controller'): if node.name == ovn_master_node.name: # master node is the reference and do not need to be checked again continue container_name = sh.execute(search_container_cmd, ssh_client=node.ssh_client, sudo=True).stdout.splitlines()[0] # verify ovn nb and sb dbs are synchronized ovn_dbs_show_dict = {} for db in ('nb', 'sb'): # check its synchronization is active sync_cmd = (' '.join( (container_cmd_prefix, ovndb_sync_cmd)).format( container=container_name, ovndb_ctl_file=ovndb_ctl_file_dict[db])) sync_status = sh.execute(sync_cmd, ssh_client=node.ssh_client, sudo=True).stdout test_case.assertIn(expected_state_backup_str, sync_status) # obtain nb and sb show output show_cmd = (' '.join( (container_cmd_prefix, ovndb_show_cmd)).format(container=container_name, ovndb=ovndb_dict[db])) ovn_db_show = sh.execute(show_cmd, ssh_client=node.ssh_client, sudo=True).stdout ovn_dbs_show_dict[db] = build_ovn_db_show_dict(ovn_db_show) test_case.assertEqual(len(ovn_dbs_show_dict[db]), len(ovn_master_dbs_show_dict[db])) for key in ovn_dbs_show_dict[db]: test_case.assertEqual( sorted(ovn_dbs_show_dict[db][key]), sorted(ovn_master_dbs_show_dict[db][key])) LOG.info("All OVN DBs are synchronized")
def setUp(self): super().setUp() try: sh.execute('pgrep systemd') except sh.ShellCommandFailed: self.skipTest("systemd is not running")
def test_python3(self): python_version = sh.execute(['/usr/bin/python3', '--version'], ssh_client=self.stack.ssh_client).stdout self.assertTrue(python_version.startswith('Python 3.'), python_version)
def _get_undercloud_file(ssh_client, source, destination, mode): content = sh.execute(['cat', source], ssh_client=ssh_client).stdout with io.open(destination, 'wb') as fd: fd.write(content.encode()) os.chmod(destination, mode)
def get_fqdn_from_topology_node(topology_node): return sh.execute("hostname -f", ssh_client=topology_node.ssh_client, expect_exit_status=None).stdout.strip()