To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-monitor
- browse files at revision 797
- compare with another revision
- download diff
- download tarball
- view history from revision 797
- Committer: Teddy Hogeborn
- Date: 2016-02-21 12:43:51 UTC
- Revision ID: teddy@recompile.se-20160221124351-3g9bc5eu90at8yis
plugin-runner.c: Use size_t to realloc() for custom plugin args.
* plugin-runner.c (main): Cast argument to realloc() to size_t when
allocating additional custom plugin command
line arguments.
* plugin-runner.c (main): Cast argument to realloc() to size_t when
allocating additional custom plugin command
line arguments.
- files added:
- debian/mandos-client.examples
- debian/upstream
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 Björn Påhlsson
6
# Copyright © 2009-2015 Teddy Hogeborn
7
# Copyright © 2009-2015 Björn Påhlsson
8
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
25
25
26
26
from __future__ import (division, absolute_import, print_function,
27
27
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
28
32
29
33
import sys
30
34
import os
31
import signal
32
35
33
36
import datetime
34
37
36
39
import urwid
37
40
38
41
from dbus.mainloop.glib import DBusGMainLoop
39
import gobject
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
40
46
41
47
import dbus
42
48
43
import UserList
44
45
49
import locale
46
50
51
if sys.version_info.major == 2:
52
str = unicode
53
47
54
locale.setlocale(locale.LC_ALL, '')
48
55
49
56
import logging
53
60
domain = 'se.recompile'
54
61
server_interface = domain + '.Mandos'
55
62
client_interface = domain + '.Mandos.Client'
56
version = "1.5.3"
57
58
# Always run in monochrome mode
59
urwid.curses_display.curses.has_colors = lambda : False
60
61
# Urwid doesn't support blinking, but we want it. Since we have no
62
# use for underline on its own, we make underline also always blink.
63
urwid.curses_display.curses.A_UNDERLINE |= (
64
urwid.curses_display.curses.A_BLINK)
63
version = "1.7.1"
64
65
try:
66
dbus.OBJECT_MANAGER_IFACE
67
except AttributeError:
68
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
65
69
66
70
def isoformat_to_datetime(iso):
67
71
"Parse an ISO 8601 date string to a datetime.datetime()"
84
88
properties and calls a hook function when any of them are
85
89
changed.
86
90
"""
87
def __init__(self, proxy_object=None, *args, **kwargs):
91
def __init__(self, proxy_object=None, properties=None, **kwargs):
88
92
self.proxy = proxy_object # Mandos Client proxy object
89
90
self.properties = dict()
93
self.properties = dict() if properties is None else properties
91
94
self.property_changed_match = (
92
self.proxy.connect_to_signal("PropertyChanged",
93
self.property_changed,
94
client_interface,
95
self.proxy.connect_to_signal("PropertiesChanged",
96
self.properties_changed,
97
dbus.PROPERTIES_IFACE,
95
98
byte_arrays=True))
96
99
97
self.properties.update(
98
self.proxy.GetAll(client_interface,
99
dbus_interface = dbus.PROPERTIES_IFACE))
100
101
#XXX This breaks good super behaviour
102
# super(MandosClientPropertyCache, self).__init__(
103
# *args, **kwargs)
100
if properties is None:
101
self.properties.update(
102
self.proxy.GetAll(client_interface,
103
dbus_interface
104
= dbus.PROPERTIES_IFACE))
105
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
104
107
105
def property_changed(self, property=None, value=None):
106
"""This is called whenever we get a PropertyChanged signal
107
It updates the changed property in the "properties" dict.
108
def properties_changed(self, interface, properties, invalidated):
109
"""This is called whenever we get a PropertiesChanged signal
110
It updates the changed properties in the "properties" dict.
108
111
"""
109
112
# Update properties dict with new value
110
self.properties[property] = value
113
if interface == client_interface:
114
self.properties.update(properties)
111
115
112
def delete(self, *args, **kwargs):
116
def delete(self):
113
117
self.property_changed_match.remove()
114
super(MandosClientPropertyCache, self).__init__(
115
*args, **kwargs)
116
118
117
119
118
120
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
122
"""
121
123
122
124
def __init__(self, server_proxy_object=None, update_hook=None,
123
delete_hook=None, logger=None, *args, **kwargs):
125
delete_hook=None, logger=None, **kwargs):
124
126
# Called on update
125
127
self.update_hook = update_hook
126
128
# Called on delete
131
133
self.logger = logger
132
134
133
135
self._update_timer_callback_tag = None
134
self._update_timer_callback_lock = 0
135
136
136
137
# The widget shown normally
137
138
self._text_widget = urwid.Text("")
138
139
# The widget shown when we have focus
139
140
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
142
*args, **kwargs)
141
super(MandosClientWidget, self).__init__(**kwargs)
143
142
self.update()
144
143
self.opened = False
145
144
146
last_checked_ok = isoformat_to_datetime(self.properties
147
["LastCheckedOK"])
148
149
if self.properties ["LastCheckerStatus"] != 0:
150
self.using_timer(True)
151
152
if self.need_approval:
153
self.using_timer(True)
154
155
145
self.match_objects = (
156
146
self.proxy.connect_to_signal("CheckerCompleted",
157
147
self.checker_completed,
173
163
self.rejected,
174
164
client_interface,
175
165
byte_arrays=True))
176
#self.logger('Created client {0}'
177
# .format(self.properties["Name"]))
178
179
def property_changed(self, property=None, value=None):
180
super(self, MandosClientWidget).property_changed(property,
181
value)
182
if property == "ApprovalPending":
183
using_timer(bool(value))
184
if property == "LastCheckerStatus":
185
using_timer(value != 0)
186
#self.logger('Checker for client {0} (command "{1}") was '
187
# ' successful'.format(self.properties["Name"],
188
# command))
166
self.logger('Created client {}'
167
.format(self.properties["Name"]), level=0)
189
168
190
169
def using_timer(self, flag):
191
170
"""Call this method with True or False when timer should be
192
171
activated or deactivated.
193
172
"""
194
old = self._update_timer_callback_lock
195
if flag:
196
self._update_timer_callback_lock += 1
197
else:
198
self._update_timer_callback_lock -= 1
199
if old == 0 and self._update_timer_callback_lock:
173
if flag and self._update_timer_callback_tag is None:
200
174
# Will update the shown timer value every second
201
175
self._update_timer_callback_tag = (gobject.timeout_add
202
176
(1000,
203
177
self.update_timer))
204
elif old and self._update_timer_callback_lock == 0:
178
elif not (flag or self._update_timer_callback_tag is None):
205
179
gobject.source_remove(self._update_timer_callback_tag)
206
180
self._update_timer_callback_tag = None
207
181
208
182
def checker_completed(self, exitstatus, condition, command):
209
183
if exitstatus == 0:
184
self.logger('Checker for client {} (command "{}")'
185
' succeeded'.format(self.properties["Name"],
186
command), level=0)
210
187
self.update()
211
188
return
212
189
# Checker failed
213
190
if os.WIFEXITED(condition):
214
self.logger('Checker for client {0} (command "{1}")'
215
' failed with exit code {2}'
191
self.logger('Checker for client {} (command "{}") failed'
192
' with exit code {}'
216
193
.format(self.properties["Name"], command,
217
194
os.WEXITSTATUS(condition)))
218
195
elif os.WIFSIGNALED(condition):
219
self.logger('Checker for client {0} (command "{1}") was'
220
' killed by signal {2}'
196
self.logger('Checker for client {} (command "{}") was'
197
' killed by signal {}'
221
198
.format(self.properties["Name"], command,
222
199
os.WTERMSIG(condition)))
223
elif os.WCOREDUMP(condition):
224
self.logger('Checker for client {0} (command "{1}")'
225
' dumped core'
226
.format(self.properties["Name"], command))
227
else:
228
self.logger('Checker for client {0} completed'
229
' mysteriously'
230
.format(self.properties["Name"]))
231
200
self.update()
232
201
233
202
def checker_started(self, command):
234
"""Server signals that a checker started. This could be useful
235
to log in the future. """
236
#self.logger('Client {0} started checker "{1}"'
237
# .format(self.properties["Name"],
238
# unicode(command)))
239
pass
203
"""Server signals that a checker started."""
204
self.logger('Client {} started checker "{}"'
205
.format(self.properties["Name"],
206
command), level=0)
240
207
241
208
def got_secret(self):
242
self.logger('Client {0} received its secret'
209
self.logger('Client {} received its secret'
243
210
.format(self.properties["Name"]))
244
211
245
212
def need_approval(self, timeout, default):
246
213
if not default:
247
message = 'Client {0} needs approval within {1} seconds'
214
message = 'Client {} needs approval within {} seconds'
248
215
else:
249
message = 'Client {0} will get its secret in {1} seconds'
216
message = 'Client {} will get its secret in {} seconds'
250
217
self.logger(message.format(self.properties["Name"],
251
218
timeout/1000))
252
self.using_timer(True)
253
219
254
220
def rejected(self, reason):
255
self.logger('Client {0} was rejected; reason: {1}'
221
self.logger('Client {} was rejected; reason: {}'
256
222
.format(self.properties["Name"], reason))
257
223
258
224
def selectable(self):
281
247
"bold-underline-blink":
282
248
"bold-underline-blink-standout",
283
249
}
284
250
285
251
# Rebuild focus and non-focus widgets using current properties
286
252
287
253
# Base part of a client. Name!
288
254
base = '{name}: '.format(name=self.properties["Name"])
289
255
if not self.properties["Enabled"]:
290
256
message = "DISABLED"
257
self.using_timer(False)
291
258
elif self.properties["ApprovalPending"]:
292
259
timeout = datetime.timedelta(milliseconds
293
260
= self.properties
295
262
last_approval_request = isoformat_to_datetime(
296
263
self.properties["LastApprovalRequest"])
297
264
if last_approval_request is not None:
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
265
timer = max(timeout - (datetime.datetime.utcnow()
266
- last_approval_request),
267
datetime.timedelta())
300
268
else:
301
269
timer = datetime.timedelta()
302
270
if self.properties["ApprovedByDefault"]:
303
message = "Approval in {0}. (d)eny?"
271
message = "Approval in {}. (d)eny?"
304
272
else:
305
message = "Denial in {0}. (a)pprove?"
306
message = message.format(unicode(timer).rsplit(".", 1)[0])
273
message = "Denial in {}. (a)pprove?"
274
message = message.format(str(timer).rsplit(".", 1)[0])
275
self.using_timer(True)
307
276
elif self.properties["LastCheckerStatus"] != 0:
308
277
# When checker has failed, show timer until client expires
309
278
expires = self.properties["Expires"]
312
281
else:
313
282
expires = (datetime.datetime.strptime
314
283
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
315
timer = expires - datetime.datetime.utcnow()
284
timer = max(expires - datetime.datetime.utcnow(),
285
datetime.timedelta())
316
286
message = ('A checker has failed! Time until client'
317
' gets disabled: {0}'
318
.format(unicode(timer).rsplit(".", 1)[0]))
287
' gets disabled: {}'
288
.format(str(timer).rsplit(".", 1)[0]))
289
self.using_timer(True)
319
290
else:
320
291
message = "enabled"
321
self._text = "{0}{1}".format(base, message)
322
292
self.using_timer(False)
293
self._text = "{}{}".format(base, message)
294
323
295
if not urwid.supports_unicode():
324
296
self._text = self._text.encode("ascii", "replace")
325
297
textlist = [("normal", self._text)]
342
314
self.update()
343
315
return True # Keep calling this
344
316
345
def delete(self, *args, **kwargs):
317
def delete(self, **kwargs):
346
318
if self._update_timer_callback_tag is not None:
347
319
gobject.source_remove(self._update_timer_callback_tag)
348
320
self._update_timer_callback_tag = None
351
323
self.match_objects = ()
352
324
if self.delete_hook is not None:
353
325
self.delete_hook(self)
354
return super(MandosClientWidget, self).delete(*args, **kwargs)
326
return super(MandosClientWidget, self).delete(**kwargs)
355
327
356
328
def render(self, maxcolrow, focus=False):
357
329
"""Render differently if we have focus.
363
335
"""Handle keys.
364
336
This overrides the method from urwid.FlowWidget"""
365
337
if key == "+":
366
self.proxy.Enable(dbus_interface = client_interface,
367
ignore_reply=True)
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply = True,
340
dbus_interface = dbus.PROPERTIES_IFACE)
368
341
elif key == "-":
369
self.proxy.Disable(dbus_interface = client_interface,
370
ignore_reply=True)
342
self.proxy.Set(client_interface, "Enabled", False,
343
ignore_reply = True,
344
dbus_interface = dbus.PROPERTIES_IFACE)
371
345
elif key == "a":
372
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
373
347
dbus_interface = client_interface,
381
355
.object_path,
382
356
ignore_reply=True)
383
357
elif key == "s":
384
self.proxy.StartChecker(dbus_interface = client_interface,
385
ignore_reply=True)
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply = True,
360
dbus_interface = dbus.PROPERTIES_IFACE)
386
361
elif key == "S":
387
self.proxy.StopChecker(dbus_interface = client_interface,
388
ignore_reply=True)
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply = True,
364
dbus_interface = dbus.PROPERTIES_IFACE)
389
365
elif key == "C":
390
366
self.proxy.CheckedOK(dbus_interface = client_interface,
391
367
ignore_reply=True)
399
375
else:
400
376
return key
401
377
402
def property_changed(self, property=None, value=None,
403
*args, **kwargs):
404
"""Call self.update() if old value is not new value.
378
def properties_changed(self, interface, properties, invalidated):
379
"""Call self.update() if any properties changed.
405
380
This overrides the method from MandosClientPropertyCache"""
406
property_name = unicode(property)
407
old_value = self.properties.get(property_name)
408
super(MandosClientWidget, self).property_changed(
409
property=property, value=value, *args, **kwargs)
410
if self.properties.get(property_name) != old_value:
381
old_values = { key: self.properties.get(key)
382
for key in properties.keys() }
383
super(MandosClientWidget, self).properties_changed(
384
interface, properties, invalidated)
385
if any(old_values[key] != self.properties.get(key)
386
for key in old_values):
411
387
self.update()
412
388
413
389
416
392
"down" key presses, thus not allowing any containing widgets to
417
393
use them as an excuse to shift focus away from this widget.
418
394
"""
419
def keypress(self, maxcolrow, key):
420
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
395
def keypress(self, *args, **kwargs):
396
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
421
397
if ret in ("up", "down"):
422
398
return
423
399
return ret
427
403
"""This is the entire user interface - the whole screen
428
404
with boxes, lists of client widgets, etc.
429
405
"""
430
def __init__(self, max_log_length=1000):
406
def __init__(self, max_log_length=1000, log_level=1):
431
407
DBusGMainLoop(set_as_default=True)
432
408
433
409
self.screen = urwid.curses_display.Screen()
436
412
("normal",
437
413
"default", "default", None),
438
414
("bold",
439
"default", "default", "bold"),
415
"bold", "default", "bold"),
440
416
("underline-blink",
441
"default", "default", "underline"),
417
"underline,blink", "default", "underline,blink"),
442
418
("standout",
443
"default", "default", "standout"),
419
"standout", "default", "standout"),
444
420
("bold-underline-blink",
445
"default", "default", ("bold", "underline")),
421
"bold,underline,blink", "default", "bold,underline,blink"),
446
422
("bold-standout",
447
"default", "default", ("bold", "standout")),
423
"bold,standout", "default", "bold,standout"),
448
424
("underline-blink-standout",
449
"default", "default", ("underline", "standout")),
425
"underline,blink,standout", "default",
426
"underline,blink,standout"),
450
427
("bold-underline-blink-standout",
451
"default", "default", ("bold", "underline",
452
"standout")),
428
"bold,underline,blink,standout", "default",
429
"bold,underline,blink,standout"),
453
430
))
454
431
455
432
if urwid.supports_unicode():
470
447
self.log = []
471
448
self.max_log_length = max_log_length
472
449
450
self.log_level = log_level
451
473
452
# We keep a reference to the log widget so we can remove it
474
453
# from the ListWalker without it getting destroyed
475
454
self.logbox = ConstrainedListBox(self.log)
489
468
self.main_loop = gobject.MainLoop()
490
469
491
470
def client_not_found(self, fingerprint, address):
492
self.log_message("Client with address {0} and fingerprint"
493
" {1} could not be found"
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
494
473
.format(address, fingerprint))
495
474
496
475
def rebuild(self):
509
488
self.uilist.append(self.logbox)
510
489
self.topwidget = urwid.Pile(self.uilist)
511
490
512
def log_message(self, message):
491
def log_message(self, message, level=1):
492
"""Log message formatted with timestamp"""
493
if level < self.log_level:
494
return
513
495
timestamp = datetime.datetime.now().isoformat()
514
self.log_message_raw(timestamp + ": " + message)
496
self.log_message_raw("{}: {}".format(timestamp, message),
497
level=level)
515
498
516
def log_message_raw(self, markup):
499
def log_message_raw(self, markup, level=1):
517
500
"""Add a log message to the log buffer."""
501
if level < self.log_level:
502
return
518
503
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
519
504
if (self.max_log_length
520
505
and len(self.log) > self.max_log_length):
527
512
"""Toggle visibility of the log buffer."""
528
513
self.log_visible = not self.log_visible
529
514
self.rebuild()
530
#self.log_message("Log visibility changed to: "
531
# + unicode(self.log_visible))
515
self.log_message("Log visibility changed to: {}"
516
.format(self.log_visible), level=0)
532
517
533
518
def change_log_display(self):
534
519
"""Change type of log display.
539
524
self.log_wrap = "clip"
540
525
for textwidget in self.log:
541
526
textwidget.set_wrap_mode(self.log_wrap)
542
#self.log_message("Wrap mode: " + self.log_wrap)
527
self.log_message("Wrap mode: {}".format(self.log_wrap),
528
level=0)
543
529
544
def find_and_remove_client(self, path, name):
530
def find_and_remove_client(self, path, interfaces):
545
531
"""Find a client by its object path and remove it.
546
532
547
This is connected to the ClientRemoved signal from the
533
This is connected to the InterfacesRemoved signal from the
548
534
Mandos server object."""
535
if client_interface not in interfaces:
536
# Not a Mandos client object; ignore
537
return
549
538
try:
550
539
client = self.clients_dict[path]
551
540
except KeyError:
552
541
# not found?
553
self.log_message("Unknown client {0!r} ({1!r}) removed"
554
.format(name, path))
542
self.log_message("Unknown client {!r} removed"
543
.format(path))
555
544
return
556
545
client.delete()
557
546
558
def add_new_client(self, path):
547
def add_new_client(self, path, ifs_and_props):
548
"""Find a client by its object path and remove it.
549
550
This is connected to the InterfacesAdded signal from the
551
Mandos server object.
552
"""
553
if client_interface not in ifs_and_props:
554
# Not a Mandos client object; ignore
555
return
559
556
client_proxy_object = self.bus.get_object(self.busname, path)
560
557
self.add_client(MandosClientWidget(server_proxy_object
561
558
=self.mandos_serv,
566
563
delete_hook
567
564
=self.remove_client,
568
565
logger
569
=self.log_message),
566
=self.log_message,
567
properties
568
= dict(ifs_and_props[
569
client_interface])),
570
570
path=path)
571
571
572
572
def add_client(self, client, path=None):
574
574
if path is None:
575
575
path = client.proxy.object_path
576
576
self.clients_dict[path] = client
577
self.clients.sort(None, lambda c: c.properties["Name"])
577
self.clients.sort(key=lambda c: c.properties["Name"])
578
578
self.refresh()
579
579
580
580
def remove_client(self, client, path=None):
582
582
if path is None:
583
583
path = client.proxy.object_path
584
584
del self.clients_dict[path]
585
if not self.clients_dict:
586
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
587
# is completely emptied, we need to recreate it.
588
self.clients = urwid.SimpleListWalker([])
589
self.rebuild()
590
585
self.refresh()
591
586
592
587
def refresh(self):
605
600
try:
606
601
mandos_clients = (self.mandos_serv
607
602
.GetAllClientsWithProperties())
603
if not mandos_clients:
604
self.log_message_raw(("bold", "Note: Server has no clients."))
608
605
except dbus.exceptions.DBusException:
606
self.log_message_raw(("bold", "Note: No Mandos server running."))
609
607
mandos_clients = dbus.Dictionary()
610
608
611
609
(self.mandos_serv
612
.connect_to_signal("ClientRemoved",
610
.connect_to_signal("InterfacesRemoved",
613
611
self.find_and_remove_client,
614
dbus_interface=server_interface,
612
dbus_interface
613
= dbus.OBJECT_MANAGER_IFACE,
615
614
byte_arrays=True))
616
615
(self.mandos_serv
617
.connect_to_signal("ClientAdded",
616
.connect_to_signal("InterfacesAdded",
618
617
self.add_new_client,
619
dbus_interface=server_interface,
618
dbus_interface
619
= dbus.OBJECT_MANAGER_IFACE,
620
620
byte_arrays=True))
621
621
(self.mandos_serv
622
622
.connect_to_signal("ClientNotFound",
623
623
self.client_not_found,
624
624
dbus_interface=server_interface,
625
625
byte_arrays=True))
626
for path, client in mandos_clients.iteritems():
626
for path, client in mandos_clients.items():
627
627
client_proxy_object = self.bus.get_object(self.busname,
628
628
path)
629
629
self.add_client(MandosClientWidget(server_proxy_object
638
638
logger
639
639
=self.log_message),
640
640
path=path)
641
641
642
642
self.refresh()
643
643
self._input_callback_tag = (gobject.io_add_watch
644
644
(sys.stdin.fileno(),
676
676
elif key == "window resize":
677
677
self.size = self.screen.get_cols_rows()
678
678
self.refresh()
679
elif key == "\f": # Ctrl-L
679
elif key == "ctrl l":
680
self.screen.clear()
680
681
self.refresh()
681
682
elif key == "l" or key == "D":
682
683
self.toggle_log_display()
694
695
"?: Help",
695
696
"l: Log window toggle",
696
697
"TAB: Switch window",
697
"w: Wrap (log)"))))
698
"w: Wrap (log lines)",
699
"v: Toggle verbose log",
700
))))
698
701
self.log_message_raw(("bold",
699
702
" "
700
703
.join(("Clients:",
713
716
else:
714
717
self.topwidget.set_focus(self.logbox)
715
718
self.refresh()
719
elif key == "v":
720
if self.log_level == 0:
721
self.log_level = 1
722
self.log_message("Verbose mode: Off")
723
else:
724
self.log_level = 0
725
self.log_message("Verbose mode: On")
716
726
#elif (key == "end" or key == "meta >" or key == "G"
717
727
# or key == ">"):
718
728
# pass # xxx end-of-buffer
741
751
ui.run()
742
752
except KeyboardInterrupt:
743
753
ui.screen.stop()
744
except Exception, e:
745
ui.log_message(unicode(e))
754
except Exception as e:
755
ui.log_message(str(e))
746
756
ui.screen.stop()
747
757
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0