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 24.1.150
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.150
- Committer: Björn Påhlsson
- Date: 2010-08-22 18:35:37 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 421.
- Revision ID: belorn@fukt.bsnet.se-20100822183537-6trr1puyjvk14ejg
* mandos: Added ClientDBus.approve_pending property. Exposed
approved_by_default, approved_delay, approved_duration as
D-Bus properties.
approved_by_default, approved_delay, approved_duration as
D-Bus properties.
- files removed:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2009,2010 Teddy Hogeborn
7
# Copyright © 2009,2010 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
3
25
from __future__ import division, absolute_import, print_function, unicode_literals
4
from __future__ import division, absolute_import, with_statement
26
5
27
6
import sys
28
7
import os
42
21
43
22
import locale
44
23
45
locale.setlocale(locale.LC_ALL, '')
46
47
import logging
48
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
24
locale.setlocale(locale.LC_ALL, u'')
49
25
50
26
# Some useful constants
51
27
domain = 'se.bsnet.fukt'
52
28
server_interface = domain + '.Mandos'
53
29
client_interface = domain + '.Mandos.Client'
54
version = "1.2.3"
30
version = "1.0.14"
55
31
56
32
# Always run in monochrome mode
57
33
urwid.curses_display.curses.has_colors = lambda : False
61
37
urwid.curses_display.curses.A_UNDERLINE |= (
62
38
urwid.curses_display.curses.A_BLINK)
63
39
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
40
class MandosClientPropertyCache(object):
81
41
"""This wraps a Mandos Client D-Bus proxy object, caches the
82
42
properties and calls a hook function when any of them are
86
46
self.proxy = proxy_object # Mandos Client proxy object
87
47
88
48
self.properties = dict()
89
self.proxy.connect_to_signal("PropertyChanged",
49
self.proxy.connect_to_signal(u"PropertyChanged",
90
50
self.property_changed,
91
51
client_interface,
92
52
byte_arrays=True)
93
53
94
54
self.properties.update(
95
55
self.proxy.GetAll(client_interface,
96
56
dbus_interface = dbus.PROPERTIES_IFACE))
97
98
#XXX This break good super behaviour!
99
# super(MandosClientPropertyCache, self).__init__(
100
# *args, **kwargs)
57
super(MandosClientPropertyCache, self).__init__(
58
proxy_object=proxy_object, *args, **kwargs)
101
59
102
60
def property_changed(self, property=None, value=None):
103
61
"""This is called whenever we get a PropertyChanged signal
122
80
# Logger
123
81
self.logger = logger
124
82
125
self._update_timer_callback_tag = None
126
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
128
129
83
# The widget shown normally
130
self._text_widget = urwid.Text("")
84
self._text_widget = urwid.Text(u"")
131
85
# The widget shown when we have focus
132
self._focus_text_widget = urwid.Text("")
86
self._focus_text_widget = urwid.Text(u"")
133
87
super(MandosClientWidget, self).__init__(
134
88
update_hook=update_hook, delete_hook=delete_hook,
135
89
*args, **kwargs)
136
90
self.update()
137
91
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",
92
self.proxy.connect_to_signal(u"CheckerCompleted",
158
93
self.checker_completed,
159
94
client_interface,
160
95
byte_arrays=True)
161
self.proxy.connect_to_signal("CheckerStarted",
96
self.proxy.connect_to_signal(u"CheckerStarted",
162
97
self.checker_started,
163
98
client_interface,
164
99
byte_arrays=True)
165
self.proxy.connect_to_signal("GotSecret",
100
self.proxy.connect_to_signal(u"GotSecret",
166
101
self.got_secret,
167
102
client_interface,
168
103
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",
104
self.proxy.connect_to_signal(u"Rejected",
174
105
self.rejected,
175
106
client_interface,
176
107
byte_arrays=True)
177
108
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
109
def checker_completed(self, exitstatus, condition, command):
202
110
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()
111
self.logger(u'Checker for client %s (command "%s")'
112
u' was successful'
113
% (self.properties[u"name"], command))
210
114
return
211
# Checker failed
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
215
115
if os.WIFEXITED(condition):
216
self.logger('Checker for client %s (command "%s")'
217
' failed with exit code %s'
218
% (self.properties["Name"], command,
116
self.logger(u'Checker for client %s (command "%s")'
117
u' failed with exit code %s'
118
% (self.properties[u"name"], command,
219
119
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,
120
return
121
if os.WIFSIGNALED(condition):
122
self.logger(u'Checker for client %s (command "%s")'
123
u' was killed by signal %s'
124
% (self.properties[u"name"], command,
224
125
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()
126
return
127
if os.WCOREDUMP(condition):
128
self.logger(u'Checker for client %s (command "%s")'
129
u' dumped core'
130
% (self.properties[u"name"], command))
131
self.logger(u'Checker for client %s completed mysteriously')
233
132
234
133
def checker_started(self, command):
235
#self.logger('Client %s started checker "%s"'
236
# % (self.properties["Name"], unicode(command)))
237
pass
134
self.logger(u'Client %s started checker "%s"'
135
% (self.properties[u"name"], unicode(command)))
238
136
239
137
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))
138
self.logger(u'Client %s received its secret'
139
% self.properties[u"name"])
140
141
def rejected(self):
142
self.logger(u'Client %s was rejected'
143
% self.properties[u"name"])
256
144
257
145
def selectable(self):
258
146
"""Make this a "selectable" widget.
259
147
This overrides the method from urwid.FlowWidget."""
260
148
return True
261
149
262
def rows(self, maxcolrow, focus=False):
150
def rows(self, (maxcol,), focus=False):
263
151
"""How many rows this widget will occupy might depend on
264
152
whether we have focus or not.
265
153
This overrides the method from urwid.FlowWidget"""
266
return self.current_widget(focus).rows(maxcolrow, focus=focus)
154
return self.current_widget(focus).rows((maxcol,), focus=focus)
267
155
268
156
def current_widget(self, focus=False):
269
157
if focus or self.opened:
273
161
def update(self):
274
162
"Called when what is visible on the screen should be updated."
275
163
# 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",
164
with_standout = { u"normal": u"standout",
165
u"bold": u"bold-standout",
166
u"underline-blink":
167
u"underline-blink-standout",
168
u"bold-underline-blink":
169
u"bold-underline-blink-standout",
282
170
}
283
171
284
172
# 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
173
self._text = (u'%(name)s: %(enabled)s'
174
% { u"name": self.properties[u"name"],
175
u"enabled":
176
(u"enabled"
177
if self.properties[u"enabled"]
178
else u"DISABLED")})
323
179
if not urwid.supports_unicode():
324
180
self._text = self._text.encode("ascii", "replace")
325
textlist = [("normal", self._text)]
181
textlist = [(u"normal", self._text)]
326
182
self._text_widget.set_text(textlist)
327
183
self._focus_text_widget.set_text([(with_standout[text[0]],
328
184
text[1])
336
192
if self.update_hook is not None:
337
193
self.update_hook()
338
194
339
def update_timer(self):
340
"called by gobject"
341
self.update()
342
return True # Keep calling this
343
344
195
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
196
if self.delete_hook is not None:
349
197
self.delete_hook(self)
350
198
351
def render(self, maxcolrow, focus=False):
199
def render(self, (maxcol,), focus=False):
352
200
"""Render differently if we have focus.
353
201
This overrides the method from urwid.FlowWidget"""
354
return self.current_widget(focus).render(maxcolrow,
202
return self.current_widget(focus).render((maxcol,),
355
203
focus=focus)
356
204
357
def keypress(self, maxcolrow, key):
205
def keypress(self, (maxcol,), key):
358
206
"""Handle keys.
359
207
This overrides the method from urwid.FlowWidget"""
360
if key == "+":
361
self.proxy.Enable(dbus_interface = client_interface)
362
elif key == "-":
363
self.proxy.Disable(dbus_interface = client_interface)
364
elif key == "a":
365
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
dbus_interface = client_interface)
367
elif key == "d":
368
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
dbus_interface = client_interface)
370
elif key == "R" or key == "_" or key == "ctrl k":
208
if key == u"e" or key == u"+":
209
self.proxy.Enable()
210
elif key == u"d" or key == u"-":
211
self.proxy.Disable()
212
elif key == u"r" or key == u"_" or key == u"ctrl k":
371
213
self.server_proxy_object.RemoveClient(self.proxy
372
214
.object_path)
373
elif key == "s":
374
self.proxy.StartChecker(dbus_interface = client_interface)
375
elif key == "S":
376
self.proxy.StopChecker(dbus_interface = client_interface)
377
elif key == "C":
378
self.proxy.CheckedOK(dbus_interface = client_interface)
215
elif key == u"s":
216
self.proxy.StartChecker()
217
elif key == u"S":
218
self.proxy.StopChecker()
219
elif key == u"C":
220
self.proxy.CheckedOK()
379
221
# xxx
380
# elif key == "p" or key == "=":
222
# elif key == u"p" or key == "=":
381
223
# self.proxy.pause()
382
# elif key == "u" or key == ":":
224
# elif key == u"u" or key == ":":
383
225
# self.proxy.unpause()
384
# elif key == "RET":
226
# elif key == u"RET":
385
227
# self.open()
386
228
else:
387
229
return key
403
245
"down" key presses, thus not allowing any containing widgets to
404
246
use them as an excuse to shift focus away from this widget.
405
247
"""
406
def keypress(self, maxcolrow, key):
407
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
408
if ret in ("up", "down"):
248
def keypress(self, (maxcol, maxrow), key):
249
ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
250
if ret in (u"up", u"down"):
409
251
return
410
252
return ret
411
253
420
262
self.screen = urwid.curses_display.Screen()
421
263
422
264
self.screen.register_palette((
423
("normal",
424
"default", "default", None),
425
("bold",
426
"default", "default", "bold"),
427
("underline-blink",
428
"default", "default", "underline"),
429
("standout",
430
"default", "default", "standout"),
431
("bold-underline-blink",
432
"default", "default", ("bold", "underline")),
433
("bold-standout",
434
"default", "default", ("bold", "standout")),
435
("underline-blink-standout",
436
"default", "default", ("underline", "standout")),
437
("bold-underline-blink-standout",
438
"default", "default", ("bold", "underline",
439
"standout")),
265
(u"normal",
266
u"default", u"default", None),
267
(u"bold",
268
u"default", u"default", u"bold"),
269
(u"underline-blink",
270
u"default", u"default", u"underline"),
271
(u"standout",
272
u"default", u"default", u"standout"),
273
(u"bold-underline-blink",
274
u"default", u"default", (u"bold", u"underline")),
275
(u"bold-standout",
276
u"default", u"default", (u"bold", u"standout")),
277
(u"underline-blink-standout",
278
u"default", u"default", (u"underline", u"standout")),
279
(u"bold-underline-blink-standout",
280
u"default", u"default", (u"bold", u"underline",
281
u"standout")),
440
282
))
441
283
442
284
if urwid.supports_unicode():
443
self.divider = "─" # \u2500
444
#self.divider = "━" # \u2501
285
self.divider = u"─" # \u2500
286
#self.divider = u"━" # \u2501
445
287
else:
446
#self.divider = "-" # \u002d
447
self.divider = "_" # \u005f
288
#self.divider = u"-" # \u002d
289
self.divider = u"_" # \u005f
448
290
449
291
self.screen.start()
450
292
464
306
# This keeps track of whether self.uilist currently has
465
307
# self.logbox in it or not
466
308
self.log_visible = True
467
self.log_wrap = "any"
309
self.log_wrap = u"any"
468
310
469
311
self.rebuild()
470
self.log_message_raw(("bold",
471
"Mandos Monitor version " + version))
472
self.log_message_raw(("bold",
473
"q: Quit ?: Help"))
312
self.log_message_raw((u"bold",
313
u"Mandos Monitor version " + version))
314
self.log_message_raw((u"bold",
315
u"q: Quit ?: Help"))
474
316
475
317
self.busname = domain + '.Mandos'
476
318
self.main_loop = gobject.MainLoop()
477
319
self.bus = dbus.SystemBus()
478
320
mandos_dbus_objc = self.bus.get_object(
479
self.busname, "/", follow_name_owner_changes=True)
321
self.busname, u"/", follow_name_owner_changes=True)
480
322
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
323
dbus_interface
482
324
= server_interface)
487
329
mandos_clients = dbus.Dictionary()
488
330
489
331
(self.mandos_serv
490
.connect_to_signal("ClientRemoved",
332
.connect_to_signal(u"ClientRemoved",
491
333
self.find_and_remove_client,
492
334
dbus_interface=server_interface,
493
335
byte_arrays=True))
494
336
(self.mandos_serv
495
.connect_to_signal("ClientAdded",
337
.connect_to_signal(u"ClientAdded",
496
338
self.add_new_client,
497
339
dbus_interface=server_interface,
498
340
byte_arrays=True))
499
341
(self.mandos_serv
500
.connect_to_signal("ClientNotFound",
342
.connect_to_signal(u"ClientNotFound",
501
343
self.client_not_found,
502
344
dbus_interface=server_interface,
503
345
byte_arrays=True))
518
360
path=path)
519
361
520
362
def client_not_found(self, fingerprint, address):
521
self.log_message(("Client with address %s and fingerprint %s"
522
" could not be found" % (address,
363
self.log_message((u"Client with address %s and fingerprint %s"
364
u" could not be found" % (address,
523
365
fingerprint)))
524
366
525
367
def rebuild(self):
527
369
Call this when the widget layout needs to change"""
528
370
self.uilist = []
529
371
#self.uilist.append(urwid.ListBox(self.clients))
530
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
531
clients),
372
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
532
373
#header=urwid.Divider(),
533
374
header=None,
534
footer=
535
urwid.Divider(div_char=
536
self.divider)))
375
footer=urwid.Divider(div_char=self.divider)))
537
376
if self.log_visible:
538
377
self.uilist.append(self.logbox)
539
378
pass
541
380
542
381
def log_message(self, message):
543
382
timestamp = datetime.datetime.now().isoformat()
544
self.log_message_raw(timestamp + ": " + message)
383
self.log_message_raw(timestamp + u": " + message)
545
384
546
385
def log_message_raw(self, markup):
547
386
"""Add a log message to the log buffer."""
550
389
and len(self.log) > self.max_log_length):
551
390
del self.log[0:len(self.log)-self.max_log_length-1]
552
391
self.logbox.set_focus(len(self.logbox.body.contents),
553
coming_from="above")
392
coming_from=u"above")
554
393
self.refresh()
555
394
556
395
def toggle_log_display(self):
557
396
"""Toggle visibility of the log buffer."""
558
397
self.log_visible = not self.log_visible
559
398
self.rebuild()
560
#self.log_message("Log visibility changed to: "
561
# + unicode(self.log_visible))
399
self.log_message(u"Log visibility changed to: "
400
+ unicode(self.log_visible))
562
401
563
402
def change_log_display(self):
564
403
"""Change type of log display.
565
404
Currently, this toggles wrapping of text lines."""
566
if self.log_wrap == "clip":
567
self.log_wrap = "any"
405
if self.log_wrap == u"clip":
406
self.log_wrap = u"any"
568
407
else:
569
self.log_wrap = "clip"
408
self.log_wrap = u"clip"
570
409
for textwidget in self.log:
571
410
textwidget.set_wrap_mode(self.log_wrap)
572
#self.log_message("Wrap mode: " + self.log_wrap)
411
self.log_message(u"Wrap mode: " + self.log_wrap)
573
412
574
413
def find_and_remove_client(self, path, name):
575
414
"""Find an client from its object path and remove it.
602
441
if path is None:
603
442
path = client.proxy.object_path
604
443
self.clients_dict[path] = client
605
self.clients.sort(None, lambda c: c.properties["Name"])
444
self.clients.sort(None, lambda c: c.properties[u"name"])
606
445
self.refresh()
607
446
608
447
def remove_client(self, client, path=None):
639
478
640
479
def process_input(self, source, condition):
641
480
keys = self.screen.get_input()
642
translations = { "ctrl n": "down", # Emacs
643
"ctrl p": "up", # Emacs
644
"ctrl v": "page down", # Emacs
645
"meta v": "page up", # Emacs
646
" ": "page down", # less
647
"f": "page down", # less
648
"b": "page up", # less
649
"j": "down", # vi
650
"k": "up", # vi
481
translations = { u"ctrl n": u"down", # Emacs
482
u"ctrl p": u"up", # Emacs
483
u"ctrl v": u"page down", # Emacs
484
u"meta v": u"page up", # Emacs
485
u" ": u"page down", # less
486
u"f": u"page down", # less
487
u"b": u"page up", # less
488
u"j": u"down", # vi
489
u"k": u"up", # vi
651
490
}
652
491
for key in keys:
653
492
try:
655
494
except KeyError: # :-)
656
495
pass
657
496
658
if key == "q" or key == "Q":
497
if key == u"q" or key == u"Q":
659
498
self.stop()
660
499
break
661
elif key == "window resize":
500
elif key == u"window resize":
662
501
self.size = self.screen.get_cols_rows()
663
502
self.refresh()
664
elif key == "\f": # Ctrl-L
503
elif key == u"\f": # Ctrl-L
665
504
self.refresh()
666
elif key == "l" or key == "D":
505
elif key == u"l" or key == u"D":
667
506
self.toggle_log_display()
668
507
self.refresh()
669
elif key == "w" or key == "i":
508
elif key == u"w" or key == u"i":
670
509
self.change_log_display()
671
510
self.refresh()
672
elif key == "?" or key == "f1" or key == "esc":
511
elif key == u"?" or key == u"f1" or key == u"esc":
673
512
if not self.log_visible:
674
513
self.log_visible = True
675
514
self.rebuild()
676
self.log_message_raw(("bold",
677
" ".
678
join(("q: Quit",
679
"?: Help",
680
"l: Log window toggle",
681
"TAB: Switch window",
682
"w: Wrap (log)"))))
683
self.log_message_raw(("bold",
684
" "
685
.join(("Clients:",
686
"+: Enable",
687
"-: Disable",
688
"R: Remove",
689
"s: Start new checker",
690
"S: Stop checker",
691
"C: Checker OK",
692
"a: Approve",
693
"d: Deny"))))
515
self.log_message_raw((u"bold",
516
u" ".
517
join((u"q: Quit",
518
u"?: Help",
519
u"l: Log window toggle",
520
u"TAB: Switch window",
521
u"w: Wrap (log)"))))
522
self.log_message_raw((u"bold",
523
u" "
524
.join((u"Clients:",
525
u"e: Enable",
526
u"d: Disable",
527
u"r: Remove",
528
u"s: Start new checker",
529
u"S: Stop checker",
530
u"C: Checker OK"))))
694
531
self.refresh()
695
elif key == "tab":
532
elif key == u"tab":
696
533
if self.topwidget.get_focus() is self.logbox:
697
534
self.topwidget.set_focus(0)
698
535
else:
699
536
self.topwidget.set_focus(self.logbox)
700
537
self.refresh()
701
#elif (key == "end" or key == "meta >" or key == "G"
702
# or key == ">"):
538
#elif (key == u"end" or key == u"meta >" or key == u"G"
539
# or key == u">"):
703
540
# pass # xxx end-of-buffer
704
#elif (key == "home" or key == "meta <" or key == "g"
705
# or key == "<"):
541
#elif (key == u"home" or key == u"meta <" or key == u"g"
542
# or key == u"<"):
706
543
# pass # xxx beginning-of-buffer
707
#elif key == "ctrl e" or key == "$":
544
#elif key == u"ctrl e" or key == u"$":
708
545
# pass # xxx move-end-of-line
709
#elif key == "ctrl a" or key == "^":
546
#elif key == u"ctrl a" or key == u"^":
710
547
# pass # xxx move-beginning-of-line
711
#elif key == "ctrl b" or key == "meta (" or key == "h":
548
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
712
549
# pass # xxx left
713
#elif key == "ctrl f" or key == "meta )" or key == "l":
550
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
714
551
# pass # xxx right
715
#elif key == "a":
552
#elif key == u"a":
716
553
# pass # scroll up log
717
#elif key == "z":
554
#elif key == u"z":
718
555
# pass # scroll down log
719
556
elif self.topwidget.selectable():
720
557
self.topwidget.keypress(self.size, key)
724
561
ui = UserInterface()
725
562
try:
726
563
ui.run()
727
except KeyboardInterrupt:
728
ui.screen.stop()
729
564
except Exception, e:
730
565
ui.log_message(unicode(e))
731
566
ui.screen.stop()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0