From de4130274374cb5ce9d8f00ba60c01f1b2e6ed3e Mon Sep 17 00:00:00 2001 From: Sajith Sasidharan Date: Thu, 7 May 2020 09:34:42 -0400 Subject: [PATCH] Update RetrieveStatusPage to use twisted renderers --- src/allmydata/web/status.py | 144 ++++++++++++++++++++++-------------- 1 file changed, 89 insertions(+), 55 deletions(-) diff --git a/src/allmydata/web/status.py b/src/allmydata/web/status.py index bc0d69d77..60e2a0a70 100644 --- a/src/allmydata/web/status.py +++ b/src/allmydata/web/status.py @@ -673,90 +673,124 @@ class DownloadStatusPage(DownloadResultsRendererMixin, rend.Page): def render_status(self, ctx, data): return data.get_status() -class RetrieveStatusPage(rend.Page, RateAndTimeMixin): - docFactory = getxmlfile("retrieve-status.xhtml") - def __init__(self, data): - rend.Page.__init__(self, data) - self.retrieve_status = data +class RetrieveStatusPage(MultiFormatResource): - def render_started(self, ctx, data): - started_s = render_time(data.get_started()) - return started_s + def __init__(self, retrieve_status): + super(RetrieveStatusPage, self).__init__() + self._retrieve_status = retrieve_status - def render_si(self, ctx, data): - si_s = base32.b2a_or_none(data.get_storage_index()) + def render_HTML(self, req): + elem = RetrieveStatusElement(self._retrieve_status) + return renderElement(req, elem) + + +class RetrieveStatusElement(Element, RateAndTimeMixin): + + loader = XMLFile(FilePath(__file__).sibling("retrieve-status.xhtml")) + + def __init__(self, retrieve_status): + super(RetrieveStatusElement, self).__init__() + self._retrieve_status = retrieve_status + + @renderer + def started(self, req, tag): + started_s = render_time(self._retrieve_status.get_started()) + return tag(started_s) + + @renderer + def si(self, req, tag): + si_s = base32.b2a_or_none(self._retrieve_status.get_storage_index()) if si_s is None: si_s = "(None)" - return si_s + return tag(si_s) - def render_helper(self, ctx, data): - return {True: "Yes", - False: "No"}[data.using_helper()] + @renderer + def helper(self, req, tag): + return tag({True: "Yes", + False: "No"}[self._retrieve_status.using_helper()]) - def render_current_size(self, ctx, data): - size = data.get_size() + @renderer + def current_size(self, req, tag): + size = self._retrieve_status.get_size() if size is None: size = "(unknown)" - return size + return tag(size) - def render_progress(self, ctx, data): - progress = data.get_progress() + @renderer + def progress(self, req, tag): + progress = self._retrieve_status.get_progress() # TODO: make an ascii-art bar - return "%.1f%%" % (100.0 * progress) + return tag("%.1f%%" % (100.0 * progress)) - def render_status(self, ctx, data): - return data.get_status() + @renderer + def status(self, req, tag): + return tag(self._retrieve_status.get_status()) - def render_encoding(self, ctx, data): - k, n = data.get_encoding() - return ctx.tag["Encoding: %s of %s" % (k, n)] + @renderer + def encoding(self, req, tag): + k, n = self._retrieve_status.get_encoding() + return tag("Encoding: %s of %s" % (k, n)) - def render_problems(self, ctx, data): - problems = data.get_problems() + @renderer + def problems(self, req, tag): + problems = self._retrieve_status.get_problems() if not problems: return "" - l = T.ul() + l = tags.ul() for peerid in sorted(problems.keys()): peerid_s = idlib.shortnodeid_b2a(peerid) - l[T.li["[%s]: %s" % (peerid_s, problems[peerid])]] - return ctx.tag["Server Problems:", l] + l(tags.li("[%s]: %s" % (peerid_s, problems[peerid]))) + return tag("Server Problems:", l) - def _get_rate(self, data, name): - file_size = self.retrieve_status.get_size() - duration = self.retrieve_status.timings.get(name) + 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) - def data_time_total(self, ctx, data): - return self.retrieve_status.timings.get("total") - def data_rate_total(self, ctx, data): - return self._get_rate(data, "total") + @renderer + def time_total(self, req, tag): + return tag(self._retrieve_status.timings.get("total")) - def data_time_fetch(self, ctx, data): - return self.retrieve_status.timings.get("fetch") - def data_rate_fetch(self, ctx, data): - return self._get_rate(data, "fetch") + @renderer + def rate_total(self, req, tag): + return tag(self._get_rate("total")) - def data_time_decode(self, ctx, data): - return self.retrieve_status.timings.get("decode") - def data_rate_decode(self, ctx, data): - return self._get_rate(data, "decode") + @renderer + def time_fetch(self, req, tag): + return tag(self._retrieve_status.timings.get("fetch")) - def data_time_decrypt(self, ctx, data): - return self.retrieve_status.timings.get("decrypt") - def data_rate_decrypt(self, ctx, data): - return self._get_rate(data, "decrypt") + @renderer + def rate_fetch(self, req, tag): + return tag(self._get_rate("fetch")) - def render_server_timings(self, ctx, data): - per_server = self.retrieve_status.timings.get("fetch_per_server") + @renderer + def time_decode(self, req, tag): + return tag(self._retrieve_status.timings.get("decode")) + + @renderer + def rate_decode(self, req, tag): + return tag(self._get_rate("decode")) + + @renderer + def time_decrypt(self, req, tag): + return tag(self._retrieve_status.timings.get("decrypt")) + + @renderer + def rate_decrypt(self, req, tag): + return tag(self._get_rate("decrypt")) + + @renderer + def server_timings(self, req, tag): + per_server = self._retrieve_status.timings.get("fetch_per_server") if not per_server: - return "" - l = T.ul() + return tag("") + l = tags.ul() for server in sorted(per_server.keys(), key=lambda s: s.get_name()): times_s = ", ".join([self.render_time(None, t) for t in per_server[server]]) - l[T.li["[%s]: %s" % (server.get_name(), times_s)]] - return T.li["Per-Server Fetch Response Times: ", l] + l(tags.li("[%s]: %s" % (server.get_name(), times_s))) + return tags.li("Per-Server Fetch Response Times: ", l) class PublishStatusPage(rend.Page, RateAndTimeMixin):