binding: Updates Jinja2 from 2.7.1 to 2.8.

third_party/jinja2/bccache.py

 # -*- coding: utf-8 -*-
 """
     jinja2.bccache
     ~~~~~~~~~~~~~~
 
     This module implements the bytecode cache system Jinja is optionally
     using.  This is useful if you have very complex template situations and
     the compiliation of all those templates slow down your application too
     much.
 
     Situations where this is useful are often forking web applications that
     are initialized on the first request.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD.
 """
 from os import path, listdir
+import os
 import sys
+import stat
+import errno
 import marshal
 import tempfile
 import fnmatch
 from hashlib import sha1
 from jinja2.utils import open_if_exists
 from jinja2._compat import BytesIO, pickle, PY2, text_type
 
 
 # marshal works better on 3.x, one hack less required
 if not PY2:
@@ skipping 49 matching lines @@
         # make sure the magic header is correct
         magic = f.read(len(bc_magic))
         if magic != bc_magic:
             self.reset()
             return
         # the source code of the file changed, we need to reload
         checksum = pickle.load(f)
         if self.checksum != checksum:
             self.reset()
             return
-        self.code = marshal_load(f)
+        # if marshal_load fails then we need to reload
+        try:
+            self.code = marshal_load(f)
+        except (EOFError, ValueError, TypeError):
+            self.reset()
+            return
 
     def write_bytecode(self, f):
         """Dump the bytecode into the file or file like object passed."""
         if self.code is None:
             raise TypeError('can\'t write empty bucket')
         f.write(bc_magic)
         pickle.dump(self.checksum, f, 2)
         marshal_dump(self.code, f)
 
     def bytecode_from_string(self, string):
@@ skipping 83 matching lines @@
     def set_bucket(self, bucket):
         """Put the bucket into the cache."""
         self.dump_bytecode(bucket)
 
 
 class FileSystemBytecodeCache(BytecodeCache):
     """A bytecode cache that stores bytecode on the filesystem.  It accepts
     two arguments: The directory where the cache items are stored and a
     pattern string that is used to build the filename.
 
-    If no directory is specified the system temporary items folder is used.
+    If no directory is specified a default cache directory is selected.  On
+    Windows the user's temp directory is used, on UNIX systems a directory
+    is created for the user in the system temp directory.
 
     The pattern can be used to have multiple separate caches operate on the
     same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s``
     is replaced with the cache key.
 
     >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
 
     This bytecode cache supports clearing of the cache using the clear method.
     """
 
     def __init__(self, directory=None, pattern='__jinja2_%s.cache'):
         if directory is None:
-            directory = tempfile.gettempdir()
+            directory = self._get_default_cache_dir()
         self.directory = directory
         self.pattern = pattern
 
+    def _get_default_cache_dir(self):
+        def _unsafe_dir():
+            raise RuntimeError('Cannot determine safe temp directory.  You '
+                               'need to explicitly provide one.')
+
+        tmpdir = tempfile.gettempdir()
+
+        # On windows the temporary directory is used specific unless
+        # explicitly forced otherwise.  We can just use that.
+        if os.name == 'nt':
+            return tmpdir
+        if not hasattr(os, 'getuid'):
+            _unsafe_dir()
+
+        dirname = '_jinja2-cache-%d' % os.getuid()
+        actual_dir = os.path.join(tmpdir, dirname)
+
+        try:
+            os.mkdir(actual_dir, stat.S_IRWXU)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+        try:
+            os.chmod(actual_dir, stat.S_IRWXU)
+            actual_dir_stat = os.lstat(actual_dir)
+            if actual_dir_stat.st_uid != os.getuid() \
+               or not stat.S_ISDIR(actual_dir_stat.st_mode) \
+               or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU:
+                _unsafe_dir()
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        actual_dir_stat = os.lstat(actual_dir)
+        if actual_dir_stat.st_uid != os.getuid() \
+           or not stat.S_ISDIR(actual_dir_stat.st_mode) \
+           or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU:
+            _unsafe_dir()
+
+        return actual_dir
+
     def _get_cache_filename(self, bucket):
         return path.join(self.directory, self.pattern % bucket.key)
 
     def load_bytecode(self, bucket):
         f = open_if_exists(self._get_cache_filename(bucket), 'rb')
         if f is not None:
             try:
                 bucket.load_bytecode(f)
             finally:
                 f.close()
@@ skipping 83 matching lines @@
 
     def dump_bytecode(self, bucket):
         args = (self.prefix + bucket.key, bucket.bytecode_to_string())
         if self.timeout is not None:
             args += (self.timeout,)
         try:
             self.client.set(*args)
         except Exception:
             if not self.ignore_memcache_errors:
                 raise