Fix for xmlrpc

fs/expose/xmlrpc.py

@@ -52,10 +52,14 @@ class RPCFSInterface(object):
 
     def getmeta(self, meta_name):
         meta = self.fs.getmeta(meta_name)
+        if isinstance(meta, basestring):
+            meta = meta.decode('base64')
         return meta
 
     def getmeta_default(self, meta_name, default):
         meta = self.fs.getmeta(meta_name, default)
+        if isinstance(meta, basestring):
+            meta = meta.decode('base64')
         return meta
 
     def hasmeta(self, meta_name):

fs/mountfs.py

@@ -160,7 +160,7 @@ class MountFS(FS):
                 return "Mount dir"
             else:
                 return "Mounted file"
-        return "Mounted dir, maps to path %s on %s" % (delegate_path, str(fs))
+        return "Mounted dir, maps to path %s on %s" % (delegate_path or '/', str(fs))
 
     @synchronize
     def isdir(self, path):

fs/rpcfs.py

@@ -26,7 +26,7 @@ def re_raise_faults(func):
     def wrapper(*args,**kwds):
         try:
             return func(*args,**kwds)
-        except xmlrpclib.Fault, f:
+        except (xmlrpclib.Fault), f:
             # Make sure it's in a form we can handle
             bits = f.faultString.split(" ")
             if bits[0] not in ["<type","<class"]:
@@ -165,9 +165,13 @@ class RPCFS(FS):
     @synchronize
     def getmeta(self, meta_name, default=NoDefaultMeta):
         if default is NoDefaultMeta:
-            return self.proxy.getmeta(meta_name)
+            meta = self.proxy.getmeta(meta_name)
         else:
-            return self.proxy.getmeta_default(meta_name, default)    
+            meta = self.proxy.getmeta_default(meta_name, default)
+        if isinstance(meta, basestring):
+            #  To allow transport of meta with invalid xml chars (like null)
+            meta = meta.encode('base64')
+        return meta
 
     @synchronize
     def hasmeta(self, meta_name):

fs/tests/test_archivefs.py

@@ -13,12 +13,20 @@ import shutil
 
 import fs.tests
 from fs.path import *
-from fs.contrib import archivefs
+try:
+    from fs.contrib import archivefs
+except ImportError:
+    libarchive_available = False
+else:
+    libarchive_available = True
+
 
 from six import PY3, b
 
 class TestReadArchiveFS(unittest.TestCase):
 
+    __test__ = libarchive_available
+
     def setUp(self):
         self.temp_filename = "".join(random.choice("abcdefghijklmnopqrstuvwxyz") for _ in range(6))+".zip"
         self.temp_filename = os.path.join(tempfile.gettempdir(), self.temp_filename)

fs/tests/test_expose.py

@@ -24,99 +24,7 @@ from fs.expose.xmlrpc import RPCFSServer
 import six
 from six import PY3, b
 
-class TestRPCFS(unittest.TestCase, FSTestCases, ThreadingTestCases):
-    
-    def makeServer(self,fs,addr):
-        return RPCFSServer(fs,addr,logRequests=False)
-
-    def startServer(self):        
-        port = 3000
-        self.temp_fs = TempFS()
-        self.server = None
-        
-        self.serve_more_requests = True
-        self.server_thread = threading.Thread(target=self.runServer)
-        self.server_thread.setDaemon(True) 
-        
-        self.start_event = threading.Event()
-        self.end_event = threading.Event()
-                   
-        self.server_thread.start()
-        
-        self.start_event.wait()
-
-    def runServer(self):
-        """Run the server, swallowing shutdown-related execptions."""
-        
-        port = 3000
-        while not self.server:
-            try:
-                self.server = self.makeServer(self.temp_fs,("127.0.0.1",port))
-            except socket.error, e:
-                if e.args[1] == "Address already in use":
-                    port += 1
-                else:
-                    raise
-        self.server_addr = ("127.0.0.1", port)
-        
-        self.server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        
-#        if sys.platform != "win32":
-#            try:
-#                self.server.socket.settimeout(1)
-#            except socket.error:
-#                pass
-#        
-        self.start_event.set()
-        
-        try:
-            #self.server.serve_forever()
-            while self.serve_more_requests:
-                self.server.handle_request()
-        except Exception, e:
-            pass
-        
-        self.end_event.set()
-
-    def setUp(self):
-        self.startServer()
-        self.fs = rpcfs.RPCFS("http://%s:%d" % self.server_addr)
-
-    def tearDown(self):
-        self.serve_more_requests = False
-        #self.server.socket.close()
-#            self.server.socket.shutdown(socket.SHUT_RDWR)
-#            self.server.socket.close()
-#            self.temp_fs.close()
-        #self.server_thread.join()
-        
-        #self.end_event.wait()
-        #return
-        
-        try:
-            self.bump()
-            self.server.server_close()
-        except Exception:
-            pass
-        #self.server_thread.join()
-        self.temp_fs.close()
-
-    def bump(self):
-        host, port = self.server_addr
-        for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
-            af, socktype, proto, cn, sa = res
-            sock = None
-            try:
-                sock = socket.socket(af, socktype, proto)
-                sock.settimeout(.1)
-                sock.connect(sa)
-                sock.send(b("\n"))
-            except socket.error, e:
-                pass
-            finally:
-                if sock is not None:
-                    sock.close()
-
+from fs.tests.test_rpcfs import TestRPCFS
 
 try:
     from fs import sftpfs
