From cb3d265849771f7e53b0587196930328005414e0 Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Mon, 19 Jan 2015 18:54:09 +0000

Subject: [PATCH 01/38] [sosreport] add --sysroot option

Add a --sysroot=SYSROOT option to specify that the root file system to

be inspected is mounted at SYSROOT.

This allows basic support for container environments where sos is

running in a container and inspecting the containing host and its

environment ('superspection').

For this to work currently the following conditions must be met:

- sos is sufficiently privileged to read and search relevant file

  system paths within SYSROOT

- sos must share the PID and network namespace of the target host

- binaries called by sos must be present and executable in the

  SYSROOT inherited by sos. If PATH includes paths inside SYSROOT

  appropriate values must be set for LD_LIBRARY_PATH to allow

  shared executables to be linked.

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 sos/sosreport.py | 16 +++++++++++++++-

 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/sos/sosreport.py b/sos/sosreport.py

index 9a0cf6c..47eddc9 100644

--- a/sos/sosreport.py

+++ b/sos/sosreport.py

@@ -529,6 +529,17 @@ class SoSOptions(object):

         self._report = value

     @property

+    def sysroot(self):

+        if self._options is not None:

+            return self._options.sysroot

+        return self._sysroot

+

+    @sysroot.setter

+    def sysroot(self, value):

+        self._check_options_initialized()

+        self._sysroot = value

+

+    @property

     def compression_type(self):

         if self._options is not None:

             return self._options.compression_type

@@ -615,6 +626,9 @@ class SoSOptions(object):

         parser.add_option("--no-report", action="store_true",

                           dest="report",

                           help="Disable HTML/XML reporting", default=False)

