Try 'sudo chmod' in make_tree_deleteable() as last effort

client/utils/file_path.py

 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 """Provides functions: get_native_path_case(), isabs() and safe_join().
 
 This module assumes that filesystem is not changing while current process
 is running and thus it caches results of functions that depend on FS state.
 """
 
 import ctypes
 import getpass
 import logging
 import os
 import posixpath
 import re
 import shlex
 import stat
 import sys
 import tempfile
 import time
 import unicodedata
 
 from utils import fs
+from utils import subprocess42
 from utils import tools
 
 
 # Types of action accepted by link_file().
 HARDLINK, HARDLINK_WITH_FALLBACK, SYMLINK, SYMLINK_WITH_FALLBACK, COPY = range(
     1, 6)
 
 
 ## OS-specific imports
 
@@ skipping 834 matching lines @@
       fs.stat(outfile).st_mode | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
 
 
 def set_read_only(path, read_only):
   """Sets or resets the write bit on a file or directory.
 
   Zaps out access to 'group' and 'others'.
   """
   mode = fs.lstat(path).st_mode
   # TODO(maruel): Stop removing GO bits.
-  mode = (mode & 0500) if read_only else (mode | 0200)
+  if read_only:
+    mode &= stat.S_IRUSR|stat.S_IXUSR # 0500
+  else:
+    mode |= stat.S_IRUSR|stat.S_IWUSR # 0600
+    if sys.platform != 'win32' and stat.S_ISDIR(mode):
+      mode |= stat.S_IXUSR # 0100
   if hasattr(os, 'lchmod'):
     fs.lchmod(path, mode)  # pylint: disable=E1101
   else:
     if stat.S_ISLNK(mode):
       # Skip symlink without lchmod() support.
       logging.debug(
           'Can\'t change %sw bit on symlink %s',
           '-' if read_only else '+', path)
       return
 
@@ skipping 200 matching lines @@
 
   On Windows, the files are modified. On other platforms, modify the directory.
   It only does the minimum so the files can be deleted safely.
 
   Warning on Windows: since file permission is modified, the file node is
   modified. This means that for hard-linked files, every directory entry for the
   file node has its file permission modified.
   """
   logging.debug('make_tree_deleteable(%s)', root)
   err = None
+  sudo_failed = False
+
+  def try_sudo(p):
+    if sys.platform == 'linux2' and not sudo_failed:
+      # Try passwordless sudo, just in case. In practice, it is preferable
+      # to use linux capabilities.
+      with open(os.devnull, 'rb') as f:
+        if not subprocess42.call(
+            ['sudo', '-n', 'chmod', 'a+rwX', p], stdin=f):
+          return False
+      logging.debug('sudo chmod %s failed', p)
+    return True
+
   if sys.platform != 'win32':
     e = set_read_only_swallow(root, False)
+    if e:
+      sudo_failed = try_sudo(root)
     if not err:
       err = e
   for dirpath, dirnames, filenames in fs.walk(root, topdown=True):
     if sys.platform == 'win32':
       for filename in filenames:
         e = set_read_only_swallow(os.path.join(dirpath, filename), False)
         if not err:
           err = e
     else:
       for dirname in dirnames:
-        e = set_read_only_swallow(os.path.join(dirpath, dirname), False)
+        p = os.path.join(dirpath, dirname)
+        e = set_read_only_swallow(p, False)
+        if e:
+          sudo_failed = try_sudo(p)
         if not err:
           err = e
   if err:
     # pylint: disable=raising-bad-type
     raise err
 
 
 def rmtree(root):
   """Wrapper around shutil.rmtree() to retry automatically on Windows.
 
   On Windows, forcibly kills processes that are found to interfere with the
   deletion.
 
   Returns:
     True on normal execution, False if berserk techniques (like killing
     processes) had to be used.
   """
   logging.info('rmtree(%s)', root)
-  assert sys.getdefaultencoding() == 'utf-8', sys.getdefaultencoding()
-  # Do not assert here yet because this would break too much code.
+  assert isinstance(root, unicode) or sys.getdefaultencoding() == 'utf-8', (
+      repr(root), sys.getdefaultencoding())
   root = unicode(root)
   try:
     make_tree_deleteable(root)
   except OSError as e:
     logging.warning('Swallowing make_tree_deleteable() error: %s', e)
 
   # First try the soft way: tries 3 times to delete and sleep a bit in between.
   # Retries help if test subprocesses outlive main process and try to actively
   # use or write to the directory while it is being deleted.
   max_tries = 3
@@ skipping 52 matching lines @@
     sys.stderr.write(
         'Failed to delete %s. The following files remain:\n' % root)
     # The same path may be listed multiple times.
     for path in sorted(set(path for _, path, _ in errors)):
       sys.stderr.write('- %s\n' % path)
     raise errors[0][2][0], errors[0][2][1], errors[0][2][2]
   return False
 
 
 ## Private code.