def _write_hosts_file(self, output): hosts = common.host_utils.extract_hosts('all_hosts', self.config) LOG.debug("Write /etc/hosts on all hosts.", hosts=hosts) run_threads([ partial(_write_hosts_file_thread, host_info, output) for host_info in hosts ])
def _run_host_command(host_list, command, config, prefix): """ For each host in the list, make a parallelized call to make_host_runner to make the appropriate host and run the set of commands. :param list host_list: List of ip addresses to connect to :param command: The command to execute. If str, run that command. If dict, type is one of upload_repo_files, upload_files, retrieve_files, exec, run_curator, or exec_mongo_shell. :type command: str, dict :param ConfigDict config: The system configuration :param str prefix: The id for the test related to the current command. If there is not a specific test related to the current command, the value of prefix should reflect the hook that the command belongs to, such as between_tests, post_task, and so on. """ if not host_list: return LOG.debug('Calling run command for %s with command %s', str(host_list), str(command)) thread_commands = [] for host_info in host_list: thread_commands.append( partial(make_host_runner, host_info, command, prefix, config)) run_threads(thread_commands, daemon=True)
def destroy(self, max_time_ms): """Kills the remote replica members. For the max_time_ms parameter, see :method:`Host.exec_command` """ run_threads( [partial(node.destroy, max_time_ms) for node in self.nodes], daemon=True)
def destroy(self, max_time_ms): """Kills the remote cluster members. For the max_time_ms parameter, see :method:`Host.exec_command` """ run_threads( [partial(shard.destroy, max_time_ms) for shard in self.shards], daemon=True) self.config_svr.destroy(max_time_ms) run_threads( [partial(mongos.destroy, max_time_ms) for mongos in self.mongoses], daemon=True)
def reset_all_delays(config): """ Reset all network delays from all hosts in infrastructure_provisioning.out. Note: This method resets delays on all hosts using multiple threads in parallel. :param ConfigDict config: The global configuration. """ LOG.info("Reset all network_delays.") hosts = common.host_utils.extract_hosts('all_hosts', config) LOG.debug("reset all network_delays.", hosts=hosts) run_threads( [partial(reset_one_host, host_info, config) for host_info in hosts])
def _start_auth_explicit(self, is_restart=False, restart_clean_db_dir=None, restart_clean_logs=None, enable_auth=False): """ Complete the remaining start (either clean or restart) operations. Any Shutdown, destroy or downloading has been handled by the caller( See :method:`start` or See :method:`restart`). :param is_restart This is a restart of the cluster, not the first start. :param restart_clean_db_dir Should we clean db dir. If not specified, uses value from ConfigDict. :param restart_clean_logs Should we clean logs and diagnostic data. If not specified, uses value from ConfigDict. """ if not all( run_threads([ partial(self.start_cluster, cluster=cluster, is_restart=is_restart, restart_clean_db_dir=restart_clean_db_dir, restart_clean_logs=restart_clean_logs, enable_auth=enable_auth) for cluster in self.clusters ], daemon=True)): LOG.error("Could not start clusters in _start. Shutting down...") self.shutdown(self.shutdown_ms) return False return True
def launch(self, initialize=True, use_numactl=True, enable_auth=False): """Starts the sharded cluster. :param boolean initialize: Initialize the cluster """ LOG.info('Launching sharded cluster...') commands = [ partial(self.config_svr.launch, initialize=initialize, use_numactl=False, enable_auth=enable_auth) ] commands.extend( partial(shard.launch, initialize=initialize, use_numactl=use_numactl, enable_auth=enable_auth) for shard in self.shards) commands.extend( partial(mongos.launch, initialize=initialize, use_numactl=use_numactl, enable_auth=enable_auth) for mongos in self.mongoses) if not all(run_threads(commands, daemon=True)): return False if initialize: if not self._add_shards(): return False if self.disable_balancer and not self.run_mongo_shell( 'sh.stopBalancer();'): return False return self.wait_until_up()
def setup_host(self, restart_clean_db_dir=None, restart_clean_logs=None): return all( run_threads([ partial(node.setup_host, restart_clean_db_dir=restart_clean_db_dir, restart_clean_logs=restart_clean_logs) for node in self.nodes ], daemon=True))
def run_validate(config, current_test_id=None, reports_dir='reports'): ''' Validate the DB after a test :param dict(ConfigDict) config: The system configuration. :param string current_test_id: Indicates the id for the test related to the current set of commands. If there is not a specific test related to the current set of commands, the value of current_test_id will be None. :param string reports_dir: the report directory. ''' LOG.debug('In run_validate before jstests_dir check') # If jstests_dir doesn't exist or is falsey, don't do anything. if 'jstests_dir' not in config[ 'test_control'] or not config['test_control']['jstests_dir']: LOG.info('No jstests_dir specified. Skipping validate.') return # If there is no validate entry in the mongodb_setup config, don't do anything. if 'validate' not in config['mongodb_setup']: LOG.warning('No validate entry in mongodb_setup. Skipping validate.') return # If jstests_dir doesn't actually exist, skip validate. # (v3.2 branch as well as official release archives.) # We check this on the workload_client, not locally. if not _remote_exists(config): LOG.warning("%s not found. Skipping validate.", config['test_control']['jstests_dir']) return LOG.info('In run_validate') # Run the checks if 'standalone' in config['mongodb_setup']['validate']: run_threads([ partial(validate_one_host, config, primary, reports_dir, current_test_id, False) for primary in config['mongodb_setup']['validate']['standalone'] ]) if 'primaries' in config['mongodb_setup']['validate']: run_threads([ partial(validate_one_host, config, primary, reports_dir, current_test_id, True) for primary in config['mongodb_setup']['validate']['primaries'] ])
def shutdown(self, max_time_ms, auth_enabled=None, retries=20): """Shutdown gracefully For the max_time_ms parameter, see :method:`Host.exec_command` """ return all( run_threads([ partial(node.shutdown, max_time_ms, auth_enabled) for node in self.nodes ], daemon=True))
def shutdown(self, max_time_ms, auth_enabled=None): """Shutdown all launched mongo programs For the max_time_ms parameter, see :method:`Host.exec_command` """ LOG.info('Calling shutdown for %s clusters', len(self.clusters)) result = all( run_threads([ partial(cluster.shutdown, max_time_ms, auth_enabled) for cluster in self.clusters ], daemon=True)) LOG.warning('shutdown: %s', 'succeeded' if result else 'failed') return result
def destroy(self, max_time_ms): """Kill all launched mongo programs For the max_time_ms parameter, see :method:`Host.exec_command` """ LOG.info('calling destroy') result = all( run_threads([ partial(cluster.destroy, max_time_ms) for cluster in self.clusters ], daemon=True)) if not result: LOG.warning('destroy: failed') return result
def shutdown(self, max_time_ms, auth_enabled=None, retries=20): """Shutdown the mongodb cluster gracefully. For the max_time_ms parameter, see :method:`Host.exec_command` """ commands = [] commands.extend( partial(shard.shutdown, max_time_ms, auth_enabled) for shard in self.shards) commands.append( partial(self.config_svr.shutdown, max_time_ms, auth_enabled)) commands.extend( partial(mongos.shutdown, max_time_ms, auth_enabled) for mongos in self.mongoses) return all(run_threads(commands, daemon=True))
def download_and_extract(self): """Download self.mongodb_binary_archive, extract it, and create some symlinks. :return: True if no mongodb_binary_archive was provided or all the commands completed successfully on all servers. """ if not self.mongodb_binary_archive: LOG.warning("DownloadMongodb: download_and_extract() was called, " "but mongodb_binary_archive isn't defined.") return True to_download = [] for host in self.hosts: commands = self._remote_commands(host) to_download.append(partial(host.run, commands)) return all(run_threads(to_download, daemon=True))
def launch(self, initialize=True, use_numactl=True, enable_auth=False): """Starts the replica set. :param boolean initialize: Initialize the replica set""" if not all( run_threads([ partial(node.launch, initialize, use_numactl=use_numactl, enable_auth=enable_auth) for node in self.nodes ], daemon=True)): return False self._set_explicit_priorities() if initialize: if not self.run_mongo_shell(self._init_replica_set()): return False # Wait for all nodes to be up return self.wait_until_up()
def setup_host(self, restart_clean_db_dir=None, restart_clean_logs=None): commands = [ partial(self.config_svr.setup_host, restart_clean_db_dir=restart_clean_db_dir, restart_clean_logs=restart_clean_logs) ] commands.extend( partial( shard.setup_host, restart_clean_db_dir=restart_clean_db_dir, restart_clean_logs=restart_clean_logs, ) for shard in self.shards) commands.extend( partial( mongos.setup_host, restart_clean_db_dir=restart_clean_db_dir, restart_clean_logs=restart_clean_logs, ) for mongos in self.mongoses) return all(run_threads(commands, daemon=True))
def close(self): """Closes SSH connections to remote hosts.""" run_threads([shard.close for shard in self.shards], daemon=True) self.config_svr.close() run_threads([mongos.close for mongos in self.mongoses], daemon=True)
def close(self): """Close connections to all hosts.""" run_threads([cluster.close for cluster in self.clusters], daemon=True)
def close(self): """Closes SSH connections to remote hosts.""" run_threads([node.close for node in self.nodes], daemon=True)