+        parser.add_option("-s", "--sysroot", action="store", dest="sysroot",

+                          help="system root directory path (default='/')",

+                          default="/")

         parser.add_option("-z", "--compression-type", dest="compression_type",

                           help="compression technology to use [auto, "

                                "gzip, bzip2, xz] (default=auto)",

-- 

1.8.3.1

From 3eed62e132f67930bb1cf5c9eaa5927083011043 Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Fri, 23 Jan 2015 15:24:00 +0000

Subject: [PATCH 02/38] [plugins] propagate sysroot to Plugin via commons

Although plugins should generally be unaware that they are being

run with an alternate sysroot the generic plugin IO code must

peform the appropriate path prefixing when sysroot is not '/'.

Propagate sysroot to plugin classes via the commons dictionary.

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 sos/sosreport.py | 6 ++++++

 1 file changed, 6 insertions(+)

diff --git a/sos/sosreport.py b/sos/sosreport.py

index 47eddc9..580b5bd 100644

--- a/sos/sosreport.py

+++ b/sos/sosreport.py

@@ -651,6 +651,7 @@ class SoSReport(object):

         self.archive = None

         self.tempfile_util = None

         self._args = args

+        self.sysroot = "/"

         try:

             import signal

@@ -681,6 +682,10 @@ class SoSReport(object):

         self.tempfile_util = TempFileUtil(self.tmpdir)

         self._set_directories()

+        # set alternate system root directory

+        if self.opts.sysroot:

+            self.sysroot = self.opts.sysroot

+

     def print_header(self):

         self.ui_log.info("\n%s\n" % _("sosreport (version %s)" %

                          (__version__,)))

@@ -693,6 +698,7 @@ class SoSReport(object):

             'tmpdir': self.tmpdir,

             'soslog': self.soslog,

             'policy': self.policy,

+            'sysroot': self.sysroot,

             'verbosity': self.opts.verbosity,

             'xmlreport': self.xml_report,

             'cmdlineopts': self.opts,

-- 

1.8.3.1

From b1f3b3373e8ef3e94238760a3e7e78d95c564260 Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Fri, 23 Jan 2015 23:17:34 +0000

Subject: [PATCH 03/38] [plugins] prefix target paths with self.sysroot

Prefix copyspecs with self.sysroot when using an alternate root

path. Prefixes are applied before expanding copyspecs and the

prefixed paths are stored as the 'srcpath' attribute in the

archive. Destination paths in the report archive do not include

the prefix.

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 sos/plugins/__init__.py | 50 +++++++++++++++++++++++++++++++++++--------

 tests/option_tests.py   |  3 ++-

 tests/plugin_tests.py   | 57 ++++++++++++++++++++++++++++++++-----------------

 3 files changed, 81 insertions(+), 29 deletions(-)

diff --git a/sos/plugins/__init__.py b/sos/plugins/__init__.py

index 413ee73..790338b 100644

--- a/sos/plugins/__init__.py

+++ b/sos/plugins/__init__.py

@@ -101,6 +101,7 @@ class Plugin(object):

     files = ()

     archive = None

     profiles = ()

+    sysroot = '/'

     def __init__(self, commons):

         if not getattr(self, "option_list", False):

@@ -117,6 +118,7 @@ class Plugin(object):

         self.copy_paths = set()

         self.copy_strings = []

         self.collect_cmds = []

+        self.sysroot = commons['sysroot']

         self.soslog = self.commons['soslog'] if 'soslog' in self.commons \

             else logging.getLogger('sos')

@@ -154,6 +156,19 @@ class Plugin(object):

     def policy(self):

         return self.commons["policy"]

+    def join_sysroot(self, path):

+        if path[0] == os.sep:

+            path = path[1:]

+        return os.path.join(self.sysroot, path)

+

+    def strip_sysroot(self, path):

+        if path.startswith(self.sysroot):

+            return path[len(self.sysroot):]

+        return path

+

+    def use_sysroot(self):

+        return self.sysroot != os.path.abspath(os.sep)

+

     def is_installed(self, package_name):

         '''Is the package $package_name installed?'''

         return self.policy().pkg_by_name(package_name) is not None

@@ -207,6 +222,7 @@ class Plugin(object):

         '''

         try:

             path = self._get_dest_for_srcpath(srcpath)

+            self._log_debug("substituting scrpath '%s'" % srcpath)

             self._log_debug("substituting '%s' for '%s' in '%s'"

                             % (subst, regexp, path))

             if not path:

@@ -257,8 +273,9 @@ class Plugin(object):

         self._log_debug("copying link '%s' pointing to '%s' with isdir=%s"

                         % (srcpath, linkdest, os.path.isdir(absdest)))

+        dstpath = self.strip_sysroot(srcpath)

         # use the relative target path in the tarball

-        self.archive.add_link(reldest, srcpath)

+        self.archive.add_link(reldest, dstpath)

         if os.path.isdir(absdest):

             self._log_debug("link '%s' is a directory, skipping..." % linkdest)

@@ -277,7 +294,7 @@ class Plugin(object):

         self._do_copy_path(absdest)

         self.copied_files.append({'srcpath': srcpath,

-                                  'dstpath': srcpath,

+                                  'dstpath': dstpath,

                                   'symlink': "yes",

                                   'pointsto': linkdest})

@@ -288,6 +305,8 @@ class Plugin(object):

             self._do_copy_path(os.path.join(srcpath, afile), dest=None)

     def _get_dest_for_srcpath(self, srcpath):

+        if self.use_sysroot():

+            srcpath = self.join_sysroot(srcpath)

         for copied in self.copied_files:

             if srcpath == copied["srcpath"]:

                 return copied["dstpath"]

@@ -315,6 +334,9 @@ class Plugin(object):

         if not dest:

             dest = srcpath

+        if self.use_sysroot():

+            dest = self.strip_sysroot(dest)

+

         try:

             st = os.lstat(srcpath)

         except (OSError, IOError):

@@ -333,7 +355,7 @@ class Plugin(object):

         if not (stat.S_ISREG(st.st_mode) or stat.S_ISDIR(st.st_mode)):

             ntype = _node_type(st)

             self._log_debug("creating %s node at archive:'%s'"

-                            % (ntype, srcpath))

+                            % (ntype, dest))

             self._copy_node(srcpath, st)

             return

@@ -347,9 +369,11 @@ class Plugin(object):

         else:

             self.archive.add_file(srcpath, dest)

-        self.copied_files.append({'srcpath': srcpath,

-                                  'dstpath': dest,

-                                  'symlink': "no"})

+        self.copied_files.append({

+            'srcpath': srcpath,

+            'dstpath': dest,

+            'symlink': "no"

+        })

     def add_forbidden_path(self, forbiddenPath):

         """Specify a path to not copy, even if it's part of a copy_specs[]

@@ -416,6 +440,9 @@ class Plugin(object):

         except Exception:

             return default

+    def _add_copy_paths(self, copy_paths):

+        self.copy_paths.update(copy_paths)

+

     def add_copy_spec_limit(self, copyspec, sizelimit=None, tailit=True):

         """Add a file or glob but limit it to sizelimit megabytes. If fname is

         a single file the file will be tailed to meet sizelimit. If the first

@@ -424,10 +451,13 @@ class Plugin(object):

         if not (copyspec and len(copyspec)):

             return False

+        if self.use_sysroot():

+            copyspec = self.join_sysroot(copyspec)

         files = glob.glob(copyspec)

         files.sort()

         if len(files) == 0:

             return

+

         current_size = 0

         limit_reached = False

         sizelimit *= 1024 * 1024  # in MB

@@ -438,7 +468,7 @@ class Plugin(object):

             if sizelimit and current_size > sizelimit:

                 limit_reached = True

                 break

-            self.add_copy_spec(_file)

+            self._add_copy_paths([_file])

         if limit_reached and tailit:

             file_name = _file

@@ -459,12 +489,14 @@ class Plugin(object):

         if isinstance(copyspecs, six.string_types):

             copyspecs = [copyspecs]

         for copyspec in copyspecs:

+            if self.use_sysroot():

+                copyspec = self.join_sysroot(copyspec)

             if not (copyspec and len(copyspec)):

                 self._log_warn("added null or empty copy spec")

                 return False

             copy_paths = self._expand_copy_spec(copyspec)

-            self.copy_paths.update(copy_paths)

-            self._log_info("added copyspec '%s'" % copyspec)

+            self._add_copy_paths(copy_paths)

+            self._log_info("added copyspec '%s'" % copy_paths)

     def get_command_output(self, prog, timeout=300, runat=None, stderr=True):

         result = sos_get_command_output(prog, timeout=timeout, runat=runat,

diff --git a/tests/option_tests.py b/tests/option_tests.py

index fe37ccf..e8a26e2 100644

--- a/tests/option_tests.py

+++ b/tests/option_tests.py

@@ -8,10 +8,11 @@ class GlobalOptionTest(unittest.TestCase):

     def setUp(self):

         self.commons = {

+            'sysroot': '/',

             'global_plugin_options': {

                 'test_option': 'foobar',

                 'baz': None,

-                'empty_global': True,

+                'empty_global': True

             },

         }

         self.plugin = Plugin(self.commons)

diff --git a/tests/plugin_tests.py b/tests/plugin_tests.py

index e30ded5..14d3b49 100644

--- a/tests/plugin_tests.py

+++ b/tests/plugin_tests.py

@@ -127,50 +127,53 @@ class PluginToolTests(unittest.TestCase):

 class PluginTests(unittest.TestCase):

+    sysroot = os.getcwd()

+

     def setUp(self):

         self.mp = MockPlugin({

-            'cmdlineopts': MockOptions()

+            'cmdlineopts': MockOptions(),

+            'sysroot': self.sysroot

         })

         self.mp.archive = MockArchive()

     def test_plugin_default_name(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.name(), "mockplugin")

     def test_plugin_set_name(self):

-        p = NamedMockPlugin({})

+        p = NamedMockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.name(), "testing")

     def test_plugin_no_descrip(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_description(), "<no description available>")

     def test_plugin_no_descrip(self):

-        p = NamedMockPlugin({})

+        p = NamedMockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_description(), "This plugin has a description.")

     def test_set_plugin_option(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         p.set_option("opt", "testing")

         self.assertEquals(p.get_option("opt"), "testing")

     def test_set_nonexistant_plugin_option(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertFalse(p.set_option("badopt", "testing"))

     def test_get_nonexistant_plugin_option(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_option("badopt"), 0)

     def test_get_unset_plugin_option(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_option("opt"), 0)

     def test_get_unset_plugin_option_with_default(self):

         # this shows that even when we pass in a default to get,

         # we'll get the option's default as set in the plugin

         # this might not be what we really want

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_option("opt", True), True)

     def test_get_unset_plugin_option_with_default_not_none(self):

@@ -178,20 +181,20 @@ class PluginTests(unittest.TestCase):

         # if the plugin default is not None

         # we'll get the option's default as set in the plugin

         # this might not be what we really want

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_option("opt2", True), False)

     def test_get_option_as_list_plugin_option(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         p.set_option("opt", "one,two,three")

         self.assertEquals(p.get_option_as_list("opt"), ['one', 'two', 'three'])

     def test_get_option_as_list_plugin_option_default(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         self.assertEquals(p.get_option_as_list("opt", default=[]), [])

     def test_get_option_as_list_plugin_option_not_list(self):

-        p = MockPlugin({})

+        p = MockPlugin({'sysroot': self.sysroot})

         p.set_option("opt", "testing")

         self.assertEquals(p.get_option_as_list("opt"), ['testing'])

@@ -205,7 +208,8 @@ class PluginTests(unittest.TestCase):

     def test_copy_dir_forbidden_path(self):

         p = ForbiddenMockPlugin({

-            'cmdlineopts': MockOptions()

+            'cmdlineopts': MockOptions(),

+            'sysroot': self.sysroot

         })

         p.archive = MockArchive()

         p.setup()

@@ -219,12 +223,18 @@ class AddCopySpecTests(unittest.TestCase):

     def setUp(self):

         self.mp = MockPlugin({

-            'cmdlineopts': MockOptions()

+            'cmdlineopts': MockOptions(),

+            'sysroot': os.getcwd()

         })

         self.mp.archive = MockArchive()

     def assert_expect_paths(self):

-        self.assertEquals(self.mp.copy_paths, self.expect_paths)

+        def pathmunge(path):

+            if path[0] == '/':

+                path = path[1:]

+            return os.path.join(self.mp.sysroot, path)

+        expected_paths = set(map(pathmunge, self.expect_paths))

+        self.assertEquals(self.mp.copy_paths, expected_paths)

     # add_copy_spec()

@@ -242,6 +252,7 @@ class AddCopySpecTests(unittest.TestCase):

     # add_copy_spec_limit()

     def test_single_file_over_limit(self):

+        self.mp.sysroot = '/'

         fn = create_file(2) # create 2MB file, consider a context manager

         self.mp.add_copy_spec_limit(fn, 1)

         content, fname = self.mp.copy_strings[0]

@@ -252,10 +263,12 @@ class AddCopySpecTests(unittest.TestCase):

         os.unlink(fn)

     def test_bad_filename(self):

+        self.mp.sysroot = '/'

         self.assertFalse(self.mp.add_copy_spec_limit('', 1))

         self.assertFalse(self.mp.add_copy_spec_limit(None, 1))

     def test_glob_file_over_limit(self):

+        self.mp.sysroot = '/'

         # assume these are in /tmp

         fn = create_file(2)

         fn2 = create_file(2)

@@ -271,7 +284,10 @@ class AddCopySpecTests(unittest.TestCase):

 class CheckEnabledTests(unittest.TestCase):

     def setUp(self):

-        self.mp = EnablerPlugin({'policy': sos.policies.load()})

+        self.mp = EnablerPlugin({

+            'policy': sos.policies.load(),

+            'sysroot': os.getcwd()

+        })

     def test_checks_for_file(self):

         f = j("tail_test.txt")

@@ -296,7 +312,8 @@ class RegexSubTests(unittest.TestCase):

     def setUp(self):

         self.mp = MockPlugin({

-            'cmdlineopts': MockOptions()

+            'cmdlineopts': MockOptions(),

+            'sysroot': os.getcwd()

         })

         self.mp.archive = MockArchive()

@@ -310,6 +327,8 @@ class RegexSubTests(unittest.TestCase):

         self.assertEquals(0, replacements)

     def test_replacements(self):

+        # test uses absolute paths

+        self.mp.sysroot = '/'

         self.mp.add_copy_spec(j("tail_test.txt"))

         self.mp.collect()

         replacements = self.mp.do_file_sub(j("tail_test.txt"), r"(tail)", "foobar")

-- 

1.8.3.1

From c4957d8aa4ea35f879639726267043f6bb46cc7c Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Sat, 24 Jan 2015 00:35:09 +0000

Subject: [PATCH 04/38] [docs] add -s/--sysroot to sosreport.1

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 man/en/sosreport.1 | 5 +++++

 1 file changed, 5 insertions(+)

diff --git a/man/en/sosreport.1 b/man/en/sosreport.1

index c2b60d8..b0a86f2 100644

--- a/man/en/sosreport.1

+++ b/man/en/sosreport.1

@@ -12,6 +12,7 @@ sosreport \- Collect and package diagnostic and support data

           [--no-report] [--config-file conf]\fR

           [--batch] [--build] [--debug]\fR

           [--name name] [--case-id id] [--ticket-number nr]

+          [-s|--sysroot]\fR

           [--tmp-dir directory]\fR

           [-p|--profile profile-name]\fR

           [--list-profiles]\fR

@@ -72,6 +73,10 @@ Disable HTML/XML report writing.

 .B \--config-file CONFIG

 Specify alternate configuration file.

 .TP

+.B \-s, \--sysroot SYSROOT

+Specify an alternate root file system path. Useful for collecting

+reports from containers and images.

+.TP

 .B \--tmp-dir DIRECTORY

 Specify alternate temporary directory to copy data as well as the

 compressed report.

-- 

1.8.3.1

From 4a0a3f9607006d402713320fc31780fb54556e6a Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Sun, 25 Jan 2015 14:20:10 +0000

Subject: [PATCH 05/38] [utilities] add chroot support to

 sos_get_command_output()

Allow callers of sos_get_command_output() to specify a path to

chroot into before executing command.

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 sos/plugins/__init__.py  |  2 +-

 sos/utilities.py         | 27 ++++++++++++++++-----------

 tests/utilities_tests.py |  5 +++++

 3 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/sos/plugins/__init__.py b/sos/plugins/__init__.py

index 790338b..137e1a1 100644

--- a/sos/plugins/__init__.py

+++ b/sos/plugins/__init__.py

@@ -499,7 +499,7 @@ class Plugin(object):

             self._log_info("added copyspec '%s'" % copy_paths)

     def get_command_output(self, prog, timeout=300, runat=None, stderr=True):

-        result = sos_get_command_output(prog, timeout=timeout, runat=runat,

+        result = sos_get_command_output(prog, timeout=timeout, chdir=runat,

                                         stderr=stderr)

         if result['status'] == 124:

             self._log_warn("command '%s' timed out after %ds"

diff --git a/sos/utilities.py b/sos/utilities.py

index dfe6128..a82ac7c 100644

--- a/sos/utilities.py

+++ b/sos/utilities.py

@@ -120,15 +120,20 @@ def is_executable(command):

     return any(os.access(path, os.X_OK) for path in candidates)

-def sos_get_command_output(command, timeout=300, runat=None, stderr=True):

-    """Execute a command through the system shell. First checks to see if the

-    requested command is executable. Returns (returncode, stdout, 0)"""

-    def _child_chdir():

-        if(runat):

-            try:

-                os.chdir(runat)

-            except:

-                self.log_error("failed to chdir to '%s'" % runat)

+def sos_get_command_output(command, timeout=300, stderr=False,

+                           chroot=None, chdir=None):

+    """Execute a command and return a dictionary of status and output,

+    optionally changing root or current working directory before

+    executing command.

+    """

+    # Change root or cwd for child only. Exceptions in the prexec_fn

+    # closure are caught in the parent (chroot and chdir are bound from

+    # the enclosing scope).

+    def _child_prep_fn():

+        if (chroot):

+                os.chroot(chroot)

+        if (chdir):

+                os.chdir(chdir)

     cmd_env = os.environ

     # ensure consistent locale for collected command output

@@ -145,7 +150,7 @@ def sos_get_command_output(command, timeout=300, runat=None, stderr=True):

         p = Popen(args, shell=False, stdout=PIPE,

                   stderr=STDOUT if stderr else PIPE,

                   bufsize=-1, env=cmd_env, close_fds=True,

-                  preexec_fn=_child_chdir)

+                  preexec_fn=_child_prep_fn)

     except OSError as e:

         if e.errno == errno.ENOENT:

             return {'status': 127, 'output': ""}

@@ -185,7 +190,7 @@ def shell_out(cmd, timeout=30, runat=None):

     """Shell out to an external command and return the output or the empty

     string in case of error.

     """

-    return sos_get_command_output(cmd, timeout=timeout, runat=runat)['output']

+    return sos_get_command_output(cmd, timeout=timeout, chdir=runat)['output']

 class ImporterHelper(object):

diff --git a/tests/utilities_tests.py b/tests/utilities_tests.py

index 607056e..9327b1f 100644

--- a/tests/utilities_tests.py

+++ b/tests/utilities_tests.py

@@ -68,6 +68,11 @@ class ExecutableTest(unittest.TestCase):

         self.assertEquals(result['status'], 127)

         self.assertEquals(result['output'], "")

+    def test_output_chdir(self):

+        result = sos_get_command_output("/usr/bin/pwd", chdir=TEST_DIR)

+        self.assertEquals(result['status'], 0)

+        self.assertEquals(result['output'].strip(), TEST_DIR)

+

     def test_shell_out(self):

         path = os.path.join(TEST_DIR, 'test_exe.py')

         self.assertEquals("executed\n", shell_out(path))

-- 

1.8.3.1

From 9a87cb3415a7a9587828ee40d689439949def1be Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Sun, 25 Jan 2015 14:30:13 +0000

Subject: [PATCH 06/38] [sosreport] add --chroot option

Add a --chroot option to sosreport to control command chrooting.

The option takes one of three values:

  * auto   - Allow callers of the API to control chroot behaviour

  * always - Always chroot external commands to --sysroot

  * never  - Never chroot external commands

This is a fairly low-level option and may not be exposed to the

user in a final release; for now it will allow tests in container

environments to control the chrooting behaviour used for a run.

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 sos/sosreport.py         | 19 +++++++++++++++++++

 tests/utilities_tests.py |  4 +++-

 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/sos/sosreport.py b/sos/sosreport.py

index 580b5bd..d9abcb8 100644

--- a/sos/sosreport.py

+++ b/sos/sosreport.py

@@ -540,6 +540,21 @@ class SoSOptions(object):

         self._sysroot = value

     @property

+    def chroot(self):

+        if self._options is not None:

+            return self._options.chroot

+        return self._chroot

+

+    @chroot.setter

+    def chroot(self, value):

+        self._check_options_initialized()

+        if value not in ["auto", "always", "never"]:

+            msg = "SoSOptions.chroot '%s' is not a valid chroot mode: "

+            msg += "('auto', 'always', 'never')"

+            raise ValueError(msg % value)

+        self._chroot = value

+

+    @property

     def compression_type(self):

         if self._options is not None:

             return self._options.compression_type

@@ -630,6 +645,10 @@ class SoSOptions(object):

         parser.add_option("-s", "--sysroot", action="store", dest="sysroot",

                           help="system root directory path (default='/')",

                           default="/")

+        parser.add_option("-c", "--chroot", action="store", dest="chroot",

+                          help="chroot executed commands to SYSROOT "

+                               "[auto, always, never] (default=auto)",

+                               default="auto")

         parser.add_option("-z", "--compression-type", dest="compression_type",

                           help="compression technology to use [auto, "

                                "gzip, bzip2, xz] (default=auto)",

diff --git a/tests/utilities_tests.py b/tests/utilities_tests.py

index 9327b1f..c464692 100644

--- a/tests/utilities_tests.py

+++ b/tests/utilities_tests.py

@@ -69,7 +69,9 @@ class ExecutableTest(unittest.TestCase):

         self.assertEquals(result['output'], "")

     def test_output_chdir(self):

-        result = sos_get_command_output("/usr/bin/pwd", chdir=TEST_DIR)

+        cmd = "/bin/bash -c 'echo $PWD'"

+        result = sos_get_command_output(cmd, chdir=TEST_DIR)

+        print(result)

         self.assertEquals(result['status'], 0)

         self.assertEquals(result['output'].strip(), TEST_DIR)

-- 

1.8.3.1

From 0d060dc3aa5e90373e7bb55f9310b4cf9db0dad4 Mon Sep 17 00:00:00 2001

From: "Bryn M. Reeves" <bmr@redhat.com>

Date: Sun, 25 Jan 2015 15:04:29 +0000

Subject: [PATCH 07/38] [plugins] implement --chroot for command callouts

When --chroot=always is given chroot all commands to SYSROOT.

Signed-off-by: Bryn M. Reeves <bmr@redhat.com>

---

 sos/plugins/__init__.py | 8 ++++++--