Revert removal of length in IStorageServer.

docs/proposed/http-storage-node-protocol.rst

@@ -599,6 +599,7 @@ For example::
            0: {
                "test": [{
                    "offset": 3,
+                   "size": 5,
                    "specimen": "hello"
                }, ...],
                "write": [{
@@ -699,7 +700,10 @@ Immutable Data
 Mutable Data
 ~~~~~~~~~~~~
 
-1. Create mutable share number ``3`` with ``10`` bytes of data in slot ``BBBBBBBBBBBBBBBB``::
+1. Create mutable share number ``3`` with ``10`` bytes of data in slot ``BBBBBBBBBBBBBBBB``.
+The special test vector of size 1 but empty bytes will only pass
+if there is no existing share,
+otherwise it will read a byte which won't match `b""`::
 
      POST /v1/mutable/BBBBBBBBBBBBBBBB/read-test-write
      {
@@ -710,7 +714,11 @@ Mutable Data
          },
          "test-write-vectors": {
              3: {
-                 "test": [],
+                 "test": [{
+                     "offset": 0,
+                     "size": 1,
+                     "specimen": ""
+                 }],
                  "write": [{
                      "offset": 0,
                      "data": "xxxxxxxxxx"
@@ -740,6 +748,7 @@ Mutable Data
              3: {
                  "test": [{
                      "offset": 0,
+                     "size": <length of checkstring>,
                      "specimen": "<checkstring>"
                  }],
                  "write": [{

src/allmydata/interfaces.py

@@ -91,8 +91,9 @@ class RIBucketReader(RemoteInterface):
 
 TestVector = ListOf(TupleOf(Offset, ReadSize, bytes, bytes))
 # elements are (offset, length, operator, specimen)
-# operator must be b"eq", you should use length==len(specimen).
+# operator must be b"eq", typically length==len(specimen), but one can ensure
-# (These are only used for wire compatibility with old versions).
+# writes don't happen to empty shares by setting length to 1 and specimen to
+# b"". The operator is still used for wire compatibility with old versions.
 DataVector = ListOf(TupleOf(Offset, ShareData))
 # (offset, data). This limits us to 30 writes of 1MiB each per call
 TestAndWriteVectorsForShares = DictOf(int,
@@ -353,7 +354,7 @@ class IStorageServer(Interface):
 
         While the interface mostly matches, test vectors are simplified.
         Instead of a tuple ``(start, offset, operator, data)`` they are just
-        ``(start, data)`` with operator implicitly being ``b"eq"``.
+        ``(start, data_length, data)`` with operator implicitly being ``b"eq"``.
         """
 
     def advise_corrupt_share(

src/allmydata/mutable/layout.py

@@ -309,7 +309,7 @@ class SDMFSlotWriteProxy(object):
                                       salt)
         else:
             checkstring = checkstring_or_seqnum
-        self._testvs = [(0, checkstring)]
+        self._testvs = [(0, len(checkstring), checkstring)]
 
 
     def get_checkstring(self):
@@ -318,7 +318,7 @@ class SDMFSlotWriteProxy(object):
         server.
         """
         if self._testvs:
-            return self._testvs[0][1]
+            return self._testvs[0][2]
         return b""
 
 
@@ -548,9 +548,9 @@ class SDMFSlotWriteProxy(object):
         if not self._testvs:
             # Our caller has not provided us with another checkstring
             # yet, so we assume that we are writing a new share, and set
-            # a test vector that will allow a new share to be written.
+            # a test vector that will only allow a new share to be written.
             self._testvs = []
-            self._testvs.append(tuple([0, b""]))
+            self._testvs.append(tuple([0, 1, b""]))
 
         tw_vectors = {}
         tw_vectors[self.shnum] = (self._testvs, datavs, None)
@@ -889,7 +889,7 @@ class MDMFSlotWriteProxy(object):
             self._testvs = []
         else:
             self._testvs = []
-            self._testvs.append((0, checkstring))
+            self._testvs.append((0, len(checkstring), checkstring))
 
 
     def __repr__(self):
@@ -1161,8 +1161,10 @@ class MDMFSlotWriteProxy(object):
         """I write the data vectors in datavs to the remote slot."""
         tw_vectors = {}
         if not self._testvs:
+            # Make sure we will only successfully write if the share didn't
+            # previously exist.
             self._testvs = []
-            self._testvs.append(tuple([0, b""]))
+            self._testvs.append(tuple([0, 1, b""]))
         if not self._written:
             # Write a new checkstring to the share when we write it, so
             # that we have something to check later.
@@ -1170,7 +1172,7 @@ class MDMFSlotWriteProxy(object):
             datavs.append((0, new_checkstring))
             def _first_write():
                 self._written = True
-                self._testvs = [(0, new_checkstring)]
+                self._testvs = [(0, len(new_checkstring), new_checkstring)]
             on_success = _first_write
         tw_vectors[self.shnum] = (self._testvs, datavs, None)
         d = self._storage_server.slot_testv_and_readv_and_writev(

src/allmydata/storage_client.py

@@ -997,7 +997,7 @@ class _StorageServer(object):
         # Match the wire protocol, which requires 4-tuples for test vectors.
         wire_format_tw_vectors = {
             key: (
-                [(start, len(data), b"eq", data) for (start, data) in value[0]],
+                [(start, length, b"eq", data) for (start, length, data) in value[0]],
                 value[1],
                 value[2],
             ) for (key, value) in tw_vectors.items()