274
## Classes for commands.
276
# Abstract classes first
277
class Command(object):
278
"""Abstract class for commands"""
279
def run(self, mandos, clients):
280
"""Normal commands should implement run_on_one_client(), but
281
commands which want to operate on all clients at the same time
282
can override this run() method instead."""
284
for client, properties in clients.items():
285
self.run_on_one_client(client, properties)
287
class PrintCmd(Command):
288
"""Abstract class for commands printing client details"""
289
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
290
"Created", "Interval", "Host", "KeyID",
291
"Fingerprint", "CheckerRunning", "LastEnabled",
292
"ApprovalPending", "ApprovedByDefault",
293
"LastApprovalRequest", "ApprovalDelay",
294
"ApprovalDuration", "Checker", "ExtendedTimeout",
295
"Expires", "LastCheckerStatus")
296
def run(self, mandos, clients):
297
print(self.output(clients.values()))
299
class PropertyCmd(Command):
300
"""Abstract class for Actions for setting one client property"""
301
def run_on_one_client(self, client, properties):
302
"""Set the Client's D-Bus property"""
303
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
304
client.__dbus_object_path__,
305
dbus.PROPERTIES_IFACE, client_interface,
306
self.propname, self.value_to_set
307
if not isinstance(self.value_to_set, dbus.Boolean)
308
else bool(self.value_to_set))
309
client.Set(client_interface, self.propname, self.value_to_set,
310
dbus_interface=dbus.PROPERTIES_IFACE)
312
class ValueArgumentMixIn(object):
313
"""Mixin class for commands taking a value as argument"""
314
def __init__(self, value):
315
self.value_to_set = value
317
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
318
"""Mixin class for commands taking a value argument as
321
def value_to_set(self):
324
def value_to_set(self, value):
325
"""When setting, convert value to a datetime.timedelta"""
326
self._vts = int(round(value.total_seconds() * 1000))
328
# Actual (non-abstract) command classes
330
class PrintTableCmd(PrintCmd):
331
def __init__(self, verbose=False):
332
self.verbose = verbose
334
def output(self, clients):
335
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
336
keywords = default_keywords
338
keywords = self.all_keywords
339
return str(self.TableOfClients(clients, keywords))
341
class TableOfClients(object):
344
"Enabled": "Enabled",
345
"Timeout": "Timeout",
346
"LastCheckedOK": "Last Successful Check",
347
"LastApprovalRequest": "Last Approval Request",
348
"Created": "Created",
349
"Interval": "Interval",
351
"Fingerprint": "Fingerprint",
353
"CheckerRunning": "Check Is Running",
354
"LastEnabled": "Last Enabled",
355
"ApprovalPending": "Approval Is Pending",
356
"ApprovedByDefault": "Approved By Default",
357
"ApprovalDelay": "Approval Delay",
358
"ApprovalDuration": "Approval Duration",
359
"Checker": "Checker",
360
"ExtendedTimeout": "Extended Timeout",
361
"Expires": "Expires",
362
"LastCheckerStatus": "Last Checker Status",
365
def __init__(self, clients, keywords, tableheaders=None):
366
self.clients = clients
367
self.keywords = keywords
368
if tableheaders is not None:
369
self.tableheaders = tableheaders
372
return "\n".join(self.rows())
374
if sys.version_info.major == 2:
375
__unicode__ = __str__
377
return str(self).encode(locale.getpreferredencoding())
380
format_string = self.row_formatting_string()
381
rows = [self.header_line(format_string)]
382
rows.extend(self.client_line(client, format_string)
383
for client in self.clients)
386
def row_formatting_string(self):
387
"Format string used to format table rows"
388
return " ".join("{{{key}:{width}}}".format(
389
width=max(len(self.tableheaders[key]),
390
*(len(self.string_from_client(client, key))
391
for client in self.clients)),
393
for key in self.keywords)
395
def string_from_client(self, client, key):
396
return self.valuetostring(client[key], key)
399
def valuetostring(value, keyword):
400
if isinstance(value, dbus.Boolean):
401
return "Yes" if value else "No"
402
if keyword in ("Timeout", "Interval", "ApprovalDelay",
403
"ApprovalDuration", "ExtendedTimeout"):
404
return milliseconds_to_string(value)
407
def header_line(self, format_string):
408
return format_string.format(**self.tableheaders)
410
def client_line(self, client, format_string):
411
return format_string.format(
412
**{key: self.string_from_client(client, key)
413
for key in self.keywords})
417
class DumpJSONCmd(PrintCmd):
418
def output(self, clients):
419
data = {client["Name"]:
420
{key: self.dbus_boolean_to_bool(client[key])
421
for key in self.all_keywords}
422
for client in clients.values()}
423
return json.dumps(data, indent=4, separators=(',', ': '))
425
def dbus_boolean_to_bool(value):
426
if isinstance(value, dbus.Boolean):
430
class IsEnabledCmd(Command):
431
def run_on_one_client(self, client, properties):
432
if self.is_enabled(client, properties):
435
def is_enabled(self, client, properties):
436
log.debug("D-Bus: %s:%s:%s.Get(%r, %r)", busname,
437
client.__dbus_object_path__,
438
dbus.PROPERTIES_IFACE, client_interface,
440
return bool(client.Get(client_interface, "Enabled",
441
dbus_interface=dbus.PROPERTIES_IFACE))
443
class RemoveCmd(Command):
444
def run_on_one_client(self, client, properties):
445
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", busname,
446
server_path, server_interface,
447
str(client.__dbus_object_path__))
448
self.mandos.RemoveClient(client.__dbus_object_path__)
450
class ApproveCmd(Command):
451
def run_on_one_client(self, client, properties):
452
log.debug("D-Bus: %s:%s.Approve(True)",
453
client.__dbus_object_path__, client_interface)
454
client.Approve(dbus.Boolean(True),
455
dbus_interface=client_interface)
457
class DenyCmd(Command):
458
def run_on_one_client(self, client, properties):
459
log.debug("D-Bus: %s:%s.Approve(False)",
460
client.__dbus_object_path__, client_interface)
461
client.Approve(dbus.Boolean(False),
462
dbus_interface=client_interface)
464
class EnableCmd(PropertyCmd):
466
value_to_set = dbus.Boolean(True)
468
class DisableCmd(PropertyCmd):
470
value_to_set = dbus.Boolean(False)
472
class BumpTimeoutCmd(PropertyCmd):
473
propname = "LastCheckedOK"
476
class StartCheckerCmd(PropertyCmd):
477
propname = "CheckerRunning"
478
value_to_set = dbus.Boolean(True)
480
class StopCheckerCmd(PropertyCmd):
481
propname = "CheckerRunning"
482
value_to_set = dbus.Boolean(False)
484
class ApproveByDefaultCmd(PropertyCmd):
485
propname = "ApprovedByDefault"
486
value_to_set = dbus.Boolean(True)
488
class DenyByDefaultCmd(PropertyCmd):
489
propname = "ApprovedByDefault"
490
value_to_set = dbus.Boolean(False)
492
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
495
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
498
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
501
def value_to_set(self):
504
def value_to_set(self, value):
505
"""When setting, read data from supplied file object"""
506
self._vts = value.read()
509
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
512
class SetExtendedTimeoutCmd(PropertyCmd,
513
MillisecondsValueArgumentMixIn):
514
propname = "ExtendedTimeout"
516
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
517
propname = "Interval"
519
class SetApprovalDelayCmd(PropertyCmd,
520
MillisecondsValueArgumentMixIn):
521
propname = "ApprovalDelay"
523
class SetApprovalDurationCmd(PropertyCmd,
524
MillisecondsValueArgumentMixIn):
525
propname = "ApprovalDuration"
527
def add_command_line_options(parser):
528
parser.add_argument("--version", action="version",
529
version="%(prog)s {}".format(version),
530
help="show version number and exit")
531
parser.add_argument("-a", "--all", action="store_true",
532
help="Select all clients")
533
parser.add_argument("-v", "--verbose", action="store_true",
534
help="Print all fields")
535
parser.add_argument("-j", "--dump-json", action="store_true",
536
help="Dump client data in JSON format")
537
enable_disable = parser.add_mutually_exclusive_group()
538
enable_disable.add_argument("-e", "--enable", action="store_true",
539
help="Enable client")
540
enable_disable.add_argument("-d", "--disable",
542
help="disable client")
543
parser.add_argument("-b", "--bump-timeout", action="store_true",
544
help="Bump timeout for client")
545
start_stop_checker = parser.add_mutually_exclusive_group()
546
start_stop_checker.add_argument("--start-checker",
548
help="Start checker for client")
549
start_stop_checker.add_argument("--stop-checker",
551
help="Stop checker for client")
552
parser.add_argument("-V", "--is-enabled", action="store_true",
553
help="Check if client is enabled")
554
parser.add_argument("-r", "--remove", action="store_true",
555
help="Remove client")
556
parser.add_argument("-c", "--checker",
557
help="Set checker command for client")
558
parser.add_argument("-t", "--timeout", type=string_to_delta,
559
help="Set timeout for client")
560
parser.add_argument("--extended-timeout", type=string_to_delta,
561
help="Set extended timeout for client")
562
parser.add_argument("-i", "--interval", type=string_to_delta,
563
help="Set checker interval for client")
564
approve_deny_default = parser.add_mutually_exclusive_group()
565
approve_deny_default.add_argument(
566
"--approve-by-default", action="store_true",
567
default=None, dest="approved_by_default",
568
help="Set client to be approved by default")
569
approve_deny_default.add_argument(
570
"--deny-by-default", action="store_false",
571
dest="approved_by_default",
572
help="Set client to be denied by default")
573
parser.add_argument("--approval-delay", type=string_to_delta,
574
help="Set delay before client approve/deny")
575
parser.add_argument("--approval-duration", type=string_to_delta,
576
help="Set duration of one client approval")
577
parser.add_argument("-H", "--host", help="Set host for client")
578
parser.add_argument("-s", "--secret",
579
type=argparse.FileType(mode="rb"),
580
help="Set password blob (file) for client")
581
approve_deny = parser.add_mutually_exclusive_group()
582
approve_deny.add_argument(
583
"-A", "--approve", action="store_true",
584
help="Approve any current client request")
585
approve_deny.add_argument("-D", "--deny", action="store_true",
586
help="Deny any current client request")
587
parser.add_argument("--debug", action="store_true",
588
help="Debug mode (show D-Bus commands)")
589
parser.add_argument("--check", action="store_true",
590
help="Run self-test")
591
parser.add_argument("client", nargs="*", help="Client name")
594
def commands_from_options(options):
598
if options.dump_json:
599
commands.append(DumpJSONCmd())
602
commands.append(EnableCmd())
605
commands.append(DisableCmd())
607
if options.bump_timeout:
608
commands.append(BumpTimeoutCmd())
610
if options.start_checker:
611
commands.append(StartCheckerCmd())
613
if options.stop_checker:
614
commands.append(StopCheckerCmd())
616
if options.is_enabled:
617
commands.append(IsEnabledCmd())
619
if options.checker is not None:
620
commands.append(SetCheckerCmd(options.checker))
622
if options.timeout is not None:
623
commands.append(SetTimeoutCmd(options.timeout))
625
if options.extended_timeout:
627
SetExtendedTimeoutCmd(options.extended_timeout))
629
if options.interval is not None:
630
commands.append(SetIntervalCmd(options.interval))
632
if options.approved_by_default is not None:
633
if options.approved_by_default:
634
commands.append(ApproveByDefaultCmd())
636
commands.append(DenyByDefaultCmd())
638
if options.approval_delay is not None:
639
commands.append(SetApprovalDelayCmd(options.approval_delay))
641
if options.approval_duration is not None:
643
SetApprovalDurationCmd(options.approval_duration))
645
if options.host is not None:
646
commands.append(SetHostCmd(options.host))
648
if options.secret is not None:
649
commands.append(SetSecretCmd(options.secret))
652
commands.append(ApproveCmd())
655
commands.append(DenyCmd())
658
commands.append(RemoveCmd())
660
# If no command option has been given, show table of clients,
661
# optionally verbosely
663
commands.append(PrintTableCmd(verbose=options.verbose))
437
668
def check_option_syntax(parser, options):
438
669
"""Apply additional restrictions on options, not expressible in
441
def has_commands(options, commands=None):
443
commands = (command.Enable,
446
command.StartChecker,
452
command.SetExtendedTimeout,
454
command.ApproveByDefault,
455
command.DenyByDefault,
456
command.SetApprovalDelay,
457
command.SetApprovalDuration,
462
return any(isinstance(cmd, commands)
463
for cmd in options.commands)
672
def has_actions(options):
673
return any((options.enable,
675
options.bump_timeout,
676
options.start_checker,
677
options.stop_checker,
680
options.checker is not None,
681
options.timeout is not None,
682
options.extended_timeout is not None,
683
options.interval is not None,
684
options.approved_by_default is not None,
685
options.approval_delay is not None,
686
options.approval_duration is not None,
687
options.host is not None,
688
options.secret is not None,
465
if has_commands(options) and not (options.client or options.all):
692
if has_actions(options) and not (options.client or options.all):
466
693
parser.error("Options require clients names or --all.")
467
if options.verbose and has_commands(options):
694
if options.verbose and has_actions(options):
468
695
parser.error("--verbose can only be used alone.")
469
if (has_commands(options, (command.DumpJSON,))
470
and (options.verbose or len(options.commands) > 1)):
696
if options.dump_json and (options.verbose
697
or has_actions(options)):
471
698
parser.error("--dump-json can only be used alone.")
472
if options.all and not has_commands(options):
699
if options.all and not has_actions(options):
473
700
parser.error("--all requires an action.")
474
if (has_commands(options, (command.IsEnabled,))
475
and len(options.client) > 1):
701
if options.is_enabled and len(options.client) > 1:
476
702
parser.error("--is-enabled requires exactly one client")
477
if (len(options.commands) > 1
478
and has_commands(options, (command.Remove,))
479
and not has_commands(options, (command.Deny,))):
480
parser.error("--remove can only be combined with --deny")
487
object_manager_iface = "org.freedesktop.DBus.ObjectManager"
488
def get_managed_objects(self, busname, objectpath):
489
return self.call_method("GetManagedObjects", busname,
491
self.object_manager_iface)
493
properties_iface = "org.freedesktop.DBus.Properties"
494
def set_property(self, busname, objectpath, interface, key,
496
self.call_method("Set", busname, objectpath,
497
self.properties_iface, interface, key,
500
def call_method(self, methodname, busname, objectpath,
502
raise NotImplementedError()
505
class MandosBus(SystemBus):
506
busname_domain = "se.recompile"
507
busname = busname_domain + ".Mandos"
509
server_interface = busname_domain + ".Mandos"
510
client_interface = busname_domain + ".Mandos.Client"
513
def get_clients_and_properties(self):
514
managed_objects = self.get_managed_objects(
515
self.busname, self.server_path)
516
return {objpath: properties[self.client_interface]
517
for objpath, properties in managed_objects.items()
518
if self.client_interface in properties}
520
def set_client_property(self, objectpath, key, value):
521
return self.set_property(self.busname, objectpath,
522
self.client_interface, key,
525
def call_client_method(self, objectpath, method, *args):
526
return self.call_method(method, self.busname, objectpath,
527
self.client_interface, *args)
529
def call_server_method(self, method, *args):
530
return self.call_method(method, self.busname,
532
self.server_interface, *args)
534
class Error(Exception):
537
class ConnectFailed(Error):
541
class dbus_python_adapter:
543
class SystemBus(dbus.MandosBus):
544
"""Use dbus-python"""
546
def __init__(self, module=dbus_python):
547
self.dbus_python = module
548
self.bus = self.dbus_python.SystemBus()
550
@contextlib.contextmanager
551
def convert_exception(self, exception_class=dbus.Error):
554
except self.dbus_python.exceptions.DBusException as e:
555
# This does what "raise from" would do
556
exc = exception_class(*e.args)
560
def call_method(self, methodname, busname, objectpath,
562
proxy_object = self.get_object(busname, objectpath)
563
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
564
interface, methodname,
565
", ".join(repr(a) for a in args))
566
method = getattr(proxy_object, methodname)
567
with self.convert_exception():
568
with dbus_python_adapter.SilenceLogger(
570
value = method(*args, dbus_interface=interface)
571
return self.type_filter(value)
573
def get_object(self, busname, objectpath):
574
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
576
with self.convert_exception(dbus.ConnectFailed):
577
return self.bus.get_object(busname, objectpath)
579
def type_filter(self, value):
580
"""Convert the most bothersome types to Python types"""
581
if isinstance(value, self.dbus_python.Boolean):
583
if isinstance(value, self.dbus_python.ObjectPath):
585
# Also recurse into dictionaries
586
if isinstance(value, self.dbus_python.Dictionary):
587
return {self.type_filter(key):
588
self.type_filter(subval)
589
for key, subval in value.items()}
592
def set_client_property(self, objectpath, key, value):
594
if not isinstance(value, bytes):
595
value = value.encode("utf-8")
596
value = self.dbus_python.ByteArray(value)
597
return self.set_property(self.busname, objectpath,
598
self.client_interface, key,
602
"Simple context manager to silence a particular logger"
603
def __init__(self, loggername):
604
self.logger = logging.getLogger(loggername)
607
self.logger.addFilter(self.nullfilter)
609
class NullFilter(logging.Filter):
610
def filter(self, record):
613
nullfilter = NullFilter()
615
def __exit__(self, exc_type, exc_val, exc_tb):
616
self.logger.removeFilter(self.nullfilter)
619
class CachingBus(SystemBus):
620
"""A caching layer for dbus_python_adapter.SystemBus"""
621
def __init__(self, *args, **kwargs):
622
self.object_cache = {}
623
super(dbus_python_adapter.CachingBus,
624
self).__init__(*args, **kwargs)
625
def get_object(self, busname, objectpath):
627
return self.object_cache[(busname, objectpath)]
630
dbus_python_adapter.CachingBus,
631
self).get_object(busname, objectpath)
632
self.object_cache[(busname, objectpath)] = new_object
636
class pydbus_adapter:
637
class SystemBus(dbus.MandosBus):
638
def __init__(self, module=pydbus):
640
self.bus = self.pydbus.SystemBus()
642
@contextlib.contextmanager
643
def convert_exception(self, exception_class=dbus.Error):
646
except gi.repository.GLib.Error as e:
647
# This does what "raise from" would do
648
exc = exception_class(*e.args)
652
def call_method(self, methodname, busname, objectpath,
654
proxy_object = self.get(busname, objectpath)
655
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
656
interface, methodname,
657
", ".join(repr(a) for a in args))
658
method = getattr(proxy_object[interface], methodname)
659
with self.convert_exception():
662
def get(self, busname, objectpath):
663
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
665
with self.convert_exception(dbus.ConnectFailed):
666
if sys.version_info.major <= 2:
667
with warnings.catch_warnings():
668
warnings.filterwarnings(
669
"ignore", "", DeprecationWarning,
670
r"^xml\.etree\.ElementTree$")
671
return self.bus.get(busname, objectpath)
673
return self.bus.get(busname, objectpath)
675
def set_property(self, busname, objectpath, interface, key,
677
proxy_object = self.get(busname, objectpath)
678
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
679
objectpath, self.properties_iface, interface,
681
setattr(proxy_object[interface], key, value)
683
class CachingBus(SystemBus):
684
"""A caching layer for pydbus_adapter.SystemBus"""
685
def __init__(self, *args, **kwargs):
686
self.object_cache = {}
687
super(pydbus_adapter.CachingBus,
688
self).__init__(*args, **kwargs)
689
def get(self, busname, objectpath):
691
return self.object_cache[(busname, objectpath)]
693
new_object = (super(pydbus_adapter.CachingBus, self)
694
.get(busname, objectpath))
695
self.object_cache[(busname, objectpath)] = new_object
699
class dbussy_adapter:
700
class SystemBus(dbus.SystemBus):
703
def __init__(self, dbussy, ravel):
706
self.bus = ravel.system_bus()
708
@contextlib.contextmanager
709
def convert_exception(self, exception_class=dbus.Error):
712
except self.dbussy.DBusError as e:
713
# This does what "raise from" would do
714
exc = exception_class(*e.args)
718
def call_method(self, methodname, busname, objectpath,
720
proxy_object = self.get_object(busname, objectpath)
721
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
722
interface, methodname,
723
", ".join(repr(a) for a in args))
724
iface = proxy_object.get_interface(interface)
725
method = getattr(iface, methodname)
726
with self.convert_exception(dbus.Error):
727
value = method(*args)
728
# DBussy returns values either as an empty list or as a
729
# list of one element with the return value
731
return self.type_filter(value[0])
733
def get_object(self, busname, objectpath):
734
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
736
with self.convert_exception(dbus.ConnectFailed):
737
return self.bus[busname][objectpath]
739
def type_filter(self, value):
740
"""Convert the most bothersome types to Python types"""
741
# A D-Bus Variant value is represented as the Python type
742
# Tuple[dbussy.DBUS.Signature, Any]
743
if isinstance(value, tuple):
745
and isinstance(value[0],
746
self.dbussy.DBUS.Signature)):
747
return self.type_filter(value[1])
748
elif isinstance(value, self.dbussy.DBUS.ObjectPath):
750
# Also recurse into dictionaries
751
elif isinstance(value, dict):
752
return {self.type_filter(key):
753
self.type_filter(subval)
754
for key, subval in value.items()}
757
def set_property(self, busname, objectpath, interface, key,
759
proxy_object = self.get_object(busname, objectpath)
760
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
761
objectpath, self.properties_iface, interface,
764
# DBussy wants a Byte Array to be a sequence of
765
# values, not a byte string
767
setattr(proxy_object.get_interface(interface), key, value)
769
class MandosBus(SystemBus, dbus.MandosBus):
772
class CachingBus(MandosBus):
773
"""A caching layer for dbussy_adapter.MandosBus"""
774
def __init__(self, *args, **kwargs):
775
self.object_cache = {}
776
super(dbussy_adapter.CachingBus, self).__init__(*args,
778
def get_object(self, busname, objectpath):
780
return self.object_cache[(busname, objectpath)]
783
dbussy_adapter.CachingBus,
784
self).get_object(busname, objectpath)
785
self.object_cache[(busname, objectpath)] = new_object
789
def commands_from_options(options):
791
commands = list(options.commands)
793
def find_cmd(cmd, commands):
795
for i, c in enumerate(commands):
796
if isinstance(c, cmd):
800
# If command.Remove is present, move any instances of command.Deny
801
# to occur ahead of command.Remove.
802
index_of_remove = find_cmd(command.Remove, commands)
803
before_remove = commands[:index_of_remove]
804
after_remove = commands[index_of_remove:]
806
for cmd in after_remove:
807
if isinstance(cmd, command.Deny):
808
before_remove.append(cmd)
810
cleaned_after.append(cmd)
811
if cleaned_after != after_remove:
812
commands = before_remove + cleaned_after
814
# If no command option has been given, show table of clients,
815
# optionally verbosely
817
commands.append(command.PrintTable(verbose=options.verbose))
823
"""A namespace for command classes"""
826
"""Abstract base class for commands"""
827
def run(self, clients, bus=None):
828
"""Normal commands should implement run_on_one_client(),
829
but commands which want to operate on all clients at the same time can
830
override this run() method instead.
833
for client, properties in clients.items():
834
self.run_on_one_client(client, properties)
837
class IsEnabled(Base):
838
def run(self, clients, bus=None):
839
properties = next(iter(clients.values()))
840
if properties["Enabled"]:
846
def run_on_one_client(self, client, properties):
847
self.bus.call_client_method(client, "Approve", True)
851
def run_on_one_client(self, client, properties):
852
self.bus.call_client_method(client, "Approve", False)
856
def run(self, clients, bus):
857
for clientpath in frozenset(clients.keys()):
858
bus.call_server_method("RemoveClient", clientpath)
862
"""Abstract class for commands outputting client details"""
863
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
864
"Created", "Interval", "Host", "KeyID",
865
"Fingerprint", "CheckerRunning",
866
"LastEnabled", "ApprovalPending",
867
"ApprovedByDefault", "LastApprovalRequest",
868
"ApprovalDelay", "ApprovalDuration",
869
"Checker", "ExtendedTimeout", "Expires",
873
class DumpJSON(Output):
874
def run(self, clients, bus=None):
875
data = {properties["Name"]:
876
{key: properties[key]
877
for key in self.all_keywords}
878
for properties in clients.values()}
879
print(json.dumps(data, indent=4, separators=(",", ": ")))
882
class PrintTable(Output):
883
def __init__(self, verbose=False):
884
self.verbose = verbose
886
def run(self, clients, bus=None):
887
default_keywords = ("Name", "Enabled", "Timeout",
889
keywords = default_keywords
891
keywords = self.all_keywords
892
print(self.TableOfClients(clients.values(), keywords))
894
class TableOfClients:
897
"Enabled": "Enabled",
898
"Timeout": "Timeout",
899
"LastCheckedOK": "Last Successful Check",
900
"LastApprovalRequest": "Last Approval Request",
901
"Created": "Created",
902
"Interval": "Interval",
904
"Fingerprint": "Fingerprint",
906
"CheckerRunning": "Check Is Running",
907
"LastEnabled": "Last Enabled",
908
"ApprovalPending": "Approval Is Pending",
909
"ApprovedByDefault": "Approved By Default",
910
"ApprovalDelay": "Approval Delay",
911
"ApprovalDuration": "Approval Duration",
912
"Checker": "Checker",
913
"ExtendedTimeout": "Extended Timeout",
914
"Expires": "Expires",
915
"LastCheckerStatus": "Last Checker Status",
918
def __init__(self, clients, keywords):
919
self.clients = clients
920
self.keywords = keywords
923
return "\n".join(self.rows())
925
if sys.version_info.major == 2:
926
__unicode__ = __str__
928
return str(self).encode(
929
locale.getpreferredencoding())
932
format_string = self.row_formatting_string()
933
rows = [self.header_line(format_string)]
934
rows.extend(self.client_line(client, format_string)
935
for client in self.clients)
938
def row_formatting_string(self):
939
"Format string used to format table rows"
940
return " ".join("{{{key}:{width}}}".format(
941
width=max(len(self.tableheaders[key]),
942
*(len(self.string_from_client(client,
944
for client in self.clients)),
946
for key in self.keywords)
948
def string_from_client(self, client, key):
949
return self.valuetostring(client[key], key)
952
def valuetostring(cls, value, keyword):
953
if isinstance(value, bool):
954
return "Yes" if value else "No"
955
if keyword in ("Timeout", "Interval", "ApprovalDelay",
956
"ApprovalDuration", "ExtendedTimeout"):
957
return cls.milliseconds_to_string(value)
960
def header_line(self, format_string):
961
return format_string.format(**self.tableheaders)
963
def client_line(self, client, format_string):
964
return format_string.format(
965
**{key: self.string_from_client(client, key)
966
for key in self.keywords})
969
def milliseconds_to_string(ms):
970
td = datetime.timedelta(0, 0, 0, ms)
971
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
972
.format(days="{}T".format(td.days)
974
hours=td.seconds // 3600,
975
minutes=(td.seconds % 3600) // 60,
976
seconds=td.seconds % 60))
979
class PropertySetter(Base):
980
"Abstract class for Actions for setting one client property"
982
def run_on_one_client(self, client, properties=None):
983
"""Set the Client's D-Bus property"""
984
self.bus.set_client_property(client, self.propname,
989
raise NotImplementedError()
992
class Enable(PropertySetter):
997
class Disable(PropertySetter):
1002
class BumpTimeout(PropertySetter):
1003
propname = "LastCheckedOK"
1007
class StartChecker(PropertySetter):
1008
propname = "CheckerRunning"
1012
class StopChecker(PropertySetter):
1013
propname = "CheckerRunning"
1014
value_to_set = False
1017
class ApproveByDefault(PropertySetter):
1018
propname = "ApprovedByDefault"
1022
class DenyByDefault(PropertySetter):
1023
propname = "ApprovedByDefault"
1024
value_to_set = False
1027
class PropertySetterValue(PropertySetter):
1028
"""Abstract class for PropertySetter recieving a value as
1029
constructor argument instead of a class attribute."""
1030
def __init__(self, value):
1031
self.value_to_set = value
1034
def argparse(cls, argtype):
1036
return cls(argtype(arg))
1039
class SetChecker(PropertySetterValue):
1040
propname = "Checker"
1043
class SetHost(PropertySetterValue):
1047
class SetSecret(PropertySetterValue):
1051
def value_to_set(self):
1054
@value_to_set.setter
1055
def value_to_set(self, value):
1056
"""When setting, read data from supplied file object"""
1057
self._vts = value.read()
1061
class PropertySetterValueMilliseconds(PropertySetterValue):
1062
"""Abstract class for PropertySetterValue taking a value
1063
argument as a datetime.timedelta() but should store it as
1067
def value_to_set(self):
1070
@value_to_set.setter
1071
def value_to_set(self, value):
1072
"When setting, convert value from a datetime.timedelta"
1073
self._vts = int(round(value.total_seconds() * 1000))
1076
class SetTimeout(PropertySetterValueMilliseconds):
1077
propname = "Timeout"
1080
class SetExtendedTimeout(PropertySetterValueMilliseconds):
1081
propname = "ExtendedTimeout"
1084
class SetInterval(PropertySetterValueMilliseconds):
1085
propname = "Interval"
1088
class SetApprovalDelay(PropertySetterValueMilliseconds):
1089
propname = "ApprovalDelay"
1092
class SetApprovalDuration(PropertySetterValueMilliseconds):
1093
propname = "ApprovalDuration"
704
options.remove = False
705
if has_actions(options) and not options.deny:
706
parser.error("--remove can only be combined with --deny")
707
options.remove = True
711
parser = argparse.ArgumentParser()
713
add_command_line_options(parser)
715
options = parser.parse_args()
717
check_option_syntax(parser, options)
719
clientnames = options.client
722
log.setLevel(logging.DEBUG)
725
bus = dbus.SystemBus()
726
log.debug("D-Bus: Connect to: (name=%r, path=%r)", busname,
728
mandos_dbus_objc = bus.get_object(busname, server_path)
729
except dbus.exceptions.DBusException:
730
log.critical("Could not connect to Mandos server")
733
mandos_serv = dbus.Interface(mandos_dbus_objc,
734
dbus_interface=server_interface)
735
mandos_serv_object_manager = dbus.Interface(
736
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
738
# Filter out log message from dbus module
739
dbus_logger = logging.getLogger("dbus.proxies")
740
class NullFilter(logging.Filter):
741
def filter(self, record):
743
dbus_filter = NullFilter()
745
dbus_logger.addFilter(dbus_filter)
746
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", busname,
747
server_path, dbus.OBJECT_MANAGER_IFACE)
748
mandos_clients = {path: ifs_and_props[client_interface]
749
for path, ifs_and_props in
750
mandos_serv_object_manager
751
.GetManagedObjects().items()
752
if client_interface in ifs_and_props}
753
except dbus.exceptions.DBusException as e:
754
log.critical("Failed to access Mandos server through D-Bus:"
758
# restore dbus logger
759
dbus_logger.removeFilter(dbus_filter)
761
# Compile dict of (clients: properties) to process
765
clients = {(log.debug("D-Bus: Connect to: (name=%r, path=%r)",
766
busname, str(path)) and False) or
767
bus.get_object(busname, path): properties
768
for path, properties in mandos_clients.items()}
770
for name in clientnames:
771
for path, client in mandos_clients.items():
772
if client["Name"] == name:
773
log.debug("D-Bus: Connect to: (name=%r, path=%r)",
775
client_objc = bus.get_object(busname, path)
776
clients[client_objc] = client
779
log.critical("Client not found on server: %r", name)
782
# Run all commands on clients
783
commands = commands_from_options(options)
784
for command in commands:
785
command.run(mandos_serv, clients)
1097
class TestCaseWithAssertLogs(unittest.TestCase):
1098
"""unittest.TestCase.assertLogs only exists in Python 3.4"""
1100
if not hasattr(unittest.TestCase, "assertLogs"):
1101
@contextlib.contextmanager
1102
def assertLogs(self, logger, level=logging.INFO):
1103
capturing_handler = self.CapturingLevelHandler(level)
1104
old_level = logger.level
1105
old_propagate = logger.propagate
1106
logger.addHandler(capturing_handler)
1107
logger.setLevel(level)
1108
logger.propagate = False
1110
yield capturing_handler.watcher
1112
logger.propagate = old_propagate
1113
logger.removeHandler(capturing_handler)
1114
logger.setLevel(old_level)
1115
self.assertGreater(len(capturing_handler.watcher.records),
1118
class CapturingLevelHandler(logging.Handler):
1119
def __init__(self, level, *args, **kwargs):
1120
logging.Handler.__init__(self, *args, **kwargs)
1121
self.watcher = self.LoggingWatcher([], [])
1122
def emit(self, record):
1123
self.watcher.records.append(record)
1124
self.watcher.output.append(self.format(record))
1126
LoggingWatcher = collections.namedtuple("LoggingWatcher",
1132
"""Class for objects which exist only to be unique objects, since
1133
unittest.mock.sentinel only exists in Python 3.3"""
1136
class Test_string_to_delta(TestCaseWithAssertLogs):
1137
# Just test basic RFC 3339 functionality here, the doc string for
1138
# rfc3339_duration_to_delta() already has more comprehensive
1139
# tests, which are run by doctest.
1141
def test_rfc3339_zero_seconds(self):
1142
self.assertEqual(datetime.timedelta(),
1143
string_to_delta("PT0S"))
1145
def test_rfc3339_zero_days(self):
1146
self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))
1148
def test_rfc3339_one_second(self):
1149
self.assertEqual(datetime.timedelta(0, 1),
1150
string_to_delta("PT1S"))
1152
def test_rfc3339_two_hours(self):
1153
self.assertEqual(datetime.timedelta(0, 7200),
1154
string_to_delta("PT2H"))
788
class Test_milliseconds_to_string(unittest.TestCase):
790
self.assertEqual(milliseconds_to_string(93785000),
792
def test_no_days(self):
793
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
794
def test_all_zero(self):
795
self.assertEqual(milliseconds_to_string(0), "00:00:00")
796
def test_no_fractional_seconds(self):
797
self.assertEqual(milliseconds_to_string(400), "00:00:00")
798
self.assertEqual(milliseconds_to_string(900), "00:00:00")
799
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
801
class Test_string_to_delta(unittest.TestCase):
802
def test_handles_basic_rfc3339(self):
803
self.assertEqual(string_to_delta("PT0S"),
804
datetime.timedelta())
805
self.assertEqual(string_to_delta("P0D"),
806
datetime.timedelta())
807
self.assertEqual(string_to_delta("PT1S"),
808
datetime.timedelta(0, 1))
809
self.assertEqual(string_to_delta("PT2H"),
810
datetime.timedelta(0, 7200))
1156
811
def test_falls_back_to_pre_1_6_1_with_warning(self):
1157
with self.assertLogs(log, logging.WARNING):
1158
value = string_to_delta("2h")
1159
self.assertEqual(datetime.timedelta(0, 7200), value)
1162
class Test_check_option_syntax(unittest.TestCase):
1164
self.parser = argparse.ArgumentParser()
1165
add_command_line_options(self.parser)
1167
def test_actions_requires_client_or_all(self):
1168
for action, value in self.actions.items():
1169
args = self.actionargs(action, value)
1170
with self.assertParseError():
1171
self.parse_args(args)
1173
# This mostly corresponds to the definition from has_commands() in
1174
# check_option_syntax()
1178
"--bump-timeout": None,
1179
"--start-checker": None,
1180
"--stop-checker": None,
1181
"--is-enabled": None,
1184
"--timeout": "PT0S",
1185
"--extended-timeout": "PT0S",
1186
"--interval": "PT0S",
1187
"--approve-by-default": None,
1188
"--deny-by-default": None,
1189
"--approval-delay": "PT0S",
1190
"--approval-duration": "PT0S",
1191
"--host": "hostname",
1192
"--secret": "/dev/null",
1198
def actionargs(action, value, *args):
1199
if value is not None:
1200
return [action, value] + list(args)
812
# assertLogs only exists in Python 3.4
813
if hasattr(self, "assertLogs"):
814
with self.assertLogs(log, logging.WARNING):
815
value = string_to_delta("2h")
1202
return [action] + list(args)
1204
@contextlib.contextmanager
1205
def assertParseError(self):
1206
with self.assertRaises(SystemExit) as e:
1207
with self.redirect_stderr_to_devnull():
1209
# Exit code from argparse is guaranteed to be "2". Reference:
1210
# https://docs.python.org/3/library
1211
# /argparse.html#exiting-methods
1212
self.assertEqual(2, e.exception.code)
1214
def parse_args(self, args):
1215
options = self.parser.parse_args(args)
1216
check_option_syntax(self.parser, options)
1219
@contextlib.contextmanager
1220
def redirect_stderr_to_devnull():
1221
old_stderr = sys.stderr
1222
with contextlib.closing(open(os.devnull, "w")) as null:
817
class WarningFilter(logging.Filter):
818
"""Don't show, but record the presence of, warnings"""
819
def filter(self, record):
820
is_warning = record.levelno >= logging.WARNING
821
self.found = is_warning or getattr(self, "found",
823
return not is_warning
824
warning_filter = WarningFilter()
825
log.addFilter(warning_filter)
827
value = string_to_delta("2h")
1227
sys.stderr = old_stderr
1229
def check_option_syntax(self, options):
1230
check_option_syntax(self.parser, options)
1232
def test_actions_all_conflicts_with_verbose(self):
1233
for action, value in self.actions.items():
1234
args = self.actionargs(action, value, "--all",
1236
with self.assertParseError():
1237
self.parse_args(args)
1239
def test_actions_with_client_conflicts_with_verbose(self):
1240
for action, value in self.actions.items():
1241
args = self.actionargs(action, value, "--verbose",
1243
with self.assertParseError():
1244
self.parse_args(args)
1246
def test_dump_json_conflicts_with_verbose(self):
1247
args = ["--dump-json", "--verbose"]
1248
with self.assertParseError():
1249
self.parse_args(args)
1251
def test_dump_json_conflicts_with_action(self):
1252
for action, value in self.actions.items():
1253
args = self.actionargs(action, value, "--dump-json")
1254
with self.assertParseError():
1255
self.parse_args(args)
1257
def test_all_can_not_be_alone(self):
1259
with self.assertParseError():
1260
self.parse_args(args)
1262
def test_all_is_ok_with_any_action(self):
1263
for action, value in self.actions.items():
1264
args = self.actionargs(action, value, "--all")
1265
self.parse_args(args)
1267
def test_any_action_is_ok_with_one_client(self):
1268
for action, value in self.actions.items():
1269
args = self.actionargs(action, value, "client")
1270
self.parse_args(args)
1272
def test_one_client_with_all_actions_except_is_enabled(self):
1273
for action, value in self.actions.items():
1274
if action == "--is-enabled":
1276
args = self.actionargs(action, value, "client")
1277
self.parse_args(args)
1279
def test_two_clients_with_all_actions_except_is_enabled(self):
1280
for action, value in self.actions.items():
1281
if action == "--is-enabled":
1283
args = self.actionargs(action, value, "client1",
1285
self.parse_args(args)
1287
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1288
for action, value in self.actions.items():
1289
if action == "--is-enabled":
1291
args = self.actionargs(action, value, "client1",
1293
self.parse_args(args)
1295
def test_is_enabled_fails_without_client(self):
1296
args = ["--is-enabled"]
1297
with self.assertParseError():
1298
self.parse_args(args)
1300
def test_is_enabled_fails_with_two_clients(self):
1301
args = ["--is-enabled", "client1", "client2"]
1302
with self.assertParseError():
1303
self.parse_args(args)
1305
def test_remove_can_only_be_combined_with_action_deny(self):
1306
for action, value in self.actions.items():
1307
if action in {"--remove", "--deny"}:
1309
args = self.actionargs(action, value, "--all",
1311
with self.assertParseError():
1312
self.parse_args(args)
1315
class Test_dbus_exceptions(unittest.TestCase):
1317
def test_dbus_ConnectFailed_is_Error(self):
1318
with self.assertRaises(dbus.Error):
1319
raise dbus.ConnectFailed()
1322
class Test_dbus_MandosBus(unittest.TestCase):
1324
class MockMandosBus(dbus.MandosBus):
1326
self._name = "se.recompile.Mandos"
1327
self._server_path = "/"
1328
self._server_interface = "se.recompile.Mandos"
1329
self._client_interface = "se.recompile.Mandos.Client"
1331
self.call_method_return = Unique()
1333
def call_method(self, methodname, busname, objectpath,
1335
self.calls.append((methodname, busname, objectpath,
1337
return self.call_method_return
1340
self.bus = self.MockMandosBus()
1342
def test_set_client_property(self):
1343
self.bus.set_client_property("objectpath", "key", "value")
1344
expected_call = ("Set", self.bus._name, "objectpath",
1345
"org.freedesktop.DBus.Properties",
1346
(self.bus._client_interface, "key", "value"))
1347
self.assertIn(expected_call, self.bus.calls)
1349
def test_call_client_method(self):
1350
ret = self.bus.call_client_method("objectpath", "methodname")
1351
self.assertIs(self.bus.call_method_return, ret)
1352
expected_call = ("methodname", self.bus._name, "objectpath",
1353
self.bus._client_interface, ())
1354
self.assertIn(expected_call, self.bus.calls)
1356
def test_call_client_method_with_args(self):
1357
args = (Unique(), Unique())
1358
ret = self.bus.call_client_method("objectpath", "methodname",
1360
self.assertIs(self.bus.call_method_return, ret)
1361
expected_call = ("methodname", self.bus._name, "objectpath",
1362
self.bus._client_interface,
1364
self.assertIn(expected_call, self.bus.calls)
1366
def test_get_clients_and_properties(self):
1369
self.bus._client_interface: {
1373
"irrelevant_interface": {
1374
"key": "othervalue",
1378
"other_objectpath": {
1379
"other_irrelevant_interface": {
1385
expected_clients_and_properties = {
1391
self.bus.call_method_return = managed_objects
1392
ret = self.bus.get_clients_and_properties()
1393
self.assertDictEqual(expected_clients_and_properties, ret)
1394
expected_call = ("GetManagedObjects", self.bus._name,
1395
self.bus._server_path,
1396
"org.freedesktop.DBus.ObjectManager", ())
1397
self.assertIn(expected_call, self.bus.calls)
1399
def test_call_server_method(self):
1400
ret = self.bus.call_server_method("methodname")
1401
self.assertIs(self.bus.call_method_return, ret)
1402
expected_call = ("methodname", self.bus._name,
1403
self.bus._server_path,
1404
self.bus._server_interface, ())
1405
self.assertIn(expected_call, self.bus.calls)
1407
def test_call_server_method_with_args(self):
1408
args = (Unique(), Unique())
1409
ret = self.bus.call_server_method("methodname", *args)
1410
self.assertIs(self.bus.call_method_return, ret)
1411
expected_call = ("methodname", self.bus._name,
1412
self.bus._server_path,
1413
self.bus._server_interface,
1415
self.assertIn(expected_call, self.bus.calls)
1418
class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):
1420
def MockDBusPython_func(self, func):
1421
class mock_dbus_python:
1422
"""mock dbus-python module"""
1424
"""Pseudo-namespace"""
1425
class DBusException(Exception):
1429
def get_object(busname, objectpath):
1430
DBusObject = collections.namedtuple(
1431
"DBusObject", ("methodname", "Set"))
1432
def method(*args, **kwargs):
1433
self.assertEqual({"dbus_interface":
1437
def set_property(interface, key, value,
1438
dbus_interface=None):
1440
"org.freedesktop.DBus.Properties",
1442
self.assertEqual("Secret", key)
1443
return func(interface, key, value,
1444
dbus_interface=dbus_interface)
1445
return DBusObject(methodname=method,
1448
def __init__(self, value):
1449
self.value = bool(value)
1452
if sys.version_info.major == 2:
1453
__nonzero__ = __bool__
1454
class ObjectPath(str):
1456
class Dictionary(dict):
1458
class ByteArray(bytes):
1460
return mock_dbus_python
1462
def call_method(self, bus, methodname, busname, objectpath,
1464
with self.assertLogs(log, logging.DEBUG):
1465
return bus.call_method(methodname, busname, objectpath,
1468
def test_call_method_returns(self):
1469
expected_method_return = Unique()
1470
method_args = (Unique(), Unique())
1472
self.assertEqual(len(method_args), len(args))
1473
for marg, arg in zip(method_args, args):
1474
self.assertIs(marg, arg)
1475
return expected_method_return
1476
mock_dbus_python = self.MockDBusPython_func(func)
1477
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1478
ret = self.call_method(bus, "methodname", "busname",
1479
"objectpath", "interface",
1481
self.assertIs(ret, expected_method_return)
1483
def test_call_method_filters_bool_true(self):
1485
return method_return
1486
mock_dbus_python = self.MockDBusPython_func(func)
1487
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1488
method_return = mock_dbus_python.Boolean(True)
1489
ret = self.call_method(bus, "methodname", "busname",
1490
"objectpath", "interface")
1491
self.assertTrue(ret)
1492
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1494
def test_call_method_filters_bool_false(self):
1496
return method_return
1497
mock_dbus_python = self.MockDBusPython_func(func)
1498
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1499
method_return = mock_dbus_python.Boolean(False)
1500
ret = self.call_method(bus, "methodname", "busname",
1501
"objectpath", "interface")
1502
self.assertFalse(ret)
1503
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1505
def test_call_method_filters_objectpath(self):
1507
return method_return
1508
mock_dbus_python = self.MockDBusPython_func(func)
1509
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1510
method_return = mock_dbus_python.ObjectPath("objectpath")
1511
ret = self.call_method(bus, "methodname", "busname",
1512
"objectpath", "interface")
1513
self.assertEqual("objectpath", ret)
1514
self.assertIsNot("objectpath", ret)
1515
self.assertNotIsInstance(ret, mock_dbus_python.ObjectPath)
1517
def test_call_method_filters_booleans_in_dict(self):
1519
return method_return
1520
mock_dbus_python = self.MockDBusPython_func(func)
1521
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1522
method_return = mock_dbus_python.Dictionary(
1523
{mock_dbus_python.Boolean(True):
1524
mock_dbus_python.Boolean(False),
1525
mock_dbus_python.Boolean(False):
1526
mock_dbus_python.Boolean(True)})
1527
ret = self.call_method(bus, "methodname", "busname",
1528
"objectpath", "interface")
1529
expected_method_return = {True: False,
1531
self.assertEqual(expected_method_return, ret)
1532
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1534
def test_call_method_filters_objectpaths_in_dict(self):
1536
return method_return
1537
mock_dbus_python = self.MockDBusPython_func(func)
1538
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1539
method_return = mock_dbus_python.Dictionary(
1540
{mock_dbus_python.ObjectPath("objectpath_key_1"):
1541
mock_dbus_python.ObjectPath("objectpath_value_1"),
1542
mock_dbus_python.ObjectPath("objectpath_key_2"):
1543
mock_dbus_python.ObjectPath("objectpath_value_2")})
1544
ret = self.call_method(bus, "methodname", "busname",
1545
"objectpath", "interface")
1546
expected_method_return = {str(key): str(value)
1548
method_return.items()}
1549
self.assertEqual(expected_method_return, ret)
1550
self.assertIsInstance(ret, dict)
1551
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1553
def test_call_method_filters_dict_in_dict(self):
1555
return method_return
1556
mock_dbus_python = self.MockDBusPython_func(func)
1557
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1558
method_return = mock_dbus_python.Dictionary(
1559
{"key1": mock_dbus_python.Dictionary({"key11": "value11",
1560
"key12": "value12"}),
1561
"key2": mock_dbus_python.Dictionary({"key21": "value21",
1562
"key22": "value22"})})
1563
ret = self.call_method(bus, "methodname", "busname",
1564
"objectpath", "interface")
1565
expected_method_return = {
1566
"key1": {"key11": "value11",
1567
"key12": "value12"},
1568
"key2": {"key21": "value21",
1569
"key22": "value22"},
1571
self.assertEqual(expected_method_return, ret)
1572
self.assertIsInstance(ret, dict)
1573
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1574
for key, value in ret.items():
1575
self.assertIsInstance(value, dict)
1576
self.assertEqual(expected_method_return[key], value)
1577
self.assertNotIsInstance(value,
1578
mock_dbus_python.Dictionary)
1580
def test_call_method_filters_dict_three_deep(self):
1582
return method_return
1583
mock_dbus_python = self.MockDBusPython_func(func)
1584
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1585
method_return = mock_dbus_python.Dictionary(
1587
mock_dbus_python.Dictionary(
1589
mock_dbus_python.Dictionary(
1591
mock_dbus_python.Boolean(True),
1595
ret = self.call_method(bus, "methodname", "busname",
1596
"objectpath", "interface")
1597
expected_method_return = {"key1": {"key2": {"key3": True}}}
1598
self.assertEqual(expected_method_return, ret)
1599
self.assertIsInstance(ret, dict)
1600
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1601
self.assertIsInstance(ret["key1"], dict)
1602
self.assertNotIsInstance(ret["key1"],
1603
mock_dbus_python.Dictionary)
1604
self.assertIsInstance(ret["key1"]["key2"], dict)
1605
self.assertNotIsInstance(ret["key1"]["key2"],
1606
mock_dbus_python.Dictionary)
1607
self.assertTrue(ret["key1"]["key2"]["key3"])
1608
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
1609
mock_dbus_python.Boolean)
1611
def test_call_method_handles_exception(self):
1612
dbus_logger = logging.getLogger("dbus.proxies")
1615
dbus_logger.error("Test")
1616
raise mock_dbus_python.exceptions.DBusException()
1618
mock_dbus_python = self.MockDBusPython_func(func)
1619
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1621
class CountingHandler(logging.Handler):
1623
def emit(self, record):
1626
counting_handler = CountingHandler()
1628
dbus_logger.addHandler(counting_handler)
1631
with self.assertRaises(dbus.Error) as e:
1632
self.call_method(bus, "methodname", "busname",
1633
"objectpath", "interface")
1635
dbus_logger.removeFilter(counting_handler)
1637
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
1639
# Make sure the dbus logger was suppressed
1640
self.assertEqual(0, counting_handler.count)
1642
def test_Set_Secret_sends_bytearray(self):
1644
def func(*args, **kwargs):
1645
ret[0] = (args, kwargs)
1646
mock_dbus_python = self.MockDBusPython_func(func)
1647
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1648
bus.set_client_property("objectpath", "Secret", "value")
1649
expected_call = (("se.recompile.Mandos.Client", "Secret",
1650
mock_dbus_python.ByteArray(b"value")),
1652
"org.freedesktop.DBus.Properties"})
1653
self.assertEqual(expected_call, ret[0])
1654
if sys.version_info.major == 2:
1655
self.assertIsInstance(ret[0][0][-1],
1656
mock_dbus_python.ByteArray)
1658
def test_get_object_converts_to_correct_exception(self):
1659
bus = dbus_python_adapter.SystemBus(
1660
self.fake_dbus_python_raises_exception_on_connect)
1661
with self.assertRaises(dbus.ConnectFailed):
1662
self.call_method(bus, "methodname", "busname",
1663
"objectpath", "interface")
1665
class fake_dbus_python_raises_exception_on_connect:
1666
"""fake dbus-python module"""
1668
"""Pseudo-namespace"""
1669
class DBusException(Exception):
1674
def get_object(busname, objectpath):
1675
raise cls.exceptions.DBusException()
1676
Bus = collections.namedtuple("Bus", ["get_object"])
1677
return Bus(get_object=get_object)
1680
class Test_dbus_python_adapter_CachingBus(unittest.TestCase):
1681
class mock_dbus_python:
1682
"""mock dbus-python modules"""
1685
def get_object(busname, objectpath):
1689
self.bus = dbus_python_adapter.CachingBus(
1690
self.mock_dbus_python)
1692
def test_returns_distinct_objectpaths(self):
1693
obj1 = self.bus.get_object("busname", "objectpath1")
1694
self.assertIsInstance(obj1, Unique)
1695
obj2 = self.bus.get_object("busname", "objectpath2")
1696
self.assertIsInstance(obj2, Unique)
1697
self.assertIsNot(obj1, obj2)
1699
def test_returns_distinct_busnames(self):
1700
obj1 = self.bus.get_object("busname1", "objectpath")
1701
self.assertIsInstance(obj1, Unique)
1702
obj2 = self.bus.get_object("busname2", "objectpath")
1703
self.assertIsInstance(obj2, Unique)
1704
self.assertIsNot(obj1, obj2)
1706
def test_returns_distinct_both(self):
1707
obj1 = self.bus.get_object("busname1", "objectpath")
1708
self.assertIsInstance(obj1, Unique)
1709
obj2 = self.bus.get_object("busname2", "objectpath")
1710
self.assertIsInstance(obj2, Unique)
1711
self.assertIsNot(obj1, obj2)
1713
def test_returns_same(self):
1714
obj1 = self.bus.get_object("busname", "objectpath")
1715
self.assertIsInstance(obj1, Unique)
1716
obj2 = self.bus.get_object("busname", "objectpath")
1717
self.assertIsInstance(obj2, Unique)
1718
self.assertIs(obj1, obj2)
1720
def test_returns_same_old(self):
1721
obj1 = self.bus.get_object("busname1", "objectpath1")
1722
self.assertIsInstance(obj1, Unique)
1723
obj2 = self.bus.get_object("busname2", "objectpath2")
1724
self.assertIsInstance(obj2, Unique)
1725
obj1b = self.bus.get_object("busname1", "objectpath1")
1726
self.assertIsInstance(obj1b, Unique)
1727
self.assertIsNot(obj1, obj2)
1728
self.assertIsNot(obj2, obj1b)
1729
self.assertIs(obj1, obj1b)
1732
class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):
1734
def Stub_pydbus_func(self, func):
1736
"""stub pydbus module"""
1739
def get(busname, objectpath):
1740
DBusObject = collections.namedtuple(
1741
"DBusObject", ("methodname",))
1742
return {"interface":
1743
DBusObject(methodname=func)}
1746
def call_method(self, bus, methodname, busname, objectpath,
1748
with self.assertLogs(log, logging.DEBUG):
1749
return bus.call_method(methodname, busname, objectpath,
1752
def test_call_method_returns(self):
1753
expected_method_return = Unique()
1754
method_args = (Unique(), Unique())
1756
self.assertEqual(len(method_args), len(args))
1757
for marg, arg in zip(method_args, args):
1758
self.assertIs(marg, arg)
1759
return expected_method_return
1760
stub_pydbus = self.Stub_pydbus_func(func)
1761
bus = pydbus_adapter.SystemBus(stub_pydbus)
1762
ret = self.call_method(bus, "methodname", "busname",
1763
"objectpath", "interface",
1765
self.assertIs(ret, expected_method_return)
1767
def test_call_method_handles_exception(self):
1768
dbus_logger = logging.getLogger("dbus.proxies")
1771
raise gi.repository.GLib.Error()
1773
stub_pydbus = self.Stub_pydbus_func(func)
1774
bus = pydbus_adapter.SystemBus(stub_pydbus)
1776
with self.assertRaises(dbus.Error) as e:
1777
self.call_method(bus, "methodname", "busname",
1778
"objectpath", "interface")
1780
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
1782
def test_get_converts_to_correct_exception(self):
1783
bus = pydbus_adapter.SystemBus(
1784
self.fake_pydbus_raises_exception_on_connect)
1785
with self.assertRaises(dbus.ConnectFailed):
1786
self.call_method(bus, "methodname", "busname",
1787
"objectpath", "interface")
1789
class fake_pydbus_raises_exception_on_connect:
1790
"""fake dbus-python module"""
1793
def get(busname, objectpath):
1794
raise gi.repository.GLib.Error()
1795
Bus = collections.namedtuple("Bus", ["get"])
1798
def test_set_property_uses_setattr(self):
1805
def get(busname, objectpath):
1806
return {"interface": obj}
1807
bus = pydbus_adapter.SystemBus(pydbus_spy)
1809
bus.set_property("busname", "objectpath", "interface", "key",
1811
self.assertIs(value, obj.key)
1813
def test_get_suppresses_xml_deprecation_warning(self):
1814
if sys.version_info.major >= 3:
1816
class stub_pydbus_get:
1819
def get(busname, objectpath):
1820
warnings.warn_explicit(
1821
"deprecated", DeprecationWarning,
1822
"xml.etree.ElementTree", 0)
1823
bus = pydbus_adapter.SystemBus(stub_pydbus_get)
1824
with warnings.catch_warnings(record=True) as w:
1825
warnings.simplefilter("always")
1826
bus.get("busname", "objectpath")
1827
self.assertEqual(0, len(w))
1830
class Test_pydbus_adapter_CachingBus(unittest.TestCase):
1832
"""stub pydbus module"""
1835
def get(busname, objectpath):
1839
self.bus = pydbus_adapter.CachingBus(self.stub_pydbus)
1841
def test_returns_distinct_objectpaths(self):
1842
obj1 = self.bus.get("busname", "objectpath1")
1843
self.assertIsInstance(obj1, Unique)
1844
obj2 = self.bus.get("busname", "objectpath2")
1845
self.assertIsInstance(obj2, Unique)
1846
self.assertIsNot(obj1, obj2)
1848
def test_returns_distinct_busnames(self):
1849
obj1 = self.bus.get("busname1", "objectpath")
1850
self.assertIsInstance(obj1, Unique)
1851
obj2 = self.bus.get("busname2", "objectpath")
1852
self.assertIsInstance(obj2, Unique)
1853
self.assertIsNot(obj1, obj2)
1855
def test_returns_distinct_both(self):
1856
obj1 = self.bus.get("busname1", "objectpath")
1857
self.assertIsInstance(obj1, Unique)
1858
obj2 = self.bus.get("busname2", "objectpath")
1859
self.assertIsInstance(obj2, Unique)
1860
self.assertIsNot(obj1, obj2)
1862
def test_returns_same(self):
1863
obj1 = self.bus.get("busname", "objectpath")
1864
self.assertIsInstance(obj1, Unique)
1865
obj2 = self.bus.get("busname", "objectpath")
1866
self.assertIsInstance(obj2, Unique)
1867
self.assertIs(obj1, obj2)
1869
def test_returns_same_old(self):
1870
obj1 = self.bus.get("busname1", "objectpath1")
1871
self.assertIsInstance(obj1, Unique)
1872
obj2 = self.bus.get("busname2", "objectpath2")
1873
self.assertIsInstance(obj2, Unique)
1874
obj1b = self.bus.get("busname1", "objectpath1")
1875
self.assertIsInstance(obj1b, Unique)
1876
self.assertIsNot(obj1, obj2)
1877
self.assertIsNot(obj2, obj1b)
1878
self.assertIs(obj1, obj1b)
1881
class Test_dbussy_adapter_SystemBus(TestCaseWithAssertLogs):
1885
class ObjectPath(str):
1887
class DBusError(Exception):
1890
def fake_ravel_func(self, func):
1894
class DBusInterfaceProxy:
1896
def methodname(*args):
1897
return [func(*args)]
1900
def get_interface(interface):
1901
if interface == "interface":
1902
return DBusInterfaceProxy()
1903
return {"busname": {"objectpath": DBusObject()}}
1906
def call_method(self, bus, methodname, busname, objectpath,
1908
with self.assertLogs(log, logging.DEBUG):
1909
return bus.call_method(methodname, busname, objectpath,
1912
def test_call_method_returns(self):
1913
expected_method_return = Unique()
1914
method_args = (Unique(), Unique())
1916
self.assertEqual(len(method_args), len(args))
1917
for marg, arg in zip(method_args, args):
1918
self.assertIs(marg, arg)
1919
return expected_method_return
1920
fake_ravel = self.fake_ravel_func(func)
1921
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1922
ret = self.call_method(bus, "methodname", "busname",
1923
"objectpath", "interface",
1925
self.assertIs(ret, expected_method_return)
1927
def test_call_method_filters_objectpath(self):
1929
return method_return
1930
fake_ravel = self.fake_ravel_func(func)
1931
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1932
method_return = (self.dummy_dbussy.DBUS
1933
.ObjectPath("objectpath"))
1934
ret = self.call_method(bus, "methodname", "busname",
1935
"objectpath", "interface")
1936
self.assertEqual("objectpath", ret)
1937
self.assertNotIsInstance(ret,
1938
self.dummy_dbussy.DBUS.ObjectPath)
1940
def test_call_method_filters_objectpaths_in_dict(self):
1941
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1943
return method_return
1944
fake_ravel = self.fake_ravel_func(func)
1945
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1947
ObjectPath("objectpath_key_1"):
1948
ObjectPath("objectpath_value_1"),
1949
ObjectPath("objectpath_key_2"):
1950
ObjectPath("objectpath_value_2"),
1952
ret = self.call_method(bus, "methodname", "busname",
1953
"objectpath", "interface")
1954
expected_method_return = {str(key): str(value)
1956
method_return.items()}
1957
for key, value in ret.items():
1958
self.assertNotIsInstance(key, ObjectPath)
1959
self.assertNotIsInstance(value, ObjectPath)
1960
self.assertEqual(expected_method_return, ret)
1961
self.assertIsInstance(ret, dict)
1963
def test_call_method_filters_objectpaths_in_dict_in_dict(self):
1964
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1966
return method_return
1967
fake_ravel = self.fake_ravel_func(func)
1968
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1970
ObjectPath("key1"): {
1971
ObjectPath("key11"): ObjectPath("value11"),
1972
ObjectPath("key12"): ObjectPath("value12"),
1974
ObjectPath("key2"): {
1975
ObjectPath("key21"): ObjectPath("value21"),
1976
ObjectPath("key22"): ObjectPath("value22"),
1979
ret = self.call_method(bus, "methodname", "busname",
1980
"objectpath", "interface")
1981
expected_method_return = {
1982
"key1": {"key11": "value11",
1983
"key12": "value12"},
1984
"key2": {"key21": "value21",
1985
"key22": "value22"},
1987
self.assertEqual(expected_method_return, ret)
1988
for key, value in ret.items():
1989
self.assertIsInstance(value, dict)
1990
self.assertEqual(expected_method_return[key], value)
1991
self.assertNotIsInstance(key, ObjectPath)
1992
for inner_key, inner_value in value.items():
1993
self.assertIsInstance(value, dict)
1995
expected_method_return[key][inner_key],
1997
self.assertNotIsInstance(key, ObjectPath)
1999
def test_call_method_filters_objectpaths_in_dict_three_deep(self):
2000
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
2002
return method_return
2003
fake_ravel = self.fake_ravel_func(func)
2004
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2006
ObjectPath("key1"): {
2007
ObjectPath("key2"): {
2008
ObjectPath("key3"): ObjectPath("value"),
2012
ret = self.call_method(bus, "methodname", "busname",
2013
"objectpath", "interface")
2014
expected_method_return = {"key1": {"key2": {"key3": "value"}}}
2015
self.assertEqual(expected_method_return, ret)
2016
self.assertIsInstance(ret, dict)
2017
self.assertNotIsInstance(next(iter(ret.keys())), ObjectPath)
2018
self.assertIsInstance(ret["key1"], dict)
2019
self.assertNotIsInstance(next(iter(ret["key1"].keys())),
2021
self.assertIsInstance(ret["key1"]["key2"], dict)
2022
self.assertNotIsInstance(
2023
next(iter(ret["key1"]["key2"].keys())),
2025
self.assertEqual("value", ret["key1"]["key2"]["key3"])
2026
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
2027
self.dummy_dbussy.DBUS.ObjectPath)
2029
def test_call_method_handles_exception(self):
2031
raise self.dummy_dbussy.DBusError()
2033
fake_ravel = self.fake_ravel_func(func)
2034
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2036
with self.assertRaises(dbus.Error) as e:
2037
self.call_method(bus, "methodname", "busname",
2038
"objectpath", "interface")
2040
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
2042
def test_get_object_converts_to_correct_exception(self):
2043
class fake_ravel_raises_exception_on_connect:
2048
def __getitem__(key):
2049
if key == "objectpath":
2050
raise self.dummy_dbussy.DBusError()
2051
raise Exception(key)
2052
return {"busname": Bus()}
2054
raise self.dummy_dbussy.DBusError()
2055
bus = dbussy_adapter.SystemBus(
2057
fake_ravel_raises_exception_on_connect)
2058
with self.assertRaises(dbus.ConnectFailed):
2059
self.call_method(bus, "methodname", "busname",
2060
"objectpath", "interface")
2063
class Test_commands_from_options(unittest.TestCase):
2066
self.parser = argparse.ArgumentParser()
2067
add_command_line_options(self.parser)
2069
def test_is_enabled(self):
2070
self.assert_command_from_args(["--is-enabled", "client"],
2073
def assert_command_from_args(self, args, command_cls, length=1,
2074
clients=None, **cmd_attrs):
2075
"""Assert that parsing ARGS should result in an instance of
2076
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
2077
options = self.parser.parse_args(args)
2078
check_option_syntax(self.parser, options)
2079
commands = commands_from_options(options)
2080
self.assertEqual(length, len(commands))
2081
for command in commands:
2082
if isinstance(command, command_cls):
2085
self.assertIsInstance(command, command_cls)
2086
if clients is not None:
2087
self.assertEqual(clients, options.client)
2088
for key, value in cmd_attrs.items():
2089
self.assertEqual(value, getattr(command, key))
2091
def assert_commands_from_args(self, args, commands, clients=None):
2092
for cmd in commands:
2093
self.assert_command_from_args(args, cmd,
2094
length=len(commands),
2097
def test_is_enabled_short(self):
2098
self.assert_command_from_args(["-V", "client"],
2101
def test_approve(self):
2102
self.assert_command_from_args(["--approve", "client"],
2105
def test_approve_short(self):
2106
self.assert_command_from_args(["-A", "client"],
2109
def test_deny(self):
2110
self.assert_command_from_args(["--deny", "client"],
2113
def test_deny_short(self):
2114
self.assert_command_from_args(["-D", "client"], command.Deny)
2116
def test_remove(self):
2117
self.assert_command_from_args(["--remove", "client"],
2120
def test_deny_before_remove(self):
2121
options = self.parser.parse_args(["--deny", "--remove",
2123
check_option_syntax(self.parser, options)
2124
commands = commands_from_options(options)
2125
self.assertEqual(2, len(commands))
2126
self.assertIsInstance(commands[0], command.Deny)
2127
self.assertIsInstance(commands[1], command.Remove)
2129
def test_deny_before_remove_reversed(self):
2130
options = self.parser.parse_args(["--remove", "--deny",
2132
check_option_syntax(self.parser, options)
2133
commands = commands_from_options(options)
2134
self.assertEqual(2, len(commands))
2135
self.assertIsInstance(commands[0], command.Deny)
2136
self.assertIsInstance(commands[1], command.Remove)
2138
def test_remove_short(self):
2139
self.assert_command_from_args(["-r", "client"],
2142
def test_dump_json(self):
2143
self.assert_command_from_args(["--dump-json"],
2146
def test_enable(self):
2147
self.assert_command_from_args(["--enable", "client"],
2150
def test_enable_short(self):
2151
self.assert_command_from_args(["-e", "client"],
2154
def test_disable(self):
2155
self.assert_command_from_args(["--disable", "client"],
2158
def test_disable_short(self):
2159
self.assert_command_from_args(["-d", "client"],
2162
def test_bump_timeout(self):
2163
self.assert_command_from_args(["--bump-timeout", "client"],
2164
command.BumpTimeout)
2166
def test_bump_timeout_short(self):
2167
self.assert_command_from_args(["-b", "client"],
2168
command.BumpTimeout)
2170
def test_start_checker(self):
2171
self.assert_command_from_args(["--start-checker", "client"],
2172
command.StartChecker)
2174
def test_stop_checker(self):
2175
self.assert_command_from_args(["--stop-checker", "client"],
2176
command.StopChecker)
2178
def test_approve_by_default(self):
2179
self.assert_command_from_args(["--approve-by-default",
2181
command.ApproveByDefault)
2183
def test_deny_by_default(self):
2184
self.assert_command_from_args(["--deny-by-default", "client"],
2185
command.DenyByDefault)
2187
def test_checker(self):
2188
self.assert_command_from_args(["--checker", ":", "client"],
2192
def test_checker_empty(self):
2193
self.assert_command_from_args(["--checker", "", "client"],
2197
def test_checker_short(self):
2198
self.assert_command_from_args(["-c", ":", "client"],
2202
def test_host(self):
2203
self.assert_command_from_args(
2204
["--host", "client.example.org", "client"],
2205
command.SetHost, value_to_set="client.example.org")
2207
def test_host_short(self):
2208
self.assert_command_from_args(
2209
["-H", "client.example.org", "client"], command.SetHost,
2210
value_to_set="client.example.org")
2212
def test_secret_devnull(self):
2213
self.assert_command_from_args(["--secret", os.path.devnull,
2214
"client"], command.SetSecret,
2217
def test_secret_tempfile(self):
2218
with tempfile.NamedTemporaryFile(mode="r+b") as f:
2219
value = b"secret\0xyzzy\nbar"
2222
self.assert_command_from_args(["--secret", f.name,
2227
def test_secret_devnull_short(self):
2228
self.assert_command_from_args(["-s", os.path.devnull,
2229
"client"], command.SetSecret,
2232
def test_secret_tempfile_short(self):
2233
with tempfile.NamedTemporaryFile(mode="r+b") as f:
2234
value = b"secret\0xyzzy\nbar"
2237
self.assert_command_from_args(["-s", f.name, "client"],
2241
def test_timeout(self):
2242
self.assert_command_from_args(["--timeout", "PT5M", "client"],
2244
value_to_set=300000)
2246
def test_timeout_short(self):
2247
self.assert_command_from_args(["-t", "PT5M", "client"],
2249
value_to_set=300000)
2251
def test_extended_timeout(self):
2252
self.assert_command_from_args(["--extended-timeout", "PT15M",
2254
command.SetExtendedTimeout,
2255
value_to_set=900000)
2257
def test_interval(self):
2258
self.assert_command_from_args(["--interval", "PT2M",
2259
"client"], command.SetInterval,
2260
value_to_set=120000)
2262
def test_interval_short(self):
2263
self.assert_command_from_args(["-i", "PT2M", "client"],
2264
command.SetInterval,
2265
value_to_set=120000)
2267
def test_approval_delay(self):
2268
self.assert_command_from_args(["--approval-delay", "PT30S",
2270
command.SetApprovalDelay,
2273
def test_approval_duration(self):
2274
self.assert_command_from_args(["--approval-duration", "PT1S",
2276
command.SetApprovalDuration,
2279
def test_print_table(self):
2280
self.assert_command_from_args([], command.PrintTable,
2283
def test_print_table_verbose(self):
2284
self.assert_command_from_args(["--verbose"],
2288
def test_print_table_verbose_short(self):
2289
self.assert_command_from_args(["-v"], command.PrintTable,
2293
def test_manual_page_example_1(self):
2294
self.assert_command_from_args("",
2299
def test_manual_page_example_2(self):
2300
self.assert_command_from_args(
2301
"--verbose foo1.example.org foo2.example.org".split(),
2302
command.PrintTable, clients=["foo1.example.org",
2303
"foo2.example.org"],
2306
def test_manual_page_example_3(self):
2307
self.assert_command_from_args("--enable --all".split(),
2311
def test_manual_page_example_4(self):
2312
self.assert_commands_from_args(
2313
("--timeout=PT5M --interval=PT1M foo1.example.org"
2314
" foo2.example.org").split(),
2315
[command.SetTimeout, command.SetInterval],
2316
clients=["foo1.example.org", "foo2.example.org"])
2318
def test_manual_page_example_5(self):
2319
self.assert_command_from_args("--approve --all".split(),
2324
class TestCommand(unittest.TestCase):
829
log.removeFilter(warning_filter)
830
self.assertTrue(getattr(warning_filter, "found", False))
831
self.assertEqual(value, datetime.timedelta(0, 7200))
834
class TestCmd(unittest.TestCase):
2325
835
"""Abstract class for tests of command classes"""
2327
class FakeMandosBus(dbus.MandosBus):
2328
def __init__(self, testcase):
2329
self.client_properties = {
838
class MockClient(object):
839
def __init__(self, name, **attributes):
840
self.__dbus_object_path__ = "objpath_{}".format(name)
841
self.attributes = attributes
842
self.attributes["Name"] = name
844
def Set(self, interface, propname, value, dbus_interface):
845
testcase.assertEqual(interface, client_interface)
846
testcase.assertEqual(dbus_interface,
847
dbus.PROPERTIES_IFACE)
848
self.attributes[propname] = value
849
def Get(self, interface, propname, dbus_interface):
850
testcase.assertEqual(interface, client_interface)
851
testcase.assertEqual(dbus_interface,
852
dbus.PROPERTIES_IFACE)
853
return self.attributes[propname]
854
def Approve(self, approve, dbus_interface):
855
testcase.assertEqual(dbus_interface, client_interface)
856
self.calls.append(("Approve", (approve,
858
self.client = MockClient(
860
KeyID=("92ed150794387c03ce684574b1139a65"
861
"94a34f895daaaf09fd8ea90a27cddb12"),
863
Host="foo.example.org",
864
Enabled=dbus.Boolean(True),
866
LastCheckedOK="2019-02-03T00:00:00",
867
Created="2019-01-02T00:00:00",
869
Fingerprint=("778827225BA7DE539C5A"
870
"7CFA59CFF7CDBD9A5920"),
871
CheckerRunning=dbus.Boolean(False),
872
LastEnabled="2019-01-03T00:00:00",
873
ApprovalPending=dbus.Boolean(False),
874
ApprovedByDefault=dbus.Boolean(True),
875
LastApprovalRequest="",
877
ApprovalDuration=1000,
878
Checker="fping -q -- %(host)s",
879
ExtendedTimeout=900000,
880
Expires="2019-02-04T00:00:00",
882
self.other_client = MockClient(
884
KeyID=("0558568eedd67d622f5c83b35a115f79"
885
"6ab612cff5ad227247e46c2b020f441c"),
888
Enabled=dbus.Boolean(True),
890
LastCheckedOK="2019-02-04T00:00:00",
891
Created="2019-01-03T00:00:00",
893
Fingerprint=("3E393AEAEFB84C7E89E2"
894
"F547B3A107558FCA3A27"),
895
CheckerRunning=dbus.Boolean(True),
896
LastEnabled="2019-01-04T00:00:00",
897
ApprovalPending=dbus.Boolean(False),
898
ApprovedByDefault=dbus.Boolean(False),
899
LastApprovalRequest="2019-01-03T00:00:00",
901
ApprovalDuration=1000,
903
ExtendedTimeout=900000,
904
Expires="2019-02-05T00:00:00",
905
LastCheckerStatus=-2)
906
self.clients = collections.OrderedDict(
908
(self.client, self.client.attributes),
909
(self.other_client, self.other_client.attributes),
911
self.one_client = {self.client: self.client.attributes}
913
class TestPrintTableCmd(TestCmd):
914
def test_normal(self):
915
output = PrintTableCmd().output(self.clients.values())
916
expected_output = """
917
Name Enabled Timeout Last Successful Check
918
foo Yes 00:05:00 2019-02-03T00:00:00
919
barbar Yes 00:05:00 2019-02-04T00:00:00
921
self.assertEqual(output, expected_output)
922
def test_verbose(self):
923
output = PrintTableCmd(verbose=True).output(
924
self.clients.values())
925
expected_output = """
926
Name Enabled Timeout Last Successful Check Created Interval Host Key ID Fingerprint Check Is Running Last Enabled Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker Extended Timeout Expires Last Checker Status
927
foo Yes 00:05:00 2019-02-03T00:00:00 2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No 2019-01-03T00:00:00 No Yes 00:00:00 00:00:01 fping -q -- %(host)s 00:15:00 2019-02-04T00:00:00 0
928
barbar Yes 00:05:00 2019-02-04T00:00:00 2019-01-03T00:00:00 00:02:00 192.0.2.3 0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e46c2b020f441c 3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 Yes 2019-01-04T00:00:00 No No 2019-01-03T00:00:00 00:00:30 00:00:01 : 00:15:00 2019-02-05T00:00:00 -2
930
self.assertEqual(output, expected_output)
931
def test_one_client(self):
932
output = PrintTableCmd().output(self.one_client.values())
933
expected_output = """
934
Name Enabled Timeout Last Successful Check
935
foo Yes 00:05:00 2019-02-03T00:00:00
937
self.assertEqual(output, expected_output)
939
class TestDumpJSONCmd(TestCmd):
941
self.expected_json = {
2331
944
"KeyID": ("92ed150794387c03ce684574b1139a65"
2332
945
"94a34f895daaaf09fd8ea90a27cddb12"),
2333
"Secret": b"secret",
2334
946
"Host": "foo.example.org",
2335
947
"Enabled": True,
2336
948
"Timeout": 300000,
2370
981
"ApprovedByDefault": False,
2371
982
"LastApprovalRequest": "2019-01-03T00:00:00",
2372
983
"ApprovalDelay": 30000,
2373
"ApprovalDuration": 93785000,
984
"ApprovalDuration": 1000,
2375
986
"ExtendedTimeout": 900000,
2376
987
"Expires": "2019-02-05T00:00:00",
2377
988
"LastCheckerStatus": -2,
2379
self.clients = collections.OrderedDict(
2381
("client_objectpath", self.client_properties),
2382
("other_client_objectpath",
2383
self.other_client_properties),
2385
self.one_client = {"client_objectpath":
2386
self.client_properties}
2387
self.testcase = testcase
2390
def call_method(self, methodname, busname, objectpath,
2392
self.testcase.assertEqual("se.recompile.Mandos", busname)
2393
self.calls.append((methodname, busname, objectpath,
2395
if interface == "org.freedesktop.DBus.Properties":
2396
if methodname == "Set":
2397
self.testcase.assertEqual(3, len(args))
2398
interface, key, value = args
2399
self.testcase.assertEqual(
2400
"se.recompile.Mandos.Client", interface)
2401
self.clients[objectpath][key] = value
2403
elif interface == "se.recompile.Mandos":
2404
self.testcase.assertEqual("RemoveClient", methodname)
2405
self.testcase.assertEqual(1, len(args))
2406
clientpath = args[0]
2407
del self.clients[clientpath]
2409
elif interface == "se.recompile.Mandos.Client":
2410
if methodname == "Approve":
2411
self.testcase.assertEqual(1, len(args))
2416
self.bus = self.FakeMandosBus(self)
2419
class TestBaseCommands(TestCommand):
2421
def test_IsEnabled_exits_successfully(self):
991
return super(TestDumpJSONCmd, self).setUp()
992
def test_normal(self):
993
json_data = json.loads(DumpJSONCmd().output(self.clients))
994
self.assertDictEqual(json_data, self.expected_json)
995
def test_one_client(self):
996
clients = self.one_client
997
json_data = json.loads(DumpJSONCmd().output(clients))
998
expected_json = {"foo": self.expected_json["foo"]}
999
self.assertDictEqual(json_data, expected_json)
1001
class TestIsEnabledCmd(TestCmd):
1002
def test_is_enabled(self):
1003
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
1004
for client, properties in self.clients.items()))
1005
def test_is_enabled_run_exits_successfully(self):
2422
1006
with self.assertRaises(SystemExit) as e:
2423
command.IsEnabled().run(self.bus.one_client)
1007
IsEnabledCmd().run(None, self.one_client)
2424
1008
if e.exception.code is not None:
2425
self.assertEqual(0, e.exception.code)
1009
self.assertEqual(e.exception.code, 0)
2427
1011
self.assertIsNone(e.exception.code)
2429
def test_IsEnabled_exits_with_failure(self):
2430
self.bus.client_properties["Enabled"] = False
1012
def test_is_enabled_run_exits_with_failure(self):
1013
self.client.attributes["Enabled"] = dbus.Boolean(False)
2431
1014
with self.assertRaises(SystemExit) as e:
2432
command.IsEnabled().run(self.bus.one_client)
1015
IsEnabledCmd().run(None, self.one_client)
2433
1016
if isinstance(e.exception.code, int):
2434
self.assertNotEqual(0, e.exception.code)
1017
self.assertNotEqual(e.exception.code, 0)
2436
1019
self.assertIsNotNone(e.exception.code)
2438
def test_Approve(self):
2439
busname = "se.recompile.Mandos"
2440
client_interface = "se.recompile.Mandos.Client"
2441
command.Approve().run(self.bus.clients, self.bus)
2442
self.assertTrue(self.bus.clients)
2443
for clientpath in self.bus.clients:
2444
self.assertIn(("Approve", busname, clientpath,
2445
client_interface, (True,)), self.bus.calls)
2447
def test_Deny(self):
2448
busname = "se.recompile.Mandos"
2449
client_interface = "se.recompile.Mandos.Client"
2450
command.Deny().run(self.bus.clients, self.bus)
2451
self.assertTrue(self.bus.clients)
2452
for clientpath in self.bus.clients:
2453
self.assertIn(("Approve", busname, clientpath,
2454
client_interface, (False,)),
2457
def test_Remove(self):
2458
busname = "se.recompile.Mandos"
2460
server_interface = "se.recompile.Mandos"
2461
orig_clients = self.bus.clients.copy()
2462
command.Remove().run(self.bus.clients, self.bus)
2463
self.assertFalse(self.bus.clients)
2464
for clientpath in orig_clients:
2465
self.assertIn(("RemoveClient", busname,
2466
server_path, server_interface,
2467
(clientpath,)), self.bus.calls)
2472
"KeyID": ("92ed150794387c03ce684574b1139a65"
2473
"94a34f895daaaf09fd8ea90a27cddb12"),
2474
"Host": "foo.example.org",
2477
"LastCheckedOK": "2019-02-03T00:00:00",
2478
"Created": "2019-01-02T00:00:00",
2480
"Fingerprint": ("778827225BA7DE539C5A"
2481
"7CFA59CFF7CDBD9A5920"),
2482
"CheckerRunning": False,
2483
"LastEnabled": "2019-01-03T00:00:00",
2484
"ApprovalPending": False,
2485
"ApprovedByDefault": True,
2486
"LastApprovalRequest": "",
2488
"ApprovalDuration": 1000,
2489
"Checker": "fping -q -- %(host)s",
2490
"ExtendedTimeout": 900000,
2491
"Expires": "2019-02-04T00:00:00",
2492
"LastCheckerStatus": 0,
2496
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
2497
"6ab612cff5ad227247e46c2b020f441c"),
2498
"Host": "192.0.2.3",
2501
"LastCheckedOK": "2019-02-04T00:00:00",
2502
"Created": "2019-01-03T00:00:00",
2504
"Fingerprint": ("3E393AEAEFB84C7E89E2"
2505
"F547B3A107558FCA3A27"),
2506
"CheckerRunning": True,
2507
"LastEnabled": "2019-01-04T00:00:00",
2508
"ApprovalPending": False,
2509
"ApprovedByDefault": False,
2510
"LastApprovalRequest": "2019-01-03T00:00:00",
2511
"ApprovalDelay": 30000,
2512
"ApprovalDuration": 93785000,
2514
"ExtendedTimeout": 900000,
2515
"Expires": "2019-02-05T00:00:00",
2516
"LastCheckerStatus": -2,
2520
def test_DumpJSON_normal(self):
2521
with self.capture_stdout_to_buffer() as buffer:
2522
command.DumpJSON().run(self.bus.clients)
2523
json_data = json.loads(buffer.getvalue())
2524
self.assertDictEqual(self.expected_json, json_data)
2527
@contextlib.contextmanager
2528
def capture_stdout_to_buffer():
2529
capture_buffer = io.StringIO()
2530
old_stdout = sys.stdout
2531
sys.stdout = capture_buffer
2533
yield capture_buffer
2535
sys.stdout = old_stdout
2537
def test_DumpJSON_one_client(self):
2538
with self.capture_stdout_to_buffer() as buffer:
2539
command.DumpJSON().run(self.bus.one_client)
2540
json_data = json.loads(buffer.getvalue())
2541
expected_json = {"foo": self.expected_json["foo"]}
2542
self.assertDictEqual(expected_json, json_data)
2544
def test_PrintTable_normal(self):
2545
with self.capture_stdout_to_buffer() as buffer:
2546
command.PrintTable().run(self.bus.clients)
2547
expected_output = "\n".join((
2548
"Name Enabled Timeout Last Successful Check",
2549
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
2550
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
2552
self.assertEqual(expected_output, buffer.getvalue())
2554
def test_PrintTable_verbose(self):
2555
with self.capture_stdout_to_buffer() as buffer:
2556
command.PrintTable(verbose=True).run(self.bus.clients)
2571
"Last Successful Check ",
2572
"2019-02-03T00:00:00 ",
2573
"2019-02-04T00:00:00 ",
2576
"2019-01-02T00:00:00 ",
2577
"2019-01-03T00:00:00 ",
2589
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
2591
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
2595
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
2596
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
2598
"Check Is Running ",
2603
"2019-01-03T00:00:00 ",
2604
"2019-01-04T00:00:00 ",
2606
"Approval Is Pending ",
2610
"Approved By Default ",
2614
"Last Approval Request ",
2616
"2019-01-03T00:00:00 ",
2622
"Approval Duration ",
2627
"fping -q -- %(host)s ",
2630
"Extended Timeout ",
2635
"2019-02-04T00:00:00 ",
2636
"2019-02-05T00:00:00 ",
2638
"Last Checker Status",
2643
num_lines = max(len(rows) for rows in columns)
2644
expected_output = ("\n".join("".join(rows[line]
2645
for rows in columns)
2646
for line in range(num_lines))
2648
self.assertEqual(expected_output, buffer.getvalue())
2650
def test_PrintTable_one_client(self):
2651
with self.capture_stdout_to_buffer() as buffer:
2652
command.PrintTable().run(self.bus.one_client)
2653
expected_output = "\n".join((
2654
"Name Enabled Timeout Last Successful Check",
2655
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
2657
self.assertEqual(expected_output, buffer.getvalue())
2660
class TestPropertySetterCmd(TestCommand):
2661
"""Abstract class for tests of command.PropertySetter classes"""
1021
class TestRemoveCmd(TestCmd):
1022
def test_remove(self):
1023
class MockMandos(object):
1026
def RemoveClient(self, dbus_path):
1027
self.calls.append(("RemoveClient", (dbus_path,)))
1028
mandos = MockMandos()
1029
super(TestRemoveCmd, self).setUp()
1030
RemoveCmd().run(mandos, self.clients)
1031
self.assertEqual(len(mandos.calls), 2)
1032
for client in self.clients:
1033
self.assertIn(("RemoveClient",
1034
(client.__dbus_object_path__,)),
1037
class TestApproveCmd(TestCmd):
1038
def test_approve(self):
1039
ApproveCmd().run(None, self.clients)
1040
for client in self.clients:
1041
self.assertIn(("Approve", (True, client_interface)),
1044
class TestDenyCmd(TestCmd):
1045
def test_deny(self):
1046
DenyCmd().run(None, self.clients)
1047
for client in self.clients:
1048
self.assertIn(("Approve", (False, client_interface)),
1051
class TestEnableCmd(TestCmd):
1052
def test_enable(self):
1053
for client in self.clients:
1054
client.attributes["Enabled"] = False
1056
EnableCmd().run(None, self.clients)
1058
for client in self.clients:
1059
self.assertTrue(client.attributes["Enabled"])
1061
class TestDisableCmd(TestCmd):
1062
def test_disable(self):
1063
DisableCmd().run(None, self.clients)
1065
for client in self.clients:
1066
self.assertFalse(client.attributes["Enabled"])
1068
class Unique(object):
1069
"""Class for objects which exist only to be unique objects, since
1070
unittest.mock.sentinel only exists in Python 3.3"""
1072
class TestPropertyCmd(TestCmd):
1073
"""Abstract class for tests of PropertyCmd classes"""
2663
1074
def runTest(self):
2664
1075
if not hasattr(self, "command"):
2665
return # Abstract TestCase class
2667
if hasattr(self, "values_to_set"):
2668
cmd_args = [(value,) for value in self.values_to_set]
2669
values_to_get = getattr(self, "values_to_get",
2672
cmd_args = [() for x in range(len(self.values_to_get))]
2673
values_to_get = self.values_to_get
2674
self.assertTrue(values_to_get)
2675
for value_to_get, cmd_arg in zip(values_to_get, cmd_args):
2676
for clientpath in self.bus.clients:
2677
self.bus.clients[clientpath][self.propname] = (
2679
self.command(*cmd_arg).run(self.bus.clients, self.bus)
2680
self.assertTrue(self.bus.clients)
2681
for clientpath in self.bus.clients:
2682
value = (self.bus.clients[clientpath]
1077
values_to_get = getattr(self, "values_to_get",
1079
for value_to_set, value_to_get in zip(self.values_to_set,
1081
for client in self.clients:
1082
old_value = client.attributes[self.propname]
1083
self.assertNotIsInstance(old_value, Unique)
1084
client.attributes[self.propname] = Unique()
1085
self.run_command(value_to_set, self.clients)
1086
for client in self.clients:
1087
value = client.attributes[self.propname]
2684
1088
self.assertNotIsInstance(value, Unique)
2685
self.assertEqual(value_to_get, value)
2688
class TestEnableCmd(TestPropertySetterCmd):
2689
command = command.Enable
2690
propname = "Enabled"
2691
values_to_get = [True]
2694
class TestDisableCmd(TestPropertySetterCmd):
2695
command = command.Disable
2696
propname = "Enabled"
2697
values_to_get = [False]
2700
class TestBumpTimeoutCmd(TestPropertySetterCmd):
2701
command = command.BumpTimeout
1089
self.assertEqual(value, value_to_get)
1090
def run_command(self, value, clients):
1091
self.command().run(None, clients)
1093
class TestBumpTimeoutCmd(TestPropertyCmd):
1094
command = BumpTimeoutCmd
2702
1095
propname = "LastCheckedOK"
2703
values_to_get = [""]
2706
class TestStartCheckerCmd(TestPropertySetterCmd):
2707
command = command.StartChecker
2708
propname = "CheckerRunning"
2709
values_to_get = [True]
2712
class TestStopCheckerCmd(TestPropertySetterCmd):
2713
command = command.StopChecker
2714
propname = "CheckerRunning"
2715
values_to_get = [False]
2718
class TestApproveByDefaultCmd(TestPropertySetterCmd):
2719
command = command.ApproveByDefault
2720
propname = "ApprovedByDefault"
2721
values_to_get = [True]
2724
class TestDenyByDefaultCmd(TestPropertySetterCmd):
2725
command = command.DenyByDefault
2726
propname = "ApprovedByDefault"
2727
values_to_get = [False]
2730
class TestSetCheckerCmd(TestPropertySetterCmd):
2731
command = command.SetChecker
1096
values_to_set = [""]
1098
class TestStartCheckerCmd(TestPropertyCmd):
1099
command = StartCheckerCmd
1100
propname = "CheckerRunning"
1101
values_to_set = [dbus.Boolean(True)]
1103
class TestStopCheckerCmd(TestPropertyCmd):
1104
command = StopCheckerCmd
1105
propname = "CheckerRunning"
1106
values_to_set = [dbus.Boolean(False)]
1108
class TestApproveByDefaultCmd(TestPropertyCmd):
1109
command = ApproveByDefaultCmd
1110
propname = "ApprovedByDefault"
1111
values_to_set = [dbus.Boolean(True)]
1113
class TestDenyByDefaultCmd(TestPropertyCmd):
1114
command = DenyByDefaultCmd
1115
propname = "ApprovedByDefault"
1116
values_to_set = [dbus.Boolean(False)]
1118
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1119
"""Abstract class for tests of PropertyCmd classes using the
1120
ValueArgumentMixIn"""
1122
if type(self) is TestValueArgumentPropertyCmd:
1124
return super(TestValueArgumentPropertyCmd, self).runTest()
1125
def run_command(self, value, clients):
1126
self.command(value).run(None, clients)
1128
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1129
command = SetCheckerCmd
2732
1130
propname = "Checker"
2733
1131
values_to_set = ["", ":", "fping -q -- %s"]
2736
class TestSetHostCmd(TestPropertySetterCmd):
2737
command = command.SetHost
1133
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1134
command = SetHostCmd
2738
1135
propname = "Host"
2739
values_to_set = ["192.0.2.3", "client.example.org"]
2742
class TestSetSecretCmd(TestPropertySetterCmd):
2743
command = command.SetSecret
1136
values_to_set = ["192.0.2.3", "foo.example.org"]
1138
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1139
command = SetSecretCmd
2744
1140
propname = "Secret"
2745
def __init__(self, *args, **kwargs):
2746
self.values_to_set = [io.BytesIO(b""),
2747
io.BytesIO(b"secret\0xyzzy\nbar")]
2748
self.values_to_get = [f.getvalue() for f in
2750
super(TestSetSecretCmd, self).__init__(*args, **kwargs)
2753
class TestSetTimeoutCmd(TestPropertySetterCmd):
2754
command = command.SetTimeout
1141
values_to_set = [io.BytesIO(b""),
1142
io.BytesIO(b"secret\0xyzzy\nbar")]
1143
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1145
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1146
command = SetTimeoutCmd
2755
1147
propname = "Timeout"
2756
1148
values_to_set = [datetime.timedelta(),
2757
1149
datetime.timedelta(minutes=5),
2758
1150
datetime.timedelta(seconds=1),
2759
1151
datetime.timedelta(weeks=1),
2760
1152
datetime.timedelta(weeks=52)]
2761
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2764
class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):
2765
command = command.SetExtendedTimeout
1153
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1155
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1156
command = SetExtendedTimeoutCmd
2766
1157
propname = "ExtendedTimeout"
2767
1158
values_to_set = [datetime.timedelta(),
2768
1159
datetime.timedelta(minutes=5),
2769
1160
datetime.timedelta(seconds=1),
2770
1161
datetime.timedelta(weeks=1),
2771
1162
datetime.timedelta(weeks=52)]
2772
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2775
class TestSetIntervalCmd(TestPropertySetterCmd):
2776
command = command.SetInterval
1163
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1165
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1166
command = SetIntervalCmd
2777
1167
propname = "Interval"
2778
1168
values_to_set = [datetime.timedelta(),
2779
1169
datetime.timedelta(minutes=5),
2780
1170
datetime.timedelta(seconds=1),
2781
1171
datetime.timedelta(weeks=1),
2782
1172
datetime.timedelta(weeks=52)]
2783
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2786
class TestSetApprovalDelayCmd(TestPropertySetterCmd):
2787
command = command.SetApprovalDelay
1173
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1175
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1176
command = SetApprovalDelayCmd
2788
1177
propname = "ApprovalDelay"
2789
1178
values_to_set = [datetime.timedelta(),
2790
1179
datetime.timedelta(minutes=5),
2791
1180
datetime.timedelta(seconds=1),
2792
1181
datetime.timedelta(weeks=1),
2793
1182
datetime.timedelta(weeks=52)]
2794
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2797
class TestSetApprovalDurationCmd(TestPropertySetterCmd):
2798
command = command.SetApprovalDuration
1183
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1185
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1186
command = SetApprovalDurationCmd
2799
1187
propname = "ApprovalDuration"
2800
1188
values_to_set = [datetime.timedelta(),
2801
1189
datetime.timedelta(minutes=5),
2802
1190
datetime.timedelta(seconds=1),
2803
1191
datetime.timedelta(weeks=1),
2804
1192
datetime.timedelta(weeks=52)]
2805
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1193
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1195
class Test_command_from_options(unittest.TestCase):
1197
self.parser = argparse.ArgumentParser()
1198
add_command_line_options(self.parser)
1199
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1200
"""Assert that parsing ARGS should result in an instance of
1201
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1202
options = self.parser.parse_args(args)
1203
check_option_syntax(self.parser, options)
1204
commands = commands_from_options(options)
1205
self.assertEqual(len(commands), 1)
1206
command = commands[0]
1207
self.assertIsInstance(command, command_cls)
1208
for key, value in cmd_attrs.items():
1209
self.assertEqual(getattr(command, key), value)
1210
def test_print_table(self):
1211
self.assert_command_from_args([], PrintTableCmd,
1214
def test_print_table_verbose(self):
1215
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1218
def test_print_table_verbose_short(self):
1219
self.assert_command_from_args(["-v"], PrintTableCmd,
1222
def test_enable(self):
1223
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1225
def test_enable_short(self):
1226
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1228
def test_disable(self):
1229
self.assert_command_from_args(["--disable", "foo"],
1232
def test_disable_short(self):
1233
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1235
def test_bump_timeout(self):
1236
self.assert_command_from_args(["--bump-timeout", "foo"],
1239
def test_bump_timeout_short(self):
1240
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1242
def test_start_checker(self):
1243
self.assert_command_from_args(["--start-checker", "foo"],
1246
def test_stop_checker(self):
1247
self.assert_command_from_args(["--stop-checker", "foo"],
1250
def test_remove(self):
1251
self.assert_command_from_args(["--remove", "foo"],
1254
def test_remove_short(self):
1255
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1257
def test_checker(self):
1258
self.assert_command_from_args(["--checker", ":", "foo"],
1259
SetCheckerCmd, value_to_set=":")
1261
def test_checker_empty(self):
1262
self.assert_command_from_args(["--checker", "", "foo"],
1263
SetCheckerCmd, value_to_set="")
1265
def test_checker_short(self):
1266
self.assert_command_from_args(["-c", ":", "foo"],
1267
SetCheckerCmd, value_to_set=":")
1269
def test_timeout(self):
1270
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1272
value_to_set=300000)
1274
def test_timeout_short(self):
1275
self.assert_command_from_args(["-t", "PT5M", "foo"],
1277
value_to_set=300000)
1279
def test_extended_timeout(self):
1280
self.assert_command_from_args(["--extended-timeout", "PT15M",
1282
SetExtendedTimeoutCmd,
1283
value_to_set=900000)
1285
def test_interval(self):
1286
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1288
value_to_set=120000)
1290
def test_interval_short(self):
1291
self.assert_command_from_args(["-i", "PT2M", "foo"],
1293
value_to_set=120000)
1295
def test_approve_by_default(self):
1296
self.assert_command_from_args(["--approve-by-default", "foo"],
1297
ApproveByDefaultCmd)
1299
def test_deny_by_default(self):
1300
self.assert_command_from_args(["--deny-by-default", "foo"],
1303
def test_approval_delay(self):
1304
self.assert_command_from_args(["--approval-delay", "PT30S",
1305
"foo"], SetApprovalDelayCmd,
1308
def test_approval_duration(self):
1309
self.assert_command_from_args(["--approval-duration", "PT1S",
1310
"foo"], SetApprovalDurationCmd,
1313
def test_host(self):
1314
self.assert_command_from_args(["--host", "foo.example.org",
1316
value_to_set="foo.example.org")
1318
def test_host_short(self):
1319
self.assert_command_from_args(["-H", "foo.example.org",
1321
value_to_set="foo.example.org")
1323
def test_secret_devnull(self):
1324
self.assert_command_from_args(["--secret", os.path.devnull,
1325
"foo"], SetSecretCmd,
1328
def test_secret_tempfile(self):
1329
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1330
value = b"secret\0xyzzy\nbar"
1333
self.assert_command_from_args(["--secret", f.name,
1334
"foo"], SetSecretCmd,
1337
def test_secret_devnull_short(self):
1338
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1339
SetSecretCmd, value_to_set=b"")
1341
def test_secret_tempfile_short(self):
1342
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1343
value = b"secret\0xyzzy\nbar"
1346
self.assert_command_from_args(["-s", f.name, "foo"],
1350
def test_approve(self):
1351
self.assert_command_from_args(["--approve", "foo"],
1354
def test_approve_short(self):
1355
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1357
def test_deny(self):
1358
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1360
def test_deny_short(self):
1361
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1363
def test_dump_json(self):
1364
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1366
def test_is_enabled(self):
1367
self.assert_command_from_args(["--is-enabled", "foo"],
1370
def test_is_enabled_short(self):
1371
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1373
def test_deny_before_remove(self):
1374
options = self.parser.parse_args(["--deny", "--remove", "foo"])
1375
check_option_syntax(self.parser, options)
1376
commands = commands_from_options(options)
1377
self.assertEqual(len(commands), 2)
1378
self.assertIsInstance(commands[0], DenyCmd)
1379
self.assertIsInstance(commands[1], RemoveCmd)
1381
def test_deny_before_remove_reversed(self):
1382
options = self.parser.parse_args(["--remove", "--deny", "--all"])
1383
check_option_syntax(self.parser, options)
1384
commands = commands_from_options(options)
1385
self.assertEqual(len(commands), 2)
1386
self.assertIsInstance(commands[0], DenyCmd)
1387
self.assertIsInstance(commands[1], RemoveCmd)
1390
class Test_check_option_syntax(unittest.TestCase):
1391
# This mostly corresponds to the definition from has_actions() in
1392
# check_option_syntax()
1394
# The actual values set here are not that important, but we do
1395
# at least stick to the correct types, even though they are
1399
"bump_timeout": True,
1400
"start_checker": True,
1401
"stop_checker": True,
1405
"timeout": datetime.timedelta(),
1406
"extended_timeout": datetime.timedelta(),
1407
"interval": datetime.timedelta(),
1408
"approved_by_default": True,
1409
"approval_delay": datetime.timedelta(),
1410
"approval_duration": datetime.timedelta(),
1412
"secret": io.BytesIO(b"x"),
1418
self.parser = argparse.ArgumentParser()
1419
add_command_line_options(self.parser)
1421
@contextlib.contextmanager
1422
def assertParseError(self):
1423
with self.assertRaises(SystemExit) as e:
1424
with self.temporarily_suppress_stderr():
1426
# Exit code from argparse is guaranteed to be "2". Reference:
1427
# https://docs.python.org/3/library/argparse.html#exiting-methods
1428
self.assertEqual(e.exception.code, 2)
1431
@contextlib.contextmanager
1432
def temporarily_suppress_stderr():
1433
null = os.open(os.path.devnull, os.O_RDWR)
1434
stderrcopy = os.dup(sys.stderr.fileno())
1435
os.dup2(null, sys.stderr.fileno())
1441
os.dup2(stderrcopy, sys.stderr.fileno())
1442
os.close(stderrcopy)
1444
def check_option_syntax(self, options):
1445
check_option_syntax(self.parser, options)
1447
def test_actions_requires_client_or_all(self):
1448
for action, value in self.actions.items():
1449
options = self.parser.parse_args()
1450
setattr(options, action, value)
1451
with self.assertParseError():
1452
self.check_option_syntax(options)
1454
def test_actions_conflicts_with_verbose(self):
1455
for action, value in self.actions.items():
1456
options = self.parser.parse_args()
1457
setattr(options, action, value)
1458
options.verbose = True
1459
with self.assertParseError():
1460
self.check_option_syntax(options)
1462
def test_dump_json_conflicts_with_verbose(self):
1463
options = self.parser.parse_args()
1464
options.dump_json = True
1465
options.verbose = True
1466
with self.assertParseError():
1467
self.check_option_syntax(options)
1469
def test_dump_json_conflicts_with_action(self):
1470
for action, value in self.actions.items():
1471
options = self.parser.parse_args()
1472
setattr(options, action, value)
1473
options.dump_json = True
1474
with self.assertParseError():
1475
self.check_option_syntax(options)
1477
def test_all_can_not_be_alone(self):
1478
options = self.parser.parse_args()
1480
with self.assertParseError():
1481
self.check_option_syntax(options)
1483
def test_all_is_ok_with_any_action(self):
1484
for action, value in self.actions.items():
1485
options = self.parser.parse_args()
1486
setattr(options, action, value)
1488
self.check_option_syntax(options)
1490
def test_is_enabled_fails_without_client(self):
1491
options = self.parser.parse_args()
1492
options.is_enabled = True
1493
with self.assertParseError():
1494
self.check_option_syntax(options)
1496
def test_is_enabled_works_with_one_client(self):
1497
options = self.parser.parse_args()
1498
options.is_enabled = True
1499
options.client = ["foo"]
1500
self.check_option_syntax(options)
1502
def test_is_enabled_fails_with_two_clients(self):
1503
options = self.parser.parse_args()
1504
options.is_enabled = True
1505
options.client = ["foo", "barbar"]
1506
with self.assertParseError():
1507
self.check_option_syntax(options)
1509
def test_remove_can_only_be_combined_with_action_deny(self):
1510
for action, value in self.actions.items():
1511
if action in {"remove", "deny"}:
1513
options = self.parser.parse_args()
1514
setattr(options, action, value)
1516
options.remove = True
1517
with self.assertParseError():
1518
self.check_option_syntax(options)
2809
def parse_test_args():
2810
# type: () -> argparse.Namespace
1522
def should_only_run_tests():
2811
1523
parser = argparse.ArgumentParser(add_help=False)
2812
parser.add_argument("--check", action="store_true")
2813
parser.add_argument("--prefix", )
1524
parser.add_argument("--check", action='store_true')
2814
1525
args, unknown_args = parser.parse_known_args()
2816
# Remove test options from sys.argv
1526
run_tests = args.check
1528
# Remove --check argument from sys.argv
2817
1529
sys.argv[1:] = unknown_args
2820
1532
# Add all tests from doctest strings
2821
1533
def load_tests(loader, tests, none):