def exercise_filesystem(self, client_address, filesystem, mdt_indexes=[0], no_of_files_per_mdt=None): """ Verify we can actually exercise a filesystem. Currently this only verifies that we can write to a filesystem as a sanity check that it was configured correctly. """ if not no_of_files_per_mdt: no_of_files_per_mdt = [10] * len(mdt_indexes) threads = [] for index, mdt_index in enumerate(mdt_indexes): thread = ExceptionThrowingThread( target=self.exercise_filesystem_mdt, args=(client_address, filesystem, mdt_index, no_of_files_per_mdt[index]), ) thread.start() threads.append(thread) ExceptionThrowingThread.wait_for_threads( threads ) # This will raise an exception if any of the threads raise an exception
def test_host_long_polling_ddos(self): def fetch_like_hell(self_, test_uri): while not self_.exit: self_.get_by_uri(test_uri, args={'limit': 0}, verify_successful=True) threads = [] self.exit = False # Hardly ddos but for today we only allow 100 connections to the db. # TODO: Increase the connections so we can have realistic numbers. for index in range(0, 64): thread = ExceptionThrowingThread(target=fetch_like_hell, args=(self, '/api/host'), use_threads=True) thread.start() threads.append(thread) # Just let them run for 30 seconds. time.sleep(1) self.exit = True ExceptionThrowingThread.wait_for_threads(threads)
def test_corosync_state_change_2(self): """Test state changes on the corosync/pacemaker through a faily random set. """ self._add_corosync_hosts(2) def run_states(server): states = ['unconfigured', 'stopped', 'started'] for corosync_state in states: self.set_state( server['corosync_configuration'], corosync_state, '%s Corosync for %s' % (corosync_state, server['fqdn'])) for pacemaker_state in states: self.set_state( server['pacemaker_configuration'], pacemaker_state, '%s Pacemaker for %s' % (pacemaker_state, server['fqnd'])) threads = [] for server in self.server_configs: thread = ExceptionThrowingThread(target=run_states, args=(server, )) thread.start() threads.append(thread) ExceptionThrowingThread.wait_for_threads( threads ) # This will raise an exception if any of the threads raise an exception
def exercise_filesystem_mdt(self, client_address, filesystem, mdt_index, files_to_create): """ Verify we can actually exercise a filesystem on a specific mdt. Currently this only verifies that we can write to a filesystem as a sanity check that it was configured correctly. """ # TODO: Expand on entire function. Perhaps use existing lustre client tests. if not filesystem.get("bytes_free"): self._test_case.wait_until_true( lambda: self._test_case.get_filesystem(filesystem["id"]).get( "bytes_free")) filesystem = self._test_case.get_filesystem(filesystem["id"]) bytes_free = filesystem.get("bytes_free") assert bytes_free > 0, "Expected bytes_free to be > 0" logger.debug("exercise_filesystem: API reports %s has %s bytes free" % (filesystem["name"], bytes_free)) test_root = "/mnt/%s/mdt%s" % (filesystem["name"], mdt_index) if mdt_index: self._ssh_address(client_address, "lfs mkdir -i %s %s" % (mdt_index, test_root)) else: self._ssh_address(client_address, "mkdir -p %s" % test_root) def actual_exercise(client_address, test_root, file_no, bytes_to_write): self._ssh_address(client_address, "mkdir -p %s/%s" % (test_root, file_no)) self._ssh_address( client_address, "dd if=/dev/zero of=%s/%s/exercisetest-%s.dat bs=1000 count=%s" % (test_root, file_no, file_no, bytes_to_write), ) threads = [] for file_no in range(0, files_to_create): thread = ExceptionThrowingThread( target=actual_exercise, args=(client_address, test_root, file_no, min((bytes_free * 0.4), 512000) / 1000), use_threads=False, ) thread.start() threads.append(thread) ExceptionThrowingThread.wait_for_threads( threads ) # This will raise an exception if any of the threads raise an exception self._ssh_address(client_address, "rm -rf %s" % test_root)
def _run(self): threads = [] for plugin_name in self._client.device_plugins.get_plugins(): thread = ExceptionThrowingThread(target=self._run_plugin, args=(plugin_name, )) threads.append(thread) thread.start() while not self._stopping.is_set(): while not (self._messages.empty() and self._retry_messages.empty()): self.send() self._messages_waiting.wait() self._messages_waiting.clear() ExceptionThrowingThread.wait_for_threads(threads)