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