def __init__(self, storage_index, helper, storage_broker, secret_holder,
incoming_file, encoding_file, log_number):
upload.CHKUploader.__init__(self, storage_broker, secret_holder)
self._storage_index = storage_index
self._helper = helper
self._incoming_file = incoming_file
self._encoding_file = encoding_file
self._upload_id = si_b2a(storage_index)[:5]
self._log_number = log_number
self._upload_status = upload.UploadStatus()
self._upload_status.set_helper(False)
self._upload_status.set_storage_index(storage_index)
self._upload_status.set_status("fetching ciphertext")
self._upload_status.set_progress(0, 1.0)
self._helper.log("CHKUploadHelper starting for SI %r" %
self._upload_id,
parent=log_number)
self._storage_broker = storage_broker
self._secret_holder = secret_holder
self._fetcher = CHKCiphertextFetcher(self, incoming_file,
encoding_file, self._log_number)
self._reader = LocalCiphertextReader(self, storage_index,
encoding_file)
self._finished_observers = observer.OneShotObserverList()
self._started = time.time()
d = self._fetcher.when_done()
d.addCallback(lambda res: self._reader.start())
d.addCallback(lambda res: self.start_encrypted(self._reader))
d.addCallback(self._finished)
d.addErrback(self._failed)
def __init__(self, rref, server, storage_index):
self._rref = rref
self._server = server
self._storage_index = storage_index
self._started = False # sent request to server
self._ready = observer.OneShotObserverList(
) # got response from server
def __init__(self, rref, peerid, storage_index):
self._rref = rref
self._peerid = peerid
peer_id_s = idlib.shortnodeid_b2a(peerid)
storage_index_s = si_b2a(storage_index)
self._reprstr = "<ReadBucketProxy %s to peer [%s] SI %s>" % (id(self), peer_id_s, storage_index_s)
self._started = False # sent request to server
self._ready = observer.OneShotObserverList() # got response from server
def test_oneshot_fireagain(self):
ol = observer.OneShotObserverList()
d = ol.when_fired()
def _addmore(res):
self.failUnlessEqual(res, "result")
ol.fire_if_not_fired("result3") # should be ignored
d2 = ol.when_fired()
d2.addCallback(self.failUnlessEqual, "result")
return d2
d.addCallback(_addmore)
ol.fire_if_not_fired("result")
ol.fire_if_not_fired("result2")
return d
def __init__(self, helper, incoming_file, encoded_file, logparent):
self._upload_helper = helper
self._incoming_file = incoming_file
self._encoding_file = encoded_file
self._upload_id = helper._upload_id
self._log_parent = logparent
self._done_observers = observer.OneShotObserverList()
self._readers = []
self._started = False
self._f = None
self._times = {
"cumulative_fetch": 0.0,
"total": 0.0,
}
self._ciphertext_fetched = 0
def test_oneshot(self):
ol = observer.OneShotObserverList()
rep = repr(ol)
self.failUnlessEqual(rep, "<OneShotObserverList [[]]>")
d1 = ol.when_fired()
d2 = ol.when_fired()
def _addmore(res):
self.failUnlessEqual(res, "result")
d3 = ol.when_fired()
d3.addCallback(self.failUnlessEqual, "result")
return d3
d1.addCallback(_addmore)
ol.fire("result")
rep = repr(ol)
self.failUnlessEqual(rep, "<OneShotObserverList -> result>")
d4 = ol.when_fired()
dl = defer.DeferredList([d1,d2,d4])
return dl
def __init__(self, basedir=u"."):
service.MultiService.__init__(self)
self.basedir = abspath_expanduser_unicode(unicode(basedir))
self._portnumfile = os.path.join(self.basedir, self.PORTNUMFILE)
self._tub_ready_observerlist = observer.OneShotObserverList()
fileutil.make_dirs(os.path.join(self.basedir, "private"), 0700)
open(os.path.join(self.basedir, "private", "README"), "w").write(PRIV_README)
# creates self.config
self.read_config()
nickname_utf8 = self.get_config("node", "nickname", "<unspecified>")
self.nickname = nickname_utf8.decode("utf-8")
assert type(self.nickname) is unicode
self.init_tempdir()
self.create_tub()
self.logSource="Node"
self.setup_ssh()
self.setup_logging()
self.log("Node constructed. " + get_package_versions_string())
iputil.increase_rlimits()
def __init__(self, verifycap, storage_broker, secret_holder,
terminator, history, download_status):
assert isinstance(verifycap, uri.CHKFileVerifierURI)
self._verifycap = verifycap
self._storage_broker = storage_broker
self._si_prefix = base32.b2a(verifycap.storage_index[:8])[:12]
self.running = True
if terminator:
terminator.register(self) # calls self.stop() at stopService()
# the rules are:
# 1: Only send network requests if you're active (self.running is True)
# 2: Use TimerService, not reactor.callLater
# 3: You can do eventual-sends any time.
# These rules should mean that once
# stopService()+flushEventualQueue() fires, everything will be done.
self._secret_holder = secret_holder
self._history = history
self._download_status = download_status
self.share_hash_tree = IncompleteHashTree(self._verifycap.total_shares)
# we guess the segment size, so Segmentation can pull non-initial
# segments in a single roundtrip. This populates
# .guessed_segment_size, .guessed_num_segments, and
# .ciphertext_hash_tree (with a dummy, to let us guess which hashes
# we'll need)
self._build_guessed_tables(DEFAULT_MAX_SEGMENT_SIZE)
# filled in when we parse a valid UEB
self.have_UEB = False
self.segment_size = None
self.tail_segment_size = None
self.tail_segment_padded = None
self.num_segments = None
self.block_size = None
self.tail_block_size = None
# things to track callers that want data
# _segment_requests can have duplicates
self._segment_requests = [] # (segnum, d, cancel_handle, seg_ev, lp)
self._active_segment = None # a SegmentFetcher, with .segnum
self._segsize_observers = observer.OneShotObserverList()
# we create one top-level logparent for this _Node, and another one
# for each read() call. Segmentation and get_segment() messages are
# associated with the read() call, everything else is tied to the
# _Node's log entry.
lp = log.msg(format="Immutable.DownloadNode(%(si)s) created:"
" size=%(size)d,"
" guessed_segsize=%(guessed_segsize)d,"
" guessed_numsegs=%(guessed_numsegs)d",
si=self._si_prefix, size=verifycap.size,
guessed_segsize=self.guessed_segment_size,
guessed_numsegs=self.guessed_num_segments,
level=log.OPERATIONAL, umid="uJ0zAQ")
self._lp = lp
self._sharefinder = ShareFinder(storage_broker, verifycap, self,
self._download_status, lp)
self._shares = set()
def __init__(self):
self.cancelled = False
self.finished = False
self.status = None
self.observer = observer.OneShotObserverList()