@@ -135,14 +43,6 @@ class TestSFTPFS(TestRPCFS):
         self.startServer()
         self.fs = sftpfs.SFTPFS(self.server_addr, no_auth=True)
 
-    #def runServer(self):
-    #    self.server.serve_forever()
-    #    
-    #def tearDown(self):
-    #    self.server.shutdown()
-    #    self.server_thread.join()
-    #    self.temp_fs.close()
-
     def bump(self):
         # paramiko doesn't like being bumped, just wait for it to timeout.
         # TODO: do this using a paramiko.Transport() connection

fs/tests/test_rpcfs.py

+
+import unittest
+import sys
+import os, os.path
+import socket
+import threading
+import time
+
+from fs.tests import FSTestCases, ThreadingTestCases
+from fs.tempfs import TempFS
+from fs.osfs import OSFS
+from fs.memoryfs import MemoryFS
+from fs.path import *
+from fs.errors import *
+
+from fs import rpcfs
+from fs.expose.xmlrpc import RPCFSServer
+
+import six
+from six import PY3, b
+
+
+class TestRPCFS(unittest.TestCase, FSTestCases, ThreadingTestCases):
+
+    def makeServer(self,fs,addr):
+        return RPCFSServer(fs,addr,logRequests=False)
+
+    def startServer(self):
+        port = 3000
+        self.temp_fs = TempFS()
+        self.server = None
+
+        self.serve_more_requests = True
+        self.server_thread = threading.Thread(target=self.runServer)
+        self.server_thread.setDaemon(True)
+
+        self.start_event = threading.Event()
+        self.end_event = threading.Event()
+
+        self.server_thread.start()
+
+        self.start_event.wait()
+
+    def runServer(self):
+        """Run the server, swallowing shutdown-related execptions."""
+
+        port = 3000
+        while not self.server:
+            try:
+                self.server = self.makeServer(self.temp_fs,("127.0.0.1",port))
+            except socket.error, e:
+                if e.args[1] == "Address already in use":
+                    port += 1
+                else:
+                    raise
+        self.server_addr = ("127.0.0.1", port)
+
+        self.server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+        self.start_event.set()
+
+        try:
+            #self.server.serve_forever()
+            while self.serve_more_requests:
+                self.server.handle_request()
+        except Exception, e:
+            pass
+
+        self.end_event.set()
+
+    def setUp(self):
+        self.startServer()
+        self.fs = rpcfs.RPCFS("http://%s:%d" % self.server_addr)
+
+    def tearDown(self):
+        self.serve_more_requests = False
+
+        try:
+            self.bump()
+            self.server.server_close()
+        except Exception:
+            pass
+        #self.server_thread.join()
+        self.temp_fs.close()
+
+    def bump(self):
+        host, port = self.server_addr
+        for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
+            af, socktype, proto, cn, sa = res
+            sock = None
+            try:
+                sock = socket.socket(af, socktype, proto)
+                sock.settimeout(.1)
+                sock.connect(sa)
+                sock.send(b("\n"))
+            except socket.error, e:
+                pass
+            finally:
+                if sock is not None:
+                    sock.close()