def changeSize(self, size):
assert len(self.mask) == 0
self.file.seek(size - 1)
assert self.file.read(1) == ''
self.file.write("\x00")
chunkCount = countChunks(size)
self.mask = bits.BitArray(size=chunkCount)
self.writeMaskFile()
def command_GET(self, name, mask=None):
peer = self.transport.getQ2QPeer()
tl = self.nexus.transloads[name]
size = tl.getSize()
if mask is None:
# all zeroes!
mask = bits.BitArray(size=countChunks(size))
# retrieve persistent scoring and such?
tl.updatePeerMask(peer, mask)
peerK = tl.peers[peer]
if (not peerK.sentGet) and peerK.mask.any(0):
# send a reciprocal GET
self.get(name, tl.mask)
return dict(size=size)
def __init__(self,
authority,
nexus,
name,
incompletePath,
fullPath,
ui,
seed=False):
"""
Create a Transload.
@param authority: the q2q address of the first authority on this file.
"""
self.incompletePath = incompletePath
self.fullPath = fullPath
self.ui = ui
self.authorities = [authority
] # q2q address(es) that you send VERIFYs to
self.seed = seed
if not seed:
self.file = openReadWrite(incompletePath.path)
else:
self.file = fullPath.open()
chunkCount = countChunks(self.getSize())
mask = bits.BitArray(size=chunkCount, default=int(seed))
if seed:
maskfile = None
else:
maskfile = openMaskFile(incompletePath.path)
self.mask = mask # BitArray object representing which chunks of
# the file I've got
self.maskfile = maskfile # ugh - open file object that keeps a record
# of the bitmask
self.sha1sums = {} # map {chunk-number: sha1sum}
self.nexus = nexus # Nexus instance that I belong to
self.name = name # the name of the file object being
# transferred.
self.changes = 0 # the number of mask changes since the last update
self.peers = {} # map {q2q address: [PeerKnowledge]}
# We want to retransmit GET every so often
self.call = self.nexus.callLater(0.002, self.maybeUpdateMask)
def command_INTRODUCE(self, peer, name):
# Like a PUT, really, but assuming the transload is already
# established.
self.nexus.ui.receivedIntroduction(peer, name)
t = self.nexus.transloads[name]
if peer in t.peers:
return {}
# all bits are set until he responds that he wants something.
t.updatePeerMask(peer, bits.BitArray(default=1, size=len(t.mask)))
self.nexus.connectPeer(peer).addCallback(
lambda peerProto: peerProto.get(name, t.mask))
return {}
def get(self, name, mask=None):
"""
Issue a GET command
Return a Deferred which fires with the size of the name being requested
"""
mypeer = self.transport.getQ2QPeer()
tl = self.nexus.transloads[name]
peerz = tl.peers
if mypeer in peerz:
peerk = peerz[mypeer]
else:
# all turned on initially; we aren't going to send them anything.
peerk = PeerKnowledge(bits.BitArray(size=len(tl.mask), default=1))
peerz[mypeer] = peerk
peerk.sentGet = True
return Get(name=name,
mask=mask).do(self).addCallback(lambda r: r['size'])
def __init__(self, nexusUI, name, sender):
self.name = name
self.sender = sender
self.nexusUI = nexusUI
self.masks = {}
self.bits = bits.BitArray()
def fromString(self, st):
size, bytes = st.split(":", 1)
b = array.array("B")
b.fromstring(bytes)
return bits.BitArray(b, int(size))