path: Add tracking of volatile paths.

recipe_modules/path/api.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.
 
 import functools
 import itertools
 import os
 import tempfile
 
 from recipe_engine import recipe_api
@@ skipping 143 matching lines @@
 
   def __init__(self, **kwargs):
     super(PathApi, self).__init__(**kwargs)
     config_types.Path.set_tostring_fn(
       PathToString(self, self._test_data))
     config_types.NamedBasePath.set_path_api(self)
 
     # Used in mkdtemp when generating and checking expectations.
     self._test_counter = 0
 
+  def _read_module_property(self, property_name, default=None):
+    """Reads a path property module from "$recipe_engine/path". If absent,
+    returns the default.
+    """
+    props = self.m.properties.get('$recipe_engine/path', {})
+    return props.get(property_name, default)
+
   def _read_path(self, property_name, default):  # pragma: no cover
     """Reads a path from a property. If absent, returns the default.
 
     Validates that the path is absolute.
     """
-    props = self.m.properties.get('$recipe_engine/path', {})
-    value = props.get(property_name)
+    value = self._read_module_property(property_name)
     if not value:
       assert os.path.isabs(default), default
       return default
     if not os.path.isabs(value):
       raise Error(
         'Path "%s" specified by module property %s is not absolute' % (
           value, property_name))
     return value
 
   def _ensure_dir(self, path):  # pragma: no cover
@@ skipping 15 matching lines @@
       cache_dir = self._read_path('cache_dir', os.path.join(os.getcwd(), 'cache'))
       self._ensure_dir(cache_dir)
       self._cache_dir = _split_path(cache_dir)
     else:
       self._path_mod = fake_path(self, self._test_data.get('exists', []))
       self._startup_cwd = ['/', 'b', 'FakeTestingCWD']
       # Appended to placeholder '[TMP]' to get fake path in test.
       self._temp_dir = ['/']
       self._cache_dir = ['/', 'b', 'c']
 
+    self._volatile_paths = self._read_module_property('volatile', [])
+
     self.set_config('BASE')
 
   def mock_add_paths(self, path):
     """For testing purposes, assert that |path| exists."""
     if self._test_data.enabled:
       self._path_mod.mock_add_paths(path)
 
   def assert_absolute(self, path):
     assert self.abspath(path) == str(path), '%s is not absolute' % path
 
+  def is_volatile(self, base):
+    """Returns (bool): True if the named path is declared as volatile.
+
+    A path is volatile if it is scoped to the recipe engine execution. Note that
+    some paths may be volatile, but not explicitly declared as such.
+    """
+    return base in self.c.volatile_paths or base in self._volatile_paths
+
   def mkdtemp(self, prefix):
     """Makes a new temp directory, returns path to it."""
     if not self._test_data.enabled:  # pragma: no cover
       # New path as str.
       new_path = tempfile.mkdtemp(prefix=prefix, dir=str(self['tmp_base']))
       # Ensure it's under self._temp_dir, convert to Path.
       new_path = _split_path(new_path)
       assert new_path[:len(self._temp_dir)] == self._temp_dir
       temp_dir = self['tmp_base'].join(*new_path[len(self._temp_dir):])
     else:
@@ skipping 73 matching lines @@
     if name in self.OK_ATTRS:
       return getattr(self._path_mod, name)
     if name in self.FILTER_METHODS:
       return string_filter(getattr(self._path_mod, name))
     raise AttributeError("'%s' object has no attribute '%s'" %
                          (self._path_mod, name))  # pragma: no cover
 
   def __dir__(self):  # pragma: no cover
     # Used for helping out show_me_the_modules.py
     return self.__dict__.keys() + list(self.OK_ATTRS + self.FILTER_METHODS)