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 322
- compare with another revision
- download diff
- download tarball
- view history from revision 322
- Committer: Teddy Hogeborn
- Date: 2014-08-06 20:56:55 UTC
- Revision ID: teddy@recompile.se-20140806205655-lq7xkfr3b9pbwr6l
Tags: version-1.6.8-1
* Makefile (version): Changed to "1.6.8".
* NEWS (Version 1.6.8): New entry.
* debian/changelog (1.6.8-1): - '' -
* NEWS (Version 1.6.8): New entry.
* debian/changelog (1.6.8-1): - '' -
- files added:
- 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-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 Björn Påhlsson
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 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 <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
21
22
#
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
# Contact the authors at <mandos@recompile.se>.
23
24
#
24
25
25
26
from __future__ import (division, absolute_import, print_function,
26
27
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
27
32
28
33
import sys
29
34
import os
30
import signal
31
35
32
36
import datetime
33
37
35
39
import urwid
36
40
37
41
from dbus.mainloop.glib import DBusGMainLoop
38
import gobject
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
39
46
40
47
import dbus
41
48
42
import UserList
43
44
49
import locale
45
50
51
if sys.version_info.major == 2:
52
str = unicode
53
46
54
locale.setlocale(locale.LC_ALL, '')
47
55
48
56
import logging
49
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
50
58
51
59
# Some useful constants
52
domain = 'se.bsnet.fukt'
60
domain = 'se.recompile'
53
61
server_interface = domain + '.Mandos'
54
62
client_interface = domain + '.Mandos.Client'
55
version = "1.3.0"
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)
63
version = "1.6.8"
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, *args, **kwargs):
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
87
87
self.proxy = proxy_object # Mandos Client proxy object
88
89
self.properties = dict()
88
self.properties = dict() if properties is None else properties
90
89
self.property_changed_match = (
91
90
self.proxy.connect_to_signal("PropertyChanged",
92
self.property_changed,
91
self._property_changed,
93
92
client_interface,
94
93
byte_arrays=True))
95
94
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)
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)
102
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
103
106
104
107
def property_changed(self, property=None, value=None):
105
108
"""This is called whenever we get a PropertyChanged signal
108
111
# Update properties dict with new value
109
112
self.properties[property] = value
110
113
111
def delete(self, *args, **kwargs):
114
def delete(self):
112
115
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
115
116
116
117
117
118
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
119
120
"""
120
121
121
122
def __init__(self, server_proxy_object=None, update_hook=None,
122
delete_hook=None, logger=None, *args, **kwargs):
123
delete_hook=None, logger=None, **kwargs):
123
124
# Called on update
124
125
self.update_hook = update_hook
125
126
# Called on delete
130
131
self.logger = logger
131
132
132
133
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
135
134
136
135
# The widget shown normally
137
136
self._text_widget = urwid.Text("")
138
137
# The widget shown when we have focus
139
138
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
142
*args, **kwargs)
139
super(MandosClientWidget, self).__init__(**kwargs)
143
140
self.update()
144
141
self.opened = False
145
142
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
164
143
self.match_objects = (
165
144
self.proxy.connect_to_signal("CheckerCompleted",
166
145
self.checker_completed,
182
161
self.rejected,
183
162
client_interface,
184
163
byte_arrays=True))
185
#self.logger('Created client %s' % (self.properties["Name"]))
164
self.logger('Created client {}'
165
.format(self.properties["Name"]), level=0)
186
166
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
193
167
def using_timer(self, flag):
194
168
"""Call this method with True or False when timer should be
195
169
activated or deactivated.
196
170
"""
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:
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
203
173
self._update_timer_callback_tag = (gobject.timeout_add
204
174
(1000,
205
175
self.update_timer))
206
elif old and self._update_timer_callback_lock == 0:
176
elif not (flag or self._update_timer_callback_tag is None):
207
177
gobject.source_remove(self._update_timer_callback_tag)
208
178
self._update_timer_callback_tag = None
209
179
210
180
def checker_completed(self, exitstatus, condition, command):
211
181
if exitstatus == 0:
212
if self.last_checker_failed:
213
self.last_checker_failed = False
214
self.using_timer(False)
215
#self.logger('Checker for client %s (command "%s")'
216
# ' was successful'
217
# % (self.properties["Name"], command))
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
184
command), level=0)
218
185
self.update()
219
186
return
220
187
# Checker failed
221
if not self.last_checker_failed:
222
self.last_checker_failed = True
223
self.using_timer(True)
224
188
if os.WIFEXITED(condition):
225
self.logger('Checker for client %s (command "%s")'
226
' failed with exit code %s'
227
% (self.properties["Name"], command,
228
os.WEXITSTATUS(condition)))
189
self.logger('Checker for client {} (command "{}") failed'
190
' with exit code {}'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
229
193
elif os.WIFSIGNALED(condition):
230
self.logger('Checker for client %s (command "%s")'
231
' was killed by signal %s'
232
% (self.properties["Name"], command,
233
os.WTERMSIG(condition)))
194
self.logger('Checker for client {} (command "{}") was'
195
' killed by signal {}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
234
198
elif os.WCOREDUMP(condition):
235
self.logger('Checker for client %s (command "%s")'
236
' dumped core'
237
% (self.properties["Name"], command))
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
201
command))
238
202
else:
239
self.logger('Checker for client %s completed'
240
' mysteriously')
203
self.logger('Checker for client {} completed'
204
' mysteriously'
205
.format(self.properties["Name"]))
241
206
self.update()
242
207
243
208
def checker_started(self, command):
244
#self.logger('Client %s started checker "%s"'
245
# % (self.properties["Name"], unicode(command)))
246
pass
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
212
command), level=0)
247
213
248
214
def got_secret(self):
249
self.last_checker_failed = False
250
self.logger('Client %s received its secret'
251
% self.properties["Name"])
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
252
217
253
218
def need_approval(self, timeout, default):
254
219
if not default:
255
message = 'Client %s needs approval within %s seconds'
220
message = 'Client {} needs approval within {} seconds'
256
221
else:
257
message = 'Client %s will get its secret in %s seconds'
258
self.logger(message
259
% (self.properties["Name"], timeout/1000))
260
self.using_timer(True)
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
224
timeout/1000))
261
225
262
226
def rejected(self, reason):
263
self.logger('Client %s was rejected; reason: %s'
264
% (self.properties["Name"], reason))
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
265
229
266
230
def selectable(self):
267
231
"""Make this a "selectable" widget.
289
253
"bold-underline-blink":
290
254
"bold-underline-blink-standout",
291
255
}
292
256
293
257
# Rebuild focus and non-focus widgets using current properties
294
258
295
259
# Base part of a client. Name!
296
base = ('%(name)s: '
297
% {"name": self.properties["Name"]})
260
base = '{name}: '.format(name=self.properties["Name"])
298
261
if not self.properties["Enabled"]:
299
262
message = "DISABLED"
263
self.using_timer(False)
300
264
elif self.properties["ApprovalPending"]:
301
265
timeout = datetime.timedelta(milliseconds
302
266
= self.properties
304
268
last_approval_request = isoformat_to_datetime(
305
269
self.properties["LastApprovalRequest"])
306
270
if last_approval_request is not None:
307
timer = timeout - (datetime.datetime.utcnow()
308
- last_approval_request)
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
309
274
else:
310
275
timer = datetime.timedelta()
311
276
if self.properties["ApprovedByDefault"]:
312
message = "Approval in %s. (d)eny?"
313
else:
314
message = "Denial in %s. (a)pprove?"
315
message = message % unicode(timer).rsplit(".", 1)[0]
316
elif self.last_checker_failed:
317
timeout = datetime.timedelta(milliseconds
318
= self.properties
319
["Timeout"])
320
last_ok = isoformat_to_datetime(
321
max((self.properties["LastCheckedOK"]
322
or self.properties["Created"]),
323
self.properties["LastEnabled"]))
324
timer = timeout - (datetime.datetime.utcnow() - last_ok)
277
message = "Approval in {}. (d)eny?"
278
else:
279
message = "Denial in {}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
285
if expires == "":
286
timer = datetime.timedelta(0)
287
else:
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
325
292
message = ('A checker has failed! Time until client'
326
' gets disabled: %s'
327
% unicode(timer).rsplit(".", 1)[0])
293
' gets disabled: {}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
328
296
else:
329
297
message = "enabled"
330
self._text = "%s%s" % (base, message)
331
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
300
332
301
if not urwid.supports_unicode():
333
302
self._text = self._text.encode("ascii", "replace")
334
303
textlist = [("normal", self._text)]
346
315
self.update_hook()
347
316
348
317
def update_timer(self):
349
"called by gobject"
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
350
320
self.update()
351
321
return True # Keep calling this
352
322
353
def delete(self, *args, **kwargs):
323
def delete(self, **kwargs):
354
324
if self._update_timer_callback_tag is not None:
355
325
gobject.source_remove(self._update_timer_callback_tag)
356
326
self._update_timer_callback_tag = None
359
329
self.match_objects = ()
360
330
if self.delete_hook is not None:
361
331
self.delete_hook(self)
362
return super(MandosClientWidget, self).delete(*args, **kwargs)
332
return super(MandosClientWidget, self).delete(**kwargs)
363
333
364
334
def render(self, maxcolrow, focus=False):
365
335
"""Render differently if we have focus.
407
377
else:
408
378
return key
409
379
410
def property_changed(self, property=None, value=None,
411
*args, **kwargs):
380
def property_changed(self, property=None, **kwargs):
412
381
"""Call self.update() if old value is not new value.
413
382
This overrides the method from MandosClientPropertyCache"""
414
property_name = unicode(property)
383
property_name = str(property)
415
384
old_value = self.properties.get(property_name)
416
385
super(MandosClientWidget, self).property_changed(
417
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
418
387
if self.properties.get(property_name) != old_value:
419
388
self.update()
420
389
424
393
"down" key presses, thus not allowing any containing widgets to
425
394
use them as an excuse to shift focus away from this widget.
426
395
"""
427
def keypress(self, maxcolrow, key):
428
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
429
398
if ret in ("up", "down"):
430
399
return
431
400
return ret
435
404
"""This is the entire user interface - the whole screen
436
405
with boxes, lists of client widgets, etc.
437
406
"""
438
def __init__(self, max_log_length=1000):
407
def __init__(self, max_log_length=1000, log_level=1):
439
408
DBusGMainLoop(set_as_default=True)
440
409
441
410
self.screen = urwid.curses_display.Screen()
444
413
("normal",
445
414
"default", "default", None),
446
415
("bold",
447
"default", "default", "bold"),
416
"bold", "default", "bold"),
448
417
("underline-blink",
449
"default", "default", "underline"),
418
"underline,blink", "default", "underline,blink"),
450
419
("standout",
451
"default", "default", "standout"),
420
"standout", "default", "standout"),
452
421
("bold-underline-blink",
453
"default", "default", ("bold", "underline")),
422
"bold,underline,blink", "default", "bold,underline,blink"),
454
423
("bold-standout",
455
"default", "default", ("bold", "standout")),
424
"bold,standout", "default", "bold,standout"),
456
425
("underline-blink-standout",
457
"default", "default", ("underline", "standout")),
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
458
428
("bold-underline-blink-standout",
459
"default", "default", ("bold", "underline",
460
"standout")),
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
461
431
))
462
432
463
433
if urwid.supports_unicode():
478
448
self.log = []
479
449
self.max_log_length = max_log_length
480
450
451
self.log_level = log_level
452
481
453
# We keep a reference to the log widget so we can remove it
482
454
# from the ListWalker without it getting destroyed
483
455
self.logbox = ConstrainedListBox(self.log)
495
467
496
468
self.busname = domain + '.Mandos'
497
469
self.main_loop = gobject.MainLoop()
498
self.bus = dbus.SystemBus()
499
mandos_dbus_objc = self.bus.get_object(
500
self.busname, "/", follow_name_owner_changes=True)
501
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
502
dbus_interface
503
= server_interface)
504
try:
505
mandos_clients = (self.mandos_serv
506
.GetAllClientsWithProperties())
507
except dbus.exceptions.DBusException:
508
mandos_clients = dbus.Dictionary()
509
510
(self.mandos_serv
511
.connect_to_signal("ClientRemoved",
512
self.find_and_remove_client,
513
dbus_interface=server_interface,
514
byte_arrays=True))
515
(self.mandos_serv
516
.connect_to_signal("ClientAdded",
517
self.add_new_client,
518
dbus_interface=server_interface,
519
byte_arrays=True))
520
(self.mandos_serv
521
.connect_to_signal("ClientNotFound",
522
self.client_not_found,
523
dbus_interface=server_interface,
524
byte_arrays=True))
525
for path, client in mandos_clients.iteritems():
526
client_proxy_object = self.bus.get_object(self.busname,
527
path)
528
self.add_client(MandosClientWidget(server_proxy_object
529
=self.mandos_serv,
530
proxy_object
531
=client_proxy_object,
532
properties=client,
533
update_hook
534
=self.refresh,
535
delete_hook
536
=self.remove_client,
537
logger
538
=self.log_message),
539
path=path)
540
470
541
471
def client_not_found(self, fingerprint, address):
542
self.log_message(("Client with address %s and fingerprint %s"
543
" could not be found" % (address,
544
fingerprint)))
472
self.log_message("Client with address {} and fingerprint {}"
473
" could not be found"
474
.format(address, fingerprint))
545
475
546
476
def rebuild(self):
547
477
"""This rebuilds the User Interface.
557
487
self.divider)))
558
488
if self.log_visible:
559
489
self.uilist.append(self.logbox)
560
pass
561
490
self.topwidget = urwid.Pile(self.uilist)
562
491
563
def log_message(self, message):
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
495
return
564
496
timestamp = datetime.datetime.now().isoformat()
565
self.log_message_raw(timestamp + ": " + message)
497
self.log_message_raw("{}: {}".format(timestamp, message),
498
level=level)
566
499
567
def log_message_raw(self, markup):
500
def log_message_raw(self, markup, level=1):
568
501
"""Add a log message to the log buffer."""
502
if level < self.log_level:
503
return
569
504
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
570
505
if (self.max_log_length
571
506
and len(self.log) > self.max_log_length):
578
513
"""Toggle visibility of the log buffer."""
579
514
self.log_visible = not self.log_visible
580
515
self.rebuild()
581
#self.log_message("Log visibility changed to: "
582
# + unicode(self.log_visible))
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
583
518
584
519
def change_log_display(self):
585
520
"""Change type of log display.
590
525
self.log_wrap = "clip"
591
526
for textwidget in self.log:
592
527
textwidget.set_wrap_mode(self.log_wrap)
593
#self.log_message("Wrap mode: " + self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
529
level=0)
594
530
595
531
def find_and_remove_client(self, path, name):
596
532
"""Find a client by its object path and remove it.
601
537
client = self.clients_dict[path]
602
538
except KeyError:
603
539
# not found?
604
self.log_message("Unknown client %r (%r) removed", name,
605
path)
540
self.log_message("Unknown client {!r} ({!r}) removed"
541
.format(name, path))
606
542
return
607
543
client.delete()
608
544
625
561
if path is None:
626
562
path = client.proxy.object_path
627
563
self.clients_dict[path] = client
628
self.clients.sort(None, lambda c: c.properties["Name"])
564
self.clients.sort(key=lambda c: c.properties["Name"])
629
565
self.refresh()
630
566
631
567
def remove_client(self, client, path=None):
633
569
if path is None:
634
570
path = client.proxy.object_path
635
571
del self.clients_dict[path]
636
if not self.clients_dict:
637
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
638
# is completely emptied, we need to recreate it.
639
self.clients = urwid.SimpleListWalker([])
640
self.rebuild()
641
572
self.refresh()
642
573
643
574
def refresh(self):
647
578
648
579
def run(self):
649
580
"""Start the main loop and exit when it's done."""
581
self.bus = dbus.SystemBus()
582
mandos_dbus_objc = self.bus.get_object(
583
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
585
dbus_interface
586
= server_interface)
587
try:
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
mandos_clients = dbus.Dictionary()
595
596
(self.mandos_serv
597
.connect_to_signal("ClientRemoved",
598
self.find_and_remove_client,
599
dbus_interface=server_interface,
600
byte_arrays=True))
601
(self.mandos_serv
602
.connect_to_signal("ClientAdded",
603
self.add_new_client,
604
dbus_interface=server_interface,
605
byte_arrays=True))
606
(self.mandos_serv
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
610
byte_arrays=True))
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
613
path)
614
self.add_client(MandosClientWidget(server_proxy_object
615
=self.mandos_serv,
616
proxy_object
617
=client_proxy_object,
618
properties=client,
619
update_hook
620
=self.refresh,
621
delete_hook
622
=self.remove_client,
623
logger
624
=self.log_message),
625
path=path)
626
650
627
self.refresh()
651
628
self._input_callback_tag = (gobject.io_add_watch
652
629
(sys.stdin.fileno(),
684
661
elif key == "window resize":
685
662
self.size = self.screen.get_cols_rows()
686
663
self.refresh()
687
elif key == "\f": # Ctrl-L
664
elif key == "ctrl l":
665
self.screen.clear()
688
666
self.refresh()
689
667
elif key == "l" or key == "D":
690
668
self.toggle_log_display()
702
680
"?: Help",
703
681
"l: Log window toggle",
704
682
"TAB: Switch window",
705
"w: Wrap (log)"))))
683
"w: Wrap (log lines)",
684
"v: Toggle verbose log",
685
))))
706
686
self.log_message_raw(("bold",
707
687
" "
708
688
.join(("Clients:",
721
701
else:
722
702
self.topwidget.set_focus(self.logbox)
723
703
self.refresh()
704
elif key == "v":
705
if self.log_level == 0:
706
self.log_level = 1
707
self.log_message("Verbose mode: Off")
708
else:
709
self.log_level = 0
710
self.log_message("Verbose mode: On")
724
711
#elif (key == "end" or key == "meta >" or key == "G"
725
712
# or key == ">"):
726
713
# pass # xxx end-of-buffer
749
736
ui.run()
750
737
except KeyboardInterrupt:
751
738
ui.screen.stop()
752
except Exception, e:
753
ui.log_message(unicode(e))
739
except Exception as e:
740
ui.log_message(str(e))
754
741
ui.screen.stop()
755
742
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0