+ import stat

+ def rmtree_skip_mounts(rootdir, mounts, rootdir_mounts=None):

+     """

+     The rmtree method based on `shutil.rmtree` skipping the `mounts` directories.

+     We want to skip these directories in case the umount fails for whatever reason.

+     We need to ensure that /mnt/odcs content is not removed.

+ 

+     This method catches the `os.error` exceptions, so the runroot task does

+     not fail because of rmtree error.

+ 

+     :param str rootdir: Full path to root directory for Mock chroot to remove.

+         For example "/var/lib/mock/foo/root".

+     :param list mounts: List of mount points to skip in case they are not umounted.

+         For example ["/mnt/odcs", "/mnt/koji"].

+     :param str rootdir_mounts: Helper variable for recursive calls of this

+         function. It is initialized by this function in the first call and is

+         passed to recursive calls. It contains the full-path to mount point.

+         For example:

+             ["/var/lib/mock/foo/root/mnt/odcs", "/var/lib/mock/foo/root/mnt/koji"]

+     :return bool: True if some subdirectory of `rootdir` has been skipped and

+         not removed.

+     """

+     if not rootdir_mounts:

+         rootdir_mounts = ["%s%s" % (rootdir, mount) for mount in mounts]

+ 

+     # Skip the directory which is mount point in case it contains some files -

+     # that means it has not been umounted.

+     # This counts with recursive call of this method. For example:

+     #   rootdir_mounts = ["/var/lib/mock/foo/root/mnt/koji"]

+     #   Call #1:      rootdir = "/var/lib/mock/foo/root/"

+     #     Call #2:    rootdir = "/var/lib/mock/foo/root/mnt"

+     #       Call #3:  rootdir = "/var/lib/mock/foo/root/mnt/koji"

+     # In the Call #3, the rootdir == rootdir_mounts[0], so this directory is

+     # not removed when not empty and True is returned back to calls #2 and #1.

+     # That tells the #2 and #1 to also not remove the "rootdir" with which

+     # they have been called.

+     if rootdir in rootdir_mounts and os.listdir(rootdir):

+         return True

+ 

+     subdirectory_skipped = False

+     names = []

+     try:

+         names = os.listdir(rootdir)

+     except os.error:

+         pass

+     for name in names:

+         fullname = os.path.join(rootdir, name)

+         try:

+             mode = os.lstat(fullname).st_mode

+         except os.error:

+             mode = 0

+         if stat.S_ISDIR(mode):

+             if rmtree_skip_mounts(fullname, mounts, rootdir_mounts):

+                 subdirectory_skipped = True

+         else:

+             try:

+                 os.remove(fullname)

+             except os.error:

+                 continue

+     if not subdirectory_skipped:

+         try:

+             os.rmdir(rootdir)

+         except os.error:

+             pass

+     return subdirectory_skipped

+ 

+ 

+     mounts = [conf.target_dir] + conf.runroot_extra_mounts

+         do_mounts(rootdir, mounts)

+         undo_mounts(rootdir, mounts)

+         # TODO: Pungi so far does not indicate anyhow that the runroot root can

+         # be removed. The last command is always "rpm -qa ...", so we use it

+         # as a mark for now that runroot root can be removed.

+         # We should try improving Pungi OpenSSH runroot method to remove this

+         # workaround later.

+         if cmd[0] == "rpm":

+             rmtree_skip_mounts(rootdir, mounts)

+ from mock import patch, mock_open, MagicMock

+     mock_runroot_install, rmtree_skip_mounts)

+ 

+     @patch("odcs.server.mock_runroot.os.rmdir")

+     @patch("odcs.server.mock_runroot.os.listdir")

+     @patch("odcs.server.mock_runroot.os.lstat")

+     @patch("odcs.server.mock_runroot.os.remove")

+     @patch("odcs.server.mock_runroot.stat.S_ISDIR")

+     def test_mock_runroot_rmtree(self, isdir, remove, lstat, listdir, rmdir):

+         """

+         Tests that `rmtree_skip_mounts` really skips the mount points when

+         removing the runroot root directory.

+ 

+         The fake runroot root directory in this test is following:

+         - /mnt/koji - empty directory which should be removed

+         - /mnt/odcs - non-empty mountpoint directory must not be removed.

+         - /x - regular file which should be removed.

+         """

+         def mocked_listdir(path):

+             # Creates fake directory structure within the /var/lib/mock/foo-bar/root:

+             #  - /mnt/koji

+             #  - /mnt/odcs/foo

+             #  - /x

+             if path == "/var/lib/mock/foo-bar/root":

+                 return ["mnt", "x"]

+             if path.endswith("/mnt"):

+                 return ["odcs", "koji"]

+             elif path.endswith("/odcs"):

+                 return ["foo"]

+             return []

+         listdir.side_effect = mocked_listdir

+ 

+         def mocked_isdir(mode):

+             # We use fake values here:

+             # - 0 means it is not a directory.

+             # - 1 means it is a directory.

+             return mode

+         isdir.side_effect = mocked_isdir

+ 

+         def mocked_lstat(path):

+             stat_result = MagicMock()

+             if path.endswith("/x"):

+                 stat_result.st_mode = 0  # Just fake return value for regular file.

+             else:

+                 stat_result.st_mode = 1  # Fake value for directory.

+             return stat_result

+         lstat.side_effect = mocked_lstat

+ 

+         rmtree_skip_mounts("/var/lib/mock/foo-bar/root", ["/mnt/odcs"])

+ 

+         rmdir.assert_called_once_with("/var/lib/mock/foo-bar/root/mnt/koji")

+         remove.assert_called_once_with("/var/lib/mock/foo-bar/root/x")