if 'version' not in result[1]:
self._log("invalid remote metadata detected")
continue
- else:
- if result[1]['version'] > max_version:
- node, metadata = result
- max_version = result[1]['version']
+
+ if result[1]['version'] > max_version:
+ node, metadata = result
+ max_version = result[1]['version']
return node, metadata
collective_dirmap_d.addCallback(highest_version)
return collective_dirmap_d
file_node, metadata = listing_map[encoded_relpath_u]
local_version = self._get_local_latest(relpath_u)
+
if 'version' not in metadata:
self._log("invalid remote metadata detected for %r" % (relpath_u,))
continue
- else:
- remote_version = metadata['version']
+
+ remote_version = metadata['version']
self._log("%r has local version %r, remote version %r" % (relpath_u, local_version, remote_version))
if local_version is None or local_version < remote_version:
public attributes::
service_name: the type of service provided, like 'storage'
- announcement_time: when we first heard about this service
last_connect_time: when we last established a connection
last_loss_time: when we last lost a connection
mtime REAL, -- ST_MTIME
ctime REAL, -- ST_CTIME
version INTEGER,
- last_uploaded_uri VARCHAR(256), -- URI:CHK:...
- last_downloaded_uri VARCHAR(256), -- URI:CHK:...
+ last_uploaded_uri VARCHAR(256), -- URI:CHK:...
+ last_downloaded_uri VARCHAR(256), -- URI:CHK:...
last_downloaded_timestamp REAL
);
"""
the their version information. I remember information about when we were
last connected too, even if we aren't currently connected.
- @ivar announcement_time: when we first heard about this service
@ivar last_connect_time: when we last established a connection
@ivar last_loss_time: when we last lost a connection
self._long_description = tubid_s
self._short_description = tubid_s[:6]
- self.announcement_time = time.time()
self.last_connect_time = None
self.last_loss_time = None
self.remote_host = None
return self.last_connect_time
def get_last_loss_time(self):
return self.last_loss_time
- def get_announcement_time(self):
- return self.announcement_time
+ def get_last_received_data_time(self):
+ if self.rref is None:
+ return None
+ else:
+ return self.rref.getDataLastReceivedAt()
def get_available_space(self):
version = self.get_version()
if required_to_quiesce and active:
self.fail("Reactor was still active when it was required to be quiescent.")
+
+class TimezoneMixin(object):
+
+ def setTimezone(self, timezone):
+ unset = object()
+ originalTimezone = os.environ.get('TZ', unset)
+ def restoreTimezone():
+ if originalTimezone is unset:
+ del os.environ['TZ']
+ time.tzset()
+ else:
+ os.environ['TZ'] = originalTimezone
+ time.tzset()
+ os.environ['TZ'] = timezone
+ time.tzset()
+ self.addCleanup(restoreTimezone)
+
+
try:
import win32file
import win32con
def test_parse_date(self):
self.failUnlessEqual(time_format.parse_date("2010-02-21"), 1266710400)
+ def test_format_time(self):
+ self.failUnlessEqual(time_format.format_time(time.gmtime(0)), '1970-01-01 00:00:00')
+ self.failUnlessEqual(time_format.format_time(time.gmtime(60)), '1970-01-01 00:01:00')
+ self.failUnlessEqual(time_format.format_time(time.gmtime(60*60)), '1970-01-01 01:00:00')
+ seconds_per_day = 60*60*24
+ leap_years_1970_to_2014_inclusive = ((2012 - 1968) // 4)
+ self.failUnlessEqual(time_format.format_time(time.gmtime(seconds_per_day*((2015 - 1970)*365+leap_years_1970_to_2014_inclusive))), '2015-01-01 00:00:00')
+
+ def test_format_time_y2038(self):
+ seconds_per_day = 60*60*24
+ leap_years_1970_to_2047_inclusive = ((2044 - 1968) // 4)
+ self.failUnlessEqual(time_format.format_time(time.gmtime(seconds_per_day*((2048 - 1970)*365+leap_years_1970_to_2047_inclusive))), '2048-01-01 00:00:00')
+
+ test_format_time_y2038.todo = "This test is known to fail on systems with 32-bit time_t."
+
+ def test_format_delta(self):
+ time_1 = 1389812723
+ time_5s_delta = 1389812728
+ time_28m7s_delta = 1389814410
+ time_1h_delta = 1389816323
+ time_1d21h46m49s_delta = 1389977532
+
+ self.failUnlessEqual(
+ time_format.format_delta(time_1, time_1), '0s')
+
+ self.failUnlessEqual(
+ time_format.format_delta(time_1, time_5s_delta), '5s')
+ self.failUnlessEqual(
+ time_format.format_delta(time_1, time_28m7s_delta), '28m 7s')
+ self.failUnlessEqual(
+ time_format.format_delta(time_1, time_1h_delta), '1h 0m 0s')
+ self.failUnlessEqual(
+ time_format.format_delta(time_1, time_1d21h46m49s_delta), '1d 21h 46m 49s')
+
+ self.failUnlessEqual(
+ time_format.format_delta(time_1d21h46m49s_delta, time_1), '-')
+
+ # time_1 with a decimal fraction will make the delta 1s less
+ time_1decimal = 1389812723.383963
+
+ self.failUnlessEqual(
+ time_format.format_delta(time_1decimal, time_5s_delta), '4s')
+ self.failUnlessEqual(
+ time_format.format_delta(time_1decimal, time_28m7s_delta), '28m 6s')
+ self.failUnlessEqual(
+ time_format.format_delta(time_1decimal, time_1h_delta), '59m 59s')
+ self.failUnlessEqual(
+ time_format.format_delta(time_1decimal, time_1d21h46m49s_delta), '1d 21h 46m 48s')
+
class CacheDir(unittest.TestCase):
def test_basic(self):
basedir = "test_util/CacheDir/test_basic"
return []
class FakeDisplayableServer(StubServer):
- def __init__(self, serverid, nickname):
+ def __init__(self, serverid, nickname, connected,
+ last_connect_time, last_loss_time, last_rx_time):
StubServer.__init__(self, serverid)
self.announcement = {"my-version": "allmydata-tahoe-fake",
"service-name": "storage",
"nickname": nickname}
+ self.connected = connected
+ self.last_loss_time = last_loss_time
+ self.last_rx_time = last_rx_time
+ self.last_connect_time = last_connect_time
def is_connected(self):
- return True
+ return self.connected
def get_permutation_seed(self):
return ""
def get_remote_host(self):
return ""
def get_last_loss_time(self):
- return None
- def get_announcement_time(self):
- return None
+ return self.last_loss_time
+ def get_last_received_data_time(self):
+ return self.last_rx_time
+ def get_last_connect_time(self):
+ return self.last_connect_time
def get_announcement(self):
return self.announcement
def get_nickname(self):
self.storage_broker = StorageFarmBroker(None, True, 0, None)
# fake knowledge of another server
self.storage_broker.test_add_server("other_nodeid",
- FakeDisplayableServer("other_nodeid", u"other_nickname \u263B"))
+ FakeDisplayableServer(
+ serverid="other_nodeid", nickname=u"other_nickname \u263B", connected = True,
+ last_connect_time = 10, last_loss_time = 20, last_rx_time = 30))
+ self.storage_broker.test_add_server("disconnected_nodeid",
+ FakeDisplayableServer(
+ serverid="other_nodeid", nickname=u"disconnected_nickname \u263B", connected = False,
+ last_connect_time = 15, last_loss_time = 25, last_rx_time = 35))
self.introducer_client = None
self.history = FakeHistory()
self.uploader = FakeUploader()
MUTABLE_SIZELIMIT = FakeMutableFileNode.MUTABLE_SIZELIMIT
-class WebMixin(object):
+class WebMixin(testutil.TimezoneMixin):
def setUp(self):
+ self.setTimezone('UTC-13:00')
self.s = FakeClient()
self.s.startService()
self.staticdir = self.mktemp()
self.clock = Clock()
+ self.fakeTime = 86460 # 1d 0h 1m 0s
self.ws = webish.WebishServer(self.s, "0", staticdir=self.staticdir,
- clock=self.clock)
+ clock=self.clock, now_fn=lambda:self.fakeTime)
self.ws.setServiceParent(self.s)
self.webish_port = self.ws.getPortnum()
self.webish_url = self.ws.getURL()
self.fail("%s was supposed to Error(302), not get '%s'" %
(which, res))
-
class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixin, unittest.TestCase):
def test_create(self):
pass
res_u = res.decode('utf-8')
self.failUnlessIn(u'<td>fake_nickname \u263A</td>', res_u)
self.failUnlessIn(u'<div class="nickname">other_nickname \u263B</div>', res_u)
+ self.failUnlessIn(u'Connected to <span>1</span>\n of <span>2</span> known storage servers', res_u)
+ self.failUnlessIn(u'<div class="status-indicator"><img src="img/connected-yes.png" alt="Connected" /></div>\n <a class="timestamp" title="1970-01-01 13:00:10">1d\u00A00h\u00A00m\u00A050s</a>', res_u)
+ self.failUnlessIn(u'<div class="status-indicator"><img src="img/connected-no.png" alt="Disconnected" /></div>\n <a class="timestamp" title="1970-01-01 13:00:25">1d\u00A00h\u00A00m\u00A035s</a>', res_u)
+ self.failUnlessIn(u'<td class="service-last-received-data"><a class="timestamp" title="1970-01-01 13:00:30">1d\u00A00h\u00A00m\u00A030s</a></td>', res_u)
+ self.failUnlessIn(u'<td class="service-last-received-data"><a class="timestamp" title="1970-01-01 13:00:35">1d\u00A00h\u00A00m\u00A025s</a></td>', res_u)
self.failUnlessIn(u'\u00A9 <a href="https://tahoe-lafs.org/">Tahoe-LAFS Software Foundation', res_u)
self.failUnlessIn('<td><h3>Available</h3></td>', res)
self.failUnlessIn('123.5kB', res)
import calendar, datetime, re, time
+def format_time(t):
+ return time.strftime("%Y-%m-%d %H:%M:%S", t)
+
def iso_utc_date(now=None, t=time.time):
if now is None:
now = t()
now = t()
return datetime.datetime.utcfromtimestamp(now).isoformat(sep)
-def iso_local(now=None, sep='_', t=time.time):
- if now is None:
- now = t()
- return datetime.datetime.fromtimestamp(now).isoformat(sep)
-
def iso_utc_time_to_seconds(isotime, _conversion_re=re.compile(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})[T_ ](?P<hour>\d{2}):(?P<minute>\d{2}):(?P<second>\d{2})(?P<subsecond>\.\d+)?")):
"""
The inverse of iso_utc().
# day
return int(iso_utc_time_to_seconds(s + "T00:00:00"))
+def format_delta(time_1, time_2):
+ if time_1 is None:
+ return "N/A"
+ if time_1 > time_2:
+ return '-'
+ delta = int(time_2 - time_1)
+ seconds = delta % 60
+ delta -= seconds
+ minutes = (delta / 60) % 60
+ delta -= minutes * 60
+ hours = delta / (60*60) % 24
+ delta -= hours * 24
+ days = delta / (24*60*60)
+ if not days:
+ if not hours:
+ if not minutes:
+ return "%ss" % (seconds)
+ else:
+ return "%sm %ss" % (minutes, seconds)
+ else:
+ return "%sh %sm %ss" % (hours, minutes, seconds)
+ else:
+ return "%sd %sh %sm %ss" % (days, hours, minutes, seconds)
+
+import time
import simplejson
+
from twisted.web import http, server
from twisted.python import log
from zope.interface import Interface
MustBeReadonlyError, MustNotBeUnknownRWError, SDMF_VERSION, MDMF_VERSION
from allmydata.mutable.common import UnrecoverableFileError
from allmydata.util import abbreviate
+from allmydata.util.time_format import format_time, format_delta
from allmydata.util.encodingutil import to_str, quote_output
-TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
-
def get_filenode_metadata(filenode):
metadata = {'mutable': filenode.is_mutable()}
if metadata['mutable']:
req.setHeader("content-length", b"%d" % len(text))
return text
+def spaces_to_nbsp(text):
+ return unicode(text).replace(u' ', u'\u00A0')
+
+def render_time_delta(time_1, time_2):
+ return spaces_to_nbsp(format_delta(time_1, time_2))
+
+def render_time(t):
+ return spaces_to_nbsp(format_time(time.localtime(t)))
+
+def render_time_attr(t):
+ return format_time(time.localtime(t))
+
class WebError(Exception):
def __init__(self, text, code=http.BAD_REQUEST):
self.text = text
from foolscap.api import fireEventually
-from allmydata.util import base32, time_format
+from allmydata.util import base32
from allmydata.util.encodingutil import to_str
from allmydata.uri import from_string_dirnode
from allmydata.interfaces import IDirectoryNode, IFileNode, IFilesystemNode, \
boolean_of_arg, get_arg, get_root, parse_replace_arg, \
should_create_intermediate_directories, \
getxmlfile, RenderMixin, humanize_failure, convert_children_json, \
- get_format, get_mutable_type, get_filenode_metadata
+ get_format, get_mutable_type, get_filenode_metadata, render_time
from allmydata.web.filenode import ReplaceMeMixin, \
FileNodeHandler, PlaceHolderNodeHandler
from allmydata.web.check_results import CheckResultsRenderer, \
times = []
linkcrtime = metadata.get('tahoe', {}).get("linkcrtime")
if linkcrtime is not None:
- times.append("lcr: " + time_format.iso_local(linkcrtime))
+ times.append("lcr: " + render_time(linkcrtime))
else:
# For backwards-compatibility with links last modified by Tahoe < 1.4.0:
if "ctime" in metadata:
- ctime = time_format.iso_local(metadata["ctime"])
+ ctime = render_time(metadata["ctime"])
times.append("c: " + ctime)
linkmotime = metadata.get('tahoe', {}).get("linkmotime")
if linkmotime is not None:
if times:
times.append(T.br())
- times.append("lmo: " + time_format.iso_local(linkmotime))
+ times.append("lmo: " + render_time(linkmotime))
else:
# For backwards-compatibility with links last modified by Tahoe < 1.4.0:
if "mtime" in metadata:
- mtime = time_format.iso_local(metadata["mtime"])
+ mtime = render_time(metadata["mtime"])
if times:
times.append(T.br())
times.append("m: " + mtime)
import simplejson
from allmydata import get_package_versions_string
from allmydata.util import idlib
-from allmydata.web.common import getxmlfile, get_arg, TIME_FORMAT
+from allmydata.web.common import getxmlfile, get_arg, render_time
class IntroducerRoot(rend.Page):
# FIXME: This code is duplicated in root.py and introweb.py.
def data_rendered_at(self, ctx, data):
- return time.strftime(TIME_FORMAT, time.localtime())
+ return render_time(time.time())
def data_version(self, ctx, data):
return get_package_versions_string()
def data_import_path(self, ctx, data):
ctx.fillSlots("connection-hints",
"connection hints: " + " ".join(ad.connection_hints))
ctx.fillSlots("connected", "?")
- when_s = time.strftime("%H:%M:%S %d-%b-%Y", time.localtime(ad.when))
+ when_s = render_time(ad.when)
ctx.fillSlots("announced", when_s)
ctx.fillSlots("version", ad.version)
ctx.fillSlots("service_name", ad.service_name)
ctx.fillSlots("nickname", s.nickname)
ctx.fillSlots("tubid", s.tubid)
ctx.fillSlots("connected", s.remote_address)
- since_s = time.strftime("%H:%M:%S %d-%b-%Y", time.localtime(s.when))
+ since_s = render_time(s.when)
ctx.fillSlots("since", since_s)
ctx.fillSlots("version", s.version)
ctx.fillSlots("service_name", s.service_name)
from allmydata.web import filenode, directory, unlinked, status, operations
from allmydata.web import storage
from allmydata.web.common import abbreviate_size, getxmlfile, WebError, \
- get_arg, RenderMixin, get_format, get_mutable_type, TIME_FORMAT
+ get_arg, RenderMixin, get_format, get_mutable_type, render_time_delta, render_time, render_time_attr
class URIHandler(RenderMixin, rend.Page):
"no": "Disconnected",
}
- def __init__(self, client, clock=None):
+ def __init__(self, client, clock=None, now_fn=None):
rend.Page.__init__(self, client)
self.client = client
# If set, clock is a twisted.internet.task.Clock that the tests
# use to test ophandle expiration.
self.child_operations = operations.OphandleTable(clock)
+ self.now_fn = now_fn
try:
s = client.getServiceNamed("storage")
except KeyError:
# FIXME: This code is duplicated in root.py and introweb.py.
def data_rendered_at(self, ctx, data):
- return time.strftime(TIME_FORMAT, time.localtime())
+ return render_time(time.time())
def data_version(self, ctx, data):
return get_package_versions_string()
def data_import_path(self, ctx, data):
ctx.fillSlots("peerid", server.get_longname())
ctx.fillSlots("nickname", server.get_nickname())
rhost = server.get_remote_host()
- if rhost:
+ if server.is_connected():
if nodeid == self.client.nodeid:
rhost_s = "(loopback)"
elif isinstance(rhost, address.IPv4Address):
else:
rhost_s = str(rhost)
addr = rhost_s
- connected = "yes"
- since = server.get_last_connect_time()
+ service_connection_status = "yes"
+ last_connect_time = server.get_last_connect_time()
+ service_connection_status_rel_time = render_time_delta(last_connect_time, self.now_fn())
+ service_connection_status_abs_time = render_time_attr(last_connect_time)
else:
addr = "N/A"
- connected = "no"
- since = server.get_last_loss_time()
- announced = server.get_announcement_time()
+ service_connection_status = "no"
+ last_loss_time = server.get_last_loss_time()
+ service_connection_status_rel_time = render_time_delta(last_loss_time, self.now_fn())
+ service_connection_status_abs_time = render_time_attr(last_loss_time)
+
+ last_received_data_time = server.get_last_received_data_time()
+ last_received_data_rel_time = render_time_delta(last_received_data_time, self.now_fn())
+ last_received_data_abs_time = render_time_attr(last_received_data_time)
+
announcement = server.get_announcement()
version = announcement["my-version"]
- service_name = announcement["service-name"]
available_space = server.get_available_space()
if available_space is None:
available_space = "N/A"
else:
available_space = abbreviate_size(available_space)
ctx.fillSlots("address", addr)
- ctx.fillSlots("connected", connected)
- ctx.fillSlots("connected_alt", self._connectedalts[connected])
+ ctx.fillSlots("service_connection_status", service_connection_status)
+ ctx.fillSlots("service_connection_status_alt", self._connectedalts[service_connection_status])
ctx.fillSlots("connected-bool", bool(rhost))
- ctx.fillSlots("since", time.strftime(TIME_FORMAT,
- time.localtime(since)))
- ctx.fillSlots("announced", time.strftime(TIME_FORMAT,
- time.localtime(announced)))
+ ctx.fillSlots("service_connection_status_abs_time", service_connection_status_abs_time)
+ ctx.fillSlots("service_connection_status_rel_time", service_connection_status_rel_time)
+ ctx.fillSlots("last_received_data_abs_time", last_received_data_abs_time)
+ ctx.fillSlots("last_received_data_rel_time", last_received_data_rel_time)
ctx.fillSlots("version", version)
- ctx.fillSlots("service_name", service_name)
ctx.fillSlots("available_space", available_space)
return ctx.tag
float: left;
margin: 5px;
}
+
+.nickname-and-peerid .timestamp {
+ float: right;
+}
+
+a.timestamp {
+ color: inherit;
+ text-decoration:none;
+}
from nevow import rend, inevow, tags as T
from allmydata.util import base32, idlib
from allmydata.web.common import getxmlfile, get_arg, \
- abbreviate_time, abbreviate_rate, abbreviate_size, plural, compute_rate
+ abbreviate_time, abbreviate_rate, abbreviate_size, plural, compute_rate, render_time
from allmydata.interfaces import IUploadStatus, IDownloadStatus, \
IPublishStatus, IRetrieveStatus, IServermapUpdaterStatus
return d
def render_started(self, ctx, data):
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_started()))
+ started_s = render_time(data.get_started())
return started_s
def render_si(self, ctx, data):
return d
def render_started(self, ctx, data):
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_started()))
+ started_s = render_time(data.get_started())
return started_s + " (%s)" % data.get_started()
def render_si(self, ctx, data):
docFactory = getxmlfile("download-status-timeline.xhtml")
def render_started(self, ctx, data):
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_started()))
+ started_s = render_time(data.get_started())
return started_s + " (%s)" % data.get_started()
def render_si(self, ctx, data):
self.retrieve_status = data
def render_started(self, ctx, data):
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_started()))
+ started_s = render_time(data.get_started())
return started_s
def render_si(self, ctx, data):
self.publish_status = data
def render_started(self, ctx, data):
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_started()))
+ started_s = render_time(data.get_started())
return started_s
def render_si(self, ctx, data):
self.update_status = data
def render_started(self, ctx, data):
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_started()))
+ started_s = render_time(data.get_started())
return started_s
def render_finished(self, ctx, data):
when = data.get_finished()
if not when:
return "not yet"
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(data.get_finished()))
+ started_s = render_time(data.get_finished())
return started_s
def render_si(self, ctx, data):
def render_row(self, ctx, data):
s = data
- TIME_FORMAT = "%H:%M:%S %d-%b-%Y"
- started_s = time.strftime(TIME_FORMAT,
- time.localtime(s.get_started()))
+ started_s = render_time(s.get_started())
ctx.fillSlots("started", started_s)
si_s = base32.b2a_or_none(s.get_storage_index())
-<!DOCTYPE html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
+ Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" xmlns:n="http://nevow.com/ns/nevow/0.1">
<head>
<meta charset="utf-8"/>
<tr n:pattern="header">
<td><h3>Nickname</h3></td>
<td><h3>Address</h3></td>
- <td><h3>Service</h3></td>
- <td><h3>Since</h3></td>
- <td><h3>Announced</h3></td>
+ <td><h3>Last RX</h3></td>
<td><h3>Version</h3></td>
<td><h3>Available</h3></td>
</tr>
</thead>
<tr n:pattern="item" n:render="service_row">
<td class="nickname-and-peerid">
- <div class="status-indicator"><img><n:attr name="src">img/connected-<n:slot name="connected" />.png</n:attr><n:attr name="alt"><n:slot name="connected_alt" /></n:attr></img></div>
+ <div class="status-indicator"><img><n:attr name="src">img/connected-<n:slot name="service_connection_status" />.png</n:attr><n:attr name="alt"><n:slot name="service_connection_status_alt" /></n:attr></img></div>
+ <a class="timestamp"><n:attr name="title"><n:slot name="service_connection_status_abs_time"/></n:attr><n:slot name="service_connection_status_rel_time"/></a>
<div class="nickname"><n:slot name="nickname"/></div>
<div class="nodeid"><n:slot name="peerid"/></div>
</td>
<td class="address"><n:slot name="address"/></td>
- <td class="service-service-name"><n:slot name="service_name"/></td>
- <td class="service-since timestamp"><n:slot name="since"/></td>
- <td class="service-announced timestamp"><n:slot name="announced"/></td>
+ <td class="service-last-received-data"><a class="timestamp"><n:attr name="title"><n:slot name="last_received_data_abs_time"/></n:attr><n:slot name="last_received_data_rel_time"/></a></td>
<td class="service-version"><n:slot name="version"/></td>
<td class="service-available-space"><n:slot name="available_space"/></td>
</tr>
- <tr n:pattern="empty"><td>You are not presently connected to any peers</td></tr>
+ <tr n:pattern="empty"><td colspan="5">You are not presently connected to any peers</td></tr>
</table>
</div><!--/span-->
</div><!--/row-->
name = "webish"
def __init__(self, client, webport, nodeurl_path=None, staticdir=None,
- clock=None):
+ clock=None, now_fn=time.time):
service.MultiService.__init__(self)
# the 'data' argument to all render() methods default to the Client
# the 'clock' argument to root.Root is, if set, a
# twisted.internet.task.Clock that is provided by the unit tests
# so that they can test features that involve the passage of
# time in a deterministic manner.
- self.root = root.Root(client, clock)
+ self.root = root.Root(client, clock, now_fn)
self.buildServer(webport, nodeurl_path, staticdir)
if self.root.child_operations:
self.site.remember(self.root.child_operations, IOpHandleTable)
projects / tahoe-lafs / tahoe-lafs.git / commitdiff