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 1099
- compare with another revision
- download diff
- download tarball
- view history from revision 1099
- Committer: Teddy Hogeborn
- Date: 2019-04-09 19:33:36 UTC
- Revision ID: teddy@recompile.se-20190409193336-6sddo74ybosqog38
Installation: Fix UMASK even if set by some other initramfs hook
* Makefile (install-client-nokey): Install initramfs-tools-conf-hook
as "/usr/share/initramfs-tools/conf-hooks.d/zz-mandos".
* debian/mandos-client.dirs: Add
"usr/share/initramfs-tools/conf-hooks.d".
* initramfs-tools-conf-hook: New.
* Makefile (install-client-nokey): Install initramfs-tools-conf-hook
as "/usr/share/initramfs-tools/conf-hooks.d/zz-mandos".
* debian/mandos-client.dirs: Add
"usr/share/initramfs-tools/conf-hooks.d".
* initramfs-tools-conf-hook: New.
- files added:
- initramfs-tools-conf-hook
- files modified:
- Makefile
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:
66
78
67
79
locale.setlocale(locale.LC_ALL, "")
68
80
69
dbus_busname_domain = "se.recompile"
70
dbus_busname = dbus_busname_domain + ".Mandos"
71
server_dbus_path = "/"
72
server_dbus_interface = dbus_busname_domain + ".Mandos"
73
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
74
del dbus_busname_domain
75
81
version = "1.8.3"
76
82
77
83
78
try:
79
dbus.OBJECT_MANAGER_IFACE
80
except AttributeError:
81
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
82
83
84
84
def main():
85
85
parser = argparse.ArgumentParser()
86
86
add_command_line_options(parser)
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
464
class NullFilter(logging.Filter):
465
def filter(self, record):
466
return False
467
468
nullfilter = NullFilter()
469
470
def __exit__(self, exc_type, exc_val, exc_tb):
471
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
def set_client_property(self, objectpath, key, value):
575
if key == "Secret":
576
if not isinstance(value, bytes):
577
value = value.encode("utf-8")
578
value = self.dbus_python.ByteArray(value)
579
return self.set_property(self.busname, objectpath,
580
self.client_interface, key,
581
value)
582
583
class SilenceLogger(object):
584
"Simple context manager to silence a particular logger"
585
def __init__(self, loggername):
586
self.logger = logging.getLogger(loggername)
587
588
def __enter__(self):
589
self.logger.addFilter(self.nullfilter)
590
591
class NullFilter(logging.Filter):
592
def filter(self, record):
593
return False
594
595
nullfilter = NullFilter()
596
597
def __exit__(self, exc_type, exc_val, exc_tb):
598
self.logger.removeFilter(self.nullfilter)
599
600
601
class CachingBus(SystemBus):
602
"""A caching layer for dbus_python_adapter.SystemBus"""
603
def __init__(self, *args, **kwargs):
604
self.object_cache = {}
605
super(dbus_python_adapter.CachingBus,
606
self).__init__(*args, **kwargs)
607
def get_object(self, busname, objectpath):
608
try:
609
return self.object_cache[(busname, objectpath)]
610
except KeyError:
611
new_object = super(
612
dbus_python_adapter.CachingBus,
613
self).get_object(busname, objectpath)
614
self.object_cache[(busname, objectpath)] = new_object
615
return new_object
616
617
618
class pydbus_adapter(object):
619
class SystemBus(dbus.MandosBus):
620
def __init__(self, module=pydbus):
621
self.pydbus = module
622
self.bus = self.pydbus.SystemBus()
623
624
@contextlib.contextmanager
625
def convert_exception(self, exception_class=dbus.Error):
626
try:
627
yield
628
except gi.repository.GLib.Error as e:
629
# This does what "raise from" would do
630
exc = exception_class(*e.args)
631
exc.__cause__ = e
632
raise exc
633
634
def call_method(self, methodname, busname, objectpath,
635
interface, *args):
636
proxy_object = self.get(busname, objectpath)
637
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
638
interface, methodname,
639
", ".join(repr(a) for a in args))
640
method = getattr(proxy_object[interface], methodname)
641
with self.convert_exception():
642
return method(*args)
643
644
def get(self, busname, objectpath):
645
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
646
busname, objectpath)
647
with self.convert_exception(dbus.ConnectFailed):
648
if sys.version_info.major <= 2:
649
with warnings.catch_warnings():
650
warnings.filterwarnings(
651
"ignore", "", DeprecationWarning,
652
r"^xml\.etree\.ElementTree$")
653
return self.bus.get(busname, objectpath)
654
else:
655
return self.bus.get(busname, objectpath)
656
657
def set_property(self, busname, objectpath, interface, key,
658
value):
659
proxy_object = self.get(busname, objectpath)
660
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
661
objectpath, self.properties_iface, interface,
662
key, value)
663
setattr(proxy_object[interface], key, value)
664
665
class CachingBus(SystemBus):
666
"""A caching layer for pydbus_adapter.SystemBus"""
667
def __init__(self, *args, **kwargs):
668
self.object_cache = {}
669
super(pydbus_adapter.CachingBus,
670
self).__init__(*args, **kwargs)
671
def get(self, busname, objectpath):
672
try:
673
return self.object_cache[(busname, objectpath)]
674
except KeyError:
675
new_object = (super(pydbus_adapter.CachingBus, self)
676
.get(busname, objectpath))
677
self.object_cache[(busname, objectpath)] = new_object
678
return new_object
472
679
473
680
474
681
def commands_from_options(options):
475
682
476
commands = []
477
478
if options.is_enabled:
479
commands.append(command.IsEnabled())
480
481
if options.approve:
482
commands.append(command.Approve())
483
484
if options.deny:
485
commands.append(command.Deny())
486
487
if options.remove:
488
commands.append(command.Remove())
489
490
if options.dump_json:
491
commands.append(command.DumpJSON())
492
493
if options.enable:
494
commands.append(command.Enable())
495
496
if options.disable:
497
commands.append(command.Disable())
498
499
if options.bump_timeout:
500
commands.append(command.BumpTimeout())
501
502
if options.start_checker:
503
commands.append(command.StartChecker())
504
505
if options.stop_checker:
506
commands.append(command.StopChecker())
507
508
if options.approved_by_default is not None:
509
if options.approved_by_default:
510
commands.append(command.ApproveByDefault())
683
commands = list(options.commands)
684
685
def find_cmd(cmd, commands):
686
i = 0
687
for i, c in enumerate(commands):
688
if isinstance(c, cmd):
689
return i
690
return i+1
691
692
# If command.Remove is present, move any instances of command.Deny
693
# to occur ahead of command.Remove.
694
index_of_remove = find_cmd(command.Remove, commands)
695
before_remove = commands[:index_of_remove]
696
after_remove = commands[index_of_remove:]
697
cleaned_after = []
698
for cmd in after_remove:
699
if isinstance(cmd, command.Deny):
700
before_remove.append(cmd)
511
701
else:
512
commands.append(command.DenyByDefault())
513
514
if options.checker is not None:
515
commands.append(command.SetChecker(options.checker))
516
517
if options.host is not None:
518
commands.append(command.SetHost(options.host))
519
520
if options.secret is not None:
521
commands.append(command.SetSecret(options.secret))
522
523
if options.timeout is not None:
524
commands.append(command.SetTimeout(options.timeout))
525
526
if options.extended_timeout:
527
commands.append(
528
command.SetExtendedTimeout(options.extended_timeout))
529
530
if options.interval is not None:
531
commands.append(command.SetInterval(options.interval))
532
533
if options.approval_delay is not None:
534
commands.append(
535
command.SetApprovalDelay(options.approval_delay))
536
537
if options.approval_duration is not None:
538
commands.append(
539
command.SetApprovalDuration(options.approval_duration))
702
cleaned_after.append(cmd)
703
if cleaned_after != after_remove:
704
commands = before_remove + cleaned_after
540
705
541
706
# If no command option has been given, show table of clients,
542
707
# optionally verbosely
551
716
552
717
class Base(object):
553
718
"""Abstract base class for commands"""
554
def run(self, clients, bus=None, mandos=None):
719
def run(self, clients, bus=None):
555
720
"""Normal commands should implement run_on_one_client(),
556
721
but commands which want to operate on all clients at the same time can
557
722
override this run() method instead.
558
723
"""
559
for clientpath, properties in clients.items():
560
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
561
dbus_busname, str(clientpath))
562
client = bus.get_object(dbus_busname, clientpath)
724
self.bus = bus
725
for client, properties in clients.items():
563
726
self.run_on_one_client(client, properties)
564
727
565
728
566
729
class IsEnabled(Base):
567
def run(self, clients, bus=None, mandos=None):
568
client, properties = next(iter(clients.items()))
569
if self.is_enabled(client, properties):
730
def run(self, clients, bus=None):
731
properties = next(iter(clients.values()))
732
if properties["Enabled"]:
570
733
sys.exit(0)
571
734
sys.exit(1)
572
def is_enabled(self, client, properties):
573
return properties["Enabled"]
574
735
575
736
576
737
class Approve(Base):
577
738
def run_on_one_client(self, client, properties):
578
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
579
client.__dbus_object_path__,
580
client_dbus_interface)
581
client.Approve(dbus.Boolean(True),
582
dbus_interface=client_dbus_interface)
739
self.bus.call_client_method(client, "Approve", True)
583
740
584
741
585
742
class Deny(Base):
586
743
def run_on_one_client(self, client, properties):
587
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
588
client.__dbus_object_path__,
589
client_dbus_interface)
590
client.Approve(dbus.Boolean(False),
591
dbus_interface=client_dbus_interface)
744
self.bus.call_client_method(client, "Approve", False)
592
745
593
746
594
747
class Remove(Base):
595
def run(self, clients, bus, mandos):
596
for clientpath in clients.keys():
597
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)",
598
dbus_busname, server_dbus_path,
599
server_dbus_interface, clientpath)
600
mandos.RemoveClient(clientpath)
748
def run(self, clients, bus):
749
for clientpath in frozenset(clients.keys()):
750
bus.call_server_method("RemoveClient", clientpath)
601
751
602
752
603
753
class Output(Base):
613
763
614
764
615
765
class DumpJSON(Output):
616
def run(self, clients, bus=None, mandos=None):
617
data = {client["Name"]:
618
{key: self.dbus_boolean_to_bool(client[key])
766
def run(self, clients, bus=None):
767
data = {properties["Name"]:
768
{key: properties[key]
619
769
for key in self.all_keywords}
620
for client in clients.values()}
770
for properties in clients.values()}
621
771
print(json.dumps(data, indent=4, separators=(',', ': ')))
622
772
623
@staticmethod
624
def dbus_boolean_to_bool(value):
625
if isinstance(value, dbus.Boolean):
626
value = bool(value)
627
return value
628
629
773
630
774
class PrintTable(Output):
631
775
def __init__(self, verbose=False):
632
776
self.verbose = verbose
633
777
634
def run(self, clients, bus=None, mandos=None):
778
def run(self, clients, bus=None):
635
779
default_keywords = ("Name", "Enabled", "Timeout",
636
780
"LastCheckedOK")
637
781
keywords = default_keywords
698
842
699
843
@classmethod
700
844
def valuetostring(cls, value, keyword):
701
if isinstance(value, dbus.Boolean):
845
if isinstance(value, bool):
702
846
return "Yes" if value else "No"
703
847
if keyword in ("Timeout", "Interval", "ApprovalDelay",
704
848
"ApprovalDuration", "ExtendedTimeout"):
727
871
class PropertySetter(Base):
728
872
"Abstract class for Actions for setting one client property"
729
873
730
def run_on_one_client(self, client, properties):
874
def run_on_one_client(self, client, properties=None):
731
875
"""Set the Client's D-Bus property"""
732
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
733
client.__dbus_object_path__,
734
dbus.PROPERTIES_IFACE, client_dbus_interface,
735
self.propname, self.value_to_set
736
if not isinstance(self.value_to_set,
737
dbus.Boolean)
738
else bool(self.value_to_set))
739
client.Set(client_dbus_interface, self.propname,
740
self.value_to_set,
741
dbus_interface=dbus.PROPERTIES_IFACE)
876
self.bus.set_client_property(client, self.propname,
877
self.value_to_set)
742
878
743
879
@property
744
880
def propname(self):
747
883
748
884
class Enable(PropertySetter):
749
885
propname = "Enabled"
750
value_to_set = dbus.Boolean(True)
886
value_to_set = True
751
887
752
888
753
889
class Disable(PropertySetter):
754
890
propname = "Enabled"
755
value_to_set = dbus.Boolean(False)
891
value_to_set = False
756
892
757
893
758
894
class BumpTimeout(PropertySetter):
762
898
763
899
class StartChecker(PropertySetter):
764
900
propname = "CheckerRunning"
765
value_to_set = dbus.Boolean(True)
901
value_to_set = True
766
902
767
903
768
904
class StopChecker(PropertySetter):
769
905
propname = "CheckerRunning"
770
value_to_set = dbus.Boolean(False)
906
value_to_set = False
771
907
772
908
773
909
class ApproveByDefault(PropertySetter):
774
910
propname = "ApprovedByDefault"
775
value_to_set = dbus.Boolean(True)
911
value_to_set = True
776
912
777
913
778
914
class DenyByDefault(PropertySetter):
779
915
propname = "ApprovedByDefault"
780
value_to_set = dbus.Boolean(False)
916
value_to_set = False
781
917
782
918
783
919
class PropertySetterValue(PropertySetter):
786
922
def __init__(self, value):
787
923
self.value_to_set = value
788
924
925
@classmethod
926
def argparse(cls, argtype):
927
def cmdtype(arg):
928
return cls(argtype(arg))
929
return cmdtype
789
930
790
931
class SetChecker(PropertySetterValue):
791
932
propname = "Checker"
879
1020
"output"))
880
1021
881
1022
1023
class Unique(object):
1024
"""Class for objects which exist only to be unique objects, since
1025
unittest.mock.sentinel only exists in Python 3.3"""
1026
1027
882
1028
class Test_string_to_delta(TestCaseWithAssertLogs):
883
1029
# Just test basic RFC 3339 functionality here, the doc string for
884
1030
# rfc3339_duration_to_delta() already has more comprehensive
885
# tests, which is run by doctest.
1031
# tests, which are run by doctest.
886
1032
887
1033
def test_rfc3339_zero_seconds(self):
888
1034
self.assertEqual(datetime.timedelta(),
912
1058
913
1059
def test_actions_requires_client_or_all(self):
914
1060
for action, value in self.actions.items():
915
options = self.parser.parse_args()
916
setattr(options, action, value)
1061
args = self.actionargs(action, value)
917
1062
with self.assertParseError():
918
self.check_option_syntax(options)
1063
self.parse_args(args)
919
1064
920
# This mostly corresponds to the definition from has_actions() in
1065
# This mostly corresponds to the definition from has_commands() in
921
1066
# check_option_syntax()
922
1067
actions = {
923
# The actual values set here are not that important, but we do
924
# at least stick to the correct types, even though they are
925
# never used
926
"enable": True,
927
"disable": True,
928
"bump_timeout": True,
929
"start_checker": True,
930
"stop_checker": True,
931
"is_enabled": True,
932
"remove": True,
933
"checker": "x",
934
"timeout": datetime.timedelta(),
935
"extended_timeout": datetime.timedelta(),
936
"interval": datetime.timedelta(),
937
"approved_by_default": True,
938
"approval_delay": datetime.timedelta(),
939
"approval_duration": datetime.timedelta(),
940
"host": "x",
941
"secret": io.BytesIO(b"x"),
942
"approve": True,
943
"deny": True,
1068
"--enable": None,
1069
"--disable": None,
1070
"--bump-timeout": None,
1071
"--start-checker": None,
1072
"--stop-checker": None,
1073
"--is-enabled": None,
1074
"--remove": None,
1075
"--checker": "x",
1076
"--timeout": "PT0S",
1077
"--extended-timeout": "PT0S",
1078
"--interval": "PT0S",
1079
"--approve-by-default": None,
1080
"--deny-by-default": None,
1081
"--approval-delay": "PT0S",
1082
"--approval-duration": "PT0S",
1083
"--host": "hostname",
1084
"--secret": "/dev/null",
1085
"--approve": None,
1086
"--deny": None,
944
1087
}
945
1088
1089
@staticmethod
1090
def actionargs(action, value, *args):
1091
if value is not None:
1092
return [action, value] + list(args)
1093
else:
1094
return [action] + list(args)
1095
946
1096
@contextlib.contextmanager
947
1097
def assertParseError(self):
948
1098
with self.assertRaises(SystemExit) as e:
953
1103
# /argparse.html#exiting-methods
954
1104
self.assertEqual(2, e.exception.code)
955
1105
1106
def parse_args(self, args):
1107
options = self.parser.parse_args(args)
1108
check_option_syntax(self.parser, options)
1109
956
1110
@staticmethod
957
1111
@contextlib.contextmanager
958
1112
def redirect_stderr_to_devnull():
969
1123
970
1124
def test_actions_all_conflicts_with_verbose(self):
971
1125
for action, value in self.actions.items():
972
options = self.parser.parse_args()
973
setattr(options, action, value)
974
options.all = True
975
options.verbose = True
1126
args = self.actionargs(action, value, "--all",
1127
"--verbose")
976
1128
with self.assertParseError():
977
self.check_option_syntax(options)
1129
self.parse_args(args)
978
1130
979
1131
def test_actions_with_client_conflicts_with_verbose(self):
980
1132
for action, value in self.actions.items():
981
options = self.parser.parse_args()
982
setattr(options, action, value)
983
options.verbose = True
984
options.client = ["client"]
1133
args = self.actionargs(action, value, "--verbose",
1134
"client")
985
1135
with self.assertParseError():
986
self.check_option_syntax(options)
1136
self.parse_args(args)
987
1137
988
1138
def test_dump_json_conflicts_with_verbose(self):
989
options = self.parser.parse_args()
990
options.dump_json = True
991
options.verbose = True
1139
args = ["--dump-json", "--verbose"]
992
1140
with self.assertParseError():
993
self.check_option_syntax(options)
1141
self.parse_args(args)
994
1142
995
1143
def test_dump_json_conflicts_with_action(self):
996
1144
for action, value in self.actions.items():
997
options = self.parser.parse_args()
998
setattr(options, action, value)
999
options.dump_json = True
1145
args = self.actionargs(action, value, "--dump-json")
1000
1146
with self.assertParseError():
1001
self.check_option_syntax(options)
1147
self.parse_args(args)
1002
1148
1003
1149
def test_all_can_not_be_alone(self):
1004
options = self.parser.parse_args()
1005
options.all = True
1150
args = ["--all"]
1006
1151
with self.assertParseError():
1007
self.check_option_syntax(options)
1152
self.parse_args(args)
1008
1153
1009
1154
def test_all_is_ok_with_any_action(self):
1010
1155
for action, value in self.actions.items():
1011
options = self.parser.parse_args()
1012
setattr(options, action, value)
1013
options.all = True
1014
self.check_option_syntax(options)
1156
args = self.actionargs(action, value, "--all")
1157
self.parse_args(args)
1015
1158
1016
1159
def test_any_action_is_ok_with_one_client(self):
1017
1160
for action, value in self.actions.items():
1018
options = self.parser.parse_args()
1019
setattr(options, action, value)
1020
options.client = ["client"]
1021
self.check_option_syntax(options)
1161
args = self.actionargs(action, value, "client")
1162
self.parse_args(args)
1022
1163
1023
1164
def test_one_client_with_all_actions_except_is_enabled(self):
1024
options = self.parser.parse_args()
1025
1165
for action, value in self.actions.items():
1026
if action == "is_enabled":
1166
if action == "--is-enabled":
1027
1167
continue
1028
setattr(options, action, value)
1029
options.client = ["client"]
1030
self.check_option_syntax(options)
1168
args = self.actionargs(action, value, "client")
1169
self.parse_args(args)
1031
1170
1032
1171
def test_two_clients_with_all_actions_except_is_enabled(self):
1033
options = self.parser.parse_args()
1034
1172
for action, value in self.actions.items():
1035
if action == "is_enabled":
1173
if action == "--is-enabled":
1036
1174
continue
1037
setattr(options, action, value)
1038
options.client = ["client1", "client2"]
1039
self.check_option_syntax(options)
1175
args = self.actionargs(action, value, "client1",
1176
"client2")
1177
self.parse_args(args)
1040
1178
1041
1179
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1042
1180
for action, value in self.actions.items():
1043
if action == "is_enabled":
1181
if action == "--is-enabled":
1044
1182
continue
1045
options = self.parser.parse_args()
1046
setattr(options, action, value)
1047
options.client = ["client1", "client2"]
1048
self.check_option_syntax(options)
1183
args = self.actionargs(action, value, "client1",
1184
"client2")
1185
self.parse_args(args)
1049
1186
1050
1187
def test_is_enabled_fails_without_client(self):
1051
options = self.parser.parse_args()
1052
options.is_enabled = True
1188
args = ["--is-enabled"]
1053
1189
with self.assertParseError():
1054
self.check_option_syntax(options)
1190
self.parse_args(args)
1055
1191
1056
1192
def test_is_enabled_fails_with_two_clients(self):
1057
options = self.parser.parse_args()
1058
options.is_enabled = True
1059
options.client = ["client1", "client2"]
1193
args = ["--is-enabled", "client1", "client2"]
1060
1194
with self.assertParseError():
1061
self.check_option_syntax(options)
1195
self.parse_args(args)
1062
1196
1063
1197
def test_remove_can_only_be_combined_with_action_deny(self):
1064
1198
for action, value in self.actions.items():
1065
if action in {"remove", "deny"}:
1199
if action in {"--remove", "--deny"}:
1066
1200
continue
1067
options = self.parser.parse_args()
1068
setattr(options, action, value)
1069
options.all = True
1070
options.remove = True
1201
args = self.actionargs(action, value, "--all",
1202
"--remove")
1071
1203
with self.assertParseError():
1072
self.check_option_syntax(options)
1073
1074
1075
class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):
1076
def test_calls_and_returns_get_object_on_bus(self):
1077
class MockBus(object):
1078
called = False
1079
def get_object(mockbus_self, busname, dbus_path):
1080
# Note that "self" is still the testcase instance,
1081
# this MockBus instance is in "mockbus_self".
1082
self.assertEqual(dbus_busname, busname)
1083
self.assertEqual(server_dbus_path, dbus_path)
1084
mockbus_self.called = True
1085
return mockbus_self
1086
1087
mockbus = get_mandos_dbus_object(bus=MockBus())
1088
self.assertIsInstance(mockbus, MockBus)
1089
self.assertTrue(mockbus.called)
1090
1091
def test_logs_and_exits_on_dbus_error(self):
1092
class FailingBusStub(object):
1093
def get_object(self, busname, dbus_path):
1094
raise dbus.exceptions.DBusException("Test")
1095
1096
with self.assertLogs(log, logging.CRITICAL):
1097
with self.assertRaises(SystemExit) as e:
1098
bus = get_mandos_dbus_object(bus=FailingBusStub())
1099
1100
if isinstance(e.exception.code, int):
1101
self.assertNotEqual(0, e.exception.code)
1102
else:
1103
self.assertIsNotNone(e.exception.code)
1104
1105
1106
class Test_get_managed_objects(TestCaseWithAssertLogs):
1107
def test_calls_and_returns_GetManagedObjects(self):
1108
managed_objects = {"/clients/client": { "Name": "client"}}
1109
class ObjectManagerStub(object):
1110
def GetManagedObjects(self):
1111
return managed_objects
1112
retval = get_managed_objects(ObjectManagerStub())
1113
self.assertDictEqual(managed_objects, retval)
1114
1115
def test_logs_and_exits_on_dbus_error(self):
1204
self.parse_args(args)
1205
1206
1207
class Test_dbus_exceptions(unittest.TestCase):
1208
1209
def test_dbus_ConnectFailed_is_Error(self):
1210
with self.assertRaises(dbus.Error):
1211
raise dbus.ConnectFailed()
1212
1213
1214
class Test_dbus_MandosBus(unittest.TestCase):
1215
1216
class MockMandosBus(dbus.MandosBus):
1217
def __init__(self):
1218
self._name = "se.recompile.Mandos"
1219
self._server_path = "/"
1220
self._server_interface = "se.recompile.Mandos"
1221
self._client_interface = "se.recompile.Mandos.Client"
1222
self.calls = []
1223
self.call_method_return = Unique()
1224
1225
def call_method(self, methodname, busname, objectpath,
1226
interface, *args):
1227
self.calls.append((methodname, busname, objectpath,
1228
interface, args))
1229
return self.call_method_return
1230
1231
def setUp(self):
1232
self.bus = self.MockMandosBus()
1233
1234
def test_set_client_property(self):
1235
self.bus.set_client_property("objectpath", "key", "value")
1236
expected_call = ("Set", self.bus._name, "objectpath",
1237
"org.freedesktop.DBus.Properties",
1238
(self.bus._client_interface, "key", "value"))
1239
self.assertIn(expected_call, self.bus.calls)
1240
1241
def test_call_client_method(self):
1242
ret = self.bus.call_client_method("objectpath", "methodname")
1243
self.assertIs(self.bus.call_method_return, ret)
1244
expected_call = ("methodname", self.bus._name, "objectpath",
1245
self.bus._client_interface, ())
1246
self.assertIn(expected_call, self.bus.calls)
1247
1248
def test_call_client_method_with_args(self):
1249
args = (Unique(), Unique())
1250
ret = self.bus.call_client_method("objectpath", "methodname",
1251
*args)
1252
self.assertIs(self.bus.call_method_return, ret)
1253
expected_call = ("methodname", self.bus._name, "objectpath",
1254
self.bus._client_interface,
1255
(args[0], args[1]))
1256
self.assertIn(expected_call, self.bus.calls)
1257
1258
def test_get_clients_and_properties(self):
1259
managed_objects = {
1260
"objectpath": {
1261
self.bus._client_interface: {
1262
"key": "value",
1263
"bool": True,
1264
},
1265
"irrelevant_interface": {
1266
"key": "othervalue",
1267
"bool": False,
1268
},
1269
},
1270
"other_objectpath": {
1271
"other_irrelevant_interface": {
1272
"key": "value 3",
1273
"bool": None,
1274
},
1275
},
1276
}
1277
expected_clients_and_properties = {
1278
"objectpath": {
1279
"key": "value",
1280
"bool": True,
1281
}
1282
}
1283
self.bus.call_method_return = managed_objects
1284
ret = self.bus.get_clients_and_properties()
1285
self.assertDictEqual(expected_clients_and_properties, ret)
1286
expected_call = ("GetManagedObjects", self.bus._name,
1287
self.bus._server_path,
1288
"org.freedesktop.DBus.ObjectManager", ())
1289
self.assertIn(expected_call, self.bus.calls)
1290
1291
def test_call_server_method(self):
1292
ret = self.bus.call_server_method("methodname")
1293
self.assertIs(self.bus.call_method_return, ret)
1294
expected_call = ("methodname", self.bus._name,
1295
self.bus._server_path,
1296
self.bus._server_interface, ())
1297
self.assertIn(expected_call, self.bus.calls)
1298
1299
def test_call_server_method_with_args(self):
1300
args = (Unique(), Unique())
1301
ret = self.bus.call_server_method("methodname", *args)
1302
self.assertIs(self.bus.call_method_return, ret)
1303
expected_call = ("methodname", self.bus._name,
1304
self.bus._server_path,
1305
self.bus._server_interface,
1306
(args[0], args[1]))
1307
self.assertIn(expected_call, self.bus.calls)
1308
1309
1310
class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):
1311
1312
def MockDBusPython_func(self, func):
1313
class mock_dbus_python(object):
1314
"""mock dbus-python module"""
1315
class exceptions(object):
1316
"""Pseudo-namespace"""
1317
class DBusException(Exception):
1318
pass
1319
class SystemBus(object):
1320
@staticmethod
1321
def get_object(busname, objectpath):
1322
DBusObject = collections.namedtuple(
1323
"DBusObject", ("methodname", "Set"))
1324
def method(*args, **kwargs):
1325
self.assertEqual({"dbus_interface":
1326
"interface"},
1327
kwargs)
1328
return func(*args)
1329
def set_property(interface, key, value,
1330
dbus_interface=None):
1331
self.assertEqual(
1332
"org.freedesktop.DBus.Properties",
1333
dbus_interface)
1334
self.assertEqual("Secret", key)
1335
return func(interface, key, value,
1336
dbus_interface=dbus_interface)
1337
return DBusObject(methodname=method,
1338
Set=set_property)
1339
class Boolean(object):
1340
def __init__(self, value):
1341
self.value = bool(value)
1342
def __bool__(self):
1343
return self.value
1344
if sys.version_info.major == 2:
1345
__nonzero__ = __bool__
1346
class ObjectPath(str):
1347
pass
1348
class Dictionary(dict):
1349
pass
1350
class ByteArray(bytes):
1351
pass
1352
return mock_dbus_python
1353
1354
def call_method(self, bus, methodname, busname, objectpath,
1355
interface, *args):
1356
with self.assertLogs(log, logging.DEBUG):
1357
return bus.call_method(methodname, busname, objectpath,
1358
interface, *args)
1359
1360
def test_call_method_returns(self):
1361
expected_method_return = Unique()
1362
method_args = (Unique(), Unique())
1363
def func(*args):
1364
self.assertEqual(len(method_args), len(args))
1365
for marg, arg in zip(method_args, args):
1366
self.assertIs(marg, arg)
1367
return expected_method_return
1368
mock_dbus_python = self.MockDBusPython_func(func)
1369
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1370
ret = self.call_method(bus, "methodname", "busname",
1371
"objectpath", "interface",
1372
*method_args)
1373
self.assertIs(ret, expected_method_return)
1374
1375
def test_call_method_filters_bool_true(self):
1376
def func():
1377
return method_return
1378
mock_dbus_python = self.MockDBusPython_func(func)
1379
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1380
method_return = mock_dbus_python.Boolean(True)
1381
ret = self.call_method(bus, "methodname", "busname",
1382
"objectpath", "interface")
1383
self.assertTrue(ret)
1384
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1385
1386
def test_call_method_filters_bool_false(self):
1387
def func():
1388
return method_return
1389
mock_dbus_python = self.MockDBusPython_func(func)
1390
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1391
method_return = mock_dbus_python.Boolean(False)
1392
ret = self.call_method(bus, "methodname", "busname",
1393
"objectpath", "interface")
1394
self.assertFalse(ret)
1395
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1396
1397
def test_call_method_filters_objectpath(self):
1398
def func():
1399
return method_return
1400
mock_dbus_python = self.MockDBusPython_func(func)
1401
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1402
method_return = mock_dbus_python.ObjectPath("objectpath")
1403
ret = self.call_method(bus, "methodname", "busname",
1404
"objectpath", "interface")
1405
self.assertEqual("objectpath", ret)
1406
self.assertIsNot("objectpath", ret)
1407
self.assertNotIsInstance(ret, mock_dbus_python.ObjectPath)
1408
1409
def test_call_method_filters_booleans_in_dict(self):
1410
def func():
1411
return method_return
1412
mock_dbus_python = self.MockDBusPython_func(func)
1413
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1414
method_return = mock_dbus_python.Dictionary(
1415
{mock_dbus_python.Boolean(True):
1416
mock_dbus_python.Boolean(False),
1417
mock_dbus_python.Boolean(False):
1418
mock_dbus_python.Boolean(True)})
1419
ret = self.call_method(bus, "methodname", "busname",
1420
"objectpath", "interface")
1421
expected_method_return = {True: False,
1422
False: True}
1423
self.assertEqual(expected_method_return, ret)
1424
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1425
1426
def test_call_method_filters_objectpaths_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
{mock_dbus_python.ObjectPath("objectpath_key_1"):
1433
mock_dbus_python.ObjectPath("objectpath_value_1"),
1434
mock_dbus_python.ObjectPath("objectpath_key_2"):
1435
mock_dbus_python.ObjectPath("objectpath_value_2")})
1436
ret = self.call_method(bus, "methodname", "busname",
1437
"objectpath", "interface")
1438
expected_method_return = {str(key): str(value)
1439
for key, value in
1440
method_return.items()}
1441
self.assertEqual(expected_method_return, ret)
1442
self.assertIsInstance(ret, dict)
1443
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1444
1445
def test_call_method_filters_dict_in_dict(self):
1446
def func():
1447
return method_return
1448
mock_dbus_python = self.MockDBusPython_func(func)
1449
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1450
method_return = mock_dbus_python.Dictionary(
1451
{"key1": mock_dbus_python.Dictionary({"key11": "value11",
1452
"key12": "value12"}),
1453
"key2": mock_dbus_python.Dictionary({"key21": "value21",
1454
"key22": "value22"})})
1455
ret = self.call_method(bus, "methodname", "busname",
1456
"objectpath", "interface")
1457
expected_method_return = {
1458
"key1": {"key11": "value11",
1459
"key12": "value12"},
1460
"key2": {"key21": "value21",
1461
"key22": "value22"},
1462
}
1463
self.assertEqual(expected_method_return, ret)
1464
self.assertIsInstance(ret, dict)
1465
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1466
for key, value in ret.items():
1467
self.assertIsInstance(value, dict)
1468
self.assertEqual(expected_method_return[key], value)
1469
self.assertNotIsInstance(value,
1470
mock_dbus_python.Dictionary)
1471
1472
def test_call_method_filters_dict_three_deep(self):
1473
def func():
1474
return method_return
1475
mock_dbus_python = self.MockDBusPython_func(func)
1476
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1477
method_return = mock_dbus_python.Dictionary(
1478
{"key1":
1479
mock_dbus_python.Dictionary(
1480
{"key2":
1481
mock_dbus_python.Dictionary(
1482
{"key3":
1483
mock_dbus_python.Boolean(True),
1484
}),
1485
}),
1486
})
1487
ret = self.call_method(bus, "methodname", "busname",
1488
"objectpath", "interface")
1489
expected_method_return = {"key1": {"key2": {"key3": True}}}
1490
self.assertEqual(expected_method_return, ret)
1491
self.assertIsInstance(ret, dict)
1492
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1493
self.assertIsInstance(ret["key1"], dict)
1494
self.assertNotIsInstance(ret["key1"],
1495
mock_dbus_python.Dictionary)
1496
self.assertIsInstance(ret["key1"]["key2"], dict)
1497
self.assertNotIsInstance(ret["key1"]["key2"],
1498
mock_dbus_python.Dictionary)
1499
self.assertTrue(ret["key1"]["key2"]["key3"])
1500
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
1501
mock_dbus_python.Boolean)
1502
1503
def test_call_method_handles_exception(self):
1116
1504
dbus_logger = logging.getLogger("dbus.proxies")
1117
1505
1118
class ObjectManagerFailingStub(object):
1119
def GetManagedObjects(self):
1120
dbus_logger.error("Test")
1121
raise dbus.exceptions.DBusException("Test")
1506
def func():
1507
dbus_logger.error("Test")
1508
raise mock_dbus_python.exceptions.DBusException()
1509
1510
mock_dbus_python = self.MockDBusPython_func(func)
1511
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1122
1512
1123
1513
class CountingHandler(logging.Handler):
1124
1514
count = 0
1130
1520
dbus_logger.addHandler(counting_handler)
1131
1521
1132
1522
try:
1133
with self.assertLogs(log, logging.CRITICAL) as watcher:
1134
with self.assertRaises(SystemExit) as e:
1135
get_managed_objects(ObjectManagerFailingStub())
1523
with self.assertRaises(dbus.Error) as e:
1524
self.call_method(bus, "methodname", "busname",
1525
"objectpath", "interface")
1136
1526
finally:
1137
1527
dbus_logger.removeFilter(counting_handler)
1138
1528
1529
self.assertNotIsInstance(e, dbus.ConnectFailed)
1530
1139
1531
# Make sure the dbus logger was suppressed
1140
1532
self.assertEqual(0, counting_handler.count)
1141
1533
1142
# Test that the dbus_logger still works
1143
with self.assertLogs(dbus_logger, logging.ERROR):
1144
dbus_logger.error("Test")
1145
1146
if isinstance(e.exception.code, int):
1147
self.assertNotEqual(0, e.exception.code)
1148
else:
1149
self.assertIsNotNone(e.exception.code)
1534
def test_Set_Secret_sends_bytearray(self):
1535
ret = [None]
1536
def func(*args, **kwargs):
1537
ret[0] = (args, kwargs)
1538
mock_dbus_python = self.MockDBusPython_func(func)
1539
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1540
bus.set_client_property("objectpath", "Secret", "value")
1541
expected_call = (("se.recompile.Mandos.Client", "Secret",
1542
mock_dbus_python.ByteArray(b"value")),
1543
{"dbus_interface":
1544
"org.freedesktop.DBus.Properties"})
1545
self.assertEqual(expected_call, ret[0])
1546
if sys.version_info.major == 2:
1547
self.assertIsInstance(ret[0][0][-1],
1548
mock_dbus_python.ByteArray)
1549
1550
def test_get_object_converts_to_correct_exception(self):
1551
bus = dbus_python_adapter.SystemBus(
1552
self.fake_dbus_python_raises_exception_on_connect)
1553
with self.assertRaises(dbus.ConnectFailed):
1554
self.call_method(bus, "methodname", "busname",
1555
"objectpath", "interface")
1556
1557
class fake_dbus_python_raises_exception_on_connect(object):
1558
"""fake dbus-python module"""
1559
class exceptions(object):
1560
"""Pseudo-namespace"""
1561
class DBusException(Exception):
1562
pass
1563
1564
@classmethod
1565
def SystemBus(cls):
1566
def get_object(busname, objectpath):
1567
raise cls.exceptions.DBusException()
1568
Bus = collections.namedtuple("Bus", ["get_object"])
1569
return Bus(get_object=get_object)
1570
1571
1572
class Test_dbus_python_adapter_CachingBus(unittest.TestCase):
1573
class mock_dbus_python(object):
1574
"""mock dbus-python modules"""
1575
class SystemBus(object):
1576
@staticmethod
1577
def get_object(busname, objectpath):
1578
return Unique()
1579
1580
def setUp(self):
1581
self.bus = dbus_python_adapter.CachingBus(
1582
self.mock_dbus_python)
1583
1584
def test_returns_distinct_objectpaths(self):
1585
obj1 = self.bus.get_object("busname", "objectpath1")
1586
self.assertIsInstance(obj1, Unique)
1587
obj2 = self.bus.get_object("busname", "objectpath2")
1588
self.assertIsInstance(obj2, Unique)
1589
self.assertIsNot(obj1, obj2)
1590
1591
def test_returns_distinct_busnames(self):
1592
obj1 = self.bus.get_object("busname1", "objectpath")
1593
self.assertIsInstance(obj1, Unique)
1594
obj2 = self.bus.get_object("busname2", "objectpath")
1595
self.assertIsInstance(obj2, Unique)
1596
self.assertIsNot(obj1, obj2)
1597
1598
def test_returns_distinct_both(self):
1599
obj1 = self.bus.get_object("busname1", "objectpath")
1600
self.assertIsInstance(obj1, Unique)
1601
obj2 = self.bus.get_object("busname2", "objectpath")
1602
self.assertIsInstance(obj2, Unique)
1603
self.assertIsNot(obj1, obj2)
1604
1605
def test_returns_same(self):
1606
obj1 = self.bus.get_object("busname", "objectpath")
1607
self.assertIsInstance(obj1, Unique)
1608
obj2 = self.bus.get_object("busname", "objectpath")
1609
self.assertIsInstance(obj2, Unique)
1610
self.assertIs(obj1, obj2)
1611
1612
def test_returns_same_old(self):
1613
obj1 = self.bus.get_object("busname1", "objectpath1")
1614
self.assertIsInstance(obj1, Unique)
1615
obj2 = self.bus.get_object("busname2", "objectpath2")
1616
self.assertIsInstance(obj2, Unique)
1617
obj1b = self.bus.get_object("busname1", "objectpath1")
1618
self.assertIsInstance(obj1b, Unique)
1619
self.assertIsNot(obj1, obj2)
1620
self.assertIsNot(obj2, obj1b)
1621
self.assertIs(obj1, obj1b)
1622
1623
1624
class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):
1625
1626
def Stub_pydbus_func(self, func):
1627
class stub_pydbus(object):
1628
"""stub pydbus module"""
1629
class SystemBus(object):
1630
@staticmethod
1631
def get(busname, objectpath):
1632
DBusObject = collections.namedtuple(
1633
"DBusObject", ("methodname",))
1634
return {"interface":
1635
DBusObject(methodname=func)}
1636
return stub_pydbus
1637
1638
def call_method(self, bus, methodname, busname, objectpath,
1639
interface, *args):
1640
with self.assertLogs(log, logging.DEBUG):
1641
return bus.call_method(methodname, busname, objectpath,
1642
interface, *args)
1643
1644
def test_call_method_returns(self):
1645
expected_method_return = Unique()
1646
method_args = (Unique(), Unique())
1647
def func(*args):
1648
self.assertEqual(len(method_args), len(args))
1649
for marg, arg in zip(method_args, args):
1650
self.assertIs(marg, arg)
1651
return expected_method_return
1652
stub_pydbus = self.Stub_pydbus_func(func)
1653
bus = pydbus_adapter.SystemBus(stub_pydbus)
1654
ret = self.call_method(bus, "methodname", "busname",
1655
"objectpath", "interface",
1656
*method_args)
1657
self.assertIs(ret, expected_method_return)
1658
1659
def test_call_method_handles_exception(self):
1660
dbus_logger = logging.getLogger("dbus.proxies")
1661
1662
def func():
1663
raise gi.repository.GLib.Error()
1664
1665
stub_pydbus = self.Stub_pydbus_func(func)
1666
bus = pydbus_adapter.SystemBus(stub_pydbus)
1667
1668
with self.assertRaises(dbus.Error) as e:
1669
self.call_method(bus, "methodname", "busname",
1670
"objectpath", "interface")
1671
1672
self.assertNotIsInstance(e, dbus.ConnectFailed)
1673
1674
def test_get_converts_to_correct_exception(self):
1675
bus = pydbus_adapter.SystemBus(
1676
self.fake_pydbus_raises_exception_on_connect)
1677
with self.assertRaises(dbus.ConnectFailed):
1678
self.call_method(bus, "methodname", "busname",
1679
"objectpath", "interface")
1680
1681
class fake_pydbus_raises_exception_on_connect(object):
1682
"""fake dbus-python module"""
1683
@classmethod
1684
def SystemBus(cls):
1685
def get(busname, objectpath):
1686
raise gi.repository.GLib.Error()
1687
Bus = collections.namedtuple("Bus", ["get"])
1688
return Bus(get=get)
1689
1690
def test_set_property_uses_setattr(self):
1691
class Object(object):
1692
pass
1693
obj = Object()
1694
class pydbus_spy(object):
1695
class SystemBus(object):
1696
@staticmethod
1697
def get(busname, objectpath):
1698
return {"interface": obj}
1699
bus = pydbus_adapter.SystemBus(pydbus_spy)
1700
value = Unique()
1701
bus.set_property("busname", "objectpath", "interface", "key",
1702
value)
1703
self.assertIs(value, obj.key)
1704
1705
def test_get_suppresses_xml_deprecation_warning(self):
1706
if sys.version_info.major >= 3:
1707
return
1708
class stub_pydbus_get(object):
1709
class SystemBus(object):
1710
@staticmethod
1711
def get(busname, objectpath):
1712
warnings.warn_explicit(
1713
"deprecated", DeprecationWarning,
1714
"xml.etree.ElementTree", 0)
1715
bus = pydbus_adapter.SystemBus(stub_pydbus_get)
1716
with warnings.catch_warnings(record=True) as w:
1717
warnings.simplefilter("always")
1718
bus.get("busname", "objectpath")
1719
self.assertEqual(0, len(w))
1720
1721
1722
class Test_pydbus_adapter_CachingBus(unittest.TestCase):
1723
class stub_pydbus(object):
1724
"""stub pydbus module"""
1725
class SystemBus(object):
1726
@staticmethod
1727
def get(busname, objectpath):
1728
return Unique()
1729
1730
def setUp(self):
1731
self.bus = pydbus_adapter.CachingBus(self.stub_pydbus)
1732
1733
def test_returns_distinct_objectpaths(self):
1734
obj1 = self.bus.get("busname", "objectpath1")
1735
self.assertIsInstance(obj1, Unique)
1736
obj2 = self.bus.get("busname", "objectpath2")
1737
self.assertIsInstance(obj2, Unique)
1738
self.assertIsNot(obj1, obj2)
1739
1740
def test_returns_distinct_busnames(self):
1741
obj1 = self.bus.get("busname1", "objectpath")
1742
self.assertIsInstance(obj1, Unique)
1743
obj2 = self.bus.get("busname2", "objectpath")
1744
self.assertIsInstance(obj2, Unique)
1745
self.assertIsNot(obj1, obj2)
1746
1747
def test_returns_distinct_both(self):
1748
obj1 = self.bus.get("busname1", "objectpath")
1749
self.assertIsInstance(obj1, Unique)
1750
obj2 = self.bus.get("busname2", "objectpath")
1751
self.assertIsInstance(obj2, Unique)
1752
self.assertIsNot(obj1, obj2)
1753
1754
def test_returns_same(self):
1755
obj1 = self.bus.get("busname", "objectpath")
1756
self.assertIsInstance(obj1, Unique)
1757
obj2 = self.bus.get("busname", "objectpath")
1758
self.assertIsInstance(obj2, Unique)
1759
self.assertIs(obj1, obj2)
1760
1761
def test_returns_same_old(self):
1762
obj1 = self.bus.get("busname1", "objectpath1")
1763
self.assertIsInstance(obj1, Unique)
1764
obj2 = self.bus.get("busname2", "objectpath2")
1765
self.assertIsInstance(obj2, Unique)
1766
obj1b = self.bus.get("busname1", "objectpath1")
1767
self.assertIsInstance(obj1b, Unique)
1768
self.assertIsNot(obj1, obj2)
1769
self.assertIsNot(obj2, obj1b)
1770
self.assertIs(obj1, obj1b)
1150
1771
1151
1772
1152
1773
class Test_commands_from_options(unittest.TestCase):
1774
1153
1775
def setUp(self):
1154
1776
self.parser = argparse.ArgumentParser()
1155
1777
add_command_line_options(self.parser)
1370
1992
class TestCommand(unittest.TestCase):
1371
1993
"""Abstract class for tests of command classes"""
1372
1994
1995
class FakeMandosBus(dbus.MandosBus):
1996
def __init__(self, testcase):
1997
self.client_properties = {
1998
"Name": "foo",
1999
"KeyID": ("92ed150794387c03ce684574b1139a65"
2000
"94a34f895daaaf09fd8ea90a27cddb12"),
2001
"Secret": b"secret",
2002
"Host": "foo.example.org",
2003
"Enabled": True,
2004
"Timeout": 300000,
2005
"LastCheckedOK": "2019-02-03T00:00:00",
2006
"Created": "2019-01-02T00:00:00",
2007
"Interval": 120000,
2008
"Fingerprint": ("778827225BA7DE539C5A"
2009
"7CFA59CFF7CDBD9A5920"),
2010
"CheckerRunning": False,
2011
"LastEnabled": "2019-01-03T00:00:00",
2012
"ApprovalPending": False,
2013
"ApprovedByDefault": True,
2014
"LastApprovalRequest": "",
2015
"ApprovalDelay": 0,
2016
"ApprovalDuration": 1000,
2017
"Checker": "fping -q -- %(host)s",
2018
"ExtendedTimeout": 900000,
2019
"Expires": "2019-02-04T00:00:00",
2020
"LastCheckerStatus": 0,
2021
}
2022
self.other_client_properties = {
2023
"Name": "barbar",
2024
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
2025
"6ab612cff5ad227247e46c2b020f441c"),
2026
"Secret": b"secretbar",
2027
"Host": "192.0.2.3",
2028
"Enabled": True,
2029
"Timeout": 300000,
2030
"LastCheckedOK": "2019-02-04T00:00:00",
2031
"Created": "2019-01-03T00:00:00",
2032
"Interval": 120000,
2033
"Fingerprint": ("3E393AEAEFB84C7E89E2"
2034
"F547B3A107558FCA3A27"),
2035
"CheckerRunning": True,
2036
"LastEnabled": "2019-01-04T00:00:00",
2037
"ApprovalPending": False,
2038
"ApprovedByDefault": False,
2039
"LastApprovalRequest": "2019-01-03T00:00:00",
2040
"ApprovalDelay": 30000,
2041
"ApprovalDuration": 93785000,
2042
"Checker": ":",
2043
"ExtendedTimeout": 900000,
2044
"Expires": "2019-02-05T00:00:00",
2045
"LastCheckerStatus": -2,
2046
}
2047
self.clients = collections.OrderedDict(
2048
[
2049
("client_objectpath", self.client_properties),
2050
("other_client_objectpath",
2051
self.other_client_properties),
2052
])
2053
self.one_client = {"client_objectpath":
2054
self.client_properties}
2055
self.testcase = testcase
2056
self.calls = []
2057
2058
def call_method(self, methodname, busname, objectpath,
2059
interface, *args):
2060
self.testcase.assertEqual("se.recompile.Mandos", busname)
2061
self.calls.append((methodname, busname, objectpath,
2062
interface, args))
2063
if interface == "org.freedesktop.DBus.Properties":
2064
if methodname == "Set":
2065
self.testcase.assertEqual(3, len(args))
2066
interface, key, value = args
2067
self.testcase.assertEqual(
2068
"se.recompile.Mandos.Client", interface)
2069
self.clients[objectpath][key] = value
2070
return
2071
elif interface == "se.recompile.Mandos":
2072
self.testcase.assertEqual("RemoveClient", methodname)
2073
self.testcase.assertEqual(1, len(args))
2074
clientpath = args[0]
2075
del self.clients[clientpath]
2076
return
2077
elif interface == "se.recompile.Mandos.Client":
2078
if methodname == "Approve":
2079
self.testcase.assertEqual(1, len(args))
2080
return
2081
raise ValueError()
2082
1373
2083
def setUp(self):
1374
testcase = self
1375
class MockClient(object):
1376
def __init__(self, name, **attributes):
1377
self.__dbus_object_path__ = "/clients/{}".format(name)
1378
self.attributes = attributes
1379
self.attributes["Name"] = name
1380
self.calls = []
1381
def Set(self, interface, propname, value, dbus_interface):
1382
testcase.assertEqual(client_dbus_interface, interface)
1383
testcase.assertEqual(dbus.PROPERTIES_IFACE,
1384
dbus_interface)
1385
self.attributes[propname] = value
1386
def Approve(self, approve, dbus_interface):
1387
testcase.assertEqual(client_dbus_interface,
1388
dbus_interface)
1389
self.calls.append(("Approve", (approve,
1390
dbus_interface)))
1391
self.client = MockClient(
1392
"foo",
1393
KeyID=("92ed150794387c03ce684574b1139a65"
1394
"94a34f895daaaf09fd8ea90a27cddb12"),
1395
Secret=b"secret",
1396
Host="foo.example.org",
1397
Enabled=dbus.Boolean(True),
1398
Timeout=300000,
1399
LastCheckedOK="2019-02-03T00:00:00",
1400
Created="2019-01-02T00:00:00",
1401
Interval=120000,
1402
Fingerprint=("778827225BA7DE539C5A"
1403
"7CFA59CFF7CDBD9A5920"),
1404
CheckerRunning=dbus.Boolean(False),
1405
LastEnabled="2019-01-03T00:00:00",
1406
ApprovalPending=dbus.Boolean(False),
1407
ApprovedByDefault=dbus.Boolean(True),
1408
LastApprovalRequest="",
1409
ApprovalDelay=0,
1410
ApprovalDuration=1000,
1411
Checker="fping -q -- %(host)s",
1412
ExtendedTimeout=900000,
1413
Expires="2019-02-04T00:00:00",
1414
LastCheckerStatus=0)
1415
self.other_client = MockClient(
1416
"barbar",
1417
KeyID=("0558568eedd67d622f5c83b35a115f79"
1418
"6ab612cff5ad227247e46c2b020f441c"),
1419
Secret=b"secretbar",
1420
Host="192.0.2.3",
1421
Enabled=dbus.Boolean(True),
1422
Timeout=300000,
1423
LastCheckedOK="2019-02-04T00:00:00",
1424
Created="2019-01-03T00:00:00",
1425
Interval=120000,
1426
Fingerprint=("3E393AEAEFB84C7E89E2"
1427
"F547B3A107558FCA3A27"),
1428
CheckerRunning=dbus.Boolean(True),
1429
LastEnabled="2019-01-04T00:00:00",
1430
ApprovalPending=dbus.Boolean(False),
1431
ApprovedByDefault=dbus.Boolean(False),
1432
LastApprovalRequest="2019-01-03T00:00:00",
1433
ApprovalDelay=30000,
1434
ApprovalDuration=93785000,
1435
Checker=":",
1436
ExtendedTimeout=900000,
1437
Expires="2019-02-05T00:00:00",
1438
LastCheckerStatus=-2)
1439
self.clients = collections.OrderedDict(
1440
[
1441
(self.client.__dbus_object_path__,
1442
self.client.attributes),
1443
(self.other_client.__dbus_object_path__,
1444
self.other_client.attributes),
1445
])
1446
self.one_client = {self.client.__dbus_object_path__:
1447
self.client.attributes}
1448
1449
@property
1450
def bus(self):
1451
class MockBus(object):
1452
@staticmethod
1453
def get_object(client_bus_name, path):
1454
self.assertEqual(dbus_busname, client_bus_name)
1455
# Note: "self" here is the TestCmd instance, not the
1456
# MockBus instance, since this is a static method!
1457
if path == self.client.__dbus_object_path__:
1458
return self.client
1459
elif path == self.other_client.__dbus_object_path__:
1460
return self.other_client
1461
return MockBus()
2084
self.bus = self.FakeMandosBus(self)
1462
2085
1463
2086
1464
2087
class TestBaseCommands(TestCommand):
1465
2088
1466
2089
def test_IsEnabled_exits_successfully(self):
1467
2090
with self.assertRaises(SystemExit) as e:
1468
command.IsEnabled().run(self.one_client)
2091
command.IsEnabled().run(self.bus.one_client)
1469
2092
if e.exception.code is not None:
1470
2093
self.assertEqual(0, e.exception.code)
1471
2094
else:
1472
2095
self.assertIsNone(e.exception.code)
1473
2096
1474
2097
def test_IsEnabled_exits_with_failure(self):
1475
self.client.attributes["Enabled"] = dbus.Boolean(False)
2098
self.bus.client_properties["Enabled"] = False
1476
2099
with self.assertRaises(SystemExit) as e:
1477
command.IsEnabled().run(self.one_client)
2100
command.IsEnabled().run(self.bus.one_client)
1478
2101
if isinstance(e.exception.code, int):
1479
2102
self.assertNotEqual(0, e.exception.code)
1480
2103
else:
1481
2104
self.assertIsNotNone(e.exception.code)
1482
2105
1483
2106
def test_Approve(self):
1484
command.Approve().run(self.clients, self.bus)
1485
for clientpath in self.clients:
1486
client = self.bus.get_object(dbus_busname, clientpath)
1487
self.assertIn(("Approve", (True, client_dbus_interface)),
1488
client.calls)
2107
busname = "se.recompile.Mandos"
2108
client_interface = "se.recompile.Mandos.Client"
2109
command.Approve().run(self.bus.clients, self.bus)
2110
for clientpath in self.bus.clients:
2111
self.assertIn(("Approve", busname, clientpath,
2112
client_interface, (True,)), self.bus.calls)
1489
2113
1490
2114
def test_Deny(self):
1491
command.Deny().run(self.clients, self.bus)
1492
for clientpath in self.clients:
1493
client = self.bus.get_object(dbus_busname, clientpath)
1494
self.assertIn(("Approve", (False, client_dbus_interface)),
1495
client.calls)
2115
busname = "se.recompile.Mandos"
2116
client_interface = "se.recompile.Mandos.Client"
2117
command.Deny().run(self.bus.clients, self.bus)
2118
for clientpath in self.bus.clients:
2119
self.assertIn(("Approve", busname, clientpath,
2120
client_interface, (False,)),
2121
self.bus.calls)
1496
2122
1497
2123
def test_Remove(self):
1498
class MandosSpy(object):
1499
def __init__(self):
1500
self.calls = []
1501
def RemoveClient(self, dbus_path):
1502
self.calls.append(("RemoveClient", (dbus_path,)))
1503
mandos = MandosSpy()
1504
command.Remove().run(self.clients, self.bus, mandos)
1505
for clientpath in self.clients:
1506
self.assertIn(("RemoveClient", (clientpath,)),
1507
mandos.calls)
2124
command.Remove().run(self.bus.clients, self.bus)
2125
for clientpath in self.bus.clients:
2126
self.assertIn(("RemoveClient", dbus_busname,
2127
dbus_server_path, dbus_server_interface,
2128
(clientpath,)), self.bus.calls)
1508
2129
1509
2130
expected_json = {
1510
2131
"foo": {
1559
2180
1560
2181
def test_DumpJSON_normal(self):
1561
2182
with self.capture_stdout_to_buffer() as buffer:
1562
command.DumpJSON().run(self.clients)
2183
command.DumpJSON().run(self.bus.clients)
1563
2184
json_data = json.loads(buffer.getvalue())
1564
2185
self.assertDictEqual(self.expected_json, json_data)
1565
2186
1576
2197
1577
2198
def test_DumpJSON_one_client(self):
1578
2199
with self.capture_stdout_to_buffer() as buffer:
1579
command.DumpJSON().run(self.one_client)
2200
command.DumpJSON().run(self.bus.one_client)
1580
2201
json_data = json.loads(buffer.getvalue())
1581
2202
expected_json = {"foo": self.expected_json["foo"]}
1582
2203
self.assertDictEqual(expected_json, json_data)
1583
2204
1584
2205
def test_PrintTable_normal(self):
1585
2206
with self.capture_stdout_to_buffer() as buffer:
1586
command.PrintTable().run(self.clients)
2207
command.PrintTable().run(self.bus.clients)
1587
2208
expected_output = "\n".join((
1588
2209
"Name Enabled Timeout Last Successful Check",
1589
2210
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1593
2214
1594
2215
def test_PrintTable_verbose(self):
1595
2216
with self.capture_stdout_to_buffer() as buffer:
1596
command.PrintTable(verbose=True).run(self.clients)
2217
command.PrintTable(verbose=True).run(self.bus.clients)
1597
2218
columns = (
1598
2219
(
1599
2220
"Name ",
1689
2310
1690
2311
def test_PrintTable_one_client(self):
1691
2312
with self.capture_stdout_to_buffer() as buffer:
1692
command.PrintTable().run(self.one_client)
2313
command.PrintTable().run(self.bus.one_client)
1693
2314
expected_output = "\n".join((
1694
2315
"Name Enabled Timeout Last Successful Check",
1695
2316
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1699
2320
1700
2321
class TestPropertySetterCmd(TestCommand):
1701
2322
"""Abstract class for tests of command.PropertySetter classes"""
2323
1702
2324
def runTest(self):
1703
2325
if not hasattr(self, "command"):
1704
return
1705
values_to_get = getattr(self, "values_to_get",
1706
self.values_to_set)
1707
for value_to_set, value_to_get in zip(self.values_to_set,
1708
values_to_get):
1709
for clientpath in self.clients:
1710
client = self.bus.get_object(dbus_busname, clientpath)
1711
old_value = client.attributes[self.propname]
1712
client.attributes[self.propname] = self.Unique()
1713
self.run_command(value_to_set, self.clients)
1714
for clientpath in self.clients:
1715
client = self.bus.get_object(dbus_busname, clientpath)
1716
value = client.attributes[self.propname]
1717
self.assertNotIsInstance(value, self.Unique)
2326
return # Abstract TestCase class
2327
2328
if hasattr(self, "values_to_set"):
2329
cmd_args = [(value,) for value in self.values_to_set]
2330
values_to_get = getattr(self, "values_to_get",
2331
self.values_to_set)
2332
else:
2333
cmd_args = [() for x in range(len(self.values_to_get))]
2334
values_to_get = self.values_to_get
2335
for value_to_get, cmd_arg in zip(values_to_get, cmd_args):
2336
for clientpath in self.bus.clients:
2337
self.bus.clients[clientpath][self.propname] = (
2338
Unique())
2339
self.command(*cmd_arg).run(self.bus.clients, self.bus)
2340
for clientpath in self.bus.clients:
2341
value = (self.bus.clients[clientpath]
2342
[self.propname])
2343
self.assertNotIsInstance(value, Unique)
1718
2344
self.assertEqual(value_to_get, value)
1719
2345
1720
class Unique(object):
1721
"""Class for objects which exist only to be unique objects,
1722
since unittest.mock.sentinel only exists in Python 3.3"""
1723
1724
def run_command(self, value, clients):
1725
self.command().run(clients, self.bus)
1726
1727
2346
1728
2347
class TestEnableCmd(TestPropertySetterCmd):
1729
2348
command = command.Enable
1730
2349
propname = "Enabled"
1731
values_to_set = [dbus.Boolean(True)]
2350
values_to_get = [True]
1732
2351
1733
2352
1734
2353
class TestDisableCmd(TestPropertySetterCmd):
1735
2354
command = command.Disable
1736
2355
propname = "Enabled"
1737
values_to_set = [dbus.Boolean(False)]
2356
values_to_get = [False]
1738
2357
1739
2358
1740
2359
class TestBumpTimeoutCmd(TestPropertySetterCmd):
1741
2360
command = command.BumpTimeout
1742
2361
propname = "LastCheckedOK"
1743
values_to_set = [""]
2362
values_to_get = [""]
1744
2363
1745
2364
1746
2365
class TestStartCheckerCmd(TestPropertySetterCmd):
1747
2366
command = command.StartChecker
1748
2367
propname = "CheckerRunning"
1749
values_to_set = [dbus.Boolean(True)]
2368
values_to_get = [True]
1750
2369
1751
2370
1752
2371
class TestStopCheckerCmd(TestPropertySetterCmd):
1753
2372
command = command.StopChecker
1754
2373
propname = "CheckerRunning"
1755
values_to_set = [dbus.Boolean(False)]
2374
values_to_get = [False]
1756
2375
1757
2376
1758
2377
class TestApproveByDefaultCmd(TestPropertySetterCmd):
1759
2378
command = command.ApproveByDefault
1760
2379
propname = "ApprovedByDefault"
1761
values_to_set = [dbus.Boolean(True)]
2380
values_to_get = [True]
1762
2381
1763
2382
1764
2383
class TestDenyByDefaultCmd(TestPropertySetterCmd):
1765
2384
command = command.DenyByDefault
1766
2385
propname = "ApprovedByDefault"
1767
values_to_set = [dbus.Boolean(False)]
1768
1769
1770
class TestPropertySetterValueCmd(TestPropertySetterCmd):
1771
"""Abstract class for tests of PropertySetterValueCmd classes"""
1772
1773
def runTest(self):
1774
if type(self) is TestPropertySetterValueCmd:
1775
return
1776
return super(TestPropertySetterValueCmd, self).runTest()
1777
1778
def run_command(self, value, clients):
1779
self.command(value).run(clients, self.bus)
1780
1781
1782
class TestSetCheckerCmd(TestPropertySetterValueCmd):
2386
values_to_get = [False]
2387
2388
2389
class TestSetCheckerCmd(TestPropertySetterCmd):
1783
2390
command = command.SetChecker
1784
2391
propname = "Checker"
1785
2392
values_to_set = ["", ":", "fping -q -- %s"]
1786
2393
1787
2394
1788
class TestSetHostCmd(TestPropertySetterValueCmd):
2395
class TestSetHostCmd(TestPropertySetterCmd):
1789
2396
command = command.SetHost
1790
2397
propname = "Host"
1791
2398
values_to_set = ["192.0.2.3", "client.example.org"]
1792
2399
1793
2400
1794
class TestSetSecretCmd(TestPropertySetterValueCmd):
2401
class TestSetSecretCmd(TestPropertySetterCmd):
1795
2402
command = command.SetSecret
1796
2403
propname = "Secret"
1797
2404
values_to_set = [io.BytesIO(b""),
1799
2406
values_to_get = [f.getvalue() for f in values_to_set]
1800
2407
1801
2408
1802
class TestSetTimeoutCmd(TestPropertySetterValueCmd):
2409
class TestSetTimeoutCmd(TestPropertySetterCmd):
1803
2410
command = command.SetTimeout
1804
2411
propname = "Timeout"
1805
2412
values_to_set = [datetime.timedelta(),
1810
2417
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1811
2418
1812
2419
1813
class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):
2420
class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):
1814
2421
command = command.SetExtendedTimeout
1815
2422
propname = "ExtendedTimeout"
1816
2423
values_to_set = [datetime.timedelta(),
1821
2428
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1822
2429
1823
2430
1824
class TestSetIntervalCmd(TestPropertySetterValueCmd):
2431
class TestSetIntervalCmd(TestPropertySetterCmd):
1825
2432
command = command.SetInterval
1826
2433
propname = "Interval"
1827
2434
values_to_set = [datetime.timedelta(),
1832
2439
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1833
2440
1834
2441
1835
class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):
2442
class TestSetApprovalDelayCmd(TestPropertySetterCmd):
1836
2443
command = command.SetApprovalDelay
1837
2444
propname = "ApprovalDelay"
1838
2445
values_to_set = [datetime.timedelta(),
1843
2450
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1844
2451
1845
2452
1846
class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):
2453
class TestSetApprovalDurationCmd(TestPropertySetterCmd):
1847
2454
command = command.SetApprovalDuration
1848
2455
propname = "ApprovalDuration"
1849
2456
values_to_set = [datetime.timedelta(),
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0