def _convert(r):
file_size = r.get_file_size()
time1 = r.get_timings().get("cumulative_encoding")
time2 = r.get_timings().get("cumulative_sending")
if (time1 is None or time2 is None):
return None
else:
return compute_rate(file_size, time1 + time2)
def _convert(r):
file_size = r.get_file_size()
time1 = r.get_timings().get("cumulative_encoding")
time2 = r.get_timings().get("cumulative_sending")
if (time1 is None or time2 is None):
return None
else:
return compute_rate(file_size, time1+time2)
def _convert(r):
file_size = r.file_size
time1 = r.timings.get("cumulative_encoding")
time2 = r.timings.get("cumulative_sending")
if time1 is None or time2 is None:
return None
else:
return compute_rate(file_size, time1 + time2)
def test_compute_rate(self):
self.failUnlessReallyEqual(common.compute_rate(None, None), None)
self.failUnlessReallyEqual(common.compute_rate(None, 1), None)
self.failUnlessReallyEqual(common.compute_rate(250000, None), None)
self.failUnlessReallyEqual(common.compute_rate(250000, 0), None)
self.failUnlessReallyEqual(common.compute_rate(250000, 10), 25000.0)
self.failUnlessReallyEqual(common.compute_rate(0, 10), 0.0)
self.shouldFail(AssertionError, "test_compute_rate", "",
common.compute_rate, -100, 10)
self.shouldFail(AssertionError, "test_compute_rate", "",
common.compute_rate, 100, -10)
# Sanity check
rate = common.compute_rate(10*1000*1000, 1)
self.failUnlessReallyEqual(common.abbreviate_rate(rate), "10.00MBps")
def _get_rate(self, data, name):
file_size = self.retrieve_status.get_size()
time = self.retrieve_status.timings.get(name)
return compute_rate(file_size, time)
def _convert(r):
file_size = r.get_file_size()
duration = r.get_timings().get(name)
return compute_rate(file_size, duration)
def _get_rate(self, data, name):
file_size = self.publish_status.get_size()
time = self.publish_status.timings.get(name)
return compute_rate(file_size, time)
def render_events(self, ctx, data):
if not self.download_status.storage_index:
return
srt = self.short_relative_time
l = T.div()
t = T.table(align="left", class_="status-download-events")
t[T.tr[T.th["serverid"], T.th["sent"], T.th["received"],
T.th["shnums"], T.th["RTT"]]]
for d_ev in self.download_status.dyhb_requests:
server = d_ev["server"]
sent = d_ev["start_time"]
shnums = d_ev["response_shnums"]
received = d_ev["finish_time"]
rtt = None
if received is not None:
rtt = received - sent
if not shnums:
shnums = ["-"]
t[T.tr(style="background: %s" % self.color(server))[
[T.td[server.get_name()], T.td[srt(sent)], T.td[srt(received)],
T.td[",".join([str(shnum) for shnum in shnums])],
T.td[self.render_time(None, rtt)],
]]]
l[T.h2["DYHB Requests:"], t]
l[T.br(clear="all")]
t = T.table(align="left",class_="status-download-events")
t[T.tr[T.th["range"], T.th["start"], T.th["finish"], T.th["got"],
T.th["time"], T.th["decrypttime"], T.th["pausedtime"],
T.th["speed"]]]
for r_ev in self.download_status.read_events:
start = r_ev["start"]
length = r_ev["length"]
bytes = r_ev["bytes_returned"]
decrypt_time = ""
if bytes:
decrypt_time = self._rate_and_time(bytes, r_ev["decrypt_time"])
speed, rtt = "",""
if r_ev["finish_time"] is not None:
rtt = r_ev["finish_time"] - r_ev["start_time"] - r_ev["paused_time"]
speed = self.render_rate(None, compute_rate(bytes, rtt))
rtt = self.render_time(None, rtt)
paused = self.render_time(None, r_ev["paused_time"])
t[T.tr[T.td["[%d:+%d]" % (start, length)],
T.td[srt(r_ev["start_time"])], T.td[srt(r_ev["finish_time"])],
T.td[bytes], T.td[rtt],
T.td[decrypt_time], T.td[paused],
T.td[speed],
]]
l[T.h2["Read Events:"], t]
l[T.br(clear="all")]
t = T.table(align="left",class_="status-download-events")
t[T.tr[T.th["segnum"], T.th["start"], T.th["active"], T.th["finish"],
T.th["range"],
T.th["decodetime"], T.th["segtime"], T.th["speed"]]]
for s_ev in self.download_status.segment_events:
range_s = "-"
segtime_s = "-"
speed = "-"
decode_time = "-"
if s_ev["finish_time"] is not None:
if s_ev["success"]:
segtime = s_ev["finish_time"] - s_ev["active_time"]
segtime_s = self.render_time(None, segtime)
seglen = s_ev["segment_length"]
range_s = "[%d:+%d]" % (s_ev["segment_start"], seglen)
speed = self.render_rate(None, compute_rate(seglen, segtime))
decode_time = self._rate_and_time(seglen, s_ev["decode_time"])
else:
# error
range_s = "error"
else:
# not finished yet
pass
t[T.tr[T.td["seg%d" % s_ev["segment_number"]],
T.td[srt(s_ev["start_time"])],
T.td[srt(s_ev["active_time"])],
T.td[srt(s_ev["finish_time"])],
T.td[range_s],
T.td[decode_time],
T.td[segtime_s], T.td[speed]]]
l[T.h2["Segment Events:"], t]
l[T.br(clear="all")]
t = T.table(align="left",class_="status-download-events")
t[T.tr[T.th["serverid"], T.th["shnum"], T.th["range"],
T.th["txtime"], T.th["rxtime"],
T.th["received"], T.th["RTT"]]]
for r_ev in self.download_status.block_requests:
server = r_ev["server"]
rtt = None
if r_ev["finish_time"] is not None:
rtt = r_ev["finish_time"] - r_ev["start_time"]
color = self.color(server)
t[T.tr(style="background: %s" % color)[
T.td[server.get_name()], T.td[r_ev["shnum"]],
T.td["[%d:+%d]" % (r_ev["start"], r_ev["length"])],
T.td[srt(r_ev["start_time"])], T.td[srt(r_ev["finish_time"])],
T.td[r_ev["response_length"] or ""],
T.td[self.render_time(None, rtt)],
]]
l[T.h2["Requests:"], t]
l[T.br(clear="all")]
return l
def _convert(r):
file_size = r.file_size
time = r.timings.get(name)
return compute_rate(file_size, time)
def _convert(r):
fetch_size = r.get_ciphertext_fetched()
time = r.get_timings().get("cumulative_fetch")
return compute_rate(fetch_size, time)
def _convert(r):
file_size = r.file_size
duration = r.timings.get(name)
return compute_rate(file_size, duration)
def render_events(self, ctx, data):
if not self.download_status.storage_index:
return
srt = self.short_relative_time
l = T.div()
t = T.table(align="left", class_="status-download-events")
t[T.tr[T.th["serverid"], T.th["sent"], T.th["received"],
T.th["shnums"], T.th["RTT"]]]
for d_ev in self.download_status.dyhb_requests:
server = d_ev["server"]
sent = d_ev["start_time"]
shnums = d_ev["response_shnums"]
received = d_ev["finish_time"]
rtt = None
if received is not None:
rtt = received - sent
if not shnums:
shnums = ["-"]
t[T.tr(style="background: %s" % self.color(server))[[
T.td[server.get_name()],
T.td[srt(sent)],
T.td[srt(received)],
T.td[",".join([str(shnum) for shnum in shnums])],
T.td[self.render_time(None, rtt)],
]]]
l[T.h2["DYHB Requests:"], t]
l[T.br(clear="all")]
t = T.table(align="left", class_="status-download-events")
t[T.tr[T.th["range"], T.th["start"], T.th["finish"], T.th["got"],
T.th["time"], T.th["decrypttime"], T.th["pausedtime"],
T.th["speed"]]]
for r_ev in self.download_status.read_events:
start = r_ev["start"]
length = r_ev["length"]
bytes = r_ev["bytes_returned"]
decrypt_time = ""
if bytes:
decrypt_time = self._rate_and_time(bytes, r_ev["decrypt_time"])
speed, rtt = "", ""
if r_ev["finish_time"] is not None:
rtt = r_ev["finish_time"] - r_ev["start_time"] - r_ev[
"paused_time"]
speed = self.render_rate(None, compute_rate(bytes, rtt))
rtt = self.render_time(None, rtt)
paused = self.render_time(None, r_ev["paused_time"])
t[T.tr[T.td["[%d:+%d]" % (start, length)],
T.td[srt(r_ev["start_time"])],
T.td[srt(r_ev["finish_time"])], T.td[bytes], T.td[rtt],
T.td[decrypt_time], T.td[paused], T.td[speed], ]]
l[T.h2["Read Events:"], t]
l[T.br(clear="all")]
t = T.table(align="left", class_="status-download-events")
t[T.tr[T.th["segnum"], T.th["start"], T.th["active"], T.th["finish"],
T.th["range"], T.th["decodetime"], T.th["segtime"],
T.th["speed"]]]
for s_ev in self.download_status.segment_events:
range_s = "-"
segtime_s = "-"
speed = "-"
decode_time = "-"
if s_ev["finish_time"] is not None:
if s_ev["success"]:
segtime = s_ev["finish_time"] - s_ev["active_time"]
segtime_s = self.render_time(None, segtime)
seglen = s_ev["segment_length"]
range_s = "[%d:+%d]" % (s_ev["segment_start"], seglen)
speed = self.render_rate(None,
compute_rate(seglen, segtime))
decode_time = self._rate_and_time(seglen,
s_ev["decode_time"])
else:
# error
range_s = "error"
else:
# not finished yet
pass
t[T.tr[T.td["seg%d" % s_ev["segment_number"]],
T.td[srt(s_ev["start_time"])],
T.td[srt(s_ev["active_time"])],
T.td[srt(s_ev["finish_time"])], T.td[range_s],
T.td[decode_time], T.td[segtime_s], T.td[speed]]]
l[T.h2["Segment Events:"], t]
l[T.br(clear="all")]
t = T.table(align="left", class_="status-download-events")
t[T.tr[T.th["serverid"], T.th["shnum"], T.th["range"], T.th["txtime"],
T.th["rxtime"], T.th["received"], T.th["RTT"]]]
for r_ev in self.download_status.block_requests:
server = r_ev["server"]
rtt = None
if r_ev["finish_time"] is not None:
rtt = r_ev["finish_time"] - r_ev["start_time"]
color = self.color(server)
t[T.tr(style="background: %s" %
color)[T.td[server.get_name()], T.td[r_ev["shnum"]],
T.td["[%d:+%d]" % (r_ev["start"], r_ev["length"])],
T.td[srt(r_ev["start_time"])],
T.td[srt(r_ev["finish_time"])],
T.td[r_ev["response_length"]
or ""], T.td[self.render_time(None, rtt)], ]]
l[T.h2["Requests:"], t]
l[T.br(clear="all")]
return l
def _convert(r):
fetch_size = r.get_ciphertext_fetched()
duration = r.get_timings().get("cumulative_fetch")
return compute_rate(fetch_size, duration)
def _convert(r):
file_size = r.file_size
time = r.timings.get(name)
return compute_rate(file_size, time)
def _convert(r):
fetch_size = r.ciphertext_fetched
time = r.timings.get("cumulative_fetch")
return compute_rate(fetch_size, time)
def render_events(self, ctx, data):
if not self.download_status.storage_index:
return
srt = self.short_relative_time
l = T.ul()
t = T.table(class_="status-download-events")
t[T.tr[T.td["serverid"], T.td["sent"], T.td["received"],
T.td["shnums"], T.td["RTT"]]]
dyhb_events = []
for serverid,requests in self.download_status.dyhb_requests.iteritems():
for req in requests:
dyhb_events.append( (serverid,) + req )
dyhb_events.sort(key=lambda req: req[1])
for d_ev in dyhb_events:
(serverid, sent, shnums, received) = d_ev
serverid_s = idlib.shortnodeid_b2a(serverid)
rtt = None
if received is not None:
rtt = received - sent
if not shnums:
shnums = []
t[T.tr(style="background: %s" % self.color(serverid))[
[T.td[serverid_s], T.td[srt(sent)], T.td[srt(received)],
T.td[",".join([str(shnum) for shnum in shnums])],
T.td[self.render_time(None, rtt)],
]]]
l["DYHB Requests:", t]
t = T.table(class_="status-download-events")
t[T.tr[T.td["range"], T.td["start"], T.td["finish"], T.td["got"],
T.td["time"], T.td["decrypttime"], T.td["pausedtime"],
T.td["speed"]]]
for r_ev in self.download_status.read_events:
(start, length, requesttime, finishtime, bytes, decrypt, paused) = r_ev
if finishtime is not None:
rtt = finishtime - requesttime - paused
speed = self.render_rate(None, compute_rate(bytes, rtt))
rtt = self.render_time(None, rtt)
decrypt = self.render_time(None, decrypt)
paused = self.render_time(None, paused)
else:
speed, rtt, decrypt, paused = "","","",""
t[T.tr[T.td["[%d:+%d]" % (start, length)],
T.td[srt(requesttime)], T.td[srt(finishtime)],
T.td[bytes], T.td[rtt], T.td[decrypt], T.td[paused],
T.td[speed],
]]
l["Read Events:", t]
t = T.table(class_="status-download-events")
t[T.tr[T.td["type"], T.td["segnum"], T.td["when"], T.td["range"],
T.td["decodetime"], T.td["segtime"], T.td["speed"]]]
reqtime = (None, None)
for s_ev in self.download_status.segment_events:
(etype, segnum, when, segstart, seglen, decodetime) = s_ev
if etype == "request":
t[T.tr[T.td["request"], T.td["seg%d" % segnum],
T.td[srt(when)]]]
reqtime = (segnum, when)
elif etype == "delivery":
if reqtime[0] == segnum:
segtime = when - reqtime[1]
speed = self.render_rate(None, compute_rate(seglen, segtime))
segtime = self.render_time(None, segtime)
else:
segtime, speed = "", ""
t[T.tr[T.td["delivery"], T.td["seg%d" % segnum],
T.td[srt(when)],
T.td["[%d:+%d]" % (segstart, seglen)],
T.td[self.render_time(None,decodetime)],
T.td[segtime], T.td[speed]]]
elif etype == "error":
t[T.tr[T.td["error"], T.td["seg%d" % segnum]]]
l["Segment Events:", t]
t = T.table(border="1")
t[T.tr[T.td["serverid"], T.td["shnum"], T.td["range"],
T.td["txtime"], T.td["rxtime"], T.td["received"], T.td["RTT"]]]
reqtime = (None, None)
request_events = []
for serverid,requests in self.download_status.requests.iteritems():
for req in requests:
request_events.append( (serverid,) + req )
request_events.sort(key=lambda req: (req[4],req[1]))
for r_ev in request_events:
(peerid, shnum, start, length, sent, receivedlen, received) = r_ev
rtt = None
if received is not None:
rtt = received - sent
peerid_s = idlib.shortnodeid_b2a(peerid)
t[T.tr(style="background: %s" % self.color(peerid))[
T.td[peerid_s], T.td[shnum],
T.td["[%d:+%d]" % (start, length)],
T.td[srt(sent)], T.td[srt(received)], T.td[receivedlen],
T.td[self.render_time(None, rtt)],
]]
l["Requests:", t]
return l
def _get_rate(self, data, name):
file_size = self.retrieve_status.get_size()
duration = self.retrieve_status.timings.get(name)
return compute_rate(file_size, duration)
def _convert(r):
file_size = r.file_size
duration = r.timings.get(name)
return compute_rate(file_size, duration)
def _convert(r):
file_size = r.get_file_size()
time = r.get_timings().get(name)
return compute_rate(file_size, time)
def _get_rate(self, data, name):
file_size = self.publish_status.get_size()
duration = self.publish_status.timings.get(name)
return compute_rate(file_size, duration)
def _get_rate(self, name):
file_size = self._retrieve_status.get_size()
duration = self._retrieve_status.timings.get(name)
return compute_rate(file_size, duration)
