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 24.1.184
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.184
- Committer: Björn Påhlsson
- Date: 2011-09-26 18:47:38 UTC
- mto: This revision was merged to the branch mainline in revision 502.
- Revision ID: belorn@fukt.bsnet.se-20110926184738-ee8kz5vc9pb3393m
updated TODO
- files removed:
- debian/mandos-client.examples
- debian/upstream
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2015 Teddy Hogeborn
7
# Copyright © 2009-2015 Björn Påhlsson
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 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
17
17
# GNU General Public License for more details.
18
18
#
19
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
21
#
23
# Contact the authors at <mandos@recompile.se>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
24
23
#
25
24
26
25
from __future__ import (division, absolute_import, print_function,
27
26
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
32
27
33
28
import sys
34
29
import os
30
import signal
35
31
36
32
import datetime
37
33
39
35
import urwid
40
36
41
37
from dbus.mainloop.glib import DBusGMainLoop
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
38
import gobject
46
39
47
40
import dbus
48
41
42
import UserList
43
49
44
import locale
50
45
51
if sys.version_info.major == 2:
52
str = unicode
53
54
46
locale.setlocale(locale.LC_ALL, '')
55
47
56
48
import logging
57
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
58
50
59
51
# Some useful constants
60
domain = 'se.recompile'
52
domain = 'se.bsnet.fukt'
61
53
server_interface = domain + '.Mandos'
62
54
client_interface = domain + '.Mandos.Client'
63
version = "1.6.9"
55
version = "1.3.1"
56
57
# Always run in monochrome mode
58
urwid.curses_display.curses.has_colors = lambda : False
59
60
# Urwid doesn't support blinking, but we want it. Since we have no
61
# use for underline on its own, we make underline also always blink.
62
urwid.curses_display.curses.A_UNDERLINE |= (
63
urwid.curses_display.curses.A_BLINK)
64
64
65
65
def isoformat_to_datetime(iso):
66
66
"Parse an ISO 8601 date string to a datetime.datetime()"
83
83
properties and calls a hook function when any of them are
84
84
changed.
85
85
"""
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
86
def __init__(self, proxy_object=None, *args, **kwargs):
87
87
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
88
89
self.properties = dict()
89
90
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertiesChanged",
91
self.properties_changed,
92
dbus.PROPERTIES_IFACE,
91
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
93
client_interface,
93
94
byte_arrays=True))
94
95
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface = dbus.PROPERTIES_IFACE))
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
102
103
103
def properties_changed(self, interface, properties, invalidated):
104
"""This is called whenever we get a PropertiesChanged signal
105
It updates the changed properties in the "properties" dict.
104
def property_changed(self, property=None, value=None):
105
"""This is called whenever we get a PropertyChanged signal
106
It updates the changed property in the "properties" dict.
106
107
"""
107
108
# Update properties dict with new value
108
self.properties.update(properties)
109
self.properties[property] = value
109
110
110
def delete(self):
111
def delete(self, *args, **kwargs):
111
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
112
115
113
116
114
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
116
119
"""
117
120
118
121
def __init__(self, server_proxy_object=None, update_hook=None,
119
delete_hook=None, logger=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
120
123
# Called on update
121
124
self.update_hook = update_hook
122
125
# Called on delete
127
130
self.logger = logger
128
131
129
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
130
135
131
136
# The widget shown normally
132
137
self._text_widget = urwid.Text("")
133
138
# The widget shown when we have focus
134
139
self._focus_text_widget = urwid.Text("")
135
super(MandosClientWidget, self).__init__(**kwargs)
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
142
*args, **kwargs)
136
143
self.update()
137
144
self.opened = False
138
145
146
last_checked_ok = isoformat_to_datetime(self.properties
147
["LastCheckedOK"])
148
if last_checked_ok is None:
149
self.last_checker_failed = True
150
else:
151
self.last_checker_failed = ((datetime.datetime.utcnow()
152
- last_checked_ok)
153
> datetime.timedelta
154
(milliseconds=
155
self.properties
156
["Interval"]))
157
158
if self.last_checker_failed:
159
self.using_timer(True)
160
161
if self.need_approval:
162
self.using_timer(True)
163
139
164
self.match_objects = (
140
165
self.proxy.connect_to_signal("CheckerCompleted",
141
166
self.checker_completed,
157
182
self.rejected,
158
183
client_interface,
159
184
byte_arrays=True))
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
185
#self.logger('Created client %s' % (self.properties["Name"]))
162
186
187
def property_changed(self, property=None, value=None):
188
super(self, MandosClientWidget).property_changed(property,
189
value)
190
if property == "ApprovalPending":
191
using_timer(bool(value))
192
163
193
def using_timer(self, flag):
164
194
"""Call this method with True or False when timer should be
165
195
activated or deactivated.
166
196
"""
167
if flag and self._update_timer_callback_tag is None:
197
old = self._update_timer_callback_lock
198
if flag:
199
self._update_timer_callback_lock += 1
200
else:
201
self._update_timer_callback_lock -= 1
202
if old == 0 and self._update_timer_callback_lock:
168
203
# Will update the shown timer value every second
169
204
self._update_timer_callback_tag = (gobject.timeout_add
170
205
(1000,
171
206
self.update_timer))
172
elif not (flag or self._update_timer_callback_tag is None):
207
elif old and self._update_timer_callback_lock == 0:
173
208
gobject.source_remove(self._update_timer_callback_tag)
174
209
self._update_timer_callback_tag = None
175
210
176
def checker_completed(self, exitstatus, signal, command):
211
def checker_completed(self, exitstatus, condition, command):
177
212
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
180
command), level=0)
213
if self.last_checker_failed:
214
self.last_checker_failed = False
215
self.using_timer(False)
216
#self.logger('Checker for client %s (command "%s")'
217
# ' was successful'
218
# % (self.properties["Name"], command))
181
219
self.update()
182
220
return
183
221
# Checker failed
184
if exitstatus >= 0:
185
self.logger('Checker for client {} (command "{}") failed'
186
' with exit code {}'
187
.format(self.properties["Name"], command,
188
exitstatus))
189
elif signal != 0:
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
signal))
222
if not self.last_checker_failed:
223
self.last_checker_failed = True
224
self.using_timer(True)
225
if os.WIFEXITED(condition):
226
self.logger('Checker for client %s (command "%s")'
227
' failed with exit code %s'
228
% (self.properties["Name"], command,
229
os.WEXITSTATUS(condition)))
230
elif os.WIFSIGNALED(condition):
231
self.logger('Checker for client %s (command "%s")'
232
' was killed by signal %s'
233
% (self.properties["Name"], command,
234
os.WTERMSIG(condition)))
235
elif os.WCOREDUMP(condition):
236
self.logger('Checker for client %s (command "%s")'
237
' dumped core'
238
% (self.properties["Name"], command))
194
239
else:
195
self.logger('Checker for client {} completed'
196
' mysteriously'
197
.format(self.properties["Name"]))
240
self.logger('Checker for client %s completed'
241
' mysteriously')
198
242
self.update()
199
243
200
244
def checker_started(self, command):
201
"""Server signals that a checker started."""
202
self.logger('Client {} started checker "{}"'
203
.format(self.properties["Name"],
204
command), level=0)
245
#self.logger('Client %s started checker "%s"'
246
# % (self.properties["Name"], unicode(command)))
247
pass
205
248
206
249
def got_secret(self):
207
self.logger('Client {} received its secret'
208
.format(self.properties["Name"]))
250
self.last_checker_failed = False
251
self.logger('Client %s received its secret'
252
% self.properties["Name"])
209
253
210
254
def need_approval(self, timeout, default):
211
255
if not default:
212
message = 'Client {} needs approval within {} seconds'
256
message = 'Client %s needs approval within %s seconds'
213
257
else:
214
message = 'Client {} will get its secret in {} seconds'
215
self.logger(message.format(self.properties["Name"],
216
timeout/1000))
258
message = 'Client %s will get its secret in %s seconds'
259
self.logger(message
260
% (self.properties["Name"], timeout/1000))
261
self.using_timer(True)
217
262
218
263
def rejected(self, reason):
219
self.logger('Client {} was rejected; reason: {}'
220
.format(self.properties["Name"], reason))
264
self.logger('Client %s was rejected; reason: %s'
265
% (self.properties["Name"], reason))
221
266
222
267
def selectable(self):
223
268
"""Make this a "selectable" widget.
245
290
"bold-underline-blink":
246
291
"bold-underline-blink-standout",
247
292
}
248
293
249
294
# Rebuild focus and non-focus widgets using current properties
250
295
251
296
# Base part of a client. Name!
252
base = '{name}: '.format(name=self.properties["Name"])
297
base = ('%(name)s: '
298
% {"name": self.properties["Name"]})
253
299
if not self.properties["Enabled"]:
254
300
message = "DISABLED"
255
self.using_timer(False)
256
301
elif self.properties["ApprovalPending"]:
257
302
timeout = datetime.timedelta(milliseconds
258
303
= self.properties
260
305
last_approval_request = isoformat_to_datetime(
261
306
self.properties["LastApprovalRequest"])
262
307
if last_approval_request is not None:
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
308
timer = timeout - (datetime.datetime.utcnow()
309
- last_approval_request)
266
310
else:
267
311
timer = datetime.timedelta()
268
312
if self.properties["ApprovedByDefault"]:
269
message = "Approval in {}. (d)eny?"
313
message = "Approval in %s. (d)eny?"
270
314
else:
271
message = "Denial in {}. (a)pprove?"
272
message = message.format(str(timer).rsplit(".", 1)[0])
273
self.using_timer(True)
274
elif self.properties["LastCheckerStatus"] != 0:
275
# When checker has failed, show timer until client expires
315
message = "Denial in %s. (a)pprove?"
316
message = message % unicode(timer).rsplit(".", 1)[0]
317
elif self.last_checker_failed:
318
# When checker has failed, print a timer until client expires
276
319
expires = self.properties["Expires"]
277
320
if expires == "":
278
321
timer = datetime.timedelta(0)
279
322
else:
280
expires = (datetime.datetime.strptime
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
282
timer = max(expires - datetime.datetime.utcnow(),
283
datetime.timedelta())
323
expires = datetime.datetime.strptime(expires,
324
'%Y-%m-%dT%H:%M:%S.%f')
325
timer = expires - datetime.datetime.utcnow()
284
326
message = ('A checker has failed! Time until client'
285
' gets disabled: {}'
286
.format(str(timer).rsplit(".", 1)[0]))
287
self.using_timer(True)
327
' gets disabled: %s'
328
% unicode(timer).rsplit(".", 1)[0])
288
329
else:
289
330
message = "enabled"
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
292
331
self._text = "%s%s" % (base, message)
332
293
333
if not urwid.supports_unicode():
294
334
self._text = self._text.encode("ascii", "replace")
295
335
textlist = [("normal", self._text)]
312
352
self.update()
313
353
return True # Keep calling this
314
354
315
def delete(self, **kwargs):
355
def delete(self, *args, **kwargs):
316
356
if self._update_timer_callback_tag is not None:
317
357
gobject.source_remove(self._update_timer_callback_tag)
318
358
self._update_timer_callback_tag = None
321
361
self.match_objects = ()
322
362
if self.delete_hook is not None:
323
363
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
364
return super(MandosClientWidget, self).delete(*args, **kwargs)
325
365
326
366
def render(self, maxcolrow, focus=False):
327
367
"""Render differently if we have focus.
369
409
else:
370
410
return key
371
411
372
def properties_changed(self, interface, properties, invalidated):
373
"""Call self.update() if any properties changed.
412
def property_changed(self, property=None, value=None,
413
*args, **kwargs):
414
"""Call self.update() if old value is not new value.
374
415
This overrides the method from MandosClientPropertyCache"""
375
old_values = { key: self.properties.get(key)
376
for key in properties.keys() }
377
super(MandosClientWidget, self).properties_changed(
378
interface, properties, invalidated)
379
if any(old_values[key] != self.properties.get(key)
380
for key in old_values):
416
property_name = unicode(property)
417
old_value = self.properties.get(property_name)
418
super(MandosClientWidget, self).property_changed(
419
property=property, value=value, *args, **kwargs)
420
if self.properties.get(property_name) != old_value:
381
421
self.update()
382
422
383
423
386
426
"down" key presses, thus not allowing any containing widgets to
387
427
use them as an excuse to shift focus away from this widget.
388
428
"""
389
def keypress(self, *args, **kwargs):
390
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
429
def keypress(self, maxcolrow, key):
430
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
391
431
if ret in ("up", "down"):
392
432
return
393
433
return ret
397
437
"""This is the entire user interface - the whole screen
398
438
with boxes, lists of client widgets, etc.
399
439
"""
400
def __init__(self, max_log_length=1000, log_level=1):
440
def __init__(self, max_log_length=1000):
401
441
DBusGMainLoop(set_as_default=True)
402
442
403
443
self.screen = urwid.curses_display.Screen()
406
446
("normal",
407
447
"default", "default", None),
408
448
("bold",
409
"bold", "default", "bold"),
449
"default", "default", "bold"),
410
450
("underline-blink",
411
"underline,blink", "default", "underline,blink"),
451
"default", "default", "underline"),
412
452
("standout",
413
"standout", "default", "standout"),
453
"default", "default", "standout"),
414
454
("bold-underline-blink",
415
"bold,underline,blink", "default", "bold,underline,blink"),
455
"default", "default", ("bold", "underline")),
416
456
("bold-standout",
417
"bold,standout", "default", "bold,standout"),
457
"default", "default", ("bold", "standout")),
418
458
("underline-blink-standout",
419
"underline,blink,standout", "default",
420
"underline,blink,standout"),
459
"default", "default", ("underline", "standout")),
421
460
("bold-underline-blink-standout",
422
"bold,underline,blink,standout", "default",
423
"bold,underline,blink,standout"),
461
"default", "default", ("bold", "underline",
462
"standout")),
424
463
))
425
464
426
465
if urwid.supports_unicode():
441
480
self.log = []
442
481
self.max_log_length = max_log_length
443
482
444
self.log_level = log_level
445
446
483
# We keep a reference to the log widget so we can remove it
447
484
# from the ListWalker without it getting destroyed
448
485
self.logbox = ConstrainedListBox(self.log)
460
497
461
498
self.busname = domain + '.Mandos'
462
499
self.main_loop = gobject.MainLoop()
500
self.bus = dbus.SystemBus()
501
mandos_dbus_objc = self.bus.get_object(
502
self.busname, "/", follow_name_owner_changes=True)
503
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
504
dbus_interface
505
= server_interface)
506
try:
507
mandos_clients = (self.mandos_serv
508
.GetAllClientsWithProperties())
509
except dbus.exceptions.DBusException:
510
mandos_clients = dbus.Dictionary()
511
512
(self.mandos_serv
513
.connect_to_signal("ClientRemoved",
514
self.find_and_remove_client,
515
dbus_interface=server_interface,
516
byte_arrays=True))
517
(self.mandos_serv
518
.connect_to_signal("ClientAdded",
519
self.add_new_client,
520
dbus_interface=server_interface,
521
byte_arrays=True))
522
(self.mandos_serv
523
.connect_to_signal("ClientNotFound",
524
self.client_not_found,
525
dbus_interface=server_interface,
526
byte_arrays=True))
527
for path, client in mandos_clients.iteritems():
528
client_proxy_object = self.bus.get_object(self.busname,
529
path)
530
self.add_client(MandosClientWidget(server_proxy_object
531
=self.mandos_serv,
532
proxy_object
533
=client_proxy_object,
534
properties=client,
535
update_hook
536
=self.refresh,
537
delete_hook
538
=self.remove_client,
539
logger
540
=self.log_message),
541
path=path)
463
542
464
543
def client_not_found(self, fingerprint, address):
465
self.log_message("Client with address {} and fingerprint {}"
466
" could not be found"
467
.format(address, fingerprint))
544
self.log_message(("Client with address %s and fingerprint %s"
545
" could not be found" % (address,
546
fingerprint)))
468
547
469
548
def rebuild(self):
470
549
"""This rebuilds the User Interface.
480
559
self.divider)))
481
560
if self.log_visible:
482
561
self.uilist.append(self.logbox)
562
pass
483
563
self.topwidget = urwid.Pile(self.uilist)
484
564
485
def log_message(self, message, level=1):
486
"""Log message formatted with timestamp"""
487
if level < self.log_level:
488
return
565
def log_message(self, message):
489
566
timestamp = datetime.datetime.now().isoformat()
490
self.log_message_raw("{}: {}".format(timestamp, message),
491
level=level)
567
self.log_message_raw(timestamp + ": " + message)
492
568
493
def log_message_raw(self, markup, level=1):
569
def log_message_raw(self, markup):
494
570
"""Add a log message to the log buffer."""
495
if level < self.log_level:
496
return
497
571
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
498
572
if (self.max_log_length
499
573
and len(self.log) > self.max_log_length):
506
580
"""Toggle visibility of the log buffer."""
507
581
self.log_visible = not self.log_visible
508
582
self.rebuild()
509
self.log_message("Log visibility changed to: {}"
510
.format(self.log_visible), level=0)
583
#self.log_message("Log visibility changed to: "
584
# + unicode(self.log_visible))
511
585
512
586
def change_log_display(self):
513
587
"""Change type of log display.
518
592
self.log_wrap = "clip"
519
593
for textwidget in self.log:
520
594
textwidget.set_wrap_mode(self.log_wrap)
521
self.log_message("Wrap mode: {}".format(self.log_wrap),
522
level=0)
595
#self.log_message("Wrap mode: " + self.log_wrap)
523
596
524
597
def find_and_remove_client(self, path, name):
525
598
"""Find a client by its object path and remove it.
530
603
client = self.clients_dict[path]
531
604
except KeyError:
532
605
# not found?
533
self.log_message("Unknown client {!r} ({!r}) removed"
534
.format(name, path))
606
self.log_message("Unknown client %r (%r) removed", name,
607
path)
535
608
return
536
609
client.delete()
537
610
554
627
if path is None:
555
628
path = client.proxy.object_path
556
629
self.clients_dict[path] = client
557
self.clients.sort(key=lambda c: c.properties["Name"])
630
self.clients.sort(None, lambda c: c.properties["Name"])
558
631
self.refresh()
559
632
560
633
def remove_client(self, client, path=None):
562
635
if path is None:
563
636
path = client.proxy.object_path
564
637
del self.clients_dict[path]
638
if not self.clients_dict:
639
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
640
# is completely emptied, we need to recreate it.
641
self.clients = urwid.SimpleListWalker([])
642
self.rebuild()
565
643
self.refresh()
566
644
567
645
def refresh(self):
571
649
572
650
def run(self):
573
651
"""Start the main loop and exit when it's done."""
574
self.bus = dbus.SystemBus()
575
mandos_dbus_objc = self.bus.get_object(
576
self.busname, "/", follow_name_owner_changes=True)
577
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
578
dbus_interface
579
= server_interface)
580
try:
581
mandos_clients = (self.mandos_serv
582
.GetAllClientsWithProperties())
583
if not mandos_clients:
584
self.log_message_raw(("bold", "Note: Server has no clients."))
585
except dbus.exceptions.DBusException:
586
self.log_message_raw(("bold", "Note: No Mandos server running."))
587
mandos_clients = dbus.Dictionary()
588
589
(self.mandos_serv
590
.connect_to_signal("ClientRemoved",
591
self.find_and_remove_client,
592
dbus_interface=server_interface,
593
byte_arrays=True))
594
(self.mandos_serv
595
.connect_to_signal("ClientAdded",
596
self.add_new_client,
597
dbus_interface=server_interface,
598
byte_arrays=True))
599
(self.mandos_serv
600
.connect_to_signal("ClientNotFound",
601
self.client_not_found,
602
dbus_interface=server_interface,
603
byte_arrays=True))
604
for path, client in mandos_clients.items():
605
client_proxy_object = self.bus.get_object(self.busname,
606
path)
607
self.add_client(MandosClientWidget(server_proxy_object
608
=self.mandos_serv,
609
proxy_object
610
=client_proxy_object,
611
properties=client,
612
update_hook
613
=self.refresh,
614
delete_hook
615
=self.remove_client,
616
logger
617
=self.log_message),
618
path=path)
619
620
652
self.refresh()
621
653
self._input_callback_tag = (gobject.io_add_watch
622
654
(sys.stdin.fileno(),
654
686
elif key == "window resize":
655
687
self.size = self.screen.get_cols_rows()
656
688
self.refresh()
657
elif key == "ctrl l":
658
self.screen.clear()
689
elif key == "\f": # Ctrl-L
659
690
self.refresh()
660
691
elif key == "l" or key == "D":
661
692
self.toggle_log_display()
673
704
"?: Help",
674
705
"l: Log window toggle",
675
706
"TAB: Switch window",
676
"w: Wrap (log lines)",
677
"v: Toggle verbose log",
678
))))
707
"w: Wrap (log)"))))
679
708
self.log_message_raw(("bold",
680
709
" "
681
710
.join(("Clients:",
694
723
else:
695
724
self.topwidget.set_focus(self.logbox)
696
725
self.refresh()
697
elif key == "v":
698
if self.log_level == 0:
699
self.log_level = 1
700
self.log_message("Verbose mode: Off")
701
else:
702
self.log_level = 0
703
self.log_message("Verbose mode: On")
704
726
#elif (key == "end" or key == "meta >" or key == "G"
705
727
# or key == ">"):
706
728
# pass # xxx end-of-buffer
729
751
ui.run()
730
752
except KeyboardInterrupt:
731
753
ui.screen.stop()
732
except Exception as e:
733
ui.log_message(str(e))
754
except Exception, e:
755
ui.log_message(unicode(e))
734
756
ui.screen.stop()
735
757
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0