ExternalVendorCode/tahoe-lafs
1
0
Fork 0
mirror of https://github.com/tahoe-lafs/tahoe-lafs.git synced 2025-03-21 03:15:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

test_system.py: remove that ugly debug_stash_RemoteencryptedUploadable hack, now that UploadResults give us a better approach

Browse Source
This commit is contained in:
Brian Warner 2008-02-07 17:27:30 -07:00
parent c7b10f4498
commit 3bd79917b2
2 changed files with 22 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/allmydata/test/test_system.py
View File

@ -32,6 +32,13 @@ This is some data to publish to the virtual drive, which needs to be large
enough to not fit inside a LIT uri.
"""
class CountingDataUploadable(upload.Data):
bytes_read = 0
def read(self, length):
self.bytes_read += length
return upload.Data.read(self, length)
class SystemTest(testutil.SignalMixin, testutil.PollMixin, unittest.TestCase):
def setUp(self):
@ -325,13 +332,12 @@ class SystemTest(testutil.SignalMixin, testutil.PollMixin, unittest.TestCase):
def _upload_resumable(res):
DATA = "Data that needs help to upload and gets interrupted" * 1000
u1 = upload.Data(DATA, contenthashkey=contenthashkey)
u2 = upload.Data(DATA, contenthashkey=contenthashkey)
u1 = CountingDataUploadable(DATA, contenthashkey=contenthashkey)
u2 = CountingDataUploadable(DATA, contenthashkey=contenthashkey)
# tell the upload to drop the connection after about 5kB
u1.debug_interrupt = 5000
u1.debug_stash_RemoteEncryptedUploadable = True
u2.debug_stash_RemoteEncryptedUploadable = True
# sneak into the helper and reduce its chunk size, so that our
# debug_interrupt will sever the connection on about the fifth
# chunk fetched. This makes sure that we've started to write the
@ -348,12 +354,13 @@ class SystemTest(testutil.SignalMixin, testutil.PollMixin, unittest.TestCase):
" with result %s" % (res,))
def _interrupted(f):
f.trap(ConnectionLost, ConnectionDone, DeadReferenceError)
reu = u1.debug_RemoteEncryptedUploadable
# make sure we actually interrupted it before finishing the
# file
self.failUnless(reu._bytes_sent < len(DATA),
"read %d out of %d total" % (reu._bytes_sent,
self.failUnless(u1.bytes_read < len(DATA),
"read %d out of %d total" % (u1.bytes_read,
len(DATA)))
log.msg("waiting for reconnect", level=log.NOISY,
facility="tahoe.test.test_system")
# now, we need to give the nodes a chance to notice that this
@ -397,7 +404,10 @@ class SystemTest(testutil.SignalMixin, testutil.PollMixin, unittest.TestCase):
uri = results.uri
log.msg("Second upload complete", level=log.NOISY,
facility="tahoe.test.test_system")
reu = u2.debug_RemoteEncryptedUploadable
# this is really bytes received rather than sent, but it's
# convenient and basically measures the same thing
bytes_sent = results.ciphertext_fetched
# We currently don't support resumption of upload if the data is
# encrypted with a random key. (Because that would require us
@ -407,18 +417,18 @@ class SystemTest(testutil.SignalMixin, testutil.PollMixin, unittest.TestCase):
if contenthashkey:
# Make sure we did not have to read the whole file the
# second time around .
self.failUnless(reu._bytes_sent < len(DATA),
self.failUnless(bytes_sent < len(DATA),
"resumption didn't save us any work:"
" read %d bytes out of %d total" %
(reu._bytes_sent, len(DATA)))
(bytes_sent, len(DATA)))
else:
# Make sure we did have to read the whole file the second
# time around -- because the one that we partially uploaded
# earlier was encrypted with a different random key.
self.failIf(reu._bytes_sent < len(DATA),
self.failIf(bytes_sent < len(DATA),
"resumption saved us some work even though we were using random keys:"
" read %d bytes out of %d total" %
(reu._bytes_sent, len(DATA)))
(bytes_sent, len(DATA)))
return self.downloader.download_to_data(uri)
d.addCallback(_uploaded)

10
src/allmydata/upload.py
View File

@ -840,16 +840,6 @@ class AssistedUploader:
# we have unit tests which want to interrupt the upload so they
# can exercise resumability. They indicate this by adding debug_
# attributes to the Uploadable.
if hasattr(self._encuploadable.original,
"debug_stash_RemoteEncryptedUploadable"):
# we communicate back to them the same way. This may look
# weird, but, well, ok, it is. However, it is better than the
# barrage of options={} dictionaries that were flying around
# before. We could also do this by setting attributes on the
# class, but that doesn't make it easy to undo when we're
# done. TODO: find a cleaner way, maybe just a small options=
# dict somewhere.
self._encuploadable.original.debug_RemoteEncryptedUploadable = reu
if hasattr(self._encuploadable.original, "debug_interrupt"):
reu._cutoff = self._encuploadable.original.debug_interrupt
def _cutoff():