Refactor CacheFS for efficiency and usability.

The main class is now CacheFSMixin, a mixin class that can add caching to
any FS implementation.  It operates explicitly on a PathMap of recent 
info dicts, making it more efficient and more robust than the old CacheFS.

The CacheFS wrapper class is still there, but it's a trivial class that
just mixes CacheFSMixin into the base WrapFS class.

TahoeFS has also been modified to use the mixin architecture.

fs/contrib/tahoefs/connection.py

@@ -62,7 +62,6 @@ class Connection:
         
     def _urlopen(self, req):
         try:
-            #print req.get_full_url()
             return urlopen(req)
         except Exception, e:
             if not getattr(e, 'getcode', None):

fs/expose/dokan/__init__.py

@@ -40,6 +40,12 @@ to subprocess.Popen::
     >>> mp = dokan.MountProcess(fs,"Q",stderr=PIPE)
     >>> dokan_errors = mp.communicate()[1]
 
+
+If you are exposing an untrusted filesystem, you may like to apply the
+wrapper class Win32SafetyFS before passing it into dokan.  This will take
+a number of steps to avoid suspicious operations on windows, such as 
+hiding autorun files.
+
 The binding to Dokan is created via ctypes.  Due to the very stable ABI of
 win32, this should work without further configuration on just about all
 systems with Dokan installed.
@@ -64,6 +70,7 @@ from fs.base import threading
 from fs.errors import *
 from fs.path import *
 from fs.local_functools import wraps
+from fs.wrapfs import WrapFS
 
 try:
     import libdokan
@@ -881,6 +888,39 @@ class MountProcess(subprocess.Popen):
         mount(fs,drive,**opts)
 
 
+
+class Win32SafetyFS(WrapFS):
+    """FS wrapper for extra safety when mounting on win32.
+
+    This wrapper class provides some safety features when mounting untrusted
+    filesystems on win32.  Specifically:
+
+        * hiding autorun files
+        * removing colons from paths
+
+    """
+
+    def __init__(self,wrapped_fs,allow_autorun=False):
+        self.allow_autorun = allow_autorun
+        super(Win32SafetyFS,self).__init__(wrapped_fs)
+
+    def _encode(self,path):
+        path = relpath(normpath(path))
+        path = path.replace(":","__colon__")
+        if not self.allow_autorun:
+            if path.lower().startswith("/_autorun."):
+                path = "/" + path[2:]
+        return path
+
+    def _decode(self,path):
+        path = relpath(normpath(path))
+        path = path.replace("__colon__",":")
+        if not self.allow_autorun:
+            if path.lower().startswith("/autorun."):
+                path = "/_" + path[1:]
+        return path
+
+
 if __name__ == "__main__":
     import os, os.path
     import tempfile

fs/tests/__init__.py

@@ -98,6 +98,7 @@ class FSTestCases(object):
         except ResourceInvalidError:
             pass
         except Exception:
+            raise
             ecls = sys.exc_info()[0]
             assert False, "%s raised instead of ResourceInvalidError" % (ecls,)
         else:

fs/tests/test_expose.py

@@ -179,6 +179,17 @@ if dokan.is_available:
             #  out.  Disabling the test for now.
             pass
 
+        def test_safety_wrapper(self):
+            rawfs = MemoryFS()
+            safefs = dokan.Win32SafetyFS(rawfs)
+            rawfs.setcontents("autoRun.inf","evilcodeevilcode")
+            self.assertFalse(safefs.exists("autoRun.inf"))
+            self.assertTrue(safefs.exists("_autoRun.inf"))
+            self.assertTrue("autoRun.inf" not in safefs.listdir("/"))
+            rawfs.setcontents("file:stream","test")
+            self.assertFalse(safefs.exists("file:stream"))
+            self.assertTrue(safefs.exists("file__colon__stream"))
+
     class TestDokan(unittest.TestCase,DokanTestCases,ThreadingTestCases):
 
         def setUp(self):
@@ -208,4 +219,4 @@ if dokan.is_available:
             self.temp_fs.close()
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()
\ No newline at end of file

fs/tests/test_remote.py

@@ -216,18 +216,51 @@ class TestRemoteFileBuffer(unittest.TestCase, FSTestCases, ThreadingTestCases):
         self.assertEquals(f.read(), contents[:10] + contents2)
         f.close()
         
+
 class TestCacheFS(unittest.TestCase,FSTestCases,ThreadingTestCases):
     """Test simple operation of CacheFS"""
 
     def setUp(self):
         self._check_interval = sys.getcheckinterval()
         sys.setcheckinterval(10)
-        self.fs = CacheFS(TempFS())
+        self.wrapped_fs = TempFS()
+        self.fs = CacheFS(self.wrapped_fs,cache_timeout=0.01)
 
     def tearDown(self):
         self.fs.close()
         sys.setcheckinterval(self._check_interval)
 
+    def test_values_are_used_from_cache(self):
+        old_timeout = self.fs.cache_timeout
+        self.fs.cache_timeout = None
+        try:
+            self.assertFalse(self.fs.isfile("hello"))
+            self.wrapped_fs.setcontents("hello","world")
+            self.assertTrue(self.fs.isfile("hello"))
+            self.wrapped_fs.remove("hello")
+            self.assertTrue(self.fs.isfile("hello"))
+            self.fs.clear_cache()
+            self.assertFalse(self.fs.isfile("hello"))
+        finally:
+            self.fs.cache_timeout = old_timeout
+
+    def test_values_are_updated_in_cache(self):
+        old_timeout = self.fs.cache_timeout
+        self.fs.cache_timeout = None
+        try:
+            self.assertFalse(self.fs.isfile("hello"))
+            self.wrapped_fs.setcontents("hello","world")
+            self.assertTrue(self.fs.isfile("hello"))
+            self.wrapped_fs.remove("hello")
+            self.assertTrue(self.fs.isfile("hello"))
+            self.wrapped_fs.setcontents("hello","world")
+            self.assertTrue(self.fs.isfile("hello"))
+            self.fs.remove("hello")
+            self.assertFalse(self.fs.isfile("hello"))
+        finally:
+            self.fs.cache_timeout = old_timeout
+         
+
 
 class TestConnectionManagerFS(unittest.TestCase,FSTestCases):#,ThreadingTestCases):
     """Test simple operation of ConnectionManagerFS"""