Merge 2b6e128 into c3e574b

src/allmydata/client.py

@@ -36,7 +36,7 @@
 import allmydata
 from allmydata.crypto import rsa, ed25519
 from allmydata.crypto.util import remove_prefix
-from allmydata.storage.server import StorageServer
+from allmydata.storage.server import StorageServer, FoolscapStorageServer
 from allmydata import storage_client
 from allmydata.immutable.upload import Uploader
 from allmydata.immutable.offloaded import Helper
@@ -834,7 +834,7 @@ def init_storage(self, announceable_storage_servers):
 
         if anonymous_storage_enabled(self.config):
             furl_file = self.config.get_private_path("storage.furl").encode(get_filesystem_encoding())
-            furl = self.tub.registerReference(ss, furlFile=furl_file)
+            furl = self.tub.registerReference(FoolscapStorageServer(ss), furlFile=furl_file)
             announcement["anonymous-storage-FURL"] = furl
 
         enabled_storage_servers = self._enable_storage_servers(

src/allmydata/storage/http_server.py

@@ -91,4 +91,4 @@ def _cbor(self, request, data):
 
     @_authorized_route(_app, "/v1/version", methods=["GET"])
     def version(self, request, authorization):
-        return self._cbor(request, self._storage_server.remote_get_version())
+        return self._cbor(request, self._storage_server.get_version())

src/allmydata/storage/immutable.py

@@ -352,8 +352,10 @@ def cancel_lease(self, cancel_secret):
         return space_freed
 
 
-@implementer(RIBucketWriter)
-class BucketWriter(Referenceable):  # type: ignore # warner/foolscap#78
+class BucketWriter(object):
+    """
+    Keep track of the process of writing to a ShareFile.
+    """
 
     def __init__(self, ss, incominghome, finalhome, max_size, lease_info, clock):
         self.ss = ss
@@ -373,7 +375,7 @@ def __init__(self, ss, incominghome, finalhome, max_size, lease_info, clock):
     def allocated_size(self):
         return self._max_size
 
-    def remote_write(self, offset, data):
+    def write(self, offset, data):
         # Delay the timeout, since we received data:
         self._timeout.reset(30 * 60)
         start = self._clock.seconds()
@@ -397,9 +399,6 @@ def remote_write(self, offset, data):
         self.ss.add_latency("write", self._clock.seconds() - start)
         self.ss.count("write")
 
-    def remote_close(self):
-        self.close()
-
     def close(self):
         precondition(not self.closed)
         self._timeout.cancel()
@@ -451,13 +450,10 @@ def _abort_due_to_timeout(self):
                 facility="tahoe.storage", level=log.UNUSUAL)
         self.abort()
 
-    def remote_abort(self):
+    def abort(self):
         log.msg("storage: aborting sharefile %s" % self.incominghome,
                 facility="tahoe.storage", level=log.UNUSUAL)
-        self.abort()
         self.ss.count("abort")
-
-    def abort(self):
         if self.closed:
             return
 
@@ -480,8 +476,28 @@ def abort(self):
             self._timeout.cancel()
 
 
-@implementer(RIBucketReader)
-class BucketReader(Referenceable):  # type: ignore # warner/foolscap#78
+@implementer(RIBucketWriter)
+class FoolscapBucketWriter(Referenceable):  # type: ignore # warner/foolscap#78
+    """
+    Foolscap-specific BucketWriter.
+    """
+    def __init__(self, bucket_writer):
+        self._bucket_writer = bucket_writer
+
+    def remote_write(self, offset, data):
+        return self._bucket_writer.write(offset, data)
+
+    def remote_close(self):
+        return self._bucket_writer.close()
+
+    def remote_abort(self):
+        return self._bucket_writer.abort()
+
+
+class BucketReader(object):
+    """
+    Manage the process for reading from a ``ShareFile``.
+    """
 
     def __init__(self, ss, sharefname, storage_index=None, shnum=None):
         self.ss = ss
@@ -496,15 +512,31 @@ def __repr__(self):
                                ),
                                self.shnum)
 
-    def remote_read(self, offset, length):
+    def read(self, offset, length):
         start = time.time()
         data = self._share_file.read_share_data(offset, length)
         self.ss.add_latency("read", time.time() - start)
         self.ss.count("read")
         return data
 
+    def advise_corrupt_share(self, reason):
+        return self.ss.advise_corrupt_share(b"immutable",
+                                            self.storage_index,
+                                            self.shnum,
+                                            reason)
+
+
+@implementer(RIBucketReader)
+class FoolscapBucketReader(Referenceable):  # type: ignore # warner/foolscap#78
+    """
+    Foolscap wrapper for ``BucketReader``
+    """
+
+    def __init__(self, bucket_reader):
+        self._bucket_reader = bucket_reader
+
+    def remote_read(self, offset, length):
+        return self._bucket_reader.read(offset, length)
+
     def remote_advise_corrupt_share(self, reason):
-        return self.ss.remote_advise_corrupt_share(b"immutable",
-                                                   self.storage_index,
-                                                   self.shnum,
-                                                   reason)
+        return self._bucket_reader.advise_corrupt_share(reason)