To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-monitor
- browse files at revision 237.2.212
- compare with another revision
- download diff
- download tarball
- view history from revision 237.2.212
- Committer: teddy at bsnet
- Date: 2010-09-27 18:57:12 UTC
- mto: (24.1.168 mandos) (237.12.2 mandos-persistent) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 270.
- Revision ID: teddy@fukt.bsnet.se-20100927185712-d4t34t3y002xr44x
* mandos-clients.conf.xml (EXPANSION/RUNTIME EXPANSION): List possible
keys.
keys.
- files removed:
- debian/source
- files modified:
- .bzrignore
added
removed
mandos-monitor
22
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
23
#
24
24
25
from __future__ import division, absolute_import, print_function, unicode_literals
25
from __future__ import division, absolute_import, with_statement
26
26
27
27
import sys
28
28
import os
42
42
43
43
import locale
44
44
45
locale.setlocale(locale.LC_ALL, '')
45
locale.setlocale(locale.LC_ALL, u'')
46
46
47
47
import logging
48
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
51
51
domain = 'se.bsnet.fukt'
52
52
server_interface = domain + '.Mandos'
53
53
client_interface = domain + '.Mandos.Client'
54
version = "1.2.3"
54
version = "1.0.15"
55
55
56
56
# Always run in monochrome mode
57
57
urwid.curses_display.curses.has_colors = lambda : False
65
65
"Parse an ISO 8601 date string to a datetime.datetime()"
66
66
if not iso:
67
67
return None
68
d, t = iso.split("T", 1)
69
year, month, day = d.split("-", 2)
70
hour, minute, second = t.split(":", 2)
68
d, t = iso.split(u"T", 1)
69
year, month, day = d.split(u"-", 2)
70
hour, minute, second = t.split(u":", 2)
71
71
second, fraction = divmod(float(second), 1)
72
72
return datetime.datetime(int(year),
73
73
int(month),
86
86
self.proxy = proxy_object # Mandos Client proxy object
87
87
88
88
self.properties = dict()
89
self.proxy.connect_to_signal("PropertyChanged",
89
self.proxy.connect_to_signal(u"PropertyChanged",
90
90
self.property_changed,
91
91
client_interface,
92
92
byte_arrays=True)
127
127
self.last_checker_failed = False
128
128
129
129
# The widget shown normally
130
self._text_widget = urwid.Text("")
130
self._text_widget = urwid.Text(u"")
131
131
# The widget shown when we have focus
132
self._focus_text_widget = urwid.Text("")
132
self._focus_text_widget = urwid.Text(u"")
133
133
super(MandosClientWidget, self).__init__(
134
134
update_hook=update_hook, delete_hook=delete_hook,
135
135
*args, **kwargs)
137
137
self.opened = False
138
138
139
139
last_checked_ok = isoformat_to_datetime(self.properties
140
["LastCheckedOK"])
140
[u"LastCheckedOK"])
141
141
if last_checked_ok is None:
142
142
self.last_checker_failed = True
143
143
else:
146
146
> datetime.timedelta
147
147
(milliseconds=
148
148
self.properties
149
["Interval"]))
149
[u"Interval"]))
150
150
151
151
if self.last_checker_failed:
152
152
self.using_timer(True)
154
154
if self.need_approval:
155
155
self.using_timer(True)
156
156
157
self.proxy.connect_to_signal("CheckerCompleted",
157
self.proxy.connect_to_signal(u"CheckerCompleted",
158
158
self.checker_completed,
159
159
client_interface,
160
160
byte_arrays=True)
161
self.proxy.connect_to_signal("CheckerStarted",
161
self.proxy.connect_to_signal(u"CheckerStarted",
162
162
self.checker_started,
163
163
client_interface,
164
164
byte_arrays=True)
165
self.proxy.connect_to_signal("GotSecret",
165
self.proxy.connect_to_signal(u"GotSecret",
166
166
self.got_secret,
167
167
client_interface,
168
168
byte_arrays=True)
169
self.proxy.connect_to_signal("NeedApproval",
169
self.proxy.connect_to_signal(u"NeedApproval",
170
170
self.need_approval,
171
171
client_interface,
172
172
byte_arrays=True)
173
self.proxy.connect_to_signal("Rejected",
173
self.proxy.connect_to_signal(u"Rejected",
174
174
self.rejected,
175
175
client_interface,
176
176
byte_arrays=True)
178
178
def property_changed(self, property=None, value=None):
179
179
super(self, MandosClientWidget).property_changed(property,
180
180
value)
181
if property == "ApprovalPending":
181
if property == u"ApprovalPending":
182
182
using_timer(bool(value))
183
183
184
184
def using_timer(self, flag):
203
203
if self.last_checker_failed:
204
204
self.last_checker_failed = False
205
205
self.using_timer(False)
206
#self.logger('Checker for client %s (command "%s")'
207
# ' was successful'
208
# % (self.properties["Name"], command))
206
#self.logger(u'Checker for client %s (command "%s")'
207
# u' was successful'
208
# % (self.properties[u"Name"], command))
209
209
self.update()
210
210
return
211
211
# Checker failed
213
213
self.last_checker_failed = True
214
214
self.using_timer(True)
215
215
if os.WIFEXITED(condition):
216
self.logger('Checker for client %s (command "%s")'
217
' failed with exit code %s'
218
% (self.properties["Name"], command,
216
self.logger(u'Checker for client %s (command "%s")'
217
u' failed with exit code %s'
218
% (self.properties[u"Name"], command,
219
219
os.WEXITSTATUS(condition)))
220
220
elif os.WIFSIGNALED(condition):
221
self.logger('Checker for client %s (command "%s")'
222
' was killed by signal %s'
223
% (self.properties["Name"], command,
221
self.logger(u'Checker for client %s (command "%s")'
222
u' was killed by signal %s'
223
% (self.properties[u"Name"], command,
224
224
os.WTERMSIG(condition)))
225
225
elif os.WCOREDUMP(condition):
226
self.logger('Checker for client %s (command "%s")'
227
' dumped core'
228
% (self.properties["Name"], command))
226
self.logger(u'Checker for client %s (command "%s")'
227
u' dumped core'
228
% (self.properties[u"Name"], command))
229
229
else:
230
self.logger('Checker for client %s completed'
231
' mysteriously')
230
self.logger(u'Checker for client %s completed'
231
u' mysteriously')
232
232
self.update()
233
233
234
234
def checker_started(self, command):
235
#self.logger('Client %s started checker "%s"'
236
# % (self.properties["Name"], unicode(command)))
235
#self.logger(u'Client %s started checker "%s"'
236
# % (self.properties[u"Name"], unicode(command)))
237
237
pass
238
238
239
239
def got_secret(self):
240
240
self.last_checker_failed = False
241
self.logger('Client %s received its secret'
242
% self.properties["Name"])
241
self.logger(u'Client %s received its secret'
242
% self.properties[u"Name"])
243
243
244
244
def need_approval(self, timeout, default):
245
245
if not default:
246
message = 'Client %s needs approval within %s seconds'
246
message = u'Client %s needs approval within %s seconds'
247
247
else:
248
message = 'Client %s will get its secret in %s seconds'
248
message = u'Client %s will get its secret in %s seconds'
249
249
self.logger(message
250
% (self.properties["Name"], timeout/1000))
250
% (self.properties[u"Name"], timeout/1000))
251
251
self.using_timer(True)
252
252
253
253
def rejected(self, reason):
254
self.logger('Client %s was rejected; reason: %s'
255
% (self.properties["Name"], reason))
254
self.logger(u'Client %s was rejected; reason: %s'
255
% (self.properties[u"Name"], reason))
256
256
257
257
def selectable(self):
258
258
"""Make this a "selectable" widget.
259
259
This overrides the method from urwid.FlowWidget."""
260
260
return True
261
261
262
def rows(self, maxcolrow, focus=False):
262
def rows(self, (maxcol,), focus=False):
263
263
"""How many rows this widget will occupy might depend on
264
264
whether we have focus or not.
265
265
This overrides the method from urwid.FlowWidget"""
266
return self.current_widget(focus).rows(maxcolrow, focus=focus)
266
return self.current_widget(focus).rows((maxcol,), focus=focus)
267
267
268
268
def current_widget(self, focus=False):
269
269
if focus or self.opened:
273
273
def update(self):
274
274
"Called when what is visible on the screen should be updated."
275
275
# How to add standout mode to a style
276
with_standout = { "normal": "standout",
277
"bold": "bold-standout",
278
"underline-blink":
279
"underline-blink-standout",
280
"bold-underline-blink":
281
"bold-underline-blink-standout",
276
with_standout = { u"normal": u"standout",
277
u"bold": u"bold-standout",
278
u"underline-blink":
279
u"underline-blink-standout",
280
u"bold-underline-blink":
281
u"bold-underline-blink-standout",
282
282
}
283
283
284
284
# Rebuild focus and non-focus widgets using current properties
285
285
286
286
# Base part of a client. Name!
287
base = ('%(name)s: '
288
% {"name": self.properties["Name"]})
289
if not self.properties["Enabled"]:
290
message = "DISABLED"
291
elif self.properties["ApprovalPending"]:
287
base = (u'%(name)s: '
288
% {u"name": self.properties[u"Name"]})
289
if not self.properties[u"Enabled"]:
290
message = u"DISABLED"
291
elif self.properties[u"ApprovalPending"]:
292
292
timeout = datetime.timedelta(milliseconds
293
293
= self.properties
294
["ApprovalDelay"])
294
[u"ApprovalDelay"])
295
295
last_approval_request = isoformat_to_datetime(
296
self.properties["LastApprovalRequest"])
296
self.properties[u"LastApprovalRequest"])
297
297
if last_approval_request is not None:
298
298
timer = timeout - (datetime.datetime.utcnow()
299
299
- last_approval_request)
300
300
else:
301
301
timer = datetime.timedelta()
302
if self.properties["ApprovedByDefault"]:
303
message = "Approval in %s. (d)eny?"
302
if self.properties[u"ApprovedByDefault"]:
303
message = u"Approval in %s. (d)eny?"
304
304
else:
305
message = "Denial in %s. (a)pprove?"
305
message = u"Denial in %s. (a)pprove?"
306
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
307
elif self.last_checker_failed:
308
308
timeout = datetime.timedelta(milliseconds
309
309
= self.properties
310
["Timeout"])
310
[u"Timeout"])
311
311
last_ok = isoformat_to_datetime(
312
max((self.properties["LastCheckedOK"]
313
or self.properties["Created"]),
314
self.properties["LastEnabled"]))
312
max((self.properties[u"LastCheckedOK"]
313
or self.properties[u"Created"]),
314
self.properties[u"LastEnabled"]))
315
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
message = ('A checker has failed! Time until client'
317
' gets disabled: %s'
316
message = (u'A checker has failed! Time until client'
317
u' gets disabled: %s'
318
318
% unicode(timer).rsplit(".", 1)[0])
319
319
else:
320
message = "enabled"
320
message = u"enabled"
321
321
self._text = "%s%s" % (base, message)
322
322
323
323
if not urwid.supports_unicode():
324
324
self._text = self._text.encode("ascii", "replace")
325
textlist = [("normal", self._text)]
325
textlist = [(u"normal", self._text)]
326
326
self._text_widget.set_text(textlist)
327
327
self._focus_text_widget.set_text([(with_standout[text[0]],
328
328
text[1])
348
348
if self.delete_hook is not None:
349
349
self.delete_hook(self)
350
350
351
def render(self, maxcolrow, focus=False):
351
def render(self, (maxcol,), focus=False):
352
352
"""Render differently if we have focus.
353
353
This overrides the method from urwid.FlowWidget"""
354
return self.current_widget(focus).render(maxcolrow,
354
return self.current_widget(focus).render((maxcol,),
355
355
focus=focus)
356
356
357
def keypress(self, maxcolrow, key):
357
def keypress(self, (maxcol,), key):
358
358
"""Handle keys.
359
359
This overrides the method from urwid.FlowWidget"""
360
if key == "+":
360
if key == u"+":
361
361
self.proxy.Enable(dbus_interface = client_interface)
362
elif key == "-":
362
elif key == u"-":
363
363
self.proxy.Disable(dbus_interface = client_interface)
364
elif key == "a":
364
elif key == u"a":
365
365
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
366
dbus_interface = client_interface)
367
elif key == "d":
367
elif key == u"d":
368
368
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
369
dbus_interface = client_interface)
370
elif key == "R" or key == "_" or key == "ctrl k":
370
elif key == u"R" or key == u"_" or key == u"ctrl k":
371
371
self.server_proxy_object.RemoveClient(self.proxy
372
372
.object_path)
373
elif key == "s":
373
elif key == u"s":
374
374
self.proxy.StartChecker(dbus_interface = client_interface)
375
elif key == "S":
375
elif key == u"S":
376
376
self.proxy.StopChecker(dbus_interface = client_interface)
377
elif key == "C":
377
elif key == u"C":
378
378
self.proxy.CheckedOK(dbus_interface = client_interface)
379
379
# xxx
380
# elif key == "p" or key == "=":
380
# elif key == u"p" or key == "=":
381
381
# self.proxy.pause()
382
# elif key == "u" or key == ":":
382
# elif key == u"u" or key == ":":
383
383
# self.proxy.unpause()
384
# elif key == "RET":
384
# elif key == u"RET":
385
385
# self.open()
386
386
else:
387
387
return key
403
403
"down" key presses, thus not allowing any containing widgets to
404
404
use them as an excuse to shift focus away from this widget.
405
405
"""
406
def keypress(self, maxcolrow, key):
407
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
408
if ret in ("up", "down"):
406
def keypress(self, (maxcol, maxrow), key):
407
ret = super(ConstrainedListBox, self).keypress((maxcol,
408
maxrow), key)
409
if ret in (u"up", u"down"):
409
410
return
410
411
return ret
411
412
420
421
self.screen = urwid.curses_display.Screen()
421
422
422
423
self.screen.register_palette((
423
("normal",
424
"default", "default", None),
425
("bold",
426
"default", "default", "bold"),
427
("underline-blink",
428
"default", "default", "underline"),
429
("standout",
430
"default", "default", "standout"),
431
("bold-underline-blink",
432
"default", "default", ("bold", "underline")),
433
("bold-standout",
434
"default", "default", ("bold", "standout")),
435
("underline-blink-standout",
436
"default", "default", ("underline", "standout")),
437
("bold-underline-blink-standout",
438
"default", "default", ("bold", "underline",
439
"standout")),
424
(u"normal",
425
u"default", u"default", None),
426
(u"bold",
427
u"default", u"default", u"bold"),
428
(u"underline-blink",
429
u"default", u"default", u"underline"),
430
(u"standout",
431
u"default", u"default", u"standout"),
432
(u"bold-underline-blink",
433
u"default", u"default", (u"bold", u"underline")),
434
(u"bold-standout",
435
u"default", u"default", (u"bold", u"standout")),
436
(u"underline-blink-standout",
437
u"default", u"default", (u"underline", u"standout")),
438
(u"bold-underline-blink-standout",
439
u"default", u"default", (u"bold", u"underline",
440
u"standout")),
440
441
))
441
442
442
443
if urwid.supports_unicode():
443
self.divider = "─" # \u2500
444
#self.divider = "━" # \u2501
444
self.divider = u"─" # \u2500
445
#self.divider = u"━" # \u2501
445
446
else:
446
#self.divider = "-" # \u002d
447
self.divider = "_" # \u005f
447
#self.divider = u"-" # \u002d
448
self.divider = u"_" # \u005f
448
449
449
450
self.screen.start()
450
451
464
465
# This keeps track of whether self.uilist currently has
465
466
# self.logbox in it or not
466
467
self.log_visible = True
467
self.log_wrap = "any"
468
self.log_wrap = u"any"
468
469
469
470
self.rebuild()
470
self.log_message_raw(("bold",
471
"Mandos Monitor version " + version))
472
self.log_message_raw(("bold",
473
"q: Quit ?: Help"))
471
self.log_message_raw((u"bold",
472
u"Mandos Monitor version " + version))
473
self.log_message_raw((u"bold",
474
u"q: Quit ?: Help"))
474
475
475
476
self.busname = domain + '.Mandos'
476
477
self.main_loop = gobject.MainLoop()
477
478
self.bus = dbus.SystemBus()
478
479
mandos_dbus_objc = self.bus.get_object(
479
self.busname, "/", follow_name_owner_changes=True)
480
self.busname, u"/", follow_name_owner_changes=True)
480
481
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
482
dbus_interface
482
483
= server_interface)
487
488
mandos_clients = dbus.Dictionary()
488
489
489
490
(self.mandos_serv
490
.connect_to_signal("ClientRemoved",
491
.connect_to_signal(u"ClientRemoved",
491
492
self.find_and_remove_client,
492
493
dbus_interface=server_interface,
493
494
byte_arrays=True))
494
495
(self.mandos_serv
495
.connect_to_signal("ClientAdded",
496
.connect_to_signal(u"ClientAdded",
496
497
self.add_new_client,
497
498
dbus_interface=server_interface,
498
499
byte_arrays=True))
499
500
(self.mandos_serv
500
.connect_to_signal("ClientNotFound",
501
.connect_to_signal(u"ClientNotFound",
501
502
self.client_not_found,
502
503
dbus_interface=server_interface,
503
504
byte_arrays=True))
518
519
path=path)
519
520
520
521
def client_not_found(self, fingerprint, address):
521
self.log_message(("Client with address %s and fingerprint %s"
522
" could not be found" % (address,
522
self.log_message((u"Client with address %s and fingerprint %s"
523
u" could not be found" % (address,
523
524
fingerprint)))
524
525
525
526
def rebuild(self):
541
542
542
543
def log_message(self, message):
543
544
timestamp = datetime.datetime.now().isoformat()
544
self.log_message_raw(timestamp + ": " + message)
545
self.log_message_raw(timestamp + u": " + message)
545
546
546
547
def log_message_raw(self, markup):
547
548
"""Add a log message to the log buffer."""
550
551
and len(self.log) > self.max_log_length):
551
552
del self.log[0:len(self.log)-self.max_log_length-1]
552
553
self.logbox.set_focus(len(self.logbox.body.contents),
553
coming_from="above")
554
coming_from=u"above")
554
555
self.refresh()
555
556
556
557
def toggle_log_display(self):
557
558
"""Toggle visibility of the log buffer."""
558
559
self.log_visible = not self.log_visible
559
560
self.rebuild()
560
#self.log_message("Log visibility changed to: "
561
#self.log_message(u"Log visibility changed to: "
561
562
# + unicode(self.log_visible))
562
563
563
564
def change_log_display(self):
564
565
"""Change type of log display.
565
566
Currently, this toggles wrapping of text lines."""
566
if self.log_wrap == "clip":
567
self.log_wrap = "any"
567
if self.log_wrap == u"clip":
568
self.log_wrap = u"any"
568
569
else:
569
self.log_wrap = "clip"
570
self.log_wrap = u"clip"
570
571
for textwidget in self.log:
571
572
textwidget.set_wrap_mode(self.log_wrap)
572
#self.log_message("Wrap mode: " + self.log_wrap)
573
#self.log_message(u"Wrap mode: " + self.log_wrap)
573
574
574
575
def find_and_remove_client(self, path, name):
575
576
"""Find an client from its object path and remove it.
602
603
if path is None:
603
604
path = client.proxy.object_path
604
605
self.clients_dict[path] = client
605
self.clients.sort(None, lambda c: c.properties["Name"])
606
self.clients.sort(None, lambda c: c.properties[u"Name"])
606
607
self.refresh()
607
608
608
609
def remove_client(self, client, path=None):
639
640
640
641
def process_input(self, source, condition):
641
642
keys = self.screen.get_input()
642
translations = { "ctrl n": "down", # Emacs
643
"ctrl p": "up", # Emacs
644
"ctrl v": "page down", # Emacs
645
"meta v": "page up", # Emacs
646
" ": "page down", # less
647
"f": "page down", # less
648
"b": "page up", # less
649
"j": "down", # vi
650
"k": "up", # vi
643
translations = { u"ctrl n": u"down", # Emacs
644
u"ctrl p": u"up", # Emacs
645
u"ctrl v": u"page down", # Emacs
646
u"meta v": u"page up", # Emacs
647
u" ": u"page down", # less
648
u"f": u"page down", # less
649
u"b": u"page up", # less
650
u"j": u"down", # vi
651
u"k": u"up", # vi
651
652
}
652
653
for key in keys:
653
654
try:
655
656
except KeyError: # :-)
656
657
pass
657
658
658
if key == "q" or key == "Q":
659
if key == u"q" or key == u"Q":
659
660
self.stop()
660
661
break
661
elif key == "window resize":
662
elif key == u"window resize":
662
663
self.size = self.screen.get_cols_rows()
663
664
self.refresh()
664
elif key == "\f": # Ctrl-L
665
elif key == u"\f": # Ctrl-L
665
666
self.refresh()
666
elif key == "l" or key == "D":
667
elif key == u"l" or key == u"D":
667
668
self.toggle_log_display()
668
669
self.refresh()
669
elif key == "w" or key == "i":
670
elif key == u"w" or key == u"i":
670
671
self.change_log_display()
671
672
self.refresh()
672
elif key == "?" or key == "f1" or key == "esc":
673
elif key == u"?" or key == u"f1" or key == u"esc":
673
674
if not self.log_visible:
674
675
self.log_visible = True
675
676
self.rebuild()
676
self.log_message_raw(("bold",
677
" ".
678
join(("q: Quit",
679
"?: Help",
680
"l: Log window toggle",
681
"TAB: Switch window",
682
"w: Wrap (log)"))))
683
self.log_message_raw(("bold",
684
" "
685
.join(("Clients:",
686
"+: Enable",
687
"-: Disable",
688
"R: Remove",
689
"s: Start new checker",
690
"S: Stop checker",
691
"C: Checker OK",
692
"a: Approve",
693
"d: Deny"))))
677
self.log_message_raw((u"bold",
678
u" ".
679
join((u"q: Quit",
680
u"?: Help",
681
u"l: Log window toggle",
682
u"TAB: Switch window",
683
u"w: Wrap (log)"))))
684
self.log_message_raw((u"bold",
685
u" "
686
.join((u"Clients:",
687
u"+: Enable",
688
u"-: Disable",
689
u"R: Remove",
690
u"s: Start new checker",
691
u"S: Stop checker",
692
u"C: Checker OK",
693
u"a: Approve",
694
u"d: Deny"))))
694
695
self.refresh()
695
elif key == "tab":
696
elif key == u"tab":
696
697
if self.topwidget.get_focus() is self.logbox:
697
698
self.topwidget.set_focus(0)
698
699
else:
699
700
self.topwidget.set_focus(self.logbox)
700
701
self.refresh()
701
#elif (key == "end" or key == "meta >" or key == "G"
702
# or key == ">"):
702
#elif (key == u"end" or key == u"meta >" or key == u"G"
703
# or key == u">"):
703
704
# pass # xxx end-of-buffer
704
#elif (key == "home" or key == "meta <" or key == "g"
705
# or key == "<"):
705
#elif (key == u"home" or key == u"meta <" or key == u"g"
706
# or key == u"<"):
706
707
# pass # xxx beginning-of-buffer
707
#elif key == "ctrl e" or key == "$":
708
#elif key == u"ctrl e" or key == u"$":
708
709
# pass # xxx move-end-of-line
709
#elif key == "ctrl a" or key == "^":
710
#elif key == u"ctrl a" or key == u"^":
710
711
# pass # xxx move-beginning-of-line
711
#elif key == "ctrl b" or key == "meta (" or key == "h":
712
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
712
713
# pass # xxx left
713
#elif key == "ctrl f" or key == "meta )" or key == "l":
714
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
714
715
# pass # xxx right
715
#elif key == "a":
716
#elif key == u"a":
716
717
# pass # scroll up log
717
#elif key == "z":
718
#elif key == u"z":
718
719
# pass # scroll down log
719
720
elif self.topwidget.selectable():
720
721
self.topwidget.keypress(self.size, key)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0