/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2024-11-22 20:28:54 UTC
  • Revision ID: teddy@recompile.se-20241122202854-dycuf117byxhxl32
mandos-monitor: Avoid debug messages from urwid

Avoid debug messages from urwid.  Any logging output before the screen
has been set up will mangle the screen.

* mandos-monitor: When setting up logging, set urwid to only show log
  messages of level INFO or above.

(Thanks to an anonymous contributor for reporting this.)

Show diffs side-by-side

added added

removed removed

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