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 505.1.23
- compare with another revision
- download diff
- download tarball
- view history from revision 505.1.23
- Committer: Teddy Hogeborn
- Date: 2011-12-21 17:16:00 UTC
- mto: This revision was merged to the branch mainline in revision 527.
- Revision ID: teddy@recompile.se-20111221171600-riv7zgtnb3rojcfl
* mandos (main): Handle EOFError when reading state file.
- files removed:
- 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-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 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
22
# Contact the authors at <mandos@recompile.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
60
52
domain = 'se.recompile'
61
53
server_interface = domain + '.Mandos'
62
54
client_interface = domain + '.Mandos.Client'
63
version = "1.6.9"
55
version = "1.4.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
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
222
if not self.last_checker_failed:
223
self.last_checker_failed = True
224
self.using_timer(True)
184
225
if os.WIFEXITED(condition):
185
self.logger('Checker for client {} (command "{}") failed'
186
' with exit code {}'
187
.format(self.properties["Name"], command,
188
os.WEXITSTATUS(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)))
189
230
elif os.WIFSIGNALED(condition):
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
os.WTERMSIG(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)))
194
235
elif os.WCOREDUMP(condition):
195
self.logger('Checker for client {} (command "{}") dumped'
196
' core'.format(self.properties["Name"],
197
command))
236
self.logger('Checker for client %s (command "%s")'
237
' dumped core'
238
% (self.properties["Name"], command))
198
239
else:
199
self.logger('Checker for client {} completed'
200
' mysteriously'
201
.format(self.properties["Name"]))
240
self.logger('Checker for client %s completed'
241
' mysteriously')
202
242
self.update()
203
243
204
244
def checker_started(self, command):
205
"""Server signals that a checker started."""
206
self.logger('Client {} started checker "{}"'
207
.format(self.properties["Name"],
208
command), level=0)
245
#self.logger('Client %s started checker "%s"'
246
# % (self.properties["Name"], unicode(command)))
247
pass
209
248
210
249
def got_secret(self):
211
self.logger('Client {} received its secret'
212
.format(self.properties["Name"]))
250
self.last_checker_failed = False
251
self.logger('Client %s received its secret'
252
% self.properties["Name"])
213
253
214
254
def need_approval(self, timeout, default):
215
255
if not default:
216
message = 'Client {} needs approval within {} seconds'
256
message = 'Client %s needs approval within %s seconds'
217
257
else:
218
message = 'Client {} will get its secret in {} seconds'
219
self.logger(message.format(self.properties["Name"],
220
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)
221
262
222
263
def rejected(self, reason):
223
self.logger('Client {} was rejected; reason: {}'
224
.format(self.properties["Name"], reason))
264
self.logger('Client %s was rejected; reason: %s'
265
% (self.properties["Name"], reason))
225
266
226
267
def selectable(self):
227
268
"""Make this a "selectable" widget.
249
290
"bold-underline-blink":
250
291
"bold-underline-blink-standout",
251
292
}
252
293
253
294
# Rebuild focus and non-focus widgets using current properties
254
295
255
296
# Base part of a client. Name!
256
base = '{name}: '.format(name=self.properties["Name"])
297
base = ('%(name)s: '
298
% {"name": self.properties["Name"]})
257
299
if not self.properties["Enabled"]:
258
300
message = "DISABLED"
259
self.using_timer(False)
260
301
elif self.properties["ApprovalPending"]:
261
302
timeout = datetime.timedelta(milliseconds
262
303
= self.properties
264
305
last_approval_request = isoformat_to_datetime(
265
306
self.properties["LastApprovalRequest"])
266
307
if last_approval_request is not None:
267
timer = max(timeout - (datetime.datetime.utcnow()
268
- last_approval_request),
269
datetime.timedelta())
308
timer = timeout - (datetime.datetime.utcnow()
309
- last_approval_request)
270
310
else:
271
311
timer = datetime.timedelta()
272
312
if self.properties["ApprovedByDefault"]:
273
message = "Approval in {}. (d)eny?"
313
message = "Approval in %s. (d)eny?"
274
314
else:
275
message = "Denial in {}. (a)pprove?"
276
message = message.format(str(timer).rsplit(".", 1)[0])
277
self.using_timer(True)
278
elif self.properties["LastCheckerStatus"] != 0:
279
# 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
280
319
expires = self.properties["Expires"]
281
320
if expires == "":
282
321
timer = datetime.timedelta(0)
283
322
else:
284
expires = (datetime.datetime.strptime
285
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
286
timer = max(expires - datetime.datetime.utcnow(),
287
datetime.timedelta())
323
expires = datetime.datetime.strptime(expires,
324
'%Y-%m-%dT%H:%M:%S.%f')
325
timer = expires - datetime.datetime.utcnow()
288
326
message = ('A checker has failed! Time until client'
289
' gets disabled: {}'
290
.format(str(timer).rsplit(".", 1)[0]))
291
self.using_timer(True)
327
' gets disabled: %s'
328
% unicode(timer).rsplit(".", 1)[0])
292
329
else:
293
330
message = "enabled"
294
self.using_timer(False)
295
self._text = "{}{}".format(base, message)
296
331
self._text = "%s%s" % (base, message)
332
297
333
if not urwid.supports_unicode():
298
334
self._text = self._text.encode("ascii", "replace")
299
335
textlist = [("normal", self._text)]
316
352
self.update()
317
353
return True # Keep calling this
318
354
319
def delete(self, **kwargs):
355
def delete(self, *args, **kwargs):
320
356
if self._update_timer_callback_tag is not None:
321
357
gobject.source_remove(self._update_timer_callback_tag)
322
358
self._update_timer_callback_tag = None
325
361
self.match_objects = ()
326
362
if self.delete_hook is not None:
327
363
self.delete_hook(self)
328
return super(MandosClientWidget, self).delete(**kwargs)
364
return super(MandosClientWidget, self).delete(*args, **kwargs)
329
365
330
366
def render(self, maxcolrow, focus=False):
331
367
"""Render differently if we have focus.
373
409
else:
374
410
return key
375
411
376
def properties_changed(self, interface, properties, invalidated):
377
"""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.
378
415
This overrides the method from MandosClientPropertyCache"""
379
old_values = { key: self.properties.get(key)
380
for key in properties.keys() }
381
super(MandosClientWidget, self).properties_changed(
382
interface, properties, invalidated)
383
if any(old_values[key] != self.properties.get(key)
384
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:
385
421
self.update()
386
422
387
423
390
426
"down" key presses, thus not allowing any containing widgets to
391
427
use them as an excuse to shift focus away from this widget.
392
428
"""
393
def keypress(self, *args, **kwargs):
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
429
def keypress(self, maxcolrow, key):
430
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
395
431
if ret in ("up", "down"):
396
432
return
397
433
return ret
401
437
"""This is the entire user interface - the whole screen
402
438
with boxes, lists of client widgets, etc.
403
439
"""
404
def __init__(self, max_log_length=1000, log_level=1):
440
def __init__(self, max_log_length=1000):
405
441
DBusGMainLoop(set_as_default=True)
406
442
407
443
self.screen = urwid.curses_display.Screen()
410
446
("normal",
411
447
"default", "default", None),
412
448
("bold",
413
"bold", "default", "bold"),
449
"default", "default", "bold"),
414
450
("underline-blink",
415
"underline,blink", "default", "underline,blink"),
451
"default", "default", "underline"),
416
452
("standout",
417
"standout", "default", "standout"),
453
"default", "default", "standout"),
418
454
("bold-underline-blink",
419
"bold,underline,blink", "default", "bold,underline,blink"),
455
"default", "default", ("bold", "underline")),
420
456
("bold-standout",
421
"bold,standout", "default", "bold,standout"),
457
"default", "default", ("bold", "standout")),
422
458
("underline-blink-standout",
423
"underline,blink,standout", "default",
424
"underline,blink,standout"),
459
"default", "default", ("underline", "standout")),
425
460
("bold-underline-blink-standout",
426
"bold,underline,blink,standout", "default",
427
"bold,underline,blink,standout"),
461
"default", "default", ("bold", "underline",
462
"standout")),
428
463
))
429
464
430
465
if urwid.supports_unicode():
445
480
self.log = []
446
481
self.max_log_length = max_log_length
447
482
448
self.log_level = log_level
449
450
483
# We keep a reference to the log widget so we can remove it
451
484
# from the ListWalker without it getting destroyed
452
485
self.logbox = ConstrainedListBox(self.log)
464
497
465
498
self.busname = domain + '.Mandos'
466
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)
467
542
468
543
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {} and fingerprint {}"
470
" could not be found"
471
.format(address, fingerprint))
544
self.log_message(("Client with address %s and fingerprint %s"
545
" could not be found" % (address,
546
fingerprint)))
472
547
473
548
def rebuild(self):
474
549
"""This rebuilds the User Interface.
484
559
self.divider)))
485
560
if self.log_visible:
486
561
self.uilist.append(self.logbox)
562
pass
487
563
self.topwidget = urwid.Pile(self.uilist)
488
564
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
565
def log_message(self, message):
493
566
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
567
self.log_message_raw(timestamp + ": " + message)
496
568
497
def log_message_raw(self, markup, level=1):
569
def log_message_raw(self, markup):
498
570
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
501
571
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
572
if (self.max_log_length
503
573
and len(self.log) > self.max_log_length):
510
580
"""Toggle visibility of the log buffer."""
511
581
self.log_visible = not self.log_visible
512
582
self.rebuild()
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
583
#self.log_message("Log visibility changed to: "
584
# + unicode(self.log_visible))
515
585
516
586
def change_log_display(self):
517
587
"""Change type of log display.
522
592
self.log_wrap = "clip"
523
593
for textwidget in self.log:
524
594
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
595
#self.log_message("Wrap mode: " + self.log_wrap)
527
596
528
597
def find_and_remove_client(self, path, name):
529
598
"""Find a client by its object path and remove it.
534
603
client = self.clients_dict[path]
535
604
except KeyError:
536
605
# not found?
537
self.log_message("Unknown client {!r} ({!r}) removed"
538
.format(name, path))
606
self.log_message("Unknown client %r (%r) removed", name,
607
path)
539
608
return
540
609
client.delete()
541
610
558
627
if path is None:
559
628
path = client.proxy.object_path
560
629
self.clients_dict[path] = client
561
self.clients.sort(key=lambda c: c.properties["Name"])
630
self.clients.sort(None, lambda c: c.properties["Name"])
562
631
self.refresh()
563
632
564
633
def remove_client(self, client, path=None):
566
635
if path is None:
567
636
path = client.proxy.object_path
568
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()
569
643
self.refresh()
570
644
571
645
def refresh(self):
575
649
576
650
def run(self):
577
651
"""Start the main loop and exit when it's done."""
578
self.bus = dbus.SystemBus()
579
mandos_dbus_objc = self.bus.get_object(
580
self.busname, "/", follow_name_owner_changes=True)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
582
dbus_interface
583
= server_interface)
584
try:
585
mandos_clients = (self.mandos_serv
586
.GetAllClientsWithProperties())
587
if not mandos_clients:
588
self.log_message_raw(("bold", "Note: Server has no clients."))
589
except dbus.exceptions.DBusException:
590
self.log_message_raw(("bold", "Note: No Mandos server running."))
591
mandos_clients = dbus.Dictionary()
592
593
(self.mandos_serv
594
.connect_to_signal("ClientRemoved",
595
self.find_and_remove_client,
596
dbus_interface=server_interface,
597
byte_arrays=True))
598
(self.mandos_serv
599
.connect_to_signal("ClientAdded",
600
self.add_new_client,
601
dbus_interface=server_interface,
602
byte_arrays=True))
603
(self.mandos_serv
604
.connect_to_signal("ClientNotFound",
605
self.client_not_found,
606
dbus_interface=server_interface,
607
byte_arrays=True))
608
for path, client in mandos_clients.items():
609
client_proxy_object = self.bus.get_object(self.busname,
610
path)
611
self.add_client(MandosClientWidget(server_proxy_object
612
=self.mandos_serv,
613
proxy_object
614
=client_proxy_object,
615
properties=client,
616
update_hook
617
=self.refresh,
618
delete_hook
619
=self.remove_client,
620
logger
621
=self.log_message),
622
path=path)
623
624
652
self.refresh()
625
653
self._input_callback_tag = (gobject.io_add_watch
626
654
(sys.stdin.fileno(),
658
686
elif key == "window resize":
659
687
self.size = self.screen.get_cols_rows()
660
688
self.refresh()
661
elif key == "ctrl l":
662
self.screen.clear()
689
elif key == "\f": # Ctrl-L
663
690
self.refresh()
664
691
elif key == "l" or key == "D":
665
692
self.toggle_log_display()
677
704
"?: Help",
678
705
"l: Log window toggle",
679
706
"TAB: Switch window",
680
"w: Wrap (log lines)",
681
"v: Toggle verbose log",
682
))))
707
"w: Wrap (log)"))))
683
708
self.log_message_raw(("bold",
684
709
" "
685
710
.join(("Clients:",
698
723
else:
699
724
self.topwidget.set_focus(self.logbox)
700
725
self.refresh()
701
elif key == "v":
702
if self.log_level == 0:
703
self.log_level = 1
704
self.log_message("Verbose mode: Off")
705
else:
706
self.log_level = 0
707
self.log_message("Verbose mode: On")
708
726
#elif (key == "end" or key == "meta >" or key == "G"
709
727
# or key == ">"):
710
728
# pass # xxx end-of-buffer
733
751
ui.run()
734
752
except KeyboardInterrupt:
735
753
ui.screen.stop()
736
except Exception as e:
737
ui.log_message(str(e))
754
except Exception, e:
755
ui.log_message(unicode(e))
738
756
ui.screen.stop()
739
757
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0