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 17
- compare with another revision
- download diff
- download tarball
- view history from revision 17
- Committer: Teddy Hogeborn
- Date: 2008-07-21 01:52:54 UTC
- mfrom: (15.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080721015254-5ut0m7j1r4t5x7hj
Merge.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
mandos-monitor
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
11
# the Free Software Foundation, either version 3 of the License, or
12
# (at your option) any later version.
13
#
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
18
#
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
#
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
#
24
25
from __future__ import division, absolute_import, print_function, unicode_literals
26
27
import sys
28
import os
29
import signal
30
31
import datetime
32
33
import urwid.curses_display
34
import urwid
35
36
from dbus.mainloop.glib import DBusGMainLoop
37
import gobject
38
39
import dbus
40
41
import UserList
42
43
import locale
44
45
locale.setlocale(locale.LC_ALL, '')
46
47
import logging
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
50
# Some useful constants
51
domain = 'se.bsnet.fukt'
52
server_interface = domain + '.Mandos'
53
client_interface = domain + '.Mandos.Client'
54
version = "1.3.0"
55
56
# Always run in monochrome mode
57
urwid.curses_display.curses.has_colors = lambda : False
58
59
# Urwid doesn't support blinking, but we want it. Since we have no
60
# use for underline on its own, we make underline also always blink.
61
urwid.curses_display.curses.A_UNDERLINE |= (
62
urwid.curses_display.curses.A_BLINK)
63
64
def isoformat_to_datetime(iso):
65
"Parse an ISO 8601 date string to a datetime.datetime()"
66
if not iso:
67
return None
68
d, t = iso.split("T", 1)
69
year, month, day = d.split("-", 2)
70
hour, minute, second = t.split(":", 2)
71
second, fraction = divmod(float(second), 1)
72
return datetime.datetime(int(year),
73
int(month),
74
int(day),
75
int(hour),
76
int(minute),
77
int(second), # Whole seconds
78
int(fraction*1000000)) # Microseconds
79
80
class MandosClientPropertyCache(object):
81
"""This wraps a Mandos Client D-Bus proxy object, caches the
82
properties and calls a hook function when any of them are
83
changed.
84
"""
85
def __init__(self, proxy_object=None, *args, **kwargs):
86
self.proxy = proxy_object # Mandos Client proxy object
87
88
self.properties = dict()
89
self.proxy.connect_to_signal("PropertyChanged",
90
self.property_changed,
91
client_interface,
92
byte_arrays=True)
93
94
self.properties.update(
95
self.proxy.GetAll(client_interface,
96
dbus_interface = dbus.PROPERTIES_IFACE))
97
98
#XXX This break good super behaviour!
99
# super(MandosClientPropertyCache, self).__init__(
100
# *args, **kwargs)
101
102
def property_changed(self, property=None, value=None):
103
"""This is called whenever we get a PropertyChanged signal
104
It updates the changed property in the "properties" dict.
105
"""
106
# Update properties dict with new value
107
self.properties[property] = value
108
109
110
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
111
"""A Mandos Client which is visible on the screen.
112
"""
113
114
def __init__(self, server_proxy_object=None, update_hook=None,
115
delete_hook=None, logger=None, *args, **kwargs):
116
# Called on update
117
self.update_hook = update_hook
118
# Called on delete
119
self.delete_hook = delete_hook
120
# Mandos Server proxy object
121
self.server_proxy_object = server_proxy_object
122
# Logger
123
self.logger = logger
124
125
self._update_timer_callback_tag = None
126
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
128
129
# The widget shown normally
130
self._text_widget = urwid.Text("")
131
# The widget shown when we have focus
132
self._focus_text_widget = urwid.Text("")
133
super(MandosClientWidget, self).__init__(
134
update_hook=update_hook, delete_hook=delete_hook,
135
*args, **kwargs)
136
self.update()
137
self.opened = False
138
139
last_checked_ok = isoformat_to_datetime(self.properties
140
["LastCheckedOK"])
141
if last_checked_ok is None:
142
self.last_checker_failed = True
143
else:
144
self.last_checker_failed = ((datetime.datetime.utcnow()
145
- last_checked_ok)
146
> datetime.timedelta
147
(milliseconds=
148
self.properties
149
["Interval"]))
150
151
if self.last_checker_failed:
152
self.using_timer(True)
153
154
if self.need_approval:
155
self.using_timer(True)
156
157
self.proxy.connect_to_signal("CheckerCompleted",
158
self.checker_completed,
159
client_interface,
160
byte_arrays=True)
161
self.proxy.connect_to_signal("CheckerStarted",
162
self.checker_started,
163
client_interface,
164
byte_arrays=True)
165
self.proxy.connect_to_signal("GotSecret",
166
self.got_secret,
167
client_interface,
168
byte_arrays=True)
169
self.proxy.connect_to_signal("NeedApproval",
170
self.need_approval,
171
client_interface,
172
byte_arrays=True)
173
self.proxy.connect_to_signal("Rejected",
174
self.rejected,
175
client_interface,
176
byte_arrays=True)
177
178
def property_changed(self, property=None, value=None):
179
super(self, MandosClientWidget).property_changed(property,
180
value)
181
if property == "ApprovalPending":
182
using_timer(bool(value))
183
184
def using_timer(self, flag):
185
"""Call this method with True or False when timer should be
186
activated or deactivated.
187
"""
188
old = self._update_timer_callback_lock
189
if flag:
190
self._update_timer_callback_lock += 1
191
else:
192
self._update_timer_callback_lock -= 1
193
if old == 0 and self._update_timer_callback_lock:
194
self._update_timer_callback_tag = (gobject.timeout_add
195
(1000,
196
self.update_timer))
197
elif old and self._update_timer_callback_lock == 0:
198
gobject.source_remove(self._update_timer_callback_tag)
199
self._update_timer_callback_tag = None
200
201
def checker_completed(self, exitstatus, condition, command):
202
if exitstatus == 0:
203
if self.last_checker_failed:
204
self.last_checker_failed = False
205
self.using_timer(False)
206
#self.logger('Checker for client %s (command "%s")'
207
# ' was successful'
208
# % (self.properties["Name"], command))
209
self.update()
210
return
211
# Checker failed
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
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,
219
os.WEXITSTATUS(condition)))
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,
224
os.WTERMSIG(condition)))
225
elif os.WCOREDUMP(condition):
226
self.logger('Checker for client %s (command "%s")'
227
' dumped core'
228
% (self.properties["Name"], command))
229
else:
230
self.logger('Checker for client %s completed'
231
' mysteriously')
232
self.update()
233
234
def checker_started(self, command):
235
#self.logger('Client %s started checker "%s"'
236
# % (self.properties["Name"], unicode(command)))
237
pass
238
239
def got_secret(self):
240
self.last_checker_failed = False
241
self.logger('Client %s received its secret'
242
% self.properties["Name"])
243
244
def need_approval(self, timeout, default):
245
if not default:
246
message = 'Client %s needs approval within %s seconds'
247
else:
248
message = 'Client %s will get its secret in %s seconds'
249
self.logger(message
250
% (self.properties["Name"], timeout/1000))
251
self.using_timer(True)
252
253
def rejected(self, reason):
254
self.logger('Client %s was rejected; reason: %s'
255
% (self.properties["Name"], reason))
256
257
def selectable(self):
258
"""Make this a "selectable" widget.
259
This overrides the method from urwid.FlowWidget."""
260
return True
261
262
def rows(self, maxcolrow, focus=False):
263
"""How many rows this widget will occupy might depend on
264
whether we have focus or not.
265
This overrides the method from urwid.FlowWidget"""
266
return self.current_widget(focus).rows(maxcolrow, focus=focus)
267
268
def current_widget(self, focus=False):
269
if focus or self.opened:
270
return self._focus_widget
271
return self._widget
272
273
def update(self):
274
"Called when what is visible on the screen should be updated."
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",
282
}
283
284
# Rebuild focus and non-focus widgets using current properties
285
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"]:
292
timeout = datetime.timedelta(milliseconds
293
= self.properties
294
["ApprovalDelay"])
295
last_approval_request = isoformat_to_datetime(
296
self.properties["LastApprovalRequest"])
297
if last_approval_request is not None:
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
300
else:
301
timer = datetime.timedelta()
302
if self.properties["ApprovedByDefault"]:
303
message = "Approval in %s. (d)eny?"
304
else:
305
message = "Denial in %s. (a)pprove?"
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
elif self.last_checker_failed:
308
timeout = datetime.timedelta(milliseconds
309
= self.properties
310
["Timeout"])
311
last_ok = isoformat_to_datetime(
312
max((self.properties["LastCheckedOK"]
313
or self.properties["Created"]),
314
self.properties["LastEnabled"]))
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
message = ('A checker has failed! Time until client'
317
' gets disabled: %s'
318
% unicode(timer).rsplit(".", 1)[0])
319
else:
320
message = "enabled"
321
self._text = "%s%s" % (base, message)
322
323
if not urwid.supports_unicode():
324
self._text = self._text.encode("ascii", "replace")
325
textlist = [("normal", self._text)]
326
self._text_widget.set_text(textlist)
327
self._focus_text_widget.set_text([(with_standout[text[0]],
328
text[1])
329
if isinstance(text, tuple)
330
else text
331
for text in textlist])
332
self._widget = self._text_widget
333
self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
334
"standout")
335
# Run update hook, if any
336
if self.update_hook is not None:
337
self.update_hook()
338
339
def update_timer(self):
340
"called by gobject"
341
self.update()
342
return True # Keep calling this
343
344
def delete(self):
345
if self._update_timer_callback_tag is not None:
346
gobject.source_remove(self._update_timer_callback_tag)
347
self._update_timer_callback_tag = None
348
if self.delete_hook is not None:
349
self.delete_hook(self)
350
351
def render(self, maxcolrow, focus=False):
352
"""Render differently if we have focus.
353
This overrides the method from urwid.FlowWidget"""
354
return self.current_widget(focus).render(maxcolrow,
355
focus=focus)
356
357
def keypress(self, maxcolrow, key):
358
"""Handle keys.
359
This overrides the method from urwid.FlowWidget"""
360
if key == "+":
361
self.proxy.Enable(dbus_interface = client_interface,
362
ignore_reply=True)
363
elif key == "-":
364
self.proxy.Disable(dbus_interface = client_interface,
365
ignore_reply=True)
366
elif key == "a":
367
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
368
dbus_interface = client_interface,
369
ignore_reply=True)
370
elif key == "d":
371
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
372
dbus_interface = client_interface,
373
ignore_reply=True)
374
elif key == "R" or key == "_" or key == "ctrl k":
375
self.server_proxy_object.RemoveClient(self.proxy
376
.object_path,
377
ignore_reply=True)
378
elif key == "s":
379
self.proxy.StartChecker(dbus_interface = client_interface,
380
ignore_reply=True)
381
elif key == "S":
382
self.proxy.StopChecker(dbus_interface = client_interface,
383
ignore_reply=True)
384
elif key == "C":
385
self.proxy.CheckedOK(dbus_interface = client_interface,
386
ignore_reply=True)
387
# xxx
388
# elif key == "p" or key == "=":
389
# self.proxy.pause()
390
# elif key == "u" or key == ":":
391
# self.proxy.unpause()
392
# elif key == "RET":
393
# self.open()
394
else:
395
return key
396
397
def property_changed(self, property=None, value=None,
398
*args, **kwargs):
399
"""Call self.update() if old value is not new value.
400
This overrides the method from MandosClientPropertyCache"""
401
property_name = unicode(property)
402
old_value = self.properties.get(property_name)
403
super(MandosClientWidget, self).property_changed(
404
property=property, value=value, *args, **kwargs)
405
if self.properties.get(property_name) != old_value:
406
self.update()
407
408
409
class ConstrainedListBox(urwid.ListBox):
410
"""Like a normal urwid.ListBox, but will consume all "up" or
411
"down" key presses, thus not allowing any containing widgets to
412
use them as an excuse to shift focus away from this widget.
413
"""
414
def keypress(self, maxcolrow, key):
415
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
416
if ret in ("up", "down"):
417
return
418
return ret
419
420
421
class UserInterface(object):
422
"""This is the entire user interface - the whole screen
423
with boxes, lists of client widgets, etc.
424
"""
425
def __init__(self, max_log_length=1000):
426
DBusGMainLoop(set_as_default=True)
427
428
self.screen = urwid.curses_display.Screen()
429
430
self.screen.register_palette((
431
("normal",
432
"default", "default", None),
433
("bold",
434
"default", "default", "bold"),
435
("underline-blink",
436
"default", "default", "underline"),
437
("standout",
438
"default", "default", "standout"),
439
("bold-underline-blink",
440
"default", "default", ("bold", "underline")),
441
("bold-standout",
442
"default", "default", ("bold", "standout")),
443
("underline-blink-standout",
444
"default", "default", ("underline", "standout")),
445
("bold-underline-blink-standout",
446
"default", "default", ("bold", "underline",
447
"standout")),
448
))
449
450
if urwid.supports_unicode():
451
self.divider = "─" # \u2500
452
#self.divider = "━" # \u2501
453
else:
454
#self.divider = "-" # \u002d
455
self.divider = "_" # \u005f
456
457
self.screen.start()
458
459
self.size = self.screen.get_cols_rows()
460
461
self.clients = urwid.SimpleListWalker([])
462
self.clients_dict = {}
463
464
# We will add Text widgets to this list
465
self.log = []
466
self.max_log_length = max_log_length
467
468
# We keep a reference to the log widget so we can remove it
469
# from the ListWalker without it getting destroyed
470
self.logbox = ConstrainedListBox(self.log)
471
472
# This keeps track of whether self.uilist currently has
473
# self.logbox in it or not
474
self.log_visible = True
475
self.log_wrap = "any"
476
477
self.rebuild()
478
self.log_message_raw(("bold",
479
"Mandos Monitor version " + version))
480
self.log_message_raw(("bold",
481
"q: Quit ?: Help"))
482
483
self.busname = domain + '.Mandos'
484
self.main_loop = gobject.MainLoop()
485
self.bus = dbus.SystemBus()
486
mandos_dbus_objc = self.bus.get_object(
487
self.busname, "/", follow_name_owner_changes=True)
488
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
489
dbus_interface
490
= server_interface)
491
try:
492
mandos_clients = (self.mandos_serv
493
.GetAllClientsWithProperties())
494
except dbus.exceptions.DBusException:
495
mandos_clients = dbus.Dictionary()
496
497
(self.mandos_serv
498
.connect_to_signal("ClientRemoved",
499
self.find_and_remove_client,
500
dbus_interface=server_interface,
501
byte_arrays=True))
502
(self.mandos_serv
503
.connect_to_signal("ClientAdded",
504
self.add_new_client,
505
dbus_interface=server_interface,
506
byte_arrays=True))
507
(self.mandos_serv
508
.connect_to_signal("ClientNotFound",
509
self.client_not_found,
510
dbus_interface=server_interface,
511
byte_arrays=True))
512
for path, client in mandos_clients.iteritems():
513
client_proxy_object = self.bus.get_object(self.busname,
514
path)
515
self.add_client(MandosClientWidget(server_proxy_object
516
=self.mandos_serv,
517
proxy_object
518
=client_proxy_object,
519
properties=client,
520
update_hook
521
=self.refresh,
522
delete_hook
523
=self.remove_client,
524
logger
525
=self.log_message),
526
path=path)
527
528
def client_not_found(self, fingerprint, address):
529
self.log_message(("Client with address %s and fingerprint %s"
530
" could not be found" % (address,
531
fingerprint)))
532
533
def rebuild(self):
534
"""This rebuilds the User Interface.
535
Call this when the widget layout needs to change"""
536
self.uilist = []
537
#self.uilist.append(urwid.ListBox(self.clients))
538
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
539
clients),
540
#header=urwid.Divider(),
541
header=None,
542
footer=
543
urwid.Divider(div_char=
544
self.divider)))
545
if self.log_visible:
546
self.uilist.append(self.logbox)
547
pass
548
self.topwidget = urwid.Pile(self.uilist)
549
550
def log_message(self, message):
551
timestamp = datetime.datetime.now().isoformat()
552
self.log_message_raw(timestamp + ": " + message)
553
554
def log_message_raw(self, markup):
555
"""Add a log message to the log buffer."""
556
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
557
if (self.max_log_length
558
and len(self.log) > self.max_log_length):
559
del self.log[0:len(self.log)-self.max_log_length-1]
560
self.logbox.set_focus(len(self.logbox.body.contents),
561
coming_from="above")
562
self.refresh()
563
564
def toggle_log_display(self):
565
"""Toggle visibility of the log buffer."""
566
self.log_visible = not self.log_visible
567
self.rebuild()
568
#self.log_message("Log visibility changed to: "
569
# + unicode(self.log_visible))
570
571
def change_log_display(self):
572
"""Change type of log display.
573
Currently, this toggles wrapping of text lines."""
574
if self.log_wrap == "clip":
575
self.log_wrap = "any"
576
else:
577
self.log_wrap = "clip"
578
for textwidget in self.log:
579
textwidget.set_wrap_mode(self.log_wrap)
580
#self.log_message("Wrap mode: " + self.log_wrap)
581
582
def find_and_remove_client(self, path, name):
583
"""Find an client from its object path and remove it.
584
585
This is connected to the ClientRemoved signal from the
586
Mandos server object."""
587
try:
588
client = self.clients_dict[path]
589
except KeyError:
590
# not found?
591
return
592
self.remove_client(client, path)
593
594
def add_new_client(self, path):
595
client_proxy_object = self.bus.get_object(self.busname, path)
596
self.add_client(MandosClientWidget(server_proxy_object
597
=self.mandos_serv,
598
proxy_object
599
=client_proxy_object,
600
update_hook
601
=self.refresh,
602
delete_hook
603
=self.remove_client,
604
logger
605
=self.log_message),
606
path=path)
607
608
def add_client(self, client, path=None):
609
self.clients.append(client)
610
if path is None:
611
path = client.proxy.object_path
612
self.clients_dict[path] = client
613
self.clients.sort(None, lambda c: c.properties["Name"])
614
self.refresh()
615
616
def remove_client(self, client, path=None):
617
self.clients.remove(client)
618
if path is None:
619
path = client.proxy.object_path
620
del self.clients_dict[path]
621
if not self.clients_dict:
622
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
623
# is completely emptied, we need to recreate it.
624
self.clients = urwid.SimpleListWalker([])
625
self.rebuild()
626
self.refresh()
627
628
def refresh(self):
629
"""Redraw the screen"""
630
canvas = self.topwidget.render(self.size, focus=True)
631
self.screen.draw_screen(self.size, canvas)
632
633
def run(self):
634
"""Start the main loop and exit when it's done."""
635
self.refresh()
636
self._input_callback_tag = (gobject.io_add_watch
637
(sys.stdin.fileno(),
638
gobject.IO_IN,
639
self.process_input))
640
self.main_loop.run()
641
# Main loop has finished, we should close everything now
642
gobject.source_remove(self._input_callback_tag)
643
self.screen.stop()
644
645
def stop(self):
646
self.main_loop.quit()
647
648
def process_input(self, source, condition):
649
keys = self.screen.get_input()
650
translations = { "ctrl n": "down", # Emacs
651
"ctrl p": "up", # Emacs
652
"ctrl v": "page down", # Emacs
653
"meta v": "page up", # Emacs
654
" ": "page down", # less
655
"f": "page down", # less
656
"b": "page up", # less
657
"j": "down", # vi
658
"k": "up", # vi
659
}
660
for key in keys:
661
try:
662
key = translations[key]
663
except KeyError: # :-)
664
pass
665
666
if key == "q" or key == "Q":
667
self.stop()
668
break
669
elif key == "window resize":
670
self.size = self.screen.get_cols_rows()
671
self.refresh()
672
elif key == "\f": # Ctrl-L
673
self.refresh()
674
elif key == "l" or key == "D":
675
self.toggle_log_display()
676
self.refresh()
677
elif key == "w" or key == "i":
678
self.change_log_display()
679
self.refresh()
680
elif key == "?" or key == "f1" or key == "esc":
681
if not self.log_visible:
682
self.log_visible = True
683
self.rebuild()
684
self.log_message_raw(("bold",
685
" ".
686
join(("q: Quit",
687
"?: Help",
688
"l: Log window toggle",
689
"TAB: Switch window",
690
"w: Wrap (log)"))))
691
self.log_message_raw(("bold",
692
" "
693
.join(("Clients:",
694
"+: Enable",
695
"-: Disable",
696
"R: Remove",
697
"s: Start new checker",
698
"S: Stop checker",
699
"C: Checker OK",
700
"a: Approve",
701
"d: Deny"))))
702
self.refresh()
703
elif key == "tab":
704
if self.topwidget.get_focus() is self.logbox:
705
self.topwidget.set_focus(0)
706
else:
707
self.topwidget.set_focus(self.logbox)
708
self.refresh()
709
#elif (key == "end" or key == "meta >" or key == "G"
710
# or key == ">"):
711
# pass # xxx end-of-buffer
712
#elif (key == "home" or key == "meta <" or key == "g"
713
# or key == "<"):
714
# pass # xxx beginning-of-buffer
715
#elif key == "ctrl e" or key == "$":
716
# pass # xxx move-end-of-line
717
#elif key == "ctrl a" or key == "^":
718
# pass # xxx move-beginning-of-line
719
#elif key == "ctrl b" or key == "meta (" or key == "h":
720
# pass # xxx left
721
#elif key == "ctrl f" or key == "meta )" or key == "l":
722
# pass # xxx right
723
#elif key == "a":
724
# pass # scroll up log
725
#elif key == "z":
726
# pass # scroll down log
727
elif self.topwidget.selectable():
728
self.topwidget.keypress(self.size, key)
729
self.refresh()
730
return True
731
732
ui = UserInterface()
733
try:
734
ui.run()
735
except KeyboardInterrupt:
736
ui.screen.stop()
737
except Exception, e:
738
ui.log_message(unicode(e))
739
ui.screen.stop()
740
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0