← Back
Editing: sosnode.py
# Copyright Red Hat 2020, Jake Hunsaker <jhunsake@redhat.com> # This file is part of the sos project: https://github.com/sosreport/sos # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # version 2 of the GNU General Public License. # # See the LICENSE file in the source distribution for further information. # pylint: disable=too-many-branches import fnmatch import inspect import logging import os import re from shlex import quote from sos.policies import load from sos.policies.init_systems import InitSystem from sos.collector.transports.juju import JujuSSH from sos.collector.transports.control_persist import SSHControlPersist from sos.collector.transports.local import LocalTransport from sos.collector.transports.oc import OCTransport from sos.collector.transports.saltstack import SaltStackMaster from sos.collector.exceptions import (CommandTimeoutException, ConnectionException, UnsupportedHostException, InvalidTransportException) from sos.utilities import sos_parse_version TRANSPORTS = { 'local': LocalTransport, 'control_persist': SSHControlPersist, 'oc': OCTransport, 'saltstack': SaltStackMaster, 'juju': JujuSSH, } class SosNode(): def __init__(self, address, commons, password=None, local_sudo=None, load_facts=True): self.address = address.strip() self.commons = commons self.opts = commons['cmdlineopts'] self._assign_config_opts() self.tmpdir = commons['tmpdir'] self.hostlen = commons['hostlen'] self.need_sudo = commons['need_sudo'] self.sos_options = commons['sos_options'] self.node_config_file = self.opts.node_config_file self.inherit_config_file = self.opts.inherit_config_file self.local = False self.host = None self.cluster = None self.hostname = None self.sos_env_vars = {} self._env_vars = {} self._password = password or self.opts.password if not self.opts.nopasswd_sudo and not self.opts.sudo_pw: self.opts.sudo_pw = self._password # override local sudo from any other source if local_sudo: self.opts.sudo_pw = local_sudo self.sos_path = None self.retrieved = False self.hash_retrieved = False self.file_list = [] self.sos_info = { 'version': None, 'enabled': [], 'disabled': [], 'options': [], 'presets': [], 'sos_cmd': commons['sos_cmd'] } self.sos_bin = 'sosreport' self.soslog = logging.getLogger('sos') self.ui_log = logging.getLogger('sos_ui') self._transport = self._load_remote_transport(commons) # Overwrite need_sudo if transports default_user # is set and is not root. if self._transport.default_user: self.need_sudo = self._transport.default_user != 'root' try: self._transport.connect(self._password) except Exception as err: self.log_error(f'Unable to open remote session: {err}') raise # load the host policy now, even if we don't want to load further # host information. This is necessary if we're running locally on the # cluster primary but do not want a local report as we still need to do # package checks in that instance self.host = self.determine_host_policy() self._sudo_binary = None self.hostname = self._transport.hostname if self.local and self.opts.no_local: load_facts = False if self.connected and load_facts: if not self.host: self._transport.disconnect() return None if self.local: if self.check_in_container(): self.host.containerized = False if self.host.containerized: self.create_sos_container() self._load_sos_info() return None @property def connected(self): if self._transport: return self._transport.connected # if no transport, we're running locally return True def disconnect(self): """Wrapper to close the remote session via our transport agent """ self._transport.disconnect() def _load_remote_transport(self, commons): """Determine the type of remote transport to load for this node, then return an instantiated instance of that transport """ if self.address in ['localhost', '127.0.0.1']: self.local = True return LocalTransport(self.address, commons) if self.opts.transport in TRANSPORTS: return TRANSPORTS[self.opts.transport](self.address, commons) if self.opts.transport != 'auto': self.log_error( "Connection failed: unknown or unsupported transport " f"{self.opts.transport}" ) raise InvalidTransportException(self.opts.transport) return SSHControlPersist(self.address, commons) def _fmt_msg(self, msg): return f"{self._hostname:<{self.hostlen + 1}} : {msg}" @property def env_vars(self): if not self._env_vars: if self.local: self._env_vars = os.environ.copy() else: ret = self.run_command("env --null") if ret['status'] == 0: for ln in ret['output'].split('\x00'): if not ln: continue _val = ln.split('=') self._env_vars[_val[0]] = _val[1] return self._env_vars @property def sudo_binary(self): if not self._sudo_binary: _bin = self.opts.sudo_binary.split('/')[-1] # verify the provided binary is at least in our PATH if ret := self.run_command(f"command -v {_bin}"): if not ret['status'] == 0: err = f"Privilege escalation command not in PATH: {_bin}" self.log_error(err) raise Exception(err) if _bin == 'sudo': _bin = 'sudo -S' self._sudo_binary = _bin return self._sudo_binary def set_node_manifest(self, manifest): """Set the manifest section that this node will write to """ self.manifest = manifest self.manifest.add_field('hostname', self._hostname) self.manifest.add_field('policy', self.host.os_release_name) self.manifest.add_field('sos_version', self.sos_info['version']) self.manifest.add_field('final_sos_command', '') self.manifest.add_field('transport', self._transport.name) def check_in_container(self): """ Tries to identify if we are currently running in a container or not. """ if os.path.exists('/run/.containerenv'): self.log_debug('Found /run/.containerenv. Running in container.') return True if os.environ.get('container') is not None: self.log_debug("Found env var 'container'. Running in container") return True return False def create_sos_container(self): """If the host is containerized, create the container we'll be using """ if self.host.containerized: cmd = self.host.create_sos_container( image=self.opts.image, auth=self.get_container_auth(), force_pull=self.opts.force_pull_image ) res = self.run_command(cmd, need_root=True) if res['status'] in [0, 125]: if res['status'] == 125: if 'unable to retrieve auth token' in res['output']: self.log_error( "Could not pull image. Provide either a username " "and password or authfile" ) raise Exception if 'unknown: Not found' in res['output']: self.log_error('Specified image not found on registry') raise Exception # 'name exists' with code 125 means the container was # created successfully, so ignore it. # initial creations leads to an exited container, restarting it # here will keep it alive for us to exec through ret = self.run_command(self.host.restart_sos_container(), need_root=True) if ret['status'] == 0: self.log_info("Temporary container " f"{self.host.sos_container_name} created") return True self.log_error("Could not start container after create: " f"{ret['output']}") raise Exception self.log_error("Could not create container on host: " f"{res['output']}") raise Exception return False def get_container_auth(self): """Determine what the auth string should be to pull the image used to deploy our temporary container """ if self.opts.registry_user: return self.host.runtimes['default'].fmt_registry_credentials( self.opts.registry_user, self.opts.registry_password ) return self.host.runtimes['default'].fmt_registry_authfile( self.opts.registry_authfile or self.host.container_authfile ) def file_exists(self, fname, need_root=False): """Checks for the presence of fname on the remote node""" try: res = self.run_command(f"stat {fname}", need_root=need_root) return res['status'] == 0 except Exception: return False @property def _hostname(self): if self.hostname and 'localhost' not in self.hostname: return self.hostname return self.address def _sanitize_log_msg(self, msg): """Attempts to obfuscate sensitive information in log messages such as passwords""" reg = r'(?P<var>(pass|key|secret|PASS|KEY|SECRET).*?=)(?P<value>.*?\s)' return re.sub(reg, r'\g<var>****** ', msg) def ui_msg(self, msg): """Format a ui message that includes host name and formatting""" self.ui_log.info(self._fmt_msg(msg)) def log_info(self, msg): """Used to print and log info messages""" caller = inspect.stack()[1][3] lmsg = f'[{self._hostname}:{caller}] {msg}' self.soslog.info(lmsg) def log_error(self, msg): """Used to print and log error messages""" caller = inspect.stack()[1][3] lmsg = f'[{self._hostname}:{caller}] {msg}' self.soslog.error(lmsg) def log_debug(self, msg): """Used to print and log debug messages""" msg = self._sanitize_log_msg(msg) caller = inspect.stack()[1][3] msg = f'[{self._hostname}:{caller}] {msg}' self.soslog.debug(msg) def _format_cmd(self, cmd): """If we need to provide a sudo or root password to a command, then here we prefix the command with the correct bits """ is_root = self._env_vars.get("USER", os.environ.get("USER")) == 'root' if self.local and is_root: return cmd if self.opts.become_root: return f"su -c {quote(cmd)}" if self.need_sudo: return f"{self.sudo_binary} {cmd}" return cmd def _load_sos_info(self): """Queries the node for information about the installed version of sos """ ver = None rel = None if self.host.container_version_command is None: pkg = self.host.package_manager.pkg_version(self.host.sos_pkg_name) if pkg is not None: ver = '.'.join(pkg['version']) if pkg['release']: rel = pkg['release'] else: # use the containerized policy's command pkgs = self.run_command(self.host.container_version_command, use_container=True, need_root=True) if pkgs['status'] == 0: _, ver, rel = pkgs['output'].strip().split('-') if ver: if len(ver.split('.')) == 2: # safeguard against maintenance releases throwing off the # comparison by parse_version ver += '.0' try: ver += f'-{rel.split(".")[0]}' except Exception as err: self.log_debug(f"Unable to fully parse sos release: {err}") self.sos_info['version'] = ver if self.sos_info['version']: self.log_info(f'sos version is {self.sos_info["version"]}') else: if not self.address == self.opts.primary: # in the case where the 'primary' enumerates nodes but is not # intended for collection (bastions), don't worry about sos not # being present self.log_error('sos is not installed on this node') self.connected = False return False # sos-4.0 changes the binary if self.check_sos_version('4.0'): self.sos_bin = 'sos report' cmd = f"{self.sos_bin} -l" sosinfo = self.run_command(cmd, use_container=True, need_root=True) if sosinfo['status'] == 0: self._load_sos_plugins(sosinfo['output']) if self.check_sos_version('3.6'): self._load_sos_presets() return None def _load_sos_presets(self): cmd = f'{self.sos_bin} --list-presets' res = self.run_command(cmd, use_container=True, need_root=True) if res['status'] == 0: for line in res['output'].splitlines(): if line.strip().startswith('name:'): pname = line.split('name:')[1].strip() self.sos_info['presets'].append(pname) def _load_sos_plugins(self, sosinfo): ENABLED = 'The following plugins are currently enabled:' DISABLED = 'The following plugins are currently disabled:' ALL_OPTIONS = 'The following options are available for ALL plugins:' OPTIONS = 'The following plugin options are available:' PROFILES = 'Profiles:' enablereg = ENABLED + '(.*?)' + DISABLED disreg = DISABLED + '(.*?)' + ALL_OPTIONS optreg = OPTIONS + '(.*?)' + PROFILES proreg = PROFILES + '(.*?)' + '\n\n' self.sos_info['enabled'] = self._regex_sos_help(enablereg, sosinfo) self.sos_info['disabled'] = self._regex_sos_help(disreg, sosinfo) self.sos_info['options'] = self._regex_sos_help(optreg, sosinfo) self.sos_info['profiles'] = self._regex_sos_help(proreg, sosinfo, True) def _regex_sos_help(self, regex, sosinfo, is_list=False): res = [] for result in re.findall(regex, sosinfo, re.S): for line in result.splitlines(): if not is_list: try: if ls := line.split(): res.append(ls[0]) except Exception as err: self.log_debug(f"Error parsing sos help: {err}") else: r = line.split(',') res.extend(p.strip() for p in r if p.strip()) return res def read_file(self, to_read): """Reads the specified file and returns the contents""" try: self.log_info(f"Reading file {to_read}") return self._transport.read_file(to_read) except Exception as err: self.log_error(f"Exception while reading {to_read}: {err}") return '' def determine_host_policy(self): """Attempts to identify the host installation against supported distributions """ if self.local: self.log_info( f"using local policy {self.commons['policy'].os_release_name}") return self.commons['policy'] host = load(cache={}, sysroot=self.opts.sysroot, init=InitSystem(), probe_runtime=True, remote_exec=self._transport.run_command, remote_check=self.read_file('/etc/os-release')) if host: self.log_info(f"loaded policy {host.os_release_name} for host") return host self.log_error('Unable to determine host installation. Ignoring node') raise UnsupportedHostException def check_sos_version(self, ver): """Checks to see if the sos installation on the node is AT LEAST the given ver. This means that if the installed version is greater than ver, this will still return True :param ver: Version number we are trying to verify is installed :type ver: ``str`` :returns: True if installed version is at least ``ver``, else False :rtype: ``bool`` """ try: _node_ver = self.sos_info['version'] return sos_parse_version(_node_ver) >= sos_parse_version(ver) except Exception as err: self.log_error(f"Error checking sos version: {err}") return False def is_installed(self, pkg): """Checks if a given package is installed on the node""" if not self.host: return False return self.host.package_manager.pkg_by_name(pkg) is not None def run_command(self, cmd, timeout=180, use_shell='auto', need_root=False, use_container=False, env=None): """Runs a given cmd, either via the SSH session or locally :param cmd: The full command to be run :type cmd: ``str`` :param timeout: Time in seconds to wait for `cmd` to complete :type timeout: ``int`` :param use_shell: If a shell is needed to run `cmd`, set to True :type use_shell: ``bool`` or ``auto`` for transport-determined :param use_container: Run this command in a container *IF* the host is a containerized host :type use_container: ``bool`` :param env: Pass environment variables to set for this `cmd` :type env: ``dict`` """ if not self.connected and not self.local: self.log_debug('Node is disconnected, attempting to reconnect') try: reconnected = self._transport.reconnect(self._password) if not reconnected: self.log_debug('Failed to reconnect to node') raise ConnectionException except Exception as err: self.log_debug(f"Error while trying to reconnect: {err}") raise if use_container and self.host.containerized: cmd = self.host.format_container_command(cmd) if need_root: cmd = self._format_cmd(cmd) if env: _cmd_env = self.env_vars env = _cmd_env.update(env) return self._transport.run_command(cmd, timeout, need_root, env, use_shell) def sosreport(self): """Run an sos report on the node, then collect it""" try: path = self.execute_sos_command() if path: self.finalize_sos_path(path) else: self.log_error('Unable to determine path of sos archive') if self.sos_path: self.retrieved = self.retrieve_sosreport() except Exception as err: self.log_error(f"Error during sos execution: {err}") self.cleanup() def _preset_exists(self, preset): """Verifies if the given preset exists on the node""" return preset in self.sos_info['presets'] def _plugin_exists(self, plugin): """Verifies if the given plugin exists on the node""" return any(plugin in s for s in [self.sos_info['enabled'], self.sos_info['disabled']]) def _check_enabled(self, plugin): """Checks to see if the plugin is default enabled on node""" return plugin in self.sos_info['enabled'] def _check_disabled(self, plugin): """Checks to see if the plugin is default disabled on node""" return plugin in self.sos_info['disabled'] def _plugin_option_exists(self, opt): """Attempts to verify that the given option is available on the node. Note that we only get available options for enabled plugins, so if a plugin has been force-enabled we cannot validate if the plugin option is correct or not""" plug = opt.split('.')[0] if not self._plugin_exists(plug): return False if (self._check_disabled(plug) and plug not in self.opts.enable_plugins): return False if self._check_enabled(plug): return opt in self.sos_info['options'] # plugin exists, but is normally disabled. Assume user knows option is # valid when enabling the plugin return True def _fmt_sos_opt_list(self, opts): """Returns a comma delimited list for sos plugins that are confirmed to exist on the node""" return ','.join(o for o in opts if self._plugin_exists(o)) def set_cluster(self, cluster): """Expose the node to the cluster profile determined for the environment """ self.cluster = cluster def update_cmd_from_cluster(self): """This is used to modify the sos report command run on the nodes. By default, sos report is run without any options, using this will allow the profile to specify what plugins to run or not and what options to use. This will NOT override user supplied options. """ if self.cluster.sos_preset: if not self.preset: self.preset = self.cluster.sos_preset else: self.log_info('Cluster specified preset ' f'{self.cluster.sos_preset} but user has also ' 'defined a preset. Using user specification.') if self.cluster.sos_plugins: for plug in self.cluster.sos_plugins: if plug not in self.enable_plugins: self.enable_plugins.append(plug) if self.cluster.sos_options: for opt in self.cluster.sos_options: # take the user specification over any cluster defaults if opt not in self.sos_options: self.sos_options[opt] = self.cluster.sos_options[opt] if self.cluster.sos_plugin_options: for opt in self.cluster.sos_plugin_options: if not any(opt in o for o in self.plugopts): option = f'{opt}={self.cluster.sos_plugin_options[opt]}' self.plugopts.append(option) # set primary-only options if self.cluster.check_node_is_primary(self): with self.cluster.lock: self.cluster.set_primary_options(self) else: with self.cluster.lock: self.cluster.set_node_options(self) def _assign_config_opts(self): """From the global opts configuration, assign those values locally to this node so that they may be acted on individually. """ # assign these to new, private copies self.only_plugins = list(self.opts.only_plugins) self.skip_plugins = list(self.opts.skip_plugins) self.enable_plugins = list(self.opts.enable_plugins) self.plugopts = list(self.opts.plugopts) self.preset = list(self.opts.preset) def finalize_sos_cmd(self): """Use host facts and compare to the cluster type to modify the sos command if needed""" sos_cmd = self.sos_info['sos_cmd'] label = self.determine_sos_label() if label: sos_cmd = f'{sos_cmd} {quote(label)} ' sos_opts = [] # sos-3.6 added --threads if self.check_sos_version('3.6'): # 4 threads is the project's default if self.opts.threads != 4: sos_opts.append(f'--threads={quote(str(self.opts.threads))}') # sos-3.7 added options if self.check_sos_version('3.7'): if self.opts.plugin_timeout: sos_opts.append( f'--plugin-timeout={quote(str(self.opts.plugin_timeout))}') # sos-3.8 added options if self.check_sos_version('3.8'): if self.opts.allow_system_changes: sos_opts.append('--allow-system-changes') if self.opts.no_env_vars: sos_opts.append('--no-env-vars') if self.opts.since: sos_opts.append(f'--since={quote(self.opts.since)}') if self.check_sos_version('4.1'): if self.opts.skip_commands: sos_opts.append('--skip-commands=' f'{quote(",".join(self.opts.skip_commands))}') if self.opts.skip_files: sos_opts.append( f'--skip-files={quote(",".join(self.opts.skip_files))}' ) if self.check_sos_version('4.2'): if self.opts.cmd_timeout: sos_opts.append( f'--cmd-timeout={quote(str(self.opts.cmd_timeout))}' ) # handle downstream versions that backported this option if self.check_sos_version('4.3') or self.check_sos_version('4.2-13'): if self.opts.container_runtime != 'auto': sos_opts.append( f"--container-runtime={self.opts.container_runtime}" ) if self.opts.namespaces: sos_opts.append( f"--namespaces={self.opts.namespaces}" ) if self.check_sos_version('4.5.2'): if self.opts.journal_size: sos_opts.append(f"--journal-size={self.opts.journal_size}") if self.opts.low_priority: sos_opts.append('--low-priority') self.update_cmd_from_cluster() sos_cmd = sos_cmd.replace( 'sosreport', os.path.join(self.host.sos_bin_path, self.sos_bin) ) for opt in self.sos_options: _val = self.sos_options[opt] sos_opts.append(f"--{opt} {_val if _val else ''}") if self.plugopts: opts = [o for o in self.plugopts if self._plugin_exists(o.split('.')[0]) and self._plugin_option_exists(o.split('=')[0])] if opts: sos_opts.append(f'-k {quote(",".join(o for o in opts))}') if self.preset: if self._preset_exists(self.preset): sos_opts.append(f'--preset={quote(self.preset)}') else: self.log_debug(f'Requested to enable preset {self.preset} but ' 'preset does not exist on node') if self.only_plugins: plugs = [o for o in self.only_plugins if self._plugin_exists(o)] if len(plugs) != len(self.only_plugins): not_only = list(set(self.only_plugins) - set(plugs)) self.log_debug(f'Requested plugins {not_only} were requested ' 'to be enabled but do not exist') only = self._fmt_sos_opt_list(self.only_plugins) if only: sos_opts.append(f'--only-plugins={quote(only)}') self.sos_cmd = f"{sos_cmd} {' '.join(sos_opts)}" self.log_info(f'Final sos command set to {self.sos_cmd}') self.manifest.add_field('final_sos_command', self.sos_cmd) return if self.skip_plugins: # only run skip-plugins for plugins that are enabled skip = [o for o in self.skip_plugins if self._check_enabled(o)] if len(skip) != len(self.skip_plugins): not_skip = list(set(self.skip_plugins) - set(skip)) self.log_debug(f'Requested to skip plugins {not_skip}, but ' 'plugins are already not enabled') skipln = self._fmt_sos_opt_list(skip) if skipln: sos_opts.append(f'--skip-plugins={quote(skipln)}') if self.enable_plugins: # only run enable for plugins that are disabled opts = [o for o in self.enable_plugins if o not in self.skip_plugins and self._check_disabled(o) and self._plugin_exists(o)] if len(opts) != len(self.enable_plugins): not_on = list(set(self.enable_plugins) - set(opts)) self.log_debug(f'Requested to enable plugins {not_on}, but ' 'plugins are already enabled or do not exist') enable = self._fmt_sos_opt_list(opts) if enable: sos_opts.append(f'--enable-plugins={quote(enable)}') self.sos_cmd = f"{sos_cmd} {' '.join(sos_opts)}" self.log_info(f'Final sos command set to {self.sos_cmd}') self.manifest.add_field('final_sos_command', self.sos_cmd) def determine_sos_label(self): """Determine what, if any, label should be added to the sos report""" label = '' label += self.cluster.get_node_label(self) if self.opts.label: label += (f'{self.opts.label}' if not label else f'-{self.opts.label}') if not label: return None self.log_debug(f'Label for sos report set to {label}') if self.check_sos_version('3.6'): lcmd = '--label' else: lcmd = '--name' label = f'{self.address.split(".")[0]}-{label}' return f'{lcmd}={label}' def finalize_sos_path(self, path): """Use host facts to determine if we need to change the sos path we are retrieving from""" pstrip = self.host.sos_path_strip if pstrip: path = path.replace(pstrip, '') path = path.split()[0] self.log_info(f'Final sos path: {path}') self.sos_path = path self.archive = path.split('/')[-1] self.manifest.add_field('collected_archive', self.archive) def determine_sos_error(self, rc, stdout): if rc == -1: return 'sos report process received SIGKILL on node' if rc == 1: if 'sudo' in stdout: return 'sudo attempt failed' if rc == 127: return 'sos report terminated unexpectedly. Check disk space' if len(stdout) > 0: return stdout.split('\n')[0:1] return f'sos exited with code {rc}' def execute_sos_command(self): """Run sos report and capture the resulting file path""" self.ui_msg('Generating sos report...') try: path = False checksum = False config_file_arg = '' if self.opts.node_config_file: config_file_arg = f'--config-file={self.opts.node_config_file}' elif self.opts.inherit_config_file: if not self.local: remote_config = f"/tmp/{self.tmpdir.split('/')[-1]}.conf" self._transport.copy_file_to_remote( self.opts.config_file, remote_config) config_file_arg = f'--config-file={remote_config}' else: config_file_arg = ( f'--config-file={self.opts.config_file}') if config_file_arg: self.sos_cmd = f"{self.sos_cmd} {config_file_arg}" res = self.run_command(self.sos_cmd, timeout=self.opts.timeout, use_shell=True, need_root=True, use_container=True, env=self.sos_env_vars) if res['status'] == 0: for line in res['output'].splitlines(): if fnmatch.fnmatch(line, '*sosreport-*tar*'): path = line.strip() if line.startswith((" sha256\t", " md5\t")): checksum = line.split("\t")[1] elif line.startswith("The checksum is: "): checksum = line.split()[3] if checksum: self.manifest.add_field('checksum', checksum) if len(checksum) == 32: self.manifest.add_field('checksum_type', 'md5') elif len(checksum) == 64: self.manifest.add_field('checksum_type', 'sha256') else: self.manifest.add_field('checksum_type', 'unknown') else: self.manifest.add_field('checksum_type', 'unknown') else: err = self.determine_sos_error(res['status'], res['output']) self.log_debug("Error running sos report. rc = " f"{res['status']} msg = {res['output']}") raise Exception(err) return path except CommandTimeoutException: self.log_error('Timeout exceeded') raise except Exception as err: self.log_info(f"Exception during sos report execution: {err}") self.ui_msg(f"Error running sos report: {err}") raise def retrieve_file(self, path): """Copies the specified file from the host to our temp dir""" destdir = self.tmpdir + '/' dest = os.path.join(destdir, path.split('/')[-1]) try: if self.file_exists(path): self.log_info(f"Copying remote {path} to local {destdir}") return self._transport.retrieve_file(path, dest) self.log_debug(f"Attempting to copy remote file {path}, but it" " does not exist on filesystem") return False except Exception as err: self.log_debug(f"Failed to retrieve {path}: {err}") return False def remove_file(self, path): """Removes the spciefied file from the host. This should only be used after we have retrieved the file already """ path = ''.join(path.split()) try: if len(path.split('/')) <= 2: # ensure we have a non '/' path self.log_debug(f"Refusing to remove path {path}: appears to " "be incorrect and possibly dangerous") return False if self.file_exists(path): self.log_info(f"Removing file {path}") cmd = f"rm -f {path}" res = self.run_command(cmd, need_root=True) return res['status'] == 0 self.log_debug(f"Attempting to remove remote file {path}, but " "it does not exist on filesystem") return False except Exception as e: self.log_debug(f'Failed to remove {path}: {e}') return False def retrieve_sosreport(self): """Collect the sos report archive from the node""" if self.need_sudo or self.opts.become_root: try: self.make_archive_readable(self.sos_path) except Exception: self.log_error('Failed to make archive readable') return False self.log_info(f'Retrieving sos report from {self.address}') self.ui_msg('Retrieving sos report...') try: ret = self.retrieve_file(self.sos_path) except Exception as err: self.log_error(err) return False if ret: self.ui_msg('Successfully collected sos report') self.file_list.append(self.sos_path.split('/')[-1]) return True self.ui_msg('Failed to retrieve sos report') return False def remove_sos_archive(self): """Remove the sos report archive from the node, since we have collected it and it would be wasted space otherwise""" if self.sos_path is None or self.local: # local transport moves the archive rather than copies it, so there # is no archive at the original location to remove return if 'sosreport' not in self.sos_path: self.log_debug(f"Node sos report path {self.sos_path} looks " "incorrect. Not attempting to remove path") return removed = self.remove_file(self.sos_path) if not removed: self.log_error('Failed to remove sos report') def cleanup(self): """Remove the sos archive from the node once we have it locally""" self.remove_sos_archive() if self.sos_path: for ext in ['.sha256', '.md5']: if self.remove_file(self.sos_path + ext): break cleanup = self.host.set_cleanup_cmd() if cleanup: self.run_command(cleanup, need_root=True) def collect_extra_cmd(self, filenames): """Collect the file created by a cluster outside of sos""" for filename in filenames: try: if self.need_sudo or self.opts.become_root: try: self.make_archive_readable(filename) except Exception as err: self.log_error(f"Unable to retrieve file {filename}") self.log_debug(f"Failed to make file {filename} " f"readable: {err}") continue ret = self.retrieve_file(filename) if ret: self.file_list.append(filename.split('/')[-1]) self.remove_file(filename) else: self.log_error(f"Unable to retrieve file {filename}") except Exception as e: msg = f'Error collecting additional data from primary: {e}' self.log_error(msg) def make_archive_readable(self, filepath): """Used to make the given archive world-readable, which is slightly better than changing the ownership outright. This is only used when we're not connecting as root. """ cmd = f'chmod o+r {filepath}' res = self.run_command(cmd, timeout=10, need_root=True) if res['status'] == 0: return True msg = "Exception while making %s readable. Return code was %s" self.log_error(msg % (filepath, res['status'])) raise Exception # vim: set et ts=4 sw=4 :
Save File
Cancel