swarming: Fix named cache support.

client/named_cache.py

 # Copyright 2016 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.
 
 """This file implements Named Caches."""
 
 import contextlib
+import logging
 import optparse
 import os
 import random
 import re
 import string
 
 from utils import lru
 from utils import file_path
 from utils import fs
 from utils import threading_utils
@@ skipping 73 matching lines @@
 
     Requires NamedCache to be open.
     """
     self._lock.assert_locked()
     assert isinstance(name, basestring), name
     path = self._lru.get(name)
     create_named_link = False
     if path is None:
       path = self._allocate_dir()
       create_named_link = True
+      logging.info('Created %r for %r', path, name)
     abs_path = os.path.join(self.root_dir, path)
 
+    # TODO(maruel): That's weird, it should exist already.
     file_path.ensure_tree(abs_path)
     self._lru.add(name, path)
 
     if create_named_link:
       # Create symlink <root_dir>/<named>/<name> -> <root_dir>/<short name>
       # for user convenience.
       named_path = self._get_named_path(name)
       if os.path.exists(named_path):
         file_path.remove(named_path)
       else:
         file_path.ensure_tree(os.path.dirname(named_path))
+      logging.info('Symlink %r to %r', named_path, abs_path)
       fs.symlink(abs_path, named_path)
 
     return abs_path
 
   def get_oldest(self):
     """Returns name of the LRU cache or None.
 
     Requires NamedCache to be open.
     """
     self._lock.assert_locked()
@@ skipping 17 matching lines @@
     """Creates symlinks in |root| for specified named_caches.
 
     named_caches must be a list of (name, path) tuples.
 
     Requires NamedCache to be open.
 
     Raises Error if cannot create a symlink.
     """
     self._lock.assert_locked()
     for name, path in named_caches:
+      logging.info('Named cache %r -> %r', name, path)
       try:
         if os.path.isabs(path):
           raise Error('named cache path must not be absolute')
         if '..' in path.split(os.path.sep):
           raise Error('named cache path must not contain ".."')
         symlink_path = os.path.abspath(os.path.join(root, path))
         file_path.ensure_tree(os.path.dirname(symlink_path))
-        fs.symlink(self.request(name), symlink_path)
+        requested = self.request(name)
+        logging.info('Symlink %r to %r', symlink_path, requested)
+        fs.symlink(requested, symlink_path)
       except (OSError, Error) as ex:
         raise Error(
             'cannot create a symlink for cache named "%s" at "%s": %s' % (
               name, symlink_path, ex))
 
   def trim(self, min_free_space):
     """Purges cache.
 
     Removes cache directories that were not accessed for a long time
     until there is enough free space and the number of caches is sane.
 
     If min_free_space is None, disk free space is not checked.
 
     Requires NamedCache to be open.
     """
     self._lock.assert_locked()
     if not os.path.isdir(self.root_dir):
       return
 
     free_space = 0
-    if min_free_space is not None:
-      file_path.get_free_space(self.root_dir)
-    while ((min_free_space is not None and free_space < min_free_space)
+    if min_free_space:
+      free_space = file_path.get_free_space(self.root_dir)
+    while ((min_free_space and free_space < min_free_space)
            or len(self._lru) > MAX_CACHE_SIZE):
+      logging.info(
+          'Making space for named cache %s > %s or %s > %s',
+          free_space, min_free_space, len(self._lru), MAX_CACHE_SIZE)
       try:
         name, (path, _) = self._lru.get_oldest()
       except KeyError:
         return
       named_dir = self._get_named_path(name)
       if fs.islink(named_dir):
         fs.unlink(named_dir)
       path_abs = os.path.join(self.root_dir, path)
       if os.path.isdir(path_abs):
+        logging.info('Removing named cache %s', path_abs)
         file_path.rmtree(path_abs)
-      if min_free_space is not None:
+      if min_free_space:
         free_space = file_path.get_free_space(self.root_dir)
       self._lru.pop(name)
 
   _DIR_ALPHABET = string.ascii_letters + string.digits
 
   def _allocate_dir(self):
     """Creates and returns relative path of a new cache directory."""
     # We randomly generate directory names that have two lower/upper case
     # letters or digits. Total number of possibilities is (26*2 + 10)^2 = 3844.
     abc_len = len(self._DIR_ALPHABET)
@@ skipping 40 matching lines @@
     parser.error('--named-cache is specified, but --named-cache-root is empty')
   for name, path in options.named_caches:
     if not CACHE_NAME_RE.match(name):
       parser.error(
           'cache name "%s" does not match %s' % (name, CACHE_NAME_RE.pattern))
     if not path:
       parser.error('cache path cannot be empty')
   if options.named_cache_root:
     return CacheManager(os.path.abspath(options.named_cache_root))
   return None