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 496
- compare with another revision
- download diff
- download tarball
- view history from revision 496
- Committer: Teddy Hogeborn
- Date: 2011-09-18 15:03:26 UTC
- Revision ID: teddy@fukt.bsnet.se-20110918150326-tj4zz5qv0cv54we3
* debian/control: Fix language for lintian.
- 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-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
# 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:
168
# Will update the shown timer value every second
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:
169
203
self._update_timer_callback_tag = (gobject.timeout_add
170
204
(1000,
171
205
self.update_timer))
172
elif not (flag or self._update_timer_callback_tag is None):
206
elif old and self._update_timer_callback_lock == 0:
173
207
gobject.source_remove(self._update_timer_callback_tag)
174
208
self._update_timer_callback_tag = None
175
209
176
210
def checker_completed(self, exitstatus, condition, command):
177
211
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
180
command), level=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))
181
218
self.update()
182
219
return
183
220
# Checker failed
221
if not self.last_checker_failed:
222
self.last_checker_failed = True
223
self.using_timer(True)
184
224
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)))
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
229
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)))
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
234
elif os.WCOREDUMP(condition):
195
self.logger('Checker for client {} (command "{}") dumped'
196
' core'.format(self.properties["Name"],
197
command))
235
self.logger('Checker for client %s (command "%s")'
236
' dumped core'
237
% (self.properties["Name"], command))
198
238
else:
199
self.logger('Checker for client {} completed'
200
' mysteriously'
201
.format(self.properties["Name"]))
239
self.logger('Checker for client %s completed'
240
' mysteriously')
202
241
self.update()
203
242
204
243
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)
244
#self.logger('Client %s started checker "%s"'
245
# % (self.properties["Name"], unicode(command)))
246
pass
209
247
210
248
def got_secret(self):
211
self.logger('Client {} received its secret'
212
.format(self.properties["Name"]))
249
self.last_checker_failed = False
250
self.logger('Client %s received its secret'
251
% self.properties["Name"])
213
252
214
253
def need_approval(self, timeout, default):
215
254
if not default:
216
message = 'Client {} needs approval within {} seconds'
255
message = 'Client %s needs approval within %s seconds'
217
256
else:
218
message = 'Client {} will get its secret in {} seconds'
219
self.logger(message.format(self.properties["Name"],
220
timeout/1000))
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)
221
261
222
262
def rejected(self, reason):
223
self.logger('Client {} was rejected; reason: {}'
224
.format(self.properties["Name"], reason))
263
self.logger('Client %s was rejected; reason: %s'
264
% (self.properties["Name"], reason))
225
265
226
266
def selectable(self):
227
267
"""Make this a "selectable" widget.
249
289
"bold-underline-blink":
250
290
"bold-underline-blink-standout",
251
291
}
252
292
253
293
# Rebuild focus and non-focus widgets using current properties
254
294
255
295
# Base part of a client. Name!
256
base = '{name}: '.format(name=self.properties["Name"])
296
base = ('%(name)s: '
297
% {"name": self.properties["Name"]})
257
298
if not self.properties["Enabled"]:
258
299
message = "DISABLED"
259
self.using_timer(False)
260
300
elif self.properties["ApprovalPending"]:
261
301
timeout = datetime.timedelta(milliseconds
262
302
= self.properties
264
304
last_approval_request = isoformat_to_datetime(
265
305
self.properties["LastApprovalRequest"])
266
306
if last_approval_request is not None:
267
timer = max(timeout - (datetime.datetime.utcnow()
268
- last_approval_request),
269
datetime.timedelta())
307
timer = timeout - (datetime.datetime.utcnow()
308
- last_approval_request)
270
309
else:
271
310
timer = datetime.timedelta()
272
311
if self.properties["ApprovedByDefault"]:
273
message = "Approval in {}. (d)eny?"
274
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
280
expires = self.properties["Expires"]
281
if expires == "":
282
timer = datetime.timedelta(0)
283
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())
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)
288
325
message = ('A checker has failed! Time until client'
289
' gets disabled: {}'
290
.format(str(timer).rsplit(".", 1)[0]))
291
self.using_timer(True)
326
' gets disabled: %s'
327
% unicode(timer).rsplit(".", 1)[0])
292
328
else:
293
329
message = "enabled"
294
self.using_timer(False)
295
self._text = "{}{}".format(base, message)
296
330
self._text = "%s%s" % (base, message)
331
297
332
if not urwid.supports_unicode():
298
333
self._text = self._text.encode("ascii", "replace")
299
334
textlist = [("normal", self._text)]
311
346
self.update_hook()
312
347
313
348
def update_timer(self):
314
"""called by gobject. Will indefinitely loop until
315
gobject.source_remove() on tag is called"""
349
"called by gobject"
316
350
self.update()
317
351
return True # Keep calling this
318
352
319
def delete(self, **kwargs):
353
def delete(self, *args, **kwargs):
320
354
if self._update_timer_callback_tag is not None:
321
355
gobject.source_remove(self._update_timer_callback_tag)
322
356
self._update_timer_callback_tag = None
325
359
self.match_objects = ()
326
360
if self.delete_hook is not None:
327
361
self.delete_hook(self)
328
return super(MandosClientWidget, self).delete(**kwargs)
362
return super(MandosClientWidget, self).delete(*args, **kwargs)
329
363
330
364
def render(self, maxcolrow, focus=False):
331
365
"""Render differently if we have focus.
373
407
else:
374
408
return key
375
409
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
410
def property_changed(self, property=None, value=None,
411
*args, **kwargs):
412
"""Call self.update() if old value is not new value.
378
413
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):
414
property_name = unicode(property)
415
old_value = self.properties.get(property_name)
416
super(MandosClientWidget, self).property_changed(
417
property=property, value=value, *args, **kwargs)
418
if self.properties.get(property_name) != old_value:
385
419
self.update()
386
420
387
421
390
424
"down" key presses, thus not allowing any containing widgets to
391
425
use them as an excuse to shift focus away from this widget.
392
426
"""
393
def keypress(self, *args, **kwargs):
394
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
427
def keypress(self, maxcolrow, key):
428
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
395
429
if ret in ("up", "down"):
396
430
return
397
431
return ret
401
435
"""This is the entire user interface - the whole screen
402
436
with boxes, lists of client widgets, etc.
403
437
"""
404
def __init__(self, max_log_length=1000, log_level=1):
438
def __init__(self, max_log_length=1000):
405
439
DBusGMainLoop(set_as_default=True)
406
440
407
441
self.screen = urwid.curses_display.Screen()
410
444
("normal",
411
445
"default", "default", None),
412
446
("bold",
413
"bold", "default", "bold"),
447
"default", "default", "bold"),
414
448
("underline-blink",
415
"underline,blink", "default", "underline,blink"),
449
"default", "default", "underline"),
416
450
("standout",
417
"standout", "default", "standout"),
451
"default", "default", "standout"),
418
452
("bold-underline-blink",
419
"bold,underline,blink", "default", "bold,underline,blink"),
453
"default", "default", ("bold", "underline")),
420
454
("bold-standout",
421
"bold,standout", "default", "bold,standout"),
455
"default", "default", ("bold", "standout")),
422
456
("underline-blink-standout",
423
"underline,blink,standout", "default",
424
"underline,blink,standout"),
457
"default", "default", ("underline", "standout")),
425
458
("bold-underline-blink-standout",
426
"bold,underline,blink,standout", "default",
427
"bold,underline,blink,standout"),
459
"default", "default", ("bold", "underline",
460
"standout")),
428
461
))
429
462
430
463
if urwid.supports_unicode():
445
478
self.log = []
446
479
self.max_log_length = max_log_length
447
480
448
self.log_level = log_level
449
450
481
# We keep a reference to the log widget so we can remove it
451
482
# from the ListWalker without it getting destroyed
452
483
self.logbox = ConstrainedListBox(self.log)
464
495
465
496
self.busname = domain + '.Mandos'
466
497
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)
467
540
468
541
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))
542
self.log_message(("Client with address %s and fingerprint %s"
543
" could not be found" % (address,
544
fingerprint)))
472
545
473
546
def rebuild(self):
474
547
"""This rebuilds the User Interface.
484
557
self.divider)))
485
558
if self.log_visible:
486
559
self.uilist.append(self.logbox)
560
pass
487
561
self.topwidget = urwid.Pile(self.uilist)
488
562
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
492
return
563
def log_message(self, message):
493
564
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
495
level=level)
565
self.log_message_raw(timestamp + ": " + message)
496
566
497
def log_message_raw(self, markup, level=1):
567
def log_message_raw(self, markup):
498
568
"""Add a log message to the log buffer."""
499
if level < self.log_level:
500
return
501
569
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
570
if (self.max_log_length
503
571
and len(self.log) > self.max_log_length):
510
578
"""Toggle visibility of the log buffer."""
511
579
self.log_visible = not self.log_visible
512
580
self.rebuild()
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
581
#self.log_message("Log visibility changed to: "
582
# + unicode(self.log_visible))
515
583
516
584
def change_log_display(self):
517
585
"""Change type of log display.
522
590
self.log_wrap = "clip"
523
591
for textwidget in self.log:
524
592
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
526
level=0)
593
#self.log_message("Wrap mode: " + self.log_wrap)
527
594
528
595
def find_and_remove_client(self, path, name):
529
596
"""Find a client by its object path and remove it.
534
601
client = self.clients_dict[path]
535
602
except KeyError:
536
603
# not found?
537
self.log_message("Unknown client {!r} ({!r}) removed"
538
.format(name, path))
604
self.log_message("Unknown client %r (%r) removed", name,
605
path)
539
606
return
540
607
client.delete()
541
608
558
625
if path is None:
559
626
path = client.proxy.object_path
560
627
self.clients_dict[path] = client
561
self.clients.sort(key=lambda c: c.properties["Name"])
628
self.clients.sort(None, lambda c: c.properties["Name"])
562
629
self.refresh()
563
630
564
631
def remove_client(self, client, path=None):
566
633
if path is None:
567
634
path = client.proxy.object_path
568
635
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()
569
641
self.refresh()
570
642
571
643
def refresh(self):
575
647
576
648
def run(self):
577
649
"""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
650
self.refresh()
625
651
self._input_callback_tag = (gobject.io_add_watch
626
652
(sys.stdin.fileno(),
658
684
elif key == "window resize":
659
685
self.size = self.screen.get_cols_rows()
660
686
self.refresh()
661
elif key == "ctrl l":
662
self.screen.clear()
687
elif key == "\f": # Ctrl-L
663
688
self.refresh()
664
689
elif key == "l" or key == "D":
665
690
self.toggle_log_display()
677
702
"?: Help",
678
703
"l: Log window toggle",
679
704
"TAB: Switch window",
680
"w: Wrap (log lines)",
681
"v: Toggle verbose log",
682
))))
705
"w: Wrap (log)"))))
683
706
self.log_message_raw(("bold",
684
707
" "
685
708
.join(("Clients:",
698
721
else:
699
722
self.topwidget.set_focus(self.logbox)
700
723
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
724
#elif (key == "end" or key == "meta >" or key == "G"
709
725
# or key == ">"):
710
726
# pass # xxx end-of-buffer
733
749
ui.run()
734
750
except KeyboardInterrupt:
735
751
ui.screen.stop()
736
except Exception as e:
737
ui.log_message(str(e))
752
except Exception, e:
753
ui.log_message(unicode(e))
738
754
ui.screen.stop()
739
755
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0