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-ctl
- browse files at revision 1097
- compare with another revision
- download diff
- download tarball
- view history from revision 1097
- Committer: Teddy Hogeborn
- Date: 2019-04-08 21:53:22 UTC
- Revision ID: teddy@recompile.se-20190408215322-y3hmfxzdgs9t84l1
plugin-runner: Fix minor memory leak
* plugin-runner.c (free_plugin): Even if argv[0] is NULL, as for the
pseudo-plugin for global options,
free all other arguments by simply
starting at argv[1] and freeing
plugin_node->name (which is always
argv[0]) separately.
* plugin-runner.c (free_plugin): Even if argv[0] is NULL, as for the
pseudo-plugin for global options,
free all other arguments by simply
starting at argv[1] and freeing
plugin_node->name (which is always
argv[0]) separately.
- files modified:
- intro.xml
added
removed
mandos-ctl
46
46
import tempfile
47
47
import contextlib
48
48
49
import dbus
49
try:
50
import pydbus
51
import gi
52
dbus_python = None
53
except ImportError:
54
import dbus as dbus_python
55
pydbus = None
56
class gi(object):
57
"""Dummy gi module, for the tests"""
58
class repository(object):
59
class GLib(object):
60
class Error(Exception):
61
pass
50
62
51
63
# Show warnings by default
52
64
if not sys.warnoptions:
61
73
62
74
if sys.version_info.major == 2:
63
75
str = unicode
76
import StringIO
77
io.StringIO = StringIO.StringIO
64
78
65
79
locale.setlocale(locale.LC_ALL, "")
66
80
67
dbus_busname_domain = "se.recompile"
68
dbus_busname = dbus_busname_domain + ".Mandos"
69
server_dbus_path = "/"
70
server_dbus_interface = dbus_busname_domain + ".Mandos"
71
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
72
del dbus_busname_domain
73
81
version = "1.8.3"
74
82
75
83
76
try:
77
dbus.OBJECT_MANAGER_IFACE
78
except AttributeError:
79
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
80
81
82
84
def main():
83
85
parser = argparse.ArgumentParser()
84
85
86
add_command_line_options(parser)
86
87
87
88
options = parser.parse_args()
88
89
89
check_option_syntax(parser, options)
90
90
91
91
clientnames = options.client
93
93
if options.debug:
94
94
log.setLevel(logging.DEBUG)
95
95
96
bus = dbus.SystemBus()
97
98
mandos_dbus_object = get_mandos_dbus_object(bus)
99
100
mandos_serv = dbus.Interface(
101
mandos_dbus_object, dbus_interface=server_dbus_interface)
102
mandos_serv_object_manager = dbus.Interface(
103
mandos_dbus_object, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
104
105
managed_objects = get_managed_objects(mandos_serv_object_manager)
106
107
all_clients = {}
108
for path, ifs_and_props in managed_objects.items():
109
try:
110
all_clients[path] = ifs_and_props[client_dbus_interface]
111
except KeyError:
112
pass
96
if pydbus is not None:
97
bus = pydbus_adapter.CachingBus(pydbus)
98
else:
99
bus = dbus_python_adapter.CachingBus(dbus_python)
100
101
try:
102
all_clients = bus.get_clients_and_properties()
103
except dbus.ConnectFailed as e:
104
log.critical("Could not connect to Mandos server: %s", e)
105
sys.exit(1)
106
except dbus.Error as e:
107
log.critical(
108
"Failed to access Mandos server through D-Bus:\n%s", e)
109
sys.exit(1)
113
110
114
111
# Compile dict of (clientpath: properties) to process
115
112
if not clientnames:
128
125
commands = commands_from_options(options)
129
126
130
127
for command in commands:
131
command.run(clients, bus, mandos_serv)
128
command.run(clients, bus)
132
129
133
130
134
131
def add_command_line_options(parser):
139
136
help="Select all clients")
140
137
parser.add_argument("-v", "--verbose", action="store_true",
141
138
help="Print all fields")
142
parser.add_argument("-j", "--dump-json", action="store_true",
139
parser.add_argument("-j", "--dump-json", dest="commands",
140
action="append_const", default=[],
141
const=command.DumpJSON(),
143
142
help="Dump client data in JSON format")
144
143
enable_disable = parser.add_mutually_exclusive_group()
145
enable_disable.add_argument("-e", "--enable", action="store_true",
144
enable_disable.add_argument("-e", "--enable", dest="commands",
145
action="append_const", default=[],
146
const=command.Enable(),
146
147
help="Enable client")
147
enable_disable.add_argument("-d", "--disable",
148
action="store_true",
148
enable_disable.add_argument("-d", "--disable", dest="commands",
149
action="append_const", default=[],
150
const=command.Disable(),
149
151
help="disable client")
150
parser.add_argument("-b", "--bump-timeout", action="store_true",
152
parser.add_argument("-b", "--bump-timeout", dest="commands",
153
action="append_const", default=[],
154
const=command.BumpTimeout(),
151
155
help="Bump timeout for client")
152
156
start_stop_checker = parser.add_mutually_exclusive_group()
153
157
start_stop_checker.add_argument("--start-checker",
154
action="store_true",
158
dest="commands",
159
action="append_const", default=[],
160
const=command.StartChecker(),
155
161
help="Start checker for client")
156
start_stop_checker.add_argument("--stop-checker",
157
action="store_true",
162
start_stop_checker.add_argument("--stop-checker", dest="commands",
163
action="append_const", default=[],
164
const=command.StopChecker(),
158
165
help="Stop checker for client")
159
parser.add_argument("-V", "--is-enabled", action="store_true",
166
parser.add_argument("-V", "--is-enabled", dest="commands",
167
action="append_const", default=[],
168
const=command.IsEnabled(),
160
169
help="Check if client is enabled")
161
parser.add_argument("-r", "--remove", action="store_true",
170
parser.add_argument("-r", "--remove", dest="commands",
171
action="append_const", default=[],
172
const=command.Remove(),
162
173
help="Remove client")
163
parser.add_argument("-c", "--checker",
174
parser.add_argument("-c", "--checker", dest="commands",
175
action="append", default=[],
176
metavar="COMMAND", type=command.SetChecker,
164
177
help="Set checker command for client")
165
parser.add_argument("-t", "--timeout", type=string_to_delta,
166
help="Set timeout for client")
167
parser.add_argument("--extended-timeout", type=string_to_delta,
168
help="Set extended timeout for client")
169
parser.add_argument("-i", "--interval", type=string_to_delta,
170
help="Set checker interval for client")
178
parser.add_argument(
179
"-t", "--timeout", dest="commands", action="append",
180
default=[], metavar="TIME",
181
type=command.SetTimeout.argparse(string_to_delta),
182
help="Set timeout for client")
183
parser.add_argument(
184
"--extended-timeout", dest="commands", action="append",
185
default=[], metavar="TIME",
186
type=command.SetExtendedTimeout.argparse(string_to_delta),
187
help="Set extended timeout for client")
188
parser.add_argument(
189
"-i", "--interval", dest="commands", action="append",
190
default=[], metavar="TIME",
191
type=command.SetInterval.argparse(string_to_delta),
192
help="Set checker interval for client")
171
193
approve_deny_default = parser.add_mutually_exclusive_group()
172
194
approve_deny_default.add_argument(
173
"--approve-by-default", action="store_true",
174
default=None, dest="approved_by_default",
195
"--approve-by-default", dest="commands",
196
action="append_const", default=[],
197
const=command.ApproveByDefault(),
175
198
help="Set client to be approved by default")
176
199
approve_deny_default.add_argument(
177
"--deny-by-default", action="store_false",
178
dest="approved_by_default",
200
"--deny-by-default", dest="commands",
201
action="append_const", default=[],
202
const=command.DenyByDefault(),
179
203
help="Set client to be denied by default")
180
parser.add_argument("--approval-delay", type=string_to_delta,
181
help="Set delay before client approve/deny")
182
parser.add_argument("--approval-duration", type=string_to_delta,
183
help="Set duration of one client approval")
184
parser.add_argument("-H", "--host", help="Set host for client")
185
parser.add_argument("-s", "--secret",
186
type=argparse.FileType(mode="rb"),
187
help="Set password blob (file) for client")
204
parser.add_argument(
205
"--approval-delay", dest="commands", action="append",
206
default=[], metavar="TIME",
207
type=command.SetApprovalDelay.argparse(string_to_delta),
208
help="Set delay before client approve/deny")
209
parser.add_argument(
210
"--approval-duration", dest="commands", action="append",
211
default=[], metavar="TIME",
212
type=command.SetApprovalDuration.argparse(string_to_delta),
213
help="Set duration of one client approval")
214
parser.add_argument("-H", "--host", dest="commands",
215
action="append", default=[], metavar="STRING",
216
type=command.SetHost,
217
help="Set host for client")
218
parser.add_argument(
219
"-s", "--secret", dest="commands", action="append",
220
default=[], metavar="FILENAME",
221
type=command.SetSecret.argparse(argparse.FileType(mode="rb")),
222
help="Set password blob (file) for client")
188
223
approve_deny = parser.add_mutually_exclusive_group()
189
224
approve_deny.add_argument(
190
"-A", "--approve", action="store_true",
225
"-A", "--approve", dest="commands", action="append_const",
226
default=[], const=command.Approve(),
191
227
help="Approve any current client request")
192
approve_deny.add_argument("-D", "--deny", action="store_true",
228
approve_deny.add_argument("-D", "--deny", dest="commands",
229
action="append_const", default=[],
230
const=command.Deny(),
193
231
help="Deny any current client request")
194
232
parser.add_argument("--debug", action="store_true",
195
233
help="Debug mode (show D-Bus commands)")
386
424
"""Apply additional restrictions on options, not expressible in
387
425
argparse"""
388
426
389
def has_actions(options):
390
return any((options.enable,
391
options.disable,
392
options.bump_timeout,
393
options.start_checker,
394
options.stop_checker,
395
options.is_enabled,
396
options.remove,
397
options.checker is not None,
398
options.timeout is not None,
399
options.extended_timeout is not None,
400
options.interval is not None,
401
options.approved_by_default is not None,
402
options.approval_delay is not None,
403
options.approval_duration is not None,
404
options.host is not None,
405
options.secret is not None,
406
options.approve,
407
options.deny))
427
def has_commands(options, commands=None):
428
if commands is None:
429
commands = (command.Enable,
430
command.Disable,
431
command.BumpTimeout,
432
command.StartChecker,
433
command.StopChecker,
434
command.IsEnabled,
435
command.Remove,
436
command.SetChecker,
437
command.SetTimeout,
438
command.SetExtendedTimeout,
439
command.SetInterval,
440
command.ApproveByDefault,
441
command.DenyByDefault,
442
command.SetApprovalDelay,
443
command.SetApprovalDuration,
444
command.SetHost,
445
command.SetSecret,
446
command.Approve,
447
command.Deny)
448
return any(isinstance(cmd, commands)
449
for cmd in options.commands)
408
450
409
if has_actions(options) and not (options.client or options.all):
451
if has_commands(options) and not (options.client or options.all):
410
452
parser.error("Options require clients names or --all.")
411
if options.verbose and has_actions(options):
453
if options.verbose and has_commands(options):
412
454
parser.error("--verbose can only be used alone.")
413
if options.dump_json and (options.verbose
414
or has_actions(options)):
455
if (has_commands(options, (command.DumpJSON,))
456
and (options.verbose or len(options.commands) > 1)):
415
457
parser.error("--dump-json can only be used alone.")
416
if options.all and not has_actions(options):
458
if options.all and not has_commands(options):
417
459
parser.error("--all requires an action.")
418
if options.is_enabled and len(options.client) > 1:
460
if (has_commands(options, (command.IsEnabled,))
461
and len(options.client) > 1):
419
462
parser.error("--is-enabled requires exactly one client")
420
if options.remove:
421
options.remove = False
422
if has_actions(options) and not options.deny:
423
parser.error("--remove can only be combined with --deny")
424
options.remove = True
425
426
427
def get_mandos_dbus_object(bus):
428
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
429
dbus_busname, server_dbus_path)
430
with if_dbus_exception_log_with_exception_and_exit(
431
"Could not connect to Mandos server: %s"):
432
mandos_dbus_object = bus.get_object(dbus_busname,
433
server_dbus_path)
434
return mandos_dbus_object
435
436
437
@contextlib.contextmanager
438
def if_dbus_exception_log_with_exception_and_exit(*args, **kwargs):
439
try:
440
yield
441
except dbus.exceptions.DBusException as e:
442
log.critical(*(args + (e,)), **kwargs)
443
sys.exit(1)
444
445
446
def get_managed_objects(object_manager):
447
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
448
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
449
with if_dbus_exception_log_with_exception_and_exit(
450
"Failed to access Mandos server through D-Bus:\n%s"):
451
with SilenceLogger("dbus.proxies"):
452
managed_objects = object_manager.GetManagedObjects()
453
return managed_objects
454
455
456
class SilenceLogger(object):
457
"Simple context manager to silence a particular logger"
458
def __init__(self, loggername):
459
self.logger = logging.getLogger(loggername)
460
461
def __enter__(self):
462
self.logger.addFilter(self.nullfilter)
463
return self
464
465
class NullFilter(logging.Filter):
466
def filter(self, record):
467
return False
468
469
nullfilter = NullFilter()
470
471
def __exit__(self, exc_type, exc_val, exc_tb):
472
self.logger.removeFilter(self.nullfilter)
463
if (len(options.commands) > 1
464
and has_commands(options, (command.Remove,))
465
and not has_commands(options, (command.Deny,))):
466
parser.error("--remove can only be combined with --deny")
467
468
469
class dbus(object):
470
471
class SystemBus(object):
472
473
object_manager_iface = "org.freedesktop.DBus.ObjectManager"
474
def get_managed_objects(self, busname, objectpath):
475
return self.call_method("GetManagedObjects", busname,
476
objectpath,
477
self.object_manager_iface)
478
479
properties_iface = "org.freedesktop.DBus.Properties"
480
def set_property(self, busname, objectpath, interface, key,
481
value):
482
self.call_method("Set", busname, objectpath,
483
self.properties_iface, interface, key,
484
value)
485
486
487
class MandosBus(SystemBus):
488
busname_domain = "se.recompile"
489
busname = busname_domain + ".Mandos"
490
server_path = "/"
491
server_interface = busname_domain + ".Mandos"
492
client_interface = busname_domain + ".Mandos.Client"
493
del busname_domain
494
495
def get_clients_and_properties(self):
496
managed_objects = self.get_managed_objects(
497
self.busname, self.server_path)
498
return {objpath: properties[self.client_interface]
499
for objpath, properties in managed_objects.items()
500
if self.client_interface in properties}
501
502
def set_client_property(self, objectpath, key, value):
503
return self.set_property(self.busname, objectpath,
504
self.client_interface, key,
505
value)
506
507
def call_client_method(self, objectpath, method, *args):
508
return self.call_method(method, self.busname, objectpath,
509
self.client_interface, *args)
510
511
def call_server_method(self, method, *args):
512
return self.call_method(method, self.busname,
513
self.server_path,
514
self.server_interface, *args)
515
516
class Error(Exception):
517
pass
518
519
class ConnectFailed(Error):
520
pass
521
522
523
class dbus_python_adapter(object):
524
525
class SystemBus(dbus.MandosBus):
526
"""Use dbus-python"""
527
528
def __init__(self, module=dbus_python):
529
self.dbus_python = module
530
self.bus = self.dbus_python.SystemBus()
531
532
@contextlib.contextmanager
533
def convert_exception(self, exception_class=dbus.Error):
534
try:
535
yield
536
except self.dbus_python.exceptions.DBusException as e:
537
# This does what "raise from" would do
538
exc = exception_class(*e.args)
539
exc.__cause__ = e
540
raise exc
541
542
def call_method(self, methodname, busname, objectpath,
543
interface, *args):
544
proxy_object = self.get_object(busname, objectpath)
545
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
546
interface, methodname,
547
", ".join(repr(a) for a in args))
548
method = getattr(proxy_object, methodname)
549
with self.convert_exception():
550
with dbus_python_adapter.SilenceLogger(
551
"dbus.proxies"):
552
value = method(*args, dbus_interface=interface)
553
return self.type_filter(value)
554
555
def get_object(self, busname, objectpath):
556
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
557
busname, objectpath)
558
with self.convert_exception(dbus.ConnectFailed):
559
return self.bus.get_object(busname, objectpath)
560
561
def type_filter(self, value):
562
"""Convert the most bothersome types to Python types"""
563
if isinstance(value, self.dbus_python.Boolean):
564
return bool(value)
565
if isinstance(value, self.dbus_python.ObjectPath):
566
return str(value)
567
# Also recurse into dictionaries
568
if isinstance(value, self.dbus_python.Dictionary):
569
return {self.type_filter(key):
570
self.type_filter(subval)
571
for key, subval in value.items()}
572
return value
573
574
575
class SilenceLogger(object):
576
"Simple context manager to silence a particular logger"
577
def __init__(self, loggername):
578
self.logger = logging.getLogger(loggername)
579
580
def __enter__(self):
581
self.logger.addFilter(self.nullfilter)
582
583
class NullFilter(logging.Filter):
584
def filter(self, record):
585
return False
586
587
nullfilter = NullFilter()
588
589
def __exit__(self, exc_type, exc_val, exc_tb):
590
self.logger.removeFilter(self.nullfilter)
591
592
593
class CachingBus(SystemBus):
594
"""A caching layer for dbus_python_adapter.SystemBus"""
595
def __init__(self, *args, **kwargs):
596
self.object_cache = {}
597
super(dbus_python_adapter.CachingBus,
598
self).__init__(*args, **kwargs)
599
def get_object(self, busname, objectpath):
600
try:
601
return self.object_cache[(busname, objectpath)]
602
except KeyError:
603
new_object = super(
604
dbus_python_adapter.CachingBus,
605
self).get_object(busname, objectpath)
606
self.object_cache[(busname, objectpath)] = new_object
607
return new_object
608
609
610
class pydbus_adapter(object):
611
class SystemBus(dbus.MandosBus):
612
def __init__(self, module=pydbus):
613
self.pydbus = module
614
self.bus = self.pydbus.SystemBus()
615
616
@contextlib.contextmanager
617
def convert_exception(self, exception_class=dbus.Error):
618
try:
619
yield
620
except gi.repository.GLib.Error as e:
621
# This does what "raise from" would do
622
exc = exception_class(*e.args)
623
exc.__cause__ = e
624
raise exc
625
626
def call_method(self, methodname, busname, objectpath,
627
interface, *args):
628
proxy_object = self.get(busname, objectpath)
629
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
630
interface, methodname,
631
", ".join(repr(a) for a in args))
632
method = getattr(proxy_object[interface], methodname)
633
with self.convert_exception():
634
return method(*args)
635
636
def get(self, busname, objectpath):
637
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
638
busname, objectpath)
639
with self.convert_exception(dbus.ConnectFailed):
640
if sys.version_info.major <= 2:
641
with warnings.catch_warnings():
642
warnings.filterwarnings(
643
"ignore", "", DeprecationWarning,
644
r"^xml\.etree\.ElementTree$")
645
return self.bus.get(busname, objectpath)
646
else:
647
return self.bus.get(busname, objectpath)
648
649
def set_property(self, busname, objectpath, interface, key,
650
value):
651
proxy_object = self.get(busname, objectpath)
652
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
653
objectpath, self.properties_iface, interface,
654
key, value)
655
setattr(proxy_object[interface], key, value)
656
657
class CachingBus(SystemBus):
658
"""A caching layer for pydbus_adapter.SystemBus"""
659
def __init__(self, *args, **kwargs):
660
self.object_cache = {}
661
super(pydbus_adapter.CachingBus,
662
self).__init__(*args, **kwargs)
663
def get(self, busname, objectpath):
664
try:
665
return self.object_cache[(busname, objectpath)]
666
except KeyError:
667
new_object = (super(pydbus_adapter.CachingBus, self)
668
.get(busname, objectpath))
669
self.object_cache[(busname, objectpath)] = new_object
670
return new_object
473
671
474
672
475
673
def commands_from_options(options):
476
674
477
commands = []
478
479
if options.is_enabled:
480
commands.append(command.IsEnabled())
481
482
if options.approve:
483
commands.append(command.Approve())
484
485
if options.deny:
486
commands.append(command.Deny())
487
488
if options.remove:
489
commands.append(command.Remove())
490
491
if options.dump_json:
492
commands.append(command.DumpJSON())
493
494
if options.enable:
495
commands.append(command.Enable())
496
497
if options.disable:
498
commands.append(command.Disable())
499
500
if options.bump_timeout:
501
commands.append(command.BumpTimeout())
502
503
if options.start_checker:
504
commands.append(command.StartChecker())
505
506
if options.stop_checker:
507
commands.append(command.StopChecker())
508
509
if options.approved_by_default is not None:
510
if options.approved_by_default:
511
commands.append(command.ApproveByDefault())
675
commands = list(options.commands)
676
677
def find_cmd(cmd, commands):
678
i = 0
679
for i, c in enumerate(commands):
680
if isinstance(c, cmd):
681
return i
682
return i+1
683
684
# If command.Remove is present, move any instances of command.Deny
685
# to occur ahead of command.Remove.
686
index_of_remove = find_cmd(command.Remove, commands)
687
before_remove = commands[:index_of_remove]
688
after_remove = commands[index_of_remove:]
689
cleaned_after = []
690
for cmd in after_remove:
691
if isinstance(cmd, command.Deny):
692
before_remove.append(cmd)
512
693
else:
513
commands.append(command.DenyByDefault())
514
515
if options.checker is not None:
516
commands.append(command.SetChecker(options.checker))
517
518
if options.host is not None:
519
commands.append(command.SetHost(options.host))
520
521
if options.secret is not None:
522
commands.append(command.SetSecret(options.secret))
523
524
if options.timeout is not None:
525
commands.append(command.SetTimeout(options.timeout))
526
527
if options.extended_timeout:
528
commands.append(
529
command.SetExtendedTimeout(options.extended_timeout))
530
531
if options.interval is not None:
532
commands.append(command.SetInterval(options.interval))
533
534
if options.approval_delay is not None:
535
commands.append(
536
command.SetApprovalDelay(options.approval_delay))
537
538
if options.approval_duration is not None:
539
commands.append(
540
command.SetApprovalDuration(options.approval_duration))
694
cleaned_after.append(cmd)
695
if cleaned_after != after_remove:
696
commands = before_remove + cleaned_after
541
697
542
698
# If no command option has been given, show table of clients,
543
699
# optionally verbosely
552
708
553
709
class Base(object):
554
710
"""Abstract base class for commands"""
555
def run(self, clients, bus=None, mandos=None):
711
def run(self, clients, bus=None):
556
712
"""Normal commands should implement run_on_one_client(),
557
713
but commands which want to operate on all clients at the same time can
558
714
override this run() method instead.
559
715
"""
560
self.mandos = mandos
561
for clientpath, properties in clients.items():
562
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
563
dbus_busname, str(clientpath))
564
client = bus.get_object(dbus_busname, clientpath)
716
self.bus = bus
717
for client, properties in clients.items():
565
718
self.run_on_one_client(client, properties)
566
719
567
720
568
721
class IsEnabled(Base):
569
def run(self, clients, bus=None, mandos=None):
570
client, properties = next(iter(clients.items()))
571
if self.is_enabled(client, properties):
722
def run(self, clients, bus=None):
723
properties = next(iter(clients.values()))
724
if properties["Enabled"]:
572
725
sys.exit(0)
573
726
sys.exit(1)
574
def is_enabled(self, client, properties):
575
return properties["Enabled"]
576
727
577
728
578
729
class Approve(Base):
579
730
def run_on_one_client(self, client, properties):
580
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
581
client.__dbus_object_path__,
582
client_dbus_interface)
583
client.Approve(dbus.Boolean(True),
584
dbus_interface=client_dbus_interface)
731
self.bus.call_client_method(client, "Approve", True)
585
732
586
733
587
734
class Deny(Base):
588
735
def run_on_one_client(self, client, properties):
589
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
590
client.__dbus_object_path__,
591
client_dbus_interface)
592
client.Approve(dbus.Boolean(False),
593
dbus_interface=client_dbus_interface)
736
self.bus.call_client_method(client, "Approve", False)
594
737
595
738
596
739
class Remove(Base):
597
def run_on_one_client(self, client, properties):
598
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)",
599
dbus_busname, server_dbus_path,
600
server_dbus_interface,
601
str(client.__dbus_object_path__))
602
self.mandos.RemoveClient(client.__dbus_object_path__)
740
def run(self, clients, bus):
741
for clientpath in frozenset(clients.keys()):
742
bus.call_server_method("RemoveClient", clientpath)
603
743
604
744
605
745
class Output(Base):
613
753
"Checker", "ExtendedTimeout", "Expires",
614
754
"LastCheckerStatus")
615
755
616
def run(self, clients, bus=None, mandos=None):
617
print(self.output(clients.values()))
618
619
def output(self, clients):
620
raise NotImplementedError()
621
622
756
623
757
class DumpJSON(Output):
624
def output(self, clients):
625
data = {client["Name"]:
626
{key: self.dbus_boolean_to_bool(client[key])
758
def run(self, clients, bus=None):
759
data = {properties["Name"]:
760
{key: properties[key]
627
761
for key in self.all_keywords}
628
for client in clients}
629
return json.dumps(data, indent=4, separators=(',', ': '))
630
631
@staticmethod
632
def dbus_boolean_to_bool(value):
633
if isinstance(value, dbus.Boolean):
634
value = bool(value)
635
return value
762
for properties in clients.values()}
763
print(json.dumps(data, indent=4, separators=(',', ': ')))
636
764
637
765
638
766
class PrintTable(Output):
639
767
def __init__(self, verbose=False):
640
768
self.verbose = verbose
641
769
642
def output(self, clients):
770
def run(self, clients, bus=None):
643
771
default_keywords = ("Name", "Enabled", "Timeout",
644
772
"LastCheckedOK")
645
773
keywords = default_keywords
646
774
if self.verbose:
647
775
keywords = self.all_keywords
648
return str(self.TableOfClients(clients, keywords))
776
print(self.TableOfClients(clients.values(), keywords))
649
777
650
778
class TableOfClients(object):
651
779
tableheaders = {
706
834
707
835
@classmethod
708
836
def valuetostring(cls, value, keyword):
709
if isinstance(value, dbus.Boolean):
837
if isinstance(value, bool):
710
838
return "Yes" if value else "No"
711
839
if keyword in ("Timeout", "Interval", "ApprovalDelay",
712
840
"ApprovalDuration", "ExtendedTimeout"):
732
860
seconds=td.seconds % 60))
733
861
734
862
735
class Property(Base):
863
class PropertySetter(Base):
736
864
"Abstract class for Actions for setting one client property"
737
865
738
def run_on_one_client(self, client, properties):
866
def run_on_one_client(self, client, properties=None):
739
867
"""Set the Client's D-Bus property"""
740
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
741
client.__dbus_object_path__,
742
dbus.PROPERTIES_IFACE, client_dbus_interface,
743
self.propname, self.value_to_set
744
if not isinstance(self.value_to_set,
745
dbus.Boolean)
746
else bool(self.value_to_set))
747
client.Set(client_dbus_interface, self.propname,
748
self.value_to_set,
749
dbus_interface=dbus.PROPERTIES_IFACE)
868
self.bus.set_client_property(client, self.propname,
869
self.value_to_set)
750
870
751
871
@property
752
872
def propname(self):
753
873
raise NotImplementedError()
754
874
755
875
756
class Enable(Property):
757
propname = "Enabled"
758
value_to_set = dbus.Boolean(True)
759
760
761
class Disable(Property):
762
propname = "Enabled"
763
value_to_set = dbus.Boolean(False)
764
765
766
class BumpTimeout(Property):
876
class Enable(PropertySetter):
877
propname = "Enabled"
878
value_to_set = True
879
880
881
class Disable(PropertySetter):
882
propname = "Enabled"
883
value_to_set = False
884
885
886
class BumpTimeout(PropertySetter):
767
887
propname = "LastCheckedOK"
768
888
value_to_set = ""
769
889
770
890
771
class StartChecker(Property):
772
propname = "CheckerRunning"
773
value_to_set = dbus.Boolean(True)
774
775
776
class StopChecker(Property):
777
propname = "CheckerRunning"
778
value_to_set = dbus.Boolean(False)
779
780
781
class ApproveByDefault(Property):
782
propname = "ApprovedByDefault"
783
value_to_set = dbus.Boolean(True)
784
785
786
class DenyByDefault(Property):
787
propname = "ApprovedByDefault"
788
value_to_set = dbus.Boolean(False)
789
790
791
class PropertyValue(Property):
792
"Abstract class for Property recieving a value as argument"
891
class StartChecker(PropertySetter):
892
propname = "CheckerRunning"
893
value_to_set = True
894
895
896
class StopChecker(PropertySetter):
897
propname = "CheckerRunning"
898
value_to_set = False
899
900
901
class ApproveByDefault(PropertySetter):
902
propname = "ApprovedByDefault"
903
value_to_set = True
904
905
906
class DenyByDefault(PropertySetter):
907
propname = "ApprovedByDefault"
908
value_to_set = False
909
910
911
class PropertySetterValue(PropertySetter):
912
"""Abstract class for PropertySetter recieving a value as
913
constructor argument instead of a class attribute."""
793
914
def __init__(self, value):
794
915
self.value_to_set = value
795
916
917
@classmethod
918
def argparse(cls, argtype):
919
def cmdtype(arg):
920
return cls(argtype(arg))
921
return cmdtype
796
922
797
class SetChecker(PropertyValue):
923
class SetChecker(PropertySetterValue):
798
924
propname = "Checker"
799
925
800
926
801
class SetHost(PropertyValue):
927
class SetHost(PropertySetterValue):
802
928
propname = "Host"
803
929
804
930
805
class SetSecret(PropertyValue):
931
class SetSecret(PropertySetterValue):
806
932
propname = "Secret"
807
933
808
934
@property
816
942
value.close()
817
943
818
944
819
class MillisecondsPropertyValueArgument(PropertyValue):
820
"""Abstract class for PropertyValue taking a value argument as
821
a datetime.timedelta() but should store it as milliseconds."""
945
class PropertySetterValueMilliseconds(PropertySetterValue):
946
"""Abstract class for PropertySetterValue taking a value
947
argument as a datetime.timedelta() but should store it as
948
milliseconds."""
822
949
823
950
@property
824
951
def value_to_set(self):
830
957
self._vts = int(round(value.total_seconds() * 1000))
831
958
832
959
833
class SetTimeout(MillisecondsPropertyValueArgument):
960
class SetTimeout(PropertySetterValueMilliseconds):
834
961
propname = "Timeout"
835
962
836
963
837
class SetExtendedTimeout(MillisecondsPropertyValueArgument):
964
class SetExtendedTimeout(PropertySetterValueMilliseconds):
838
965
propname = "ExtendedTimeout"
839
966
840
967
841
class SetInterval(MillisecondsPropertyValueArgument):
968
class SetInterval(PropertySetterValueMilliseconds):
842
969
propname = "Interval"
843
970
844
971
845
class SetApprovalDelay(MillisecondsPropertyValueArgument):
972
class SetApprovalDelay(PropertySetterValueMilliseconds):
846
973
propname = "ApprovalDelay"
847
974
848
975
849
class SetApprovalDuration(MillisecondsPropertyValueArgument):
976
class SetApprovalDuration(PropertySetterValueMilliseconds):
850
977
propname = "ApprovalDuration"
851
978
852
979
885
1012
"output"))
886
1013
887
1014
1015
class Unique(object):
1016
"""Class for objects which exist only to be unique objects, since
1017
unittest.mock.sentinel only exists in Python 3.3"""
1018
1019
888
1020
class Test_string_to_delta(TestCaseWithAssertLogs):
889
1021
# Just test basic RFC 3339 functionality here, the doc string for
890
1022
# rfc3339_duration_to_delta() already has more comprehensive
891
# tests, which is run by doctest.
1023
# tests, which are run by doctest.
892
1024
893
1025
def test_rfc3339_zero_seconds(self):
894
1026
self.assertEqual(datetime.timedelta(),
918
1050
919
1051
def test_actions_requires_client_or_all(self):
920
1052
for action, value in self.actions.items():
921
options = self.parser.parse_args()
922
setattr(options, action, value)
1053
args = self.actionargs(action, value)
923
1054
with self.assertParseError():
924
self.check_option_syntax(options)
1055
self.parse_args(args)
925
1056
926
# This mostly corresponds to the definition from has_actions() in
1057
# This mostly corresponds to the definition from has_commands() in
927
1058
# check_option_syntax()
928
1059
actions = {
929
# The actual values set here are not that important, but we do
930
# at least stick to the correct types, even though they are
931
# never used
932
"enable": True,
933
"disable": True,
934
"bump_timeout": True,
935
"start_checker": True,
936
"stop_checker": True,
937
"is_enabled": True,
938
"remove": True,
939
"checker": "x",
940
"timeout": datetime.timedelta(),
941
"extended_timeout": datetime.timedelta(),
942
"interval": datetime.timedelta(),
943
"approved_by_default": True,
944
"approval_delay": datetime.timedelta(),
945
"approval_duration": datetime.timedelta(),
946
"host": "x",
947
"secret": io.BytesIO(b"x"),
948
"approve": True,
949
"deny": True,
1060
"--enable": None,
1061
"--disable": None,
1062
"--bump-timeout": None,
1063
"--start-checker": None,
1064
"--stop-checker": None,
1065
"--is-enabled": None,
1066
"--remove": None,
1067
"--checker": "x",
1068
"--timeout": "PT0S",
1069
"--extended-timeout": "PT0S",
1070
"--interval": "PT0S",
1071
"--approve-by-default": None,
1072
"--deny-by-default": None,
1073
"--approval-delay": "PT0S",
1074
"--approval-duration": "PT0S",
1075
"--host": "hostname",
1076
"--secret": "/dev/null",
1077
"--approve": None,
1078
"--deny": None,
950
1079
}
951
1080
1081
@staticmethod
1082
def actionargs(action, value, *args):
1083
if value is not None:
1084
return [action, value] + list(args)
1085
else:
1086
return [action] + list(args)
1087
952
1088
@contextlib.contextmanager
953
1089
def assertParseError(self):
954
1090
with self.assertRaises(SystemExit) as e:
959
1095
# /argparse.html#exiting-methods
960
1096
self.assertEqual(2, e.exception.code)
961
1097
1098
def parse_args(self, args):
1099
options = self.parser.parse_args(args)
1100
check_option_syntax(self.parser, options)
1101
962
1102
@staticmethod
963
1103
@contextlib.contextmanager
964
1104
def redirect_stderr_to_devnull():
965
null = os.open(os.path.devnull, os.O_RDWR)
966
stderrcopy = os.dup(sys.stderr.fileno())
967
os.dup2(null, sys.stderr.fileno())
968
os.close(null)
969
try:
970
yield
971
finally:
972
# restore stderr
973
os.dup2(stderrcopy, sys.stderr.fileno())
974
os.close(stderrcopy)
1105
old_stderr = sys.stderr
1106
with contextlib.closing(open(os.devnull, "w")) as null:
1107
sys.stderr = null
1108
try:
1109
yield
1110
finally:
1111
sys.stderr = old_stderr
975
1112
976
1113
def check_option_syntax(self, options):
977
1114
check_option_syntax(self.parser, options)
978
1115
979
1116
def test_actions_all_conflicts_with_verbose(self):
980
1117
for action, value in self.actions.items():
981
options = self.parser.parse_args()
982
setattr(options, action, value)
983
options.all = True
984
options.verbose = True
1118
args = self.actionargs(action, value, "--all",
1119
"--verbose")
985
1120
with self.assertParseError():
986
self.check_option_syntax(options)
1121
self.parse_args(args)
987
1122
988
1123
def test_actions_with_client_conflicts_with_verbose(self):
989
1124
for action, value in self.actions.items():
990
options = self.parser.parse_args()
991
setattr(options, action, value)
992
options.verbose = True
993
options.client = ["foo"]
1125
args = self.actionargs(action, value, "--verbose",
1126
"client")
994
1127
with self.assertParseError():
995
self.check_option_syntax(options)
1128
self.parse_args(args)
996
1129
997
1130
def test_dump_json_conflicts_with_verbose(self):
998
options = self.parser.parse_args()
999
options.dump_json = True
1000
options.verbose = True
1131
args = ["--dump-json", "--verbose"]
1001
1132
with self.assertParseError():
1002
self.check_option_syntax(options)
1133
self.parse_args(args)
1003
1134
1004
1135
def test_dump_json_conflicts_with_action(self):
1005
1136
for action, value in self.actions.items():
1006
options = self.parser.parse_args()
1007
setattr(options, action, value)
1008
options.dump_json = True
1137
args = self.actionargs(action, value, "--dump-json")
1009
1138
with self.assertParseError():
1010
self.check_option_syntax(options)
1139
self.parse_args(args)
1011
1140
1012
1141
def test_all_can_not_be_alone(self):
1013
options = self.parser.parse_args()
1014
options.all = True
1142
args = ["--all"]
1015
1143
with self.assertParseError():
1016
self.check_option_syntax(options)
1144
self.parse_args(args)
1017
1145
1018
1146
def test_all_is_ok_with_any_action(self):
1019
1147
for action, value in self.actions.items():
1020
options = self.parser.parse_args()
1021
setattr(options, action, value)
1022
options.all = True
1023
self.check_option_syntax(options)
1148
args = self.actionargs(action, value, "--all")
1149
self.parse_args(args)
1024
1150
1025
1151
def test_any_action_is_ok_with_one_client(self):
1026
1152
for action, value in self.actions.items():
1027
options = self.parser.parse_args()
1028
setattr(options, action, value)
1029
options.client = ["foo"]
1030
self.check_option_syntax(options)
1153
args = self.actionargs(action, value, "client")
1154
self.parse_args(args)
1031
1155
1032
1156
def test_one_client_with_all_actions_except_is_enabled(self):
1033
options = self.parser.parse_args()
1034
1157
for action, value in self.actions.items():
1035
if action == "is_enabled":
1158
if action == "--is-enabled":
1036
1159
continue
1037
setattr(options, action, value)
1038
options.client = ["foo"]
1039
self.check_option_syntax(options)
1160
args = self.actionargs(action, value, "client")
1161
self.parse_args(args)
1040
1162
1041
1163
def test_two_clients_with_all_actions_except_is_enabled(self):
1042
options = self.parser.parse_args()
1043
1164
for action, value in self.actions.items():
1044
if action == "is_enabled":
1165
if action == "--is-enabled":
1045
1166
continue
1046
setattr(options, action, value)
1047
options.client = ["foo", "barbar"]
1048
self.check_option_syntax(options)
1167
args = self.actionargs(action, value, "client1",
1168
"client2")
1169
self.parse_args(args)
1049
1170
1050
1171
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1051
1172
for action, value in self.actions.items():
1052
if action == "is_enabled":
1173
if action == "--is-enabled":
1053
1174
continue
1054
options = self.parser.parse_args()
1055
setattr(options, action, value)
1056
options.client = ["foo", "barbar"]
1057
self.check_option_syntax(options)
1175
args = self.actionargs(action, value, "client1",
1176
"client2")
1177
self.parse_args(args)
1058
1178
1059
1179
def test_is_enabled_fails_without_client(self):
1060
options = self.parser.parse_args()
1061
options.is_enabled = True
1180
args = ["--is-enabled"]
1062
1181
with self.assertParseError():
1063
self.check_option_syntax(options)
1182
self.parse_args(args)
1064
1183
1065
1184
def test_is_enabled_fails_with_two_clients(self):
1066
options = self.parser.parse_args()
1067
options.is_enabled = True
1068
options.client = ["foo", "barbar"]
1185
args = ["--is-enabled", "client1", "client2"]
1069
1186
with self.assertParseError():
1070
self.check_option_syntax(options)
1187
self.parse_args(args)
1071
1188
1072
1189
def test_remove_can_only_be_combined_with_action_deny(self):
1073
1190
for action, value in self.actions.items():
1074
if action in {"remove", "deny"}:
1191
if action in {"--remove", "--deny"}:
1075
1192
continue
1076
options = self.parser.parse_args()
1077
setattr(options, action, value)
1078
options.all = True
1079
options.remove = True
1193
args = self.actionargs(action, value, "--all",
1194
"--remove")
1080
1195
with self.assertParseError():
1081
self.check_option_syntax(options)
1082
1083
1084
class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):
1085
def test_calls_and_returns_get_object_on_bus(self):
1086
class MockBus(object):
1087
called = False
1088
def get_object(mockbus_self, busname, dbus_path):
1089
# Note that "self" is still the testcase instance,
1090
# this MockBus instance is in "mockbus_self".
1091
self.assertEqual(dbus_busname, busname)
1092
self.assertEqual(server_dbus_path, dbus_path)
1093
mockbus_self.called = True
1094
return mockbus_self
1095
1096
mockbus = get_mandos_dbus_object(bus=MockBus())
1097
self.assertIsInstance(mockbus, MockBus)
1098
self.assertTrue(mockbus.called)
1099
1100
def test_logs_and_exits_on_dbus_error(self):
1101
class MockBusFailing(object):
1102
def get_object(self, busname, dbus_path):
1103
raise dbus.exceptions.DBusException("Test")
1104
1105
with self.assertLogs(log, logging.CRITICAL):
1106
with self.assertRaises(SystemExit) as e:
1107
bus = get_mandos_dbus_object(bus=MockBusFailing())
1108
1109
if isinstance(e.exception.code, int):
1110
self.assertNotEqual(0, e.exception.code)
1111
else:
1112
self.assertIsNotNone(e.exception.code)
1113
1114
1115
class Test_get_managed_objects(TestCaseWithAssertLogs):
1116
def test_calls_and_returns_GetManagedObjects(self):
1117
managed_objects = {"/clients/foo": { "Name": "foo"}}
1118
class MockObjectManager(object):
1119
def GetManagedObjects(self):
1120
return managed_objects
1121
retval = get_managed_objects(MockObjectManager())
1122
self.assertDictEqual(managed_objects, retval)
1123
1124
def test_logs_and_exits_on_dbus_error(self):
1196
self.parse_args(args)
1197
1198
1199
class Test_dbus_exceptions(unittest.TestCase):
1200
1201
def test_dbus_ConnectFailed_is_Error(self):
1202
with self.assertRaises(dbus.Error):
1203
raise dbus.ConnectFailed()
1204
1205
1206
class Test_dbus_MandosBus(unittest.TestCase):
1207
1208
class MockMandosBus(dbus.MandosBus):
1209
def __init__(self):
1210
self._name = "se.recompile.Mandos"
1211
self._server_path = "/"
1212
self._server_interface = "se.recompile.Mandos"
1213
self._client_interface = "se.recompile.Mandos.Client"
1214
self.calls = []
1215
self.call_method_return = Unique()
1216
1217
def call_method(self, methodname, busname, objectpath,
1218
interface, *args):
1219
self.calls.append((methodname, busname, objectpath,
1220
interface, args))
1221
return self.call_method_return
1222
1223
def setUp(self):
1224
self.bus = self.MockMandosBus()
1225
1226
def test_set_client_property(self):
1227
self.bus.set_client_property("objectpath", "key", "value")
1228
expected_call = ("Set", self.bus._name, "objectpath",
1229
"org.freedesktop.DBus.Properties",
1230
(self.bus._client_interface, "key", "value"))
1231
self.assertIn(expected_call, self.bus.calls)
1232
1233
def test_call_client_method(self):
1234
ret = self.bus.call_client_method("objectpath", "methodname")
1235
self.assertIs(self.bus.call_method_return, ret)
1236
expected_call = ("methodname", self.bus._name, "objectpath",
1237
self.bus._client_interface, ())
1238
self.assertIn(expected_call, self.bus.calls)
1239
1240
def test_call_client_method_with_args(self):
1241
args = (Unique(), Unique())
1242
ret = self.bus.call_client_method("objectpath", "methodname",
1243
*args)
1244
self.assertIs(self.bus.call_method_return, ret)
1245
expected_call = ("methodname", self.bus._name, "objectpath",
1246
self.bus._client_interface,
1247
(args[0], args[1]))
1248
self.assertIn(expected_call, self.bus.calls)
1249
1250
def test_get_clients_and_properties(self):
1251
managed_objects = {
1252
"objectpath": {
1253
self.bus._client_interface: {
1254
"key": "value",
1255
"bool": True,
1256
},
1257
"irrelevant_interface": {
1258
"key": "othervalue",
1259
"bool": False,
1260
},
1261
},
1262
"other_objectpath": {
1263
"other_irrelevant_interface": {
1264
"key": "value 3",
1265
"bool": None,
1266
},
1267
},
1268
}
1269
expected_clients_and_properties = {
1270
"objectpath": {
1271
"key": "value",
1272
"bool": True,
1273
}
1274
}
1275
self.bus.call_method_return = managed_objects
1276
ret = self.bus.get_clients_and_properties()
1277
self.assertDictEqual(expected_clients_and_properties, ret)
1278
expected_call = ("GetManagedObjects", self.bus._name,
1279
self.bus._server_path,
1280
"org.freedesktop.DBus.ObjectManager", ())
1281
self.assertIn(expected_call, self.bus.calls)
1282
1283
def test_call_server_method(self):
1284
ret = self.bus.call_server_method("methodname")
1285
self.assertIs(self.bus.call_method_return, ret)
1286
expected_call = ("methodname", self.bus._name,
1287
self.bus._server_path,
1288
self.bus._server_interface, ())
1289
self.assertIn(expected_call, self.bus.calls)
1290
1291
def test_call_server_method_with_args(self):
1292
args = (Unique(), Unique())
1293
ret = self.bus.call_server_method("methodname", *args)
1294
self.assertIs(self.bus.call_method_return, ret)
1295
expected_call = ("methodname", self.bus._name,
1296
self.bus._server_path,
1297
self.bus._server_interface,
1298
(args[0], args[1]))
1299
self.assertIn(expected_call, self.bus.calls)
1300
1301
1302
class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):
1303
1304
def MockDBusPython_func(self, func):
1305
class mock_dbus_python(object):
1306
"""mock dbus-python module"""
1307
class exceptions(object):
1308
"""Pseudo-namespace"""
1309
class DBusException(Exception):
1310
pass
1311
class SystemBus(object):
1312
@staticmethod
1313
def get_object(busname, objectpath):
1314
DBusObject = collections.namedtuple(
1315
"DBusObject", ("methodname",))
1316
def method(*args, **kwargs):
1317
self.assertEqual({"dbus_interface":
1318
"interface"},
1319
kwargs)
1320
return func(*args)
1321
return DBusObject(methodname=method)
1322
class Boolean(object):
1323
def __init__(self, value):
1324
self.value = bool(value)
1325
def __bool__(self):
1326
return self.value
1327
if sys.version_info.major == 2:
1328
__nonzero__ = __bool__
1329
class ObjectPath(str):
1330
pass
1331
class Dictionary(dict):
1332
pass
1333
return mock_dbus_python
1334
1335
def call_method(self, bus, methodname, busname, objectpath,
1336
interface, *args):
1337
with self.assertLogs(log, logging.DEBUG):
1338
return bus.call_method(methodname, busname, objectpath,
1339
interface, *args)
1340
1341
def test_call_method_returns(self):
1342
expected_method_return = Unique()
1343
method_args = (Unique(), Unique())
1344
def func(*args):
1345
self.assertEqual(len(method_args), len(args))
1346
for marg, arg in zip(method_args, args):
1347
self.assertIs(marg, arg)
1348
return expected_method_return
1349
mock_dbus_python = self.MockDBusPython_func(func)
1350
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1351
ret = self.call_method(bus, "methodname", "busname",
1352
"objectpath", "interface",
1353
*method_args)
1354
self.assertIs(ret, expected_method_return)
1355
1356
def test_call_method_filters_bool_true(self):
1357
def func():
1358
return method_return
1359
mock_dbus_python = self.MockDBusPython_func(func)
1360
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1361
method_return = mock_dbus_python.Boolean(True)
1362
ret = self.call_method(bus, "methodname", "busname",
1363
"objectpath", "interface")
1364
self.assertTrue(ret)
1365
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1366
1367
def test_call_method_filters_bool_false(self):
1368
def func():
1369
return method_return
1370
mock_dbus_python = self.MockDBusPython_func(func)
1371
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1372
method_return = mock_dbus_python.Boolean(False)
1373
ret = self.call_method(bus, "methodname", "busname",
1374
"objectpath", "interface")
1375
self.assertFalse(ret)
1376
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1377
1378
def test_call_method_filters_objectpath(self):
1379
def func():
1380
return method_return
1381
mock_dbus_python = self.MockDBusPython_func(func)
1382
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1383
method_return = mock_dbus_python.ObjectPath("objectpath")
1384
ret = self.call_method(bus, "methodname", "busname",
1385
"objectpath", "interface")
1386
self.assertEqual("objectpath", ret)
1387
self.assertIsNot("objectpath", ret)
1388
self.assertNotIsInstance(ret, mock_dbus_python.ObjectPath)
1389
1390
def test_call_method_filters_booleans_in_dict(self):
1391
def func():
1392
return method_return
1393
mock_dbus_python = self.MockDBusPython_func(func)
1394
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1395
method_return = mock_dbus_python.Dictionary(
1396
{mock_dbus_python.Boolean(True):
1397
mock_dbus_python.Boolean(False),
1398
mock_dbus_python.Boolean(False):
1399
mock_dbus_python.Boolean(True)})
1400
ret = self.call_method(bus, "methodname", "busname",
1401
"objectpath", "interface")
1402
expected_method_return = {True: False,
1403
False: True}
1404
self.assertEqual(expected_method_return, ret)
1405
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1406
1407
def test_call_method_filters_objectpaths_in_dict(self):
1408
def func():
1409
return method_return
1410
mock_dbus_python = self.MockDBusPython_func(func)
1411
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1412
method_return = mock_dbus_python.Dictionary(
1413
{mock_dbus_python.ObjectPath("objectpath_key_1"):
1414
mock_dbus_python.ObjectPath("objectpath_value_1"),
1415
mock_dbus_python.ObjectPath("objectpath_key_2"):
1416
mock_dbus_python.ObjectPath("objectpath_value_2")})
1417
ret = self.call_method(bus, "methodname", "busname",
1418
"objectpath", "interface")
1419
expected_method_return = {str(key): str(value)
1420
for key, value in
1421
method_return.items()}
1422
self.assertEqual(expected_method_return, ret)
1423
self.assertIsInstance(ret, dict)
1424
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1425
1426
def test_call_method_filters_dict_in_dict(self):
1427
def func():
1428
return method_return
1429
mock_dbus_python = self.MockDBusPython_func(func)
1430
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1431
method_return = mock_dbus_python.Dictionary(
1432
{"key1": mock_dbus_python.Dictionary({"key11": "value11",
1433
"key12": "value12"}),
1434
"key2": mock_dbus_python.Dictionary({"key21": "value21",
1435
"key22": "value22"})})
1436
ret = self.call_method(bus, "methodname", "busname",
1437
"objectpath", "interface")
1438
expected_method_return = {
1439
"key1": {"key11": "value11",
1440
"key12": "value12"},
1441
"key2": {"key21": "value21",
1442
"key22": "value22"},
1443
}
1444
self.assertEqual(expected_method_return, ret)
1445
self.assertIsInstance(ret, dict)
1446
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1447
for key, value in ret.items():
1448
self.assertIsInstance(value, dict)
1449
self.assertEqual(expected_method_return[key], value)
1450
self.assertNotIsInstance(value,
1451
mock_dbus_python.Dictionary)
1452
1453
def test_call_method_filters_dict_three_deep(self):
1454
def func():
1455
return method_return
1456
mock_dbus_python = self.MockDBusPython_func(func)
1457
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1458
method_return = mock_dbus_python.Dictionary(
1459
{"key1":
1460
mock_dbus_python.Dictionary(
1461
{"key2":
1462
mock_dbus_python.Dictionary(
1463
{"key3":
1464
mock_dbus_python.Boolean(True),
1465
}),
1466
}),
1467
})
1468
ret = self.call_method(bus, "methodname", "busname",
1469
"objectpath", "interface")
1470
expected_method_return = {"key1": {"key2": {"key3": True}}}
1471
self.assertEqual(expected_method_return, ret)
1472
self.assertIsInstance(ret, dict)
1473
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1474
self.assertIsInstance(ret["key1"], dict)
1475
self.assertNotIsInstance(ret["key1"],
1476
mock_dbus_python.Dictionary)
1477
self.assertIsInstance(ret["key1"]["key2"], dict)
1478
self.assertNotIsInstance(ret["key1"]["key2"],
1479
mock_dbus_python.Dictionary)
1480
self.assertTrue(ret["key1"]["key2"]["key3"])
1481
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
1482
mock_dbus_python.Boolean)
1483
1484
def test_call_method_handles_exception(self):
1125
1485
dbus_logger = logging.getLogger("dbus.proxies")
1126
1486
1127
class MockObjectManagerFailing(object):
1128
def GetManagedObjects(self):
1129
dbus_logger.error("Test")
1130
raise dbus.exceptions.DBusException("Test")
1487
def func():
1488
dbus_logger.error("Test")
1489
raise mock_dbus_python.exceptions.DBusException()
1490
1491
mock_dbus_python = self.MockDBusPython_func(func)
1492
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1131
1493
1132
1494
class CountingHandler(logging.Handler):
1133
1495
count = 0
1139
1501
dbus_logger.addHandler(counting_handler)
1140
1502
1141
1503
try:
1142
with self.assertLogs(log, logging.CRITICAL) as watcher:
1143
with self.assertRaises(SystemExit) as e:
1144
get_managed_objects(MockObjectManagerFailing())
1504
with self.assertRaises(dbus.Error) as e:
1505
self.call_method(bus, "methodname", "busname",
1506
"objectpath", "interface")
1145
1507
finally:
1146
1508
dbus_logger.removeFilter(counting_handler)
1147
1509
1510
self.assertNotIsInstance(e, dbus.ConnectFailed)
1511
1148
1512
# Make sure the dbus logger was suppressed
1149
1513
self.assertEqual(0, counting_handler.count)
1150
1514
1151
# Test that the dbus_logger still works
1152
with self.assertLogs(dbus_logger, logging.ERROR):
1153
dbus_logger.error("Test")
1154
1155
if isinstance(e.exception.code, int):
1156
self.assertNotEqual(0, e.exception.code)
1157
else:
1158
self.assertIsNotNone(e.exception.code)
1515
def test_get_object_converts_to_correct_exception(self):
1516
bus = dbus_python_adapter.SystemBus(
1517
self.fake_dbus_python_raises_exception_on_connect)
1518
with self.assertRaises(dbus.ConnectFailed):
1519
self.call_method(bus, "methodname", "busname",
1520
"objectpath", "interface")
1521
1522
class fake_dbus_python_raises_exception_on_connect(object):
1523
"""fake dbus-python module"""
1524
class exceptions(object):
1525
"""Pseudo-namespace"""
1526
class DBusException(Exception):
1527
pass
1528
1529
@classmethod
1530
def SystemBus(cls):
1531
def get_object(busname, objectpath):
1532
raise cls.exceptions.DBusException()
1533
Bus = collections.namedtuple("Bus", ["get_object"])
1534
return Bus(get_object=get_object)
1535
1536
1537
class Test_dbus_python_adapter_CachingBus(unittest.TestCase):
1538
class mock_dbus_python(object):
1539
"""mock dbus-python modules"""
1540
class SystemBus(object):
1541
@staticmethod
1542
def get_object(busname, objectpath):
1543
return Unique()
1544
1545
def setUp(self):
1546
self.bus = dbus_python_adapter.CachingBus(
1547
self.mock_dbus_python)
1548
1549
def test_returns_distinct_objectpaths(self):
1550
obj1 = self.bus.get_object("busname", "objectpath1")
1551
self.assertIsInstance(obj1, Unique)
1552
obj2 = self.bus.get_object("busname", "objectpath2")
1553
self.assertIsInstance(obj2, Unique)
1554
self.assertIsNot(obj1, obj2)
1555
1556
def test_returns_distinct_busnames(self):
1557
obj1 = self.bus.get_object("busname1", "objectpath")
1558
self.assertIsInstance(obj1, Unique)
1559
obj2 = self.bus.get_object("busname2", "objectpath")
1560
self.assertIsInstance(obj2, Unique)
1561
self.assertIsNot(obj1, obj2)
1562
1563
def test_returns_distinct_both(self):
1564
obj1 = self.bus.get_object("busname1", "objectpath")
1565
self.assertIsInstance(obj1, Unique)
1566
obj2 = self.bus.get_object("busname2", "objectpath")
1567
self.assertIsInstance(obj2, Unique)
1568
self.assertIsNot(obj1, obj2)
1569
1570
def test_returns_same(self):
1571
obj1 = self.bus.get_object("busname", "objectpath")
1572
self.assertIsInstance(obj1, Unique)
1573
obj2 = self.bus.get_object("busname", "objectpath")
1574
self.assertIsInstance(obj2, Unique)
1575
self.assertIs(obj1, obj2)
1576
1577
def test_returns_same_old(self):
1578
obj1 = self.bus.get_object("busname1", "objectpath1")
1579
self.assertIsInstance(obj1, Unique)
1580
obj2 = self.bus.get_object("busname2", "objectpath2")
1581
self.assertIsInstance(obj2, Unique)
1582
obj1b = self.bus.get_object("busname1", "objectpath1")
1583
self.assertIsInstance(obj1b, Unique)
1584
self.assertIsNot(obj1, obj2)
1585
self.assertIsNot(obj2, obj1b)
1586
self.assertIs(obj1, obj1b)
1587
1588
1589
class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):
1590
1591
def Stub_pydbus_func(self, func):
1592
class stub_pydbus(object):
1593
"""stub pydbus module"""
1594
class SystemBus(object):
1595
@staticmethod
1596
def get(busname, objectpath):
1597
DBusObject = collections.namedtuple(
1598
"DBusObject", ("methodname",))
1599
return {"interface":
1600
DBusObject(methodname=func)}
1601
return stub_pydbus
1602
1603
def call_method(self, bus, methodname, busname, objectpath,
1604
interface, *args):
1605
with self.assertLogs(log, logging.DEBUG):
1606
return bus.call_method(methodname, busname, objectpath,
1607
interface, *args)
1608
1609
def test_call_method_returns(self):
1610
expected_method_return = Unique()
1611
method_args = (Unique(), Unique())
1612
def func(*args):
1613
self.assertEqual(len(method_args), len(args))
1614
for marg, arg in zip(method_args, args):
1615
self.assertIs(marg, arg)
1616
return expected_method_return
1617
stub_pydbus = self.Stub_pydbus_func(func)
1618
bus = pydbus_adapter.SystemBus(stub_pydbus)
1619
ret = self.call_method(bus, "methodname", "busname",
1620
"objectpath", "interface",
1621
*method_args)
1622
self.assertIs(ret, expected_method_return)
1623
1624
def test_call_method_handles_exception(self):
1625
dbus_logger = logging.getLogger("dbus.proxies")
1626
1627
def func():
1628
raise gi.repository.GLib.Error()
1629
1630
stub_pydbus = self.Stub_pydbus_func(func)
1631
bus = pydbus_adapter.SystemBus(stub_pydbus)
1632
1633
with self.assertRaises(dbus.Error) as e:
1634
self.call_method(bus, "methodname", "busname",
1635
"objectpath", "interface")
1636
1637
self.assertNotIsInstance(e, dbus.ConnectFailed)
1638
1639
def test_get_converts_to_correct_exception(self):
1640
bus = pydbus_adapter.SystemBus(
1641
self.fake_pydbus_raises_exception_on_connect)
1642
with self.assertRaises(dbus.ConnectFailed):
1643
self.call_method(bus, "methodname", "busname",
1644
"objectpath", "interface")
1645
1646
class fake_pydbus_raises_exception_on_connect(object):
1647
"""fake dbus-python module"""
1648
@classmethod
1649
def SystemBus(cls):
1650
def get(busname, objectpath):
1651
raise gi.repository.GLib.Error()
1652
Bus = collections.namedtuple("Bus", ["get"])
1653
return Bus(get=get)
1654
1655
def test_set_property_uses_setattr(self):
1656
class Object(object):
1657
pass
1658
obj = Object()
1659
class pydbus_spy(object):
1660
class SystemBus(object):
1661
@staticmethod
1662
def get(busname, objectpath):
1663
return {"interface": obj}
1664
bus = pydbus_adapter.SystemBus(pydbus_spy)
1665
value = Unique()
1666
bus.set_property("busname", "objectpath", "interface", "key",
1667
value)
1668
self.assertIs(value, obj.key)
1669
1670
def test_get_suppresses_xml_deprecation_warning(self):
1671
if sys.version_info.major >= 3:
1672
return
1673
class stub_pydbus_get(object):
1674
class SystemBus(object):
1675
@staticmethod
1676
def get(busname, objectpath):
1677
warnings.warn_explicit(
1678
"deprecated", DeprecationWarning,
1679
"xml.etree.ElementTree", 0)
1680
bus = pydbus_adapter.SystemBus(stub_pydbus_get)
1681
with warnings.catch_warnings(record=True) as w:
1682
warnings.simplefilter("always")
1683
bus.get("busname", "objectpath")
1684
self.assertEqual(0, len(w))
1685
1686
1687
class Test_pydbus_adapter_CachingBus(unittest.TestCase):
1688
class stub_pydbus(object):
1689
"""stub pydbus module"""
1690
class SystemBus(object):
1691
@staticmethod
1692
def get(busname, objectpath):
1693
return Unique()
1694
1695
def setUp(self):
1696
self.bus = pydbus_adapter.CachingBus(self.stub_pydbus)
1697
1698
def test_returns_distinct_objectpaths(self):
1699
obj1 = self.bus.get("busname", "objectpath1")
1700
self.assertIsInstance(obj1, Unique)
1701
obj2 = self.bus.get("busname", "objectpath2")
1702
self.assertIsInstance(obj2, Unique)
1703
self.assertIsNot(obj1, obj2)
1704
1705
def test_returns_distinct_busnames(self):
1706
obj1 = self.bus.get("busname1", "objectpath")
1707
self.assertIsInstance(obj1, Unique)
1708
obj2 = self.bus.get("busname2", "objectpath")
1709
self.assertIsInstance(obj2, Unique)
1710
self.assertIsNot(obj1, obj2)
1711
1712
def test_returns_distinct_both(self):
1713
obj1 = self.bus.get("busname1", "objectpath")
1714
self.assertIsInstance(obj1, Unique)
1715
obj2 = self.bus.get("busname2", "objectpath")
1716
self.assertIsInstance(obj2, Unique)
1717
self.assertIsNot(obj1, obj2)
1718
1719
def test_returns_same(self):
1720
obj1 = self.bus.get("busname", "objectpath")
1721
self.assertIsInstance(obj1, Unique)
1722
obj2 = self.bus.get("busname", "objectpath")
1723
self.assertIsInstance(obj2, Unique)
1724
self.assertIs(obj1, obj2)
1725
1726
def test_returns_same_old(self):
1727
obj1 = self.bus.get("busname1", "objectpath1")
1728
self.assertIsInstance(obj1, Unique)
1729
obj2 = self.bus.get("busname2", "objectpath2")
1730
self.assertIsInstance(obj2, Unique)
1731
obj1b = self.bus.get("busname1", "objectpath1")
1732
self.assertIsInstance(obj1b, Unique)
1733
self.assertIsNot(obj1, obj2)
1734
self.assertIsNot(obj2, obj1b)
1735
self.assertIs(obj1, obj1b)
1159
1736
1160
1737
1161
1738
class Test_commands_from_options(unittest.TestCase):
1739
1162
1740
def setUp(self):
1163
1741
self.parser = argparse.ArgumentParser()
1164
1742
add_command_line_options(self.parser)
1165
1743
1166
1744
def test_is_enabled(self):
1167
self.assert_command_from_args(["--is-enabled", "foo"],
1745
self.assert_command_from_args(["--is-enabled", "client"],
1168
1746
command.IsEnabled)
1169
1747
1170
1748
def assert_command_from_args(self, args, command_cls,
1181
1759
self.assertEqual(value, getattr(command, key))
1182
1760
1183
1761
def test_is_enabled_short(self):
1184
self.assert_command_from_args(["-V", "foo"],
1762
self.assert_command_from_args(["-V", "client"],
1185
1763
command.IsEnabled)
1186
1764
1187
1765
def test_approve(self):
1188
self.assert_command_from_args(["--approve", "foo"],
1766
self.assert_command_from_args(["--approve", "client"],
1189
1767
command.Approve)
1190
1768
1191
1769
def test_approve_short(self):
1192
self.assert_command_from_args(["-A", "foo"], command.Approve)
1770
self.assert_command_from_args(["-A", "client"],
1771
command.Approve)
1193
1772
1194
1773
def test_deny(self):
1195
self.assert_command_from_args(["--deny", "foo"], command.Deny)
1774
self.assert_command_from_args(["--deny", "client"],
1775
command.Deny)
1196
1776
1197
1777
def test_deny_short(self):
1198
self.assert_command_from_args(["-D", "foo"], command.Deny)
1778
self.assert_command_from_args(["-D", "client"], command.Deny)
1199
1779
1200
1780
def test_remove(self):
1201
self.assert_command_from_args(["--remove", "foo"],
1781
self.assert_command_from_args(["--remove", "client"],
1202
1782
command.Remove)
1203
1783
1204
1784
def test_deny_before_remove(self):
1205
1785
options = self.parser.parse_args(["--deny", "--remove",
1206
"foo"])
1786
"client"])
1207
1787
check_option_syntax(self.parser, options)
1208
1788
commands = commands_from_options(options)
1209
1789
self.assertEqual(2, len(commands))
1220
1800
self.assertIsInstance(commands[1], command.Remove)
1221
1801
1222
1802
def test_remove_short(self):
1223
self.assert_command_from_args(["-r", "foo"], command.Remove)
1803
self.assert_command_from_args(["-r", "client"],
1804
command.Remove)
1224
1805
1225
1806
def test_dump_json(self):
1226
1807
self.assert_command_from_args(["--dump-json"],
1227
1808
command.DumpJSON)
1228
1809
1229
1810
def test_enable(self):
1230
self.assert_command_from_args(["--enable", "foo"],
1811
self.assert_command_from_args(["--enable", "client"],
1231
1812
command.Enable)
1232
1813
1233
1814
def test_enable_short(self):
1234
self.assert_command_from_args(["-e", "foo"], command.Enable)
1815
self.assert_command_from_args(["-e", "client"],
1816
command.Enable)
1235
1817
1236
1818
def test_disable(self):
1237
self.assert_command_from_args(["--disable", "foo"],
1819
self.assert_command_from_args(["--disable", "client"],
1238
1820
command.Disable)
1239
1821
1240
1822
def test_disable_short(self):
1241
self.assert_command_from_args(["-d", "foo"], command.Disable)
1823
self.assert_command_from_args(["-d", "client"],
1824
command.Disable)
1242
1825
1243
1826
def test_bump_timeout(self):
1244
self.assert_command_from_args(["--bump-timeout", "foo"],
1827
self.assert_command_from_args(["--bump-timeout", "client"],
1245
1828
command.BumpTimeout)
1246
1829
1247
1830
def test_bump_timeout_short(self):
1248
self.assert_command_from_args(["-b", "foo"],
1831
self.assert_command_from_args(["-b", "client"],
1249
1832
command.BumpTimeout)
1250
1833
1251
1834
def test_start_checker(self):
1252
self.assert_command_from_args(["--start-checker", "foo"],
1835
self.assert_command_from_args(["--start-checker", "client"],
1253
1836
command.StartChecker)
1254
1837
1255
1838
def test_stop_checker(self):
1256
self.assert_command_from_args(["--stop-checker", "foo"],
1839
self.assert_command_from_args(["--stop-checker", "client"],
1257
1840
command.StopChecker)
1258
1841
1259
1842
def test_approve_by_default(self):
1260
self.assert_command_from_args(["--approve-by-default", "foo"],
1843
self.assert_command_from_args(["--approve-by-default",
1844
"client"],
1261
1845
command.ApproveByDefault)
1262
1846
1263
1847
def test_deny_by_default(self):
1264
self.assert_command_from_args(["--deny-by-default", "foo"],
1848
self.assert_command_from_args(["--deny-by-default", "client"],
1265
1849
command.DenyByDefault)
1266
1850
1267
1851
def test_checker(self):
1268
self.assert_command_from_args(["--checker", ":", "foo"],
1852
self.assert_command_from_args(["--checker", ":", "client"],
1269
1853
command.SetChecker,
1270
1854
value_to_set=":")
1271
1855
1272
1856
def test_checker_empty(self):
1273
self.assert_command_from_args(["--checker", "", "foo"],
1857
self.assert_command_from_args(["--checker", "", "client"],
1274
1858
command.SetChecker,
1275
1859
value_to_set="")
1276
1860
1277
1861
def test_checker_short(self):
1278
self.assert_command_from_args(["-c", ":", "foo"],
1862
self.assert_command_from_args(["-c", ":", "client"],
1279
1863
command.SetChecker,
1280
1864
value_to_set=":")
1281
1865
1282
1866
def test_host(self):
1283
self.assert_command_from_args(["--host", "foo.example.org",
1284
"foo"], command.SetHost,
1285
value_to_set="foo.example.org")
1867
self.assert_command_from_args(
1868
["--host", "client.example.org", "client"],
1869
command.SetHost, value_to_set="client.example.org")
1286
1870
1287
1871
def test_host_short(self):
1288
self.assert_command_from_args(["-H", "foo.example.org",
1289
"foo"], command.SetHost,
1290
value_to_set="foo.example.org")
1872
self.assert_command_from_args(
1873
["-H", "client.example.org", "client"], command.SetHost,
1874
value_to_set="client.example.org")
1291
1875
1292
1876
def test_secret_devnull(self):
1293
1877
self.assert_command_from_args(["--secret", os.path.devnull,
1294
"foo"], command.SetSecret,
1878
"client"], command.SetSecret,
1295
1879
value_to_set=b"")
1296
1880
1297
1881
def test_secret_tempfile(self):
1300
1884
f.write(value)
1301
1885
f.seek(0)
1302
1886
self.assert_command_from_args(["--secret", f.name,
1303
"foo"], command.SetSecret,
1887
"client"],
1888
command.SetSecret,
1304
1889
value_to_set=value)
1305
1890
1306
1891
def test_secret_devnull_short(self):
1307
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1308
command.SetSecret,
1892
self.assert_command_from_args(["-s", os.path.devnull,
1893
"client"], command.SetSecret,
1309
1894
value_to_set=b"")
1310
1895
1311
1896
def test_secret_tempfile_short(self):
1313
1898
value = b"secret\0xyzzy\nbar"
1314
1899
f.write(value)
1315
1900
f.seek(0)
1316
self.assert_command_from_args(["-s", f.name, "foo"],
1901
self.assert_command_from_args(["-s", f.name, "client"],
1317
1902
command.SetSecret,
1318
1903
value_to_set=value)
1319
1904
1320
1905
def test_timeout(self):
1321
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1906
self.assert_command_from_args(["--timeout", "PT5M", "client"],
1322
1907
command.SetTimeout,
1323
1908
value_to_set=300000)
1324
1909
1325
1910
def test_timeout_short(self):
1326
self.assert_command_from_args(["-t", "PT5M", "foo"],
1911
self.assert_command_from_args(["-t", "PT5M", "client"],
1327
1912
command.SetTimeout,
1328
1913
value_to_set=300000)
1329
1914
1330
1915
def test_extended_timeout(self):
1331
1916
self.assert_command_from_args(["--extended-timeout", "PT15M",
1332
"foo"],
1917
"client"],
1333
1918
command.SetExtendedTimeout,
1334
1919
value_to_set=900000)
1335
1920
1336
1921
def test_interval(self):
1337
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1338
command.SetInterval,
1922
self.assert_command_from_args(["--interval", "PT2M",
1923
"client"], command.SetInterval,
1339
1924
value_to_set=120000)
1340
1925
1341
1926
def test_interval_short(self):
1342
self.assert_command_from_args(["-i", "PT2M", "foo"],
1927
self.assert_command_from_args(["-i", "PT2M", "client"],
1343
1928
command.SetInterval,
1344
1929
value_to_set=120000)
1345
1930
1346
1931
def test_approval_delay(self):
1347
1932
self.assert_command_from_args(["--approval-delay", "PT30S",
1348
"foo"],
1933
"client"],
1349
1934
command.SetApprovalDelay,
1350
1935
value_to_set=30000)
1351
1936
1352
1937
def test_approval_duration(self):
1353
1938
self.assert_command_from_args(["--approval-duration", "PT1S",
1354
"foo"],
1939
"client"],
1355
1940
command.SetApprovalDuration,
1356
1941
value_to_set=1000)
1357
1942
1372
1957
class TestCommand(unittest.TestCase):
1373
1958
"""Abstract class for tests of command classes"""
1374
1959
1960
class FakeMandosBus(dbus.MandosBus):
1961
def __init__(self, testcase):
1962
self.client_properties = {
1963
"Name": "foo",
1964
"KeyID": ("92ed150794387c03ce684574b1139a65"
1965
"94a34f895daaaf09fd8ea90a27cddb12"),
1966
"Secret": b"secret",
1967
"Host": "foo.example.org",
1968
"Enabled": True,
1969
"Timeout": 300000,
1970
"LastCheckedOK": "2019-02-03T00:00:00",
1971
"Created": "2019-01-02T00:00:00",
1972
"Interval": 120000,
1973
"Fingerprint": ("778827225BA7DE539C5A"
1974
"7CFA59CFF7CDBD9A5920"),
1975
"CheckerRunning": False,
1976
"LastEnabled": "2019-01-03T00:00:00",
1977
"ApprovalPending": False,
1978
"ApprovedByDefault": True,
1979
"LastApprovalRequest": "",
1980
"ApprovalDelay": 0,
1981
"ApprovalDuration": 1000,
1982
"Checker": "fping -q -- %(host)s",
1983
"ExtendedTimeout": 900000,
1984
"Expires": "2019-02-04T00:00:00",
1985
"LastCheckerStatus": 0,
1986
}
1987
self.other_client_properties = {
1988
"Name": "barbar",
1989
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1990
"6ab612cff5ad227247e46c2b020f441c"),
1991
"Secret": b"secretbar",
1992
"Host": "192.0.2.3",
1993
"Enabled": True,
1994
"Timeout": 300000,
1995
"LastCheckedOK": "2019-02-04T00:00:00",
1996
"Created": "2019-01-03T00:00:00",
1997
"Interval": 120000,
1998
"Fingerprint": ("3E393AEAEFB84C7E89E2"
1999
"F547B3A107558FCA3A27"),
2000
"CheckerRunning": True,
2001
"LastEnabled": "2019-01-04T00:00:00",
2002
"ApprovalPending": False,
2003
"ApprovedByDefault": False,
2004
"LastApprovalRequest": "2019-01-03T00:00:00",
2005
"ApprovalDelay": 30000,
2006
"ApprovalDuration": 93785000,
2007
"Checker": ":",
2008
"ExtendedTimeout": 900000,
2009
"Expires": "2019-02-05T00:00:00",
2010
"LastCheckerStatus": -2,
2011
}
2012
self.clients = collections.OrderedDict(
2013
[
2014
("client_objectpath", self.client_properties),
2015
("other_client_objectpath",
2016
self.other_client_properties),
2017
])
2018
self.one_client = {"client_objectpath":
2019
self.client_properties}
2020
self.testcase = testcase
2021
self.calls = []
2022
2023
def call_method(self, methodname, busname, objectpath,
2024
interface, *args):
2025
self.testcase.assertEqual("se.recompile.Mandos", busname)
2026
self.calls.append((methodname, busname, objectpath,
2027
interface, args))
2028
if interface == "org.freedesktop.DBus.Properties":
2029
if methodname == "Set":
2030
self.testcase.assertEqual(3, len(args))
2031
interface, key, value = args
2032
self.testcase.assertEqual(
2033
"se.recompile.Mandos.Client", interface)
2034
self.clients[objectpath][key] = value
2035
return
2036
elif interface == "se.recompile.Mandos":
2037
self.testcase.assertEqual("RemoveClient", methodname)
2038
self.testcase.assertEqual(1, len(args))
2039
clientpath = args[0]
2040
del self.clients[clientpath]
2041
return
2042
elif interface == "se.recompile.Mandos.Client":
2043
if methodname == "Approve":
2044
self.testcase.assertEqual(1, len(args))
2045
return
2046
raise ValueError()
2047
1375
2048
def setUp(self):
1376
testcase = self
1377
class MockClient(object):
1378
def __init__(self, name, **attributes):
1379
self.__dbus_object_path__ = "/clients/{}".format(name)
1380
self.attributes = attributes
1381
self.attributes["Name"] = name
1382
self.calls = []
1383
def Set(self, interface, propname, value, dbus_interface):
1384
testcase.assertEqual(client_dbus_interface, interface)
1385
testcase.assertEqual(dbus.PROPERTIES_IFACE,
1386
dbus_interface)
1387
self.attributes[propname] = value
1388
def Approve(self, approve, dbus_interface):
1389
testcase.assertEqual(client_dbus_interface,
1390
dbus_interface)
1391
self.calls.append(("Approve", (approve,
1392
dbus_interface)))
1393
self.client = MockClient(
1394
"foo",
1395
KeyID=("92ed150794387c03ce684574b1139a65"
1396
"94a34f895daaaf09fd8ea90a27cddb12"),
1397
Secret=b"secret",
1398
Host="foo.example.org",
1399
Enabled=dbus.Boolean(True),
1400
Timeout=300000,
1401
LastCheckedOK="2019-02-03T00:00:00",
1402
Created="2019-01-02T00:00:00",
1403
Interval=120000,
1404
Fingerprint=("778827225BA7DE539C5A"
1405
"7CFA59CFF7CDBD9A5920"),
1406
CheckerRunning=dbus.Boolean(False),
1407
LastEnabled="2019-01-03T00:00:00",
1408
ApprovalPending=dbus.Boolean(False),
1409
ApprovedByDefault=dbus.Boolean(True),
1410
LastApprovalRequest="",
1411
ApprovalDelay=0,
1412
ApprovalDuration=1000,
1413
Checker="fping -q -- %(host)s",
1414
ExtendedTimeout=900000,
1415
Expires="2019-02-04T00:00:00",
1416
LastCheckerStatus=0)
1417
self.other_client = MockClient(
1418
"barbar",
1419
KeyID=("0558568eedd67d622f5c83b35a115f79"
1420
"6ab612cff5ad227247e46c2b020f441c"),
1421
Secret=b"secretbar",
1422
Host="192.0.2.3",
1423
Enabled=dbus.Boolean(True),
1424
Timeout=300000,
1425
LastCheckedOK="2019-02-04T00:00:00",
1426
Created="2019-01-03T00:00:00",
1427
Interval=120000,
1428
Fingerprint=("3E393AEAEFB84C7E89E2"
1429
"F547B3A107558FCA3A27"),
1430
CheckerRunning=dbus.Boolean(True),
1431
LastEnabled="2019-01-04T00:00:00",
1432
ApprovalPending=dbus.Boolean(False),
1433
ApprovedByDefault=dbus.Boolean(False),
1434
LastApprovalRequest="2019-01-03T00:00:00",
1435
ApprovalDelay=30000,
1436
ApprovalDuration=93785000,
1437
Checker=":",
1438
ExtendedTimeout=900000,
1439
Expires="2019-02-05T00:00:00",
1440
LastCheckerStatus=-2)
1441
self.clients = collections.OrderedDict(
1442
[
1443
("/clients/foo", self.client.attributes),
1444
("/clients/barbar", self.other_client.attributes),
1445
])
1446
self.one_client = {"/clients/foo": self.client.attributes}
1447
1448
@property
1449
def bus(self):
1450
class Bus(object):
1451
@staticmethod
1452
def get_object(client_bus_name, path):
1453
self.assertEqual(dbus_busname, client_bus_name)
1454
return {
1455
# Note: "self" here is the TestCmd instance, not
1456
# the Bus instance, since this is a static method!
1457
"/clients/foo": self.client,
1458
"/clients/barbar": self.other_client,
1459
}[path]
1460
return Bus()
2049
self.bus = self.FakeMandosBus(self)
1461
2050
1462
2051
1463
2052
class TestBaseCommands(TestCommand):
1464
2053
1465
2054
def test_IsEnabled_exits_successfully(self):
1466
2055
with self.assertRaises(SystemExit) as e:
1467
command.IsEnabled().run(self.one_client)
2056
command.IsEnabled().run(self.bus.one_client)
1468
2057
if e.exception.code is not None:
1469
2058
self.assertEqual(0, e.exception.code)
1470
2059
else:
1471
2060
self.assertIsNone(e.exception.code)
1472
2061
1473
2062
def test_IsEnabled_exits_with_failure(self):
1474
self.client.attributes["Enabled"] = dbus.Boolean(False)
2063
self.bus.client_properties["Enabled"] = False
1475
2064
with self.assertRaises(SystemExit) as e:
1476
command.IsEnabled().run(self.one_client)
2065
command.IsEnabled().run(self.bus.one_client)
1477
2066
if isinstance(e.exception.code, int):
1478
2067
self.assertNotEqual(0, e.exception.code)
1479
2068
else:
1480
2069
self.assertIsNotNone(e.exception.code)
1481
2070
1482
2071
def test_Approve(self):
1483
command.Approve().run(self.clients, self.bus)
1484
for clientpath in self.clients:
1485
client = self.bus.get_object(dbus_busname, clientpath)
1486
self.assertIn(("Approve", (True, client_dbus_interface)),
1487
client.calls)
2072
busname = "se.recompile.Mandos"
2073
client_interface = "se.recompile.Mandos.Client"
2074
command.Approve().run(self.bus.clients, self.bus)
2075
for clientpath in self.bus.clients:
2076
self.assertIn(("Approve", busname, clientpath,
2077
client_interface, (True,)), self.bus.calls)
1488
2078
1489
2079
def test_Deny(self):
1490
command.Deny().run(self.clients, self.bus)
1491
for clientpath in self.clients:
1492
client = self.bus.get_object(dbus_busname, clientpath)
1493
self.assertIn(("Approve", (False, client_dbus_interface)),
1494
client.calls)
2080
busname = "se.recompile.Mandos"
2081
client_interface = "se.recompile.Mandos.Client"
2082
command.Deny().run(self.bus.clients, self.bus)
2083
for clientpath in self.bus.clients:
2084
self.assertIn(("Approve", busname, clientpath,
2085
client_interface, (False,)),
2086
self.bus.calls)
1495
2087
1496
2088
def test_Remove(self):
1497
class MockMandos(object):
1498
def __init__(self):
1499
self.calls = []
1500
def RemoveClient(self, dbus_path):
1501
self.calls.append(("RemoveClient", (dbus_path,)))
1502
mandos = MockMandos()
1503
command.Remove().run(self.clients, self.bus, mandos)
1504
for clientpath in self.clients:
1505
self.assertIn(("RemoveClient", (clientpath,)),
1506
mandos.calls)
2089
command.Remove().run(self.bus.clients, self.bus)
2090
for clientpath in self.bus.clients:
2091
self.assertIn(("RemoveClient", dbus_busname,
2092
dbus_server_path, dbus_server_interface,
2093
(clientpath,)), self.bus.calls)
1507
2094
1508
2095
expected_json = {
1509
2096
"foo": {
1557
2144
}
1558
2145
1559
2146
def test_DumpJSON_normal(self):
1560
output = command.DumpJSON().output(self.clients.values())
1561
json_data = json.loads(output)
2147
with self.capture_stdout_to_buffer() as buffer:
2148
command.DumpJSON().run(self.bus.clients)
2149
json_data = json.loads(buffer.getvalue())
1562
2150
self.assertDictEqual(self.expected_json, json_data)
1563
2151
2152
@staticmethod
2153
@contextlib.contextmanager
2154
def capture_stdout_to_buffer():
2155
capture_buffer = io.StringIO()
2156
old_stdout = sys.stdout
2157
sys.stdout = capture_buffer
2158
try:
2159
yield capture_buffer
2160
finally:
2161
sys.stdout = old_stdout
2162
1564
2163
def test_DumpJSON_one_client(self):
1565
output = command.DumpJSON().output(self.one_client.values())
1566
json_data = json.loads(output)
2164
with self.capture_stdout_to_buffer() as buffer:
2165
command.DumpJSON().run(self.bus.one_client)
2166
json_data = json.loads(buffer.getvalue())
1567
2167
expected_json = {"foo": self.expected_json["foo"]}
1568
2168
self.assertDictEqual(expected_json, json_data)
1569
2169
1570
2170
def test_PrintTable_normal(self):
1571
output = command.PrintTable().output(self.clients.values())
2171
with self.capture_stdout_to_buffer() as buffer:
2172
command.PrintTable().run(self.bus.clients)
1572
2173
expected_output = "\n".join((
1573
2174
"Name Enabled Timeout Last Successful Check",
1574
2175
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1575
2176
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1576
))
1577
self.assertEqual(expected_output, output)
2177
)) + "\n"
2178
self.assertEqual(expected_output, buffer.getvalue())
1578
2179
1579
2180
def test_PrintTable_verbose(self):
1580
output = command.PrintTable(verbose=True).output(
1581
self.clients.values())
2181
with self.capture_stdout_to_buffer() as buffer:
2182
command.PrintTable(verbose=True).run(self.bus.clients)
1582
2183
columns = (
1583
2184
(
1584
2185
"Name ",
1666
2267
)
1667
2268
)
1668
2269
num_lines = max(len(rows) for rows in columns)
1669
expected_output = "\n".join("".join(rows[line]
1670
for rows in columns)
1671
for line in range(num_lines))
1672
self.assertEqual(expected_output, output)
2270
expected_output = ("\n".join("".join(rows[line]
2271
for rows in columns)
2272
for line in range(num_lines))
2273
+ "\n")
2274
self.assertEqual(expected_output, buffer.getvalue())
1673
2275
1674
2276
def test_PrintTable_one_client(self):
1675
output = command.PrintTable().output(self.one_client.values())
2277
with self.capture_stdout_to_buffer() as buffer:
2278
command.PrintTable().run(self.bus.one_client)
1676
2279
expected_output = "\n".join((
1677
2280
"Name Enabled Timeout Last Successful Check",
1678
2281
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1679
))
1680
self.assertEqual(expected_output, output)
1681
1682
1683
class TestPropertyCmd(TestCommand):
1684
"""Abstract class for tests of command.Property classes"""
2282
)) + "\n"
2283
self.assertEqual(expected_output, buffer.getvalue())
2284
2285
2286
class TestPropertySetterCmd(TestCommand):
2287
"""Abstract class for tests of command.PropertySetter classes"""
2288
1685
2289
def runTest(self):
1686
2290
if not hasattr(self, "command"):
1687
return
1688
values_to_get = getattr(self, "values_to_get",
1689
self.values_to_set)
1690
for value_to_set, value_to_get in zip(self.values_to_set,
1691
values_to_get):
1692
for clientpath in self.clients:
1693
client = self.bus.get_object(dbus_busname, clientpath)
1694
old_value = client.attributes[self.propname]
1695
client.attributes[self.propname] = self.Unique()
1696
self.run_command(value_to_set, self.clients)
1697
for clientpath in self.clients:
1698
client = self.bus.get_object(dbus_busname, clientpath)
1699
value = client.attributes[self.propname]
1700
self.assertNotIsInstance(value, self.Unique)
2291
return # Abstract TestCase class
2292
2293
if hasattr(self, "values_to_set"):
2294
cmd_args = [(value,) for value in self.values_to_set]
2295
values_to_get = getattr(self, "values_to_get",
2296
self.values_to_set)
2297
else:
2298
cmd_args = [() for x in range(len(self.values_to_get))]
2299
values_to_get = self.values_to_get
2300
for value_to_get, cmd_arg in zip(values_to_get, cmd_args):
2301
for clientpath in self.bus.clients:
2302
self.bus.clients[clientpath][self.propname] = (
2303
Unique())
2304
self.command(*cmd_arg).run(self.bus.clients, self.bus)
2305
for clientpath in self.bus.clients:
2306
value = (self.bus.clients[clientpath]
2307
[self.propname])
2308
self.assertNotIsInstance(value, Unique)
1701
2309
self.assertEqual(value_to_get, value)
1702
2310
1703
class Unique(object):
1704
"""Class for objects which exist only to be unique objects,
1705
since unittest.mock.sentinel only exists in Python 3.3"""
1706
1707
def run_command(self, value, clients):
1708
self.command().run(clients, self.bus)
1709
1710
1711
class TestEnableCmd(TestPropertyCmd):
2311
2312
class TestEnableCmd(TestPropertySetterCmd):
1712
2313
command = command.Enable
1713
2314
propname = "Enabled"
1714
values_to_set = [dbus.Boolean(True)]
1715
1716
1717
class TestDisableCmd(TestPropertyCmd):
2315
values_to_get = [True]
2316
2317
2318
class TestDisableCmd(TestPropertySetterCmd):
1718
2319
command = command.Disable
1719
2320
propname = "Enabled"
1720
values_to_set = [dbus.Boolean(False)]
1721
1722
1723
class TestBumpTimeoutCmd(TestPropertyCmd):
2321
values_to_get = [False]
2322
2323
2324
class TestBumpTimeoutCmd(TestPropertySetterCmd):
1724
2325
command = command.BumpTimeout
1725
2326
propname = "LastCheckedOK"
1726
values_to_set = [""]
1727
1728
1729
class TestStartCheckerCmd(TestPropertyCmd):
2327
values_to_get = [""]
2328
2329
2330
class TestStartCheckerCmd(TestPropertySetterCmd):
1730
2331
command = command.StartChecker
1731
2332
propname = "CheckerRunning"
1732
values_to_set = [dbus.Boolean(True)]
1733
1734
1735
class TestStopCheckerCmd(TestPropertyCmd):
2333
values_to_get = [True]
2334
2335
2336
class TestStopCheckerCmd(TestPropertySetterCmd):
1736
2337
command = command.StopChecker
1737
2338
propname = "CheckerRunning"
1738
values_to_set = [dbus.Boolean(False)]
1739
1740
1741
class TestApproveByDefaultCmd(TestPropertyCmd):
2339
values_to_get = [False]
2340
2341
2342
class TestApproveByDefaultCmd(TestPropertySetterCmd):
1742
2343
command = command.ApproveByDefault
1743
2344
propname = "ApprovedByDefault"
1744
values_to_set = [dbus.Boolean(True)]
1745
1746
1747
class TestDenyByDefaultCmd(TestPropertyCmd):
2345
values_to_get = [True]
2346
2347
2348
class TestDenyByDefaultCmd(TestPropertySetterCmd):
1748
2349
command = command.DenyByDefault
1749
2350
propname = "ApprovedByDefault"
1750
values_to_set = [dbus.Boolean(False)]
1751
1752
1753
class TestPropertyValueCmd(TestPropertyCmd):
1754
"""Abstract class for tests of PropertyValueCmd classes"""
1755
1756
def runTest(self):
1757
if type(self) is TestPropertyValueCmd:
1758
return
1759
return super(TestPropertyValueCmd, self).runTest()
1760
1761
def run_command(self, value, clients):
1762
self.command(value).run(clients, self.bus)
1763
1764
1765
class TestSetCheckerCmd(TestPropertyValueCmd):
2351
values_to_get = [False]
2352
2353
2354
class TestSetCheckerCmd(TestPropertySetterCmd):
1766
2355
command = command.SetChecker
1767
2356
propname = "Checker"
1768
2357
values_to_set = ["", ":", "fping -q -- %s"]
1769
2358
1770
2359
1771
class TestSetHostCmd(TestPropertyValueCmd):
2360
class TestSetHostCmd(TestPropertySetterCmd):
1772
2361
command = command.SetHost
1773
2362
propname = "Host"
1774
values_to_set = ["192.0.2.3", "foo.example.org"]
1775
1776
1777
class TestSetSecretCmd(TestPropertyValueCmd):
2363
values_to_set = ["192.0.2.3", "client.example.org"]
2364
2365
2366
class TestSetSecretCmd(TestPropertySetterCmd):
1778
2367
command = command.SetSecret
1779
2368
propname = "Secret"
1780
2369
values_to_set = [io.BytesIO(b""),
1781
2370
io.BytesIO(b"secret\0xyzzy\nbar")]
1782
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1783
1784
1785
class TestSetTimeoutCmd(TestPropertyValueCmd):
2371
values_to_get = [f.getvalue() for f in values_to_set]
2372
2373
2374
class TestSetTimeoutCmd(TestPropertySetterCmd):
1786
2375
command = command.SetTimeout
1787
2376
propname = "Timeout"
1788
2377
values_to_set = [datetime.timedelta(),
1790
2379
datetime.timedelta(seconds=1),
1791
2380
datetime.timedelta(weeks=1),
1792
2381
datetime.timedelta(weeks=52)]
1793
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1794
1795
1796
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
2382
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2383
2384
2385
class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):
1797
2386
command = command.SetExtendedTimeout
1798
2387
propname = "ExtendedTimeout"
1799
2388
values_to_set = [datetime.timedelta(),
1801
2390
datetime.timedelta(seconds=1),
1802
2391
datetime.timedelta(weeks=1),
1803
2392
datetime.timedelta(weeks=52)]
1804
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1805
1806
1807
class TestSetIntervalCmd(TestPropertyValueCmd):
2393
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2394
2395
2396
class TestSetIntervalCmd(TestPropertySetterCmd):
1808
2397
command = command.SetInterval
1809
2398
propname = "Interval"
1810
2399
values_to_set = [datetime.timedelta(),
1812
2401
datetime.timedelta(seconds=1),
1813
2402
datetime.timedelta(weeks=1),
1814
2403
datetime.timedelta(weeks=52)]
1815
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1816
1817
1818
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
2404
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2405
2406
2407
class TestSetApprovalDelayCmd(TestPropertySetterCmd):
1819
2408
command = command.SetApprovalDelay
1820
2409
propname = "ApprovalDelay"
1821
2410
values_to_set = [datetime.timedelta(),
1823
2412
datetime.timedelta(seconds=1),
1824
2413
datetime.timedelta(weeks=1),
1825
2414
datetime.timedelta(weeks=52)]
1826
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1827
1828
1829
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
2415
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2416
2417
2418
class TestSetApprovalDurationCmd(TestPropertySetterCmd):
1830
2419
command = command.SetApprovalDuration
1831
2420
propname = "ApprovalDuration"
1832
2421
values_to_set = [datetime.timedelta(),
1834
2423
datetime.timedelta(seconds=1),
1835
2424
datetime.timedelta(weeks=1),
1836
2425
datetime.timedelta(weeks=52)]
1837
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
2426
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1838
2427
1839
2428
1840
2429
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0