271
## Classes for commands.
273
# Abstract classes first
274
class Command(object):
275
"""Abstract class for commands"""
276
def run(self, mandos, clients):
277
"""Normal commands should implement run_on_one_client(), but
278
commands which want to operate on all clients at the same time
279
can override this run() method instead."""
281
for client in clients:
282
self.run_on_one_client(client)
284
class PrintCmd(Command):
285
"""Abstract class for commands printing client details"""
286
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
287
"Created", "Interval", "Host", "KeyID",
288
"Fingerprint", "CheckerRunning", "LastEnabled",
289
"ApprovalPending", "ApprovedByDefault",
290
"LastApprovalRequest", "ApprovalDelay",
291
"ApprovalDuration", "Checker", "ExtendedTimeout",
292
"Expires", "LastCheckerStatus")
293
def run(self, mandos, clients):
294
print(self.output(clients))
296
class PropertyCmd(Command):
297
"""Abstract class for Actions for setting one client property"""
298
def run_on_one_client(self, client):
299
"""Set the Client's D-Bus property"""
300
client.Set(client_interface, self.property, self.value_to_set,
301
dbus_interface=dbus.PROPERTIES_IFACE)
303
class ValueArgumentMixIn(object):
304
"""Mixin class for commands taking a value as argument"""
305
def __init__(self, value):
306
self.value_to_set = value
308
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
309
"""Mixin class for commands taking a value argument as
312
def value_to_set(self):
315
def value_to_set(self, value):
316
"""When setting, convert value to a datetime.timedelta"""
317
self._vts = string_to_delta(value).total_seconds() * 1000
319
# Actual (non-abstract) command classes
321
class PrintTableCmd(PrintCmd):
322
def __init__(self, verbose=False):
323
self.verbose = verbose
325
def output(self, clients):
327
keywords = self.all_keywords
329
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
330
return str(self.TableOfClients(clients.values(), keywords))
332
class TableOfClients(object):
335
"Enabled": "Enabled",
336
"Timeout": "Timeout",
337
"LastCheckedOK": "Last Successful Check",
338
"LastApprovalRequest": "Last Approval Request",
339
"Created": "Created",
340
"Interval": "Interval",
342
"Fingerprint": "Fingerprint",
344
"CheckerRunning": "Check Is Running",
345
"LastEnabled": "Last Enabled",
346
"ApprovalPending": "Approval Is Pending",
347
"ApprovedByDefault": "Approved By Default",
348
"ApprovalDelay": "Approval Delay",
349
"ApprovalDuration": "Approval Duration",
350
"Checker": "Checker",
351
"ExtendedTimeout": "Extended Timeout",
352
"Expires": "Expires",
353
"LastCheckerStatus": "Last Checker Status",
356
def __init__(self, clients, keywords, tableheaders=None):
357
self.clients = clients
358
self.keywords = keywords
359
if tableheaders is not None:
360
self.tableheaders = tableheaders
363
return "\n".join(self.rows())
365
if sys.version_info.major == 2:
366
__unicode__ = __str__
368
return str(self).encode(locale.getpreferredencoding())
371
format_string = self.row_formatting_string()
372
rows = [self.header_line(format_string)]
373
rows.extend(self.client_line(client, format_string)
374
for client in self.clients)
377
def row_formatting_string(self):
378
"Format string used to format table rows"
379
return " ".join("{{{key}:{width}}}".format(
380
width=max(len(self.tableheaders[key]),
381
*(len(self.string_from_client(client, key))
382
for client in self.clients)),
384
for key in self.keywords)
386
def string_from_client(self, client, key):
387
return self.valuetostring(client[key], key)
390
def valuetostring(value, keyword):
391
if isinstance(value, dbus.Boolean):
392
return "Yes" if value else "No"
393
if keyword in ("Timeout", "Interval", "ApprovalDelay",
394
"ApprovalDuration", "ExtendedTimeout"):
395
return milliseconds_to_string(value)
398
def header_line(self, format_string):
399
return format_string.format(**self.tableheaders)
401
def client_line(self, client, format_string):
402
return format_string.format(
403
**{key: self.string_from_client(client, key)
404
for key in self.keywords})
408
class DumpJSONCmd(PrintCmd):
409
def output(self, clients):
410
data = {client["Name"]:
411
{key: self.dbus_boolean_to_bool(client[key])
412
for key in self.all_keywords}
413
for client in clients.values()}
414
return json.dumps(data, indent=4, separators=(',', ': '))
416
def dbus_boolean_to_bool(value):
417
if isinstance(value, dbus.Boolean):
421
class IsEnabledCmd(Command):
422
def run_on_one_client(self, client):
423
if self.is_enabled(client):
385
def check_option_syntax(parser, options):
386
"""Apply additional restrictions on options, not expressible in
389
def has_actions(options):
390
return any((options.enable,
392
options.bump_timeout,
393
options.start_checker,
394
options.stop_checker,
397
options.checker is not None,
398
options.timeout is not None,
399
options.extended_timeout is not None,
400
options.interval is not None,
401
options.approved_by_default is not None,
402
options.approval_delay is not None,
403
options.approval_duration is not None,
404
options.host is not None,
405
options.secret is not None,
409
if has_actions(options) and not (options.client or options.all):
410
parser.error("Options require clients names or --all.")
411
if options.verbose and has_actions(options):
412
parser.error("--verbose can only be used alone.")
413
if options.dump_json and (options.verbose
414
or has_actions(options)):
415
parser.error("--dump-json can only be used alone.")
416
if options.all and not has_actions(options):
417
parser.error("--all requires an action.")
418
if options.is_enabled and len(options.client) > 1:
419
parser.error("--is-enabled requires exactly one client")
421
options.remove = False
422
if has_actions(options) and not options.deny:
423
parser.error("--remove can only be combined with --deny")
424
options.remove = True
427
def get_mandos_dbus_object(bus):
428
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
429
dbus_busname, server_dbus_path)
430
with if_dbus_exception_log_with_exception_and_exit(
431
"Could not connect to Mandos server: %s"):
432
mandos_dbus_object = bus.get_object(dbus_busname,
434
return mandos_dbus_object
437
@contextlib.contextmanager
438
def if_dbus_exception_log_with_exception_and_exit(*args, **kwargs):
441
except dbus.exceptions.DBusException as e:
442
log.critical(*(args + (e,)), **kwargs)
426
def is_enabled(self, client):
427
return client.Get(client_interface, "Enabled",
428
dbus_interface=dbus.PROPERTIES_IFACE)
430
class RemoveCmd(Command):
431
def run_on_one_client(self, client):
432
self.mandos.RemoveClient(client.__dbus_object_path__)
434
class ApproveCmd(Command):
435
def run_on_one_client(self, client):
436
client.Approve(dbus.Boolean(True),
437
dbus_interface=client_interface)
439
class DenyCmd(Command):
440
def run_on_one_client(self, client):
441
client.Approve(dbus.Boolean(False),
442
dbus_interface=client_interface)
444
class EnableCmd(PropertyCmd):
446
value_to_set = dbus.Boolean(True)
448
class DisableCmd(PropertyCmd):
450
value_to_set = dbus.Boolean(False)
452
class BumpTimeoutCmd(PropertyCmd):
453
property = "LastCheckedOK"
456
class StartCheckerCmd(PropertyCmd):
457
property = "CheckerRunning"
458
value_to_set = dbus.Boolean(True)
460
class StopCheckerCmd(PropertyCmd):
461
property = "CheckerRunning"
462
value_to_set = dbus.Boolean(False)
464
class ApproveByDefaultCmd(PropertyCmd):
465
property = "ApprovedByDefault"
466
value_to_set = dbus.Boolean(True)
468
class DenyByDefaultCmd(PropertyCmd):
469
property = "ApprovedByDefault"
470
value_to_set = dbus.Boolean(False)
472
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
475
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
478
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
481
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
484
class SetExtendedTimeoutCmd(PropertyCmd,
485
MillisecondsValueArgumentMixIn):
486
property = "ExtendedTimeout"
488
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
489
property = "Interval"
491
class SetApprovalDelayCmd(PropertyCmd,
492
MillisecondsValueArgumentMixIn):
493
property = "ApprovalDelay"
495
class SetApprovalDurationCmd(PropertyCmd,
496
MillisecondsValueArgumentMixIn):
497
property = "ApprovalDuration"
499
def has_actions(options):
500
return any((options.enable,
502
options.bump_timeout,
503
options.start_checker,
504
options.stop_checker,
507
options.checker is not None,
508
options.timeout is not None,
509
options.extended_timeout is not None,
510
options.interval is not None,
511
options.approved_by_default is not None,
512
options.approval_delay is not None,
513
options.approval_duration is not None,
514
options.host is not None,
515
options.secret is not None,
519
def add_command_line_options(parser):
520
parser.add_argument("--version", action="version",
521
version="%(prog)s {}".format(version),
522
help="show version number and exit")
523
parser.add_argument("-a", "--all", action="store_true",
524
help="Select all clients")
525
parser.add_argument("-v", "--verbose", action="store_true",
526
help="Print all fields")
527
parser.add_argument("-j", "--dump-json", action="store_true",
528
help="Dump client data in JSON format")
529
enable_disable = parser.add_mutually_exclusive_group()
530
enable_disable.add_argument("-e", "--enable", action="store_true",
531
help="Enable client")
532
enable_disable.add_argument("-d", "--disable",
534
help="disable client")
535
parser.add_argument("-b", "--bump-timeout", action="store_true",
536
help="Bump timeout for client")
537
start_stop_checker = parser.add_mutually_exclusive_group()
538
start_stop_checker.add_argument("--start-checker",
540
help="Start checker for client")
541
start_stop_checker.add_argument("--stop-checker",
543
help="Stop checker for client")
544
parser.add_argument("-V", "--is-enabled", action="store_true",
545
help="Check if client is enabled")
546
parser.add_argument("-r", "--remove", action="store_true",
547
help="Remove client")
548
parser.add_argument("-c", "--checker",
549
help="Set checker command for client")
550
parser.add_argument("-t", "--timeout",
551
help="Set timeout for client")
552
parser.add_argument("--extended-timeout",
553
help="Set extended timeout for client")
554
parser.add_argument("-i", "--interval",
555
help="Set checker interval for client")
556
approve_deny_default = parser.add_mutually_exclusive_group()
557
approve_deny_default.add_argument(
558
"--approve-by-default", action="store_true",
559
default=None, dest="approved_by_default",
560
help="Set client to be approved by default")
561
approve_deny_default.add_argument(
562
"--deny-by-default", action="store_false",
563
dest="approved_by_default",
564
help="Set client to be denied by default")
565
parser.add_argument("--approval-delay",
566
help="Set delay before client approve/deny")
567
parser.add_argument("--approval-duration",
568
help="Set duration of one client approval")
569
parser.add_argument("-H", "--host", help="Set host for client")
570
parser.add_argument("-s", "--secret",
571
type=argparse.FileType(mode="rb"),
572
help="Set password blob (file) for client")
573
approve_deny = parser.add_mutually_exclusive_group()
574
approve_deny.add_argument(
575
"-A", "--approve", action="store_true",
576
help="Approve any current client request")
577
approve_deny.add_argument("-D", "--deny", action="store_true",
578
help="Deny any current client request")
579
parser.add_argument("--check", action="store_true",
580
help="Run self-test")
581
parser.add_argument("client", nargs="*", help="Client name")
584
def commands_and_clients_from_options(options):
446
def get_managed_objects(object_manager):
447
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
448
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
449
with if_dbus_exception_log_with_exception_and_exit(
450
"Failed to access Mandos server through D-Bus:\n%s"):
451
with SilenceLogger("dbus.proxies"):
452
managed_objects = object_manager.GetManagedObjects()
453
return managed_objects
456
class SilenceLogger(object):
457
"Simple context manager to silence a particular logger"
458
def __init__(self, loggername):
459
self.logger = logging.getLogger(loggername)
462
self.logger.addFilter(self.nullfilter)
464
class NullFilter(logging.Filter):
465
def filter(self, record):
468
nullfilter = NullFilter()
470
def __exit__(self, exc_type, exc_val, exc_tb):
471
self.logger.removeFilter(self.nullfilter)
474
def commands_from_options(options):
478
if options.is_enabled:
479
commands.append(command.IsEnabled())
482
commands.append(command.Approve())
485
commands.append(command.Deny())
488
commands.append(command.Remove())
588
490
if options.dump_json:
589
commands.append(DumpJSONCmd())
491
commands.append(command.DumpJSON())
591
493
if options.enable:
592
commands.append(EnableCmd())
494
commands.append(command.Enable())
594
496
if options.disable:
595
commands.append(DisableCmd())
497
commands.append(command.Disable())
597
499
if options.bump_timeout:
598
commands.append(BumpTimeoutCmd(options.bump_timeout))
500
commands.append(command.BumpTimeout())
600
502
if options.start_checker:
601
commands.append(StartCheckerCmd())
503
commands.append(command.StartChecker())
603
505
if options.stop_checker:
604
commands.append(StopCheckerCmd())
606
if options.is_enabled:
607
commands.append(IsEnabledCmd())
610
commands.append(RemoveCmd())
506
commands.append(command.StopChecker())
508
if options.approved_by_default is not None:
509
if options.approved_by_default:
510
commands.append(command.ApproveByDefault())
512
commands.append(command.DenyByDefault())
612
514
if options.checker is not None:
613
commands.append(SetCheckerCmd())
515
commands.append(command.SetChecker(options.checker))
517
if options.host is not None:
518
commands.append(command.SetHost(options.host))
520
if options.secret is not None:
521
commands.append(command.SetSecret(options.secret))
615
523
if options.timeout is not None:
616
commands.append(SetTimeoutCmd(options.timeout))
524
commands.append(command.SetTimeout(options.timeout))
618
526
if options.extended_timeout:
620
SetExtendedTimeoutCmd(options.extended_timeout))
528
command.SetExtendedTimeout(options.extended_timeout))
622
530
if options.interval is not None:
623
command.append(SetIntervalCmd(options.interval))
625
if options.approved_by_default is not None:
626
if options.approved_by_default:
627
command.append(ApproveByDefaultCmd())
629
command.append(DenyByDefaultCmd())
531
commands.append(command.SetInterval(options.interval))
631
533
if options.approval_delay is not None:
632
command.append(SetApprovalDelayCmd(options.approval_delay))
535
command.SetApprovalDelay(options.approval_delay))
634
537
if options.approval_duration is not None:
636
SetApprovalDurationCmd(options.approval_duration))
638
if options.host is not None:
639
command.append(SetHostCmd(options.host))
641
if options.secret is not None:
642
command.append(SetSecretCmd(options.secret))
645
commands.append(ApproveCmd())
648
commands.append(DenyCmd())
539
command.SetApprovalDuration(options.approval_duration))
650
541
# If no command option has been given, show table of clients,
651
542
# optionally verbosely
653
commands.append(PrintTableCmd(verbose=options.verbose))
655
return commands, options.client
659
parser = argparse.ArgumentParser()
661
add_command_line_options(parser)
663
options = parser.parse_args()
665
if has_actions(options) and not (options.client or options.all):
666
parser.error("Options require clients names or --all.")
667
if options.verbose and has_actions(options):
668
parser.error("--verbose can only be used alone.")
669
if options.dump_json and (options.verbose
670
or has_actions(options)):
671
parser.error("--dump-json can only be used alone.")
672
if options.all and not has_actions(options):
673
parser.error("--all requires an action.")
674
if options.is_enabled and len(options.client) > 1:
675
parser.error("--is-enabled requires exactly one client")
677
commands, clientnames = commands_and_clients_from_options(options)
680
bus = dbus.SystemBus()
681
mandos_dbus_objc = bus.get_object(busname, server_path)
682
except dbus.exceptions.DBusException:
683
log.critical("Could not connect to Mandos server")
686
mandos_serv = dbus.Interface(mandos_dbus_objc,
687
dbus_interface=server_interface)
688
mandos_serv_object_manager = dbus.Interface(
689
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
691
# Filter out log message from dbus module
692
dbus_logger = logging.getLogger("dbus.proxies")
693
class NullFilter(logging.Filter):
694
def filter(self, record):
696
dbus_filter = NullFilter()
698
dbus_logger.addFilter(dbus_filter)
699
mandos_clients = {path: ifs_and_props[client_interface]
700
for path, ifs_and_props in
701
mandos_serv_object_manager
702
.GetManagedObjects().items()
703
if client_interface in ifs_and_props}
704
except dbus.exceptions.DBusException as e:
705
log.critical("Failed to access Mandos server through D-Bus:"
709
# restore dbus logger
710
dbus_logger.removeFilter(dbus_filter)
712
# Compile dict of (clients: properties) to process
716
clients = {bus.get_object(busname, path): properties
717
for path, properties in mandos_clients.items()}
719
for name in clientnames:
720
for path, client in mandos_clients.items():
721
if client["Name"] == name:
722
client_objc = bus.get_object(busname, path)
723
clients[client_objc] = client
726
log.critical("Client not found on server: %r", name)
729
# Run all commands on clients
730
for command in commands:
731
command.run(mandos_serv, clients)
544
commands.append(command.PrintTable(verbose=options.verbose))
549
class command(object):
550
"""A namespace for command classes"""
553
"""Abstract base class for commands"""
554
def run(self, clients, bus=None, mandos=None):
555
"""Normal commands should implement run_on_one_client(),
556
but commands which want to operate on all clients at the same time can
557
override this run() method instead.
559
for clientpath, properties in clients.items():
560
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
561
dbus_busname, str(clientpath))
562
client = bus.get_object(dbus_busname, clientpath)
563
self.run_on_one_client(client, properties)
566
class IsEnabled(Base):
567
def run(self, clients, bus=None, mandos=None):
568
client, properties = next(iter(clients.items()))
569
if self.is_enabled(client, properties):
572
def is_enabled(self, client, properties):
573
return properties["Enabled"]
577
def run_on_one_client(self, client, properties):
578
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
579
client.__dbus_object_path__,
580
client_dbus_interface)
581
client.Approve(dbus.Boolean(True),
582
dbus_interface=client_dbus_interface)
586
def run_on_one_client(self, client, properties):
587
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
588
client.__dbus_object_path__,
589
client_dbus_interface)
590
client.Approve(dbus.Boolean(False),
591
dbus_interface=client_dbus_interface)
595
def run(self, clients, bus, mandos):
596
for clientpath in clients.keys():
597
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)",
598
dbus_busname, server_dbus_path,
599
server_dbus_interface, clientpath)
600
mandos.RemoveClient(clientpath)
604
"""Abstract class for commands outputting client details"""
605
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
606
"Created", "Interval", "Host", "KeyID",
607
"Fingerprint", "CheckerRunning",
608
"LastEnabled", "ApprovalPending",
609
"ApprovedByDefault", "LastApprovalRequest",
610
"ApprovalDelay", "ApprovalDuration",
611
"Checker", "ExtendedTimeout", "Expires",
615
class DumpJSON(Output):
616
def run(self, clients, bus=None, mandos=None):
617
data = {client["Name"]:
618
{key: self.dbus_boolean_to_bool(client[key])
619
for key in self.all_keywords}
620
for client in clients.values()}
621
print(json.dumps(data, indent=4, separators=(',', ': ')))
624
def dbus_boolean_to_bool(value):
625
if isinstance(value, dbus.Boolean):
630
class PrintTable(Output):
631
def __init__(self, verbose=False):
632
self.verbose = verbose
634
def run(self, clients, bus=None, mandos=None):
635
default_keywords = ("Name", "Enabled", "Timeout",
637
keywords = default_keywords
639
keywords = self.all_keywords
640
print(self.TableOfClients(clients.values(), keywords))
642
class TableOfClients(object):
645
"Enabled": "Enabled",
646
"Timeout": "Timeout",
647
"LastCheckedOK": "Last Successful Check",
648
"LastApprovalRequest": "Last Approval Request",
649
"Created": "Created",
650
"Interval": "Interval",
652
"Fingerprint": "Fingerprint",
654
"CheckerRunning": "Check Is Running",
655
"LastEnabled": "Last Enabled",
656
"ApprovalPending": "Approval Is Pending",
657
"ApprovedByDefault": "Approved By Default",
658
"ApprovalDelay": "Approval Delay",
659
"ApprovalDuration": "Approval Duration",
660
"Checker": "Checker",
661
"ExtendedTimeout": "Extended Timeout",
662
"Expires": "Expires",
663
"LastCheckerStatus": "Last Checker Status",
666
def __init__(self, clients, keywords):
667
self.clients = clients
668
self.keywords = keywords
671
return "\n".join(self.rows())
673
if sys.version_info.major == 2:
674
__unicode__ = __str__
676
return str(self).encode(
677
locale.getpreferredencoding())
680
format_string = self.row_formatting_string()
681
rows = [self.header_line(format_string)]
682
rows.extend(self.client_line(client, format_string)
683
for client in self.clients)
686
def row_formatting_string(self):
687
"Format string used to format table rows"
688
return " ".join("{{{key}:{width}}}".format(
689
width=max(len(self.tableheaders[key]),
690
*(len(self.string_from_client(client,
692
for client in self.clients)),
694
for key in self.keywords)
696
def string_from_client(self, client, key):
697
return self.valuetostring(client[key], key)
700
def valuetostring(cls, value, keyword):
701
if isinstance(value, dbus.Boolean):
702
return "Yes" if value else "No"
703
if keyword in ("Timeout", "Interval", "ApprovalDelay",
704
"ApprovalDuration", "ExtendedTimeout"):
705
return cls.milliseconds_to_string(value)
708
def header_line(self, format_string):
709
return format_string.format(**self.tableheaders)
711
def client_line(self, client, format_string):
712
return format_string.format(
713
**{key: self.string_from_client(client, key)
714
for key in self.keywords})
717
def milliseconds_to_string(ms):
718
td = datetime.timedelta(0, 0, 0, ms)
719
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
720
.format(days="{}T".format(td.days)
722
hours=td.seconds // 3600,
723
minutes=(td.seconds % 3600) // 60,
724
seconds=td.seconds % 60))
727
class PropertySetter(Base):
728
"Abstract class for Actions for setting one client property"
730
def run_on_one_client(self, client, properties):
731
"""Set the Client's D-Bus property"""
732
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
733
client.__dbus_object_path__,
734
dbus.PROPERTIES_IFACE, client_dbus_interface,
735
self.propname, self.value_to_set
736
if not isinstance(self.value_to_set,
738
else bool(self.value_to_set))
739
client.Set(client_dbus_interface, self.propname,
741
dbus_interface=dbus.PROPERTIES_IFACE)
745
raise NotImplementedError()
748
class Enable(PropertySetter):
750
value_to_set = dbus.Boolean(True)
753
class Disable(PropertySetter):
755
value_to_set = dbus.Boolean(False)
758
class BumpTimeout(PropertySetter):
759
propname = "LastCheckedOK"
763
class StartChecker(PropertySetter):
764
propname = "CheckerRunning"
765
value_to_set = dbus.Boolean(True)
768
class StopChecker(PropertySetter):
769
propname = "CheckerRunning"
770
value_to_set = dbus.Boolean(False)
773
class ApproveByDefault(PropertySetter):
774
propname = "ApprovedByDefault"
775
value_to_set = dbus.Boolean(True)
778
class DenyByDefault(PropertySetter):
779
propname = "ApprovedByDefault"
780
value_to_set = dbus.Boolean(False)
783
class PropertySetterValue(PropertySetter):
784
"""Abstract class for PropertySetter recieving a value as
785
constructor argument instead of a class attribute."""
786
def __init__(self, value):
787
self.value_to_set = value
790
class SetChecker(PropertySetterValue):
794
class SetHost(PropertySetterValue):
798
class SetSecret(PropertySetterValue):
802
def value_to_set(self):
806
def value_to_set(self, value):
807
"""When setting, read data from supplied file object"""
808
self._vts = value.read()
812
class PropertySetterValueMilliseconds(PropertySetterValue):
813
"""Abstract class for PropertySetterValue taking a value
814
argument as a datetime.timedelta() but should store it as
818
def value_to_set(self):
822
def value_to_set(self, value):
823
"When setting, convert value from a datetime.timedelta"
824
self._vts = int(round(value.total_seconds() * 1000))
827
class SetTimeout(PropertySetterValueMilliseconds):
831
class SetExtendedTimeout(PropertySetterValueMilliseconds):
832
propname = "ExtendedTimeout"
835
class SetInterval(PropertySetterValueMilliseconds):
836
propname = "Interval"
839
class SetApprovalDelay(PropertySetterValueMilliseconds):
840
propname = "ApprovalDelay"
843
class SetApprovalDuration(PropertySetterValueMilliseconds):
844
propname = "ApprovalDuration"
734
class Test_milliseconds_to_string(unittest.TestCase):
736
self.assertEqual(milliseconds_to_string(93785000),
738
def test_no_days(self):
739
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
740
def test_all_zero(self):
741
self.assertEqual(milliseconds_to_string(0), "00:00:00")
742
def test_no_fractional_seconds(self):
743
self.assertEqual(milliseconds_to_string(400), "00:00:00")
744
self.assertEqual(milliseconds_to_string(900), "00:00:00")
745
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
747
class Test_string_to_delta(unittest.TestCase):
748
def test_handles_basic_rfc3339(self):
749
self.assertEqual(string_to_delta("PT2H"),
750
datetime.timedelta(0, 7200))
848
class TestCaseWithAssertLogs(unittest.TestCase):
849
"""unittest.TestCase.assertLogs only exists in Python 3.4"""
851
if not hasattr(unittest.TestCase, "assertLogs"):
852
@contextlib.contextmanager
853
def assertLogs(self, logger, level=logging.INFO):
854
capturing_handler = self.CapturingLevelHandler(level)
855
old_level = logger.level
856
old_propagate = logger.propagate
857
logger.addHandler(capturing_handler)
858
logger.setLevel(level)
859
logger.propagate = False
861
yield capturing_handler.watcher
863
logger.propagate = old_propagate
864
logger.removeHandler(capturing_handler)
865
logger.setLevel(old_level)
866
self.assertGreater(len(capturing_handler.watcher.records),
869
class CapturingLevelHandler(logging.Handler):
870
def __init__(self, level, *args, **kwargs):
871
logging.Handler.__init__(self, *args, **kwargs)
872
self.watcher = self.LoggingWatcher([], [])
873
def emit(self, record):
874
self.watcher.records.append(record)
875
self.watcher.output.append(self.format(record))
877
LoggingWatcher = collections.namedtuple("LoggingWatcher",
882
class Test_string_to_delta(TestCaseWithAssertLogs):
883
# Just test basic RFC 3339 functionality here, the doc string for
884
# rfc3339_duration_to_delta() already has more comprehensive
885
# tests, which is run by doctest.
887
def test_rfc3339_zero_seconds(self):
888
self.assertEqual(datetime.timedelta(),
889
string_to_delta("PT0S"))
891
def test_rfc3339_zero_days(self):
892
self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))
894
def test_rfc3339_one_second(self):
895
self.assertEqual(datetime.timedelta(0, 1),
896
string_to_delta("PT1S"))
898
def test_rfc3339_two_hours(self):
899
self.assertEqual(datetime.timedelta(0, 7200),
900
string_to_delta("PT2H"))
751
902
def test_falls_back_to_pre_1_6_1_with_warning(self):
752
# assertLogs only exists in Python 3.4
753
if hasattr(self, "assertLogs"):
754
with self.assertLogs(log, logging.WARNING):
755
value = string_to_delta("2h")
757
class WarningFilter(logging.Filter):
758
"""Don't show, but record the presence of, warnings"""
759
def filter(self, record):
760
is_warning = record.levelno >= logging.WARNING
761
self.found = is_warning or getattr(self, "found",
763
return not is_warning
764
warning_filter = WarningFilter()
765
log.addFilter(warning_filter)
903
with self.assertLogs(log, logging.WARNING):
904
value = string_to_delta("2h")
905
self.assertEqual(datetime.timedelta(0, 7200), value)
908
class Test_check_option_syntax(unittest.TestCase):
910
self.parser = argparse.ArgumentParser()
911
add_command_line_options(self.parser)
913
def test_actions_requires_client_or_all(self):
914
for action, value in self.actions.items():
915
options = self.parser.parse_args()
916
setattr(options, action, value)
917
with self.assertParseError():
918
self.check_option_syntax(options)
920
# This mostly corresponds to the definition from has_actions() in
921
# check_option_syntax()
923
# The actual values set here are not that important, but we do
924
# at least stick to the correct types, even though they are
928
"bump_timeout": True,
929
"start_checker": True,
930
"stop_checker": True,
934
"timeout": datetime.timedelta(),
935
"extended_timeout": datetime.timedelta(),
936
"interval": datetime.timedelta(),
937
"approved_by_default": True,
938
"approval_delay": datetime.timedelta(),
939
"approval_duration": datetime.timedelta(),
941
"secret": io.BytesIO(b"x"),
946
@contextlib.contextmanager
947
def assertParseError(self):
948
with self.assertRaises(SystemExit) as e:
949
with self.redirect_stderr_to_devnull():
951
# Exit code from argparse is guaranteed to be "2". Reference:
952
# https://docs.python.org/3/library
953
# /argparse.html#exiting-methods
954
self.assertEqual(2, e.exception.code)
957
@contextlib.contextmanager
958
def redirect_stderr_to_devnull():
959
old_stderr = sys.stderr
960
with contextlib.closing(open(os.devnull, "w")) as null:
767
value = string_to_delta("2h")
769
log.removeFilter(warning_filter)
770
self.assertTrue(getattr(warning_filter, "found", False))
771
self.assertEqual(value, datetime.timedelta(0, 7200))
774
class TestCmd(unittest.TestCase):
965
sys.stderr = old_stderr
967
def check_option_syntax(self, options):
968
check_option_syntax(self.parser, options)
970
def test_actions_all_conflicts_with_verbose(self):
971
for action, value in self.actions.items():
972
options = self.parser.parse_args()
973
setattr(options, action, value)
975
options.verbose = True
976
with self.assertParseError():
977
self.check_option_syntax(options)
979
def test_actions_with_client_conflicts_with_verbose(self):
980
for action, value in self.actions.items():
981
options = self.parser.parse_args()
982
setattr(options, action, value)
983
options.verbose = True
984
options.client = ["client"]
985
with self.assertParseError():
986
self.check_option_syntax(options)
988
def test_dump_json_conflicts_with_verbose(self):
989
options = self.parser.parse_args()
990
options.dump_json = True
991
options.verbose = True
992
with self.assertParseError():
993
self.check_option_syntax(options)
995
def test_dump_json_conflicts_with_action(self):
996
for action, value in self.actions.items():
997
options = self.parser.parse_args()
998
setattr(options, action, value)
999
options.dump_json = True
1000
with self.assertParseError():
1001
self.check_option_syntax(options)
1003
def test_all_can_not_be_alone(self):
1004
options = self.parser.parse_args()
1006
with self.assertParseError():
1007
self.check_option_syntax(options)
1009
def test_all_is_ok_with_any_action(self):
1010
for action, value in self.actions.items():
1011
options = self.parser.parse_args()
1012
setattr(options, action, value)
1014
self.check_option_syntax(options)
1016
def test_any_action_is_ok_with_one_client(self):
1017
for action, value in self.actions.items():
1018
options = self.parser.parse_args()
1019
setattr(options, action, value)
1020
options.client = ["client"]
1021
self.check_option_syntax(options)
1023
def test_one_client_with_all_actions_except_is_enabled(self):
1024
options = self.parser.parse_args()
1025
for action, value in self.actions.items():
1026
if action == "is_enabled":
1028
setattr(options, action, value)
1029
options.client = ["client"]
1030
self.check_option_syntax(options)
1032
def test_two_clients_with_all_actions_except_is_enabled(self):
1033
options = self.parser.parse_args()
1034
for action, value in self.actions.items():
1035
if action == "is_enabled":
1037
setattr(options, action, value)
1038
options.client = ["client1", "client2"]
1039
self.check_option_syntax(options)
1041
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1042
for action, value in self.actions.items():
1043
if action == "is_enabled":
1045
options = self.parser.parse_args()
1046
setattr(options, action, value)
1047
options.client = ["client1", "client2"]
1048
self.check_option_syntax(options)
1050
def test_is_enabled_fails_without_client(self):
1051
options = self.parser.parse_args()
1052
options.is_enabled = True
1053
with self.assertParseError():
1054
self.check_option_syntax(options)
1056
def test_is_enabled_fails_with_two_clients(self):
1057
options = self.parser.parse_args()
1058
options.is_enabled = True
1059
options.client = ["client1", "client2"]
1060
with self.assertParseError():
1061
self.check_option_syntax(options)
1063
def test_remove_can_only_be_combined_with_action_deny(self):
1064
for action, value in self.actions.items():
1065
if action in {"remove", "deny"}:
1067
options = self.parser.parse_args()
1068
setattr(options, action, value)
1070
options.remove = True
1071
with self.assertParseError():
1072
self.check_option_syntax(options)
1075
class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):
1076
def test_calls_and_returns_get_object_on_bus(self):
1077
class MockBus(object):
1079
def get_object(mockbus_self, busname, dbus_path):
1080
# Note that "self" is still the testcase instance,
1081
# this MockBus instance is in "mockbus_self".
1082
self.assertEqual(dbus_busname, busname)
1083
self.assertEqual(server_dbus_path, dbus_path)
1084
mockbus_self.called = True
1087
mockbus = get_mandos_dbus_object(bus=MockBus())
1088
self.assertIsInstance(mockbus, MockBus)
1089
self.assertTrue(mockbus.called)
1091
def test_logs_and_exits_on_dbus_error(self):
1092
class FailingBusStub(object):
1093
def get_object(self, busname, dbus_path):
1094
raise dbus.exceptions.DBusException("Test")
1096
with self.assertLogs(log, logging.CRITICAL):
1097
with self.assertRaises(SystemExit) as e:
1098
bus = get_mandos_dbus_object(bus=FailingBusStub())
1100
if isinstance(e.exception.code, int):
1101
self.assertNotEqual(0, e.exception.code)
1103
self.assertIsNotNone(e.exception.code)
1106
class Test_get_managed_objects(TestCaseWithAssertLogs):
1107
def test_calls_and_returns_GetManagedObjects(self):
1108
managed_objects = {"/clients/client": { "Name": "client"}}
1109
class ObjectManagerStub(object):
1110
def GetManagedObjects(self):
1111
return managed_objects
1112
retval = get_managed_objects(ObjectManagerStub())
1113
self.assertDictEqual(managed_objects, retval)
1115
def test_logs_and_exits_on_dbus_error(self):
1116
dbus_logger = logging.getLogger("dbus.proxies")
1118
class ObjectManagerFailingStub(object):
1119
def GetManagedObjects(self):
1120
dbus_logger.error("Test")
1121
raise dbus.exceptions.DBusException("Test")
1123
class CountingHandler(logging.Handler):
1125
def emit(self, record):
1128
counting_handler = CountingHandler()
1130
dbus_logger.addHandler(counting_handler)
1133
with self.assertLogs(log, logging.CRITICAL) as watcher:
1134
with self.assertRaises(SystemExit) as e:
1135
get_managed_objects(ObjectManagerFailingStub())
1137
dbus_logger.removeFilter(counting_handler)
1139
# Make sure the dbus logger was suppressed
1140
self.assertEqual(0, counting_handler.count)
1142
# Test that the dbus_logger still works
1143
with self.assertLogs(dbus_logger, logging.ERROR):
1144
dbus_logger.error("Test")
1146
if isinstance(e.exception.code, int):
1147
self.assertNotEqual(0, e.exception.code)
1149
self.assertIsNotNone(e.exception.code)
1152
class Test_commands_from_options(unittest.TestCase):
1154
self.parser = argparse.ArgumentParser()
1155
add_command_line_options(self.parser)
1157
def test_is_enabled(self):
1158
self.assert_command_from_args(["--is-enabled", "client"],
1161
def assert_command_from_args(self, args, command_cls,
1163
"""Assert that parsing ARGS should result in an instance of
1164
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1165
options = self.parser.parse_args(args)
1166
check_option_syntax(self.parser, options)
1167
commands = commands_from_options(options)
1168
self.assertEqual(1, len(commands))
1169
command = commands[0]
1170
self.assertIsInstance(command, command_cls)
1171
for key, value in cmd_attrs.items():
1172
self.assertEqual(value, getattr(command, key))
1174
def test_is_enabled_short(self):
1175
self.assert_command_from_args(["-V", "client"],
1178
def test_approve(self):
1179
self.assert_command_from_args(["--approve", "client"],
1182
def test_approve_short(self):
1183
self.assert_command_from_args(["-A", "client"],
1186
def test_deny(self):
1187
self.assert_command_from_args(["--deny", "client"],
1190
def test_deny_short(self):
1191
self.assert_command_from_args(["-D", "client"], command.Deny)
1193
def test_remove(self):
1194
self.assert_command_from_args(["--remove", "client"],
1197
def test_deny_before_remove(self):
1198
options = self.parser.parse_args(["--deny", "--remove",
1200
check_option_syntax(self.parser, options)
1201
commands = commands_from_options(options)
1202
self.assertEqual(2, len(commands))
1203
self.assertIsInstance(commands[0], command.Deny)
1204
self.assertIsInstance(commands[1], command.Remove)
1206
def test_deny_before_remove_reversed(self):
1207
options = self.parser.parse_args(["--remove", "--deny",
1209
check_option_syntax(self.parser, options)
1210
commands = commands_from_options(options)
1211
self.assertEqual(2, len(commands))
1212
self.assertIsInstance(commands[0], command.Deny)
1213
self.assertIsInstance(commands[1], command.Remove)
1215
def test_remove_short(self):
1216
self.assert_command_from_args(["-r", "client"],
1219
def test_dump_json(self):
1220
self.assert_command_from_args(["--dump-json"],
1223
def test_enable(self):
1224
self.assert_command_from_args(["--enable", "client"],
1227
def test_enable_short(self):
1228
self.assert_command_from_args(["-e", "client"],
1231
def test_disable(self):
1232
self.assert_command_from_args(["--disable", "client"],
1235
def test_disable_short(self):
1236
self.assert_command_from_args(["-d", "client"],
1239
def test_bump_timeout(self):
1240
self.assert_command_from_args(["--bump-timeout", "client"],
1241
command.BumpTimeout)
1243
def test_bump_timeout_short(self):
1244
self.assert_command_from_args(["-b", "client"],
1245
command.BumpTimeout)
1247
def test_start_checker(self):
1248
self.assert_command_from_args(["--start-checker", "client"],
1249
command.StartChecker)
1251
def test_stop_checker(self):
1252
self.assert_command_from_args(["--stop-checker", "client"],
1253
command.StopChecker)
1255
def test_approve_by_default(self):
1256
self.assert_command_from_args(["--approve-by-default",
1258
command.ApproveByDefault)
1260
def test_deny_by_default(self):
1261
self.assert_command_from_args(["--deny-by-default", "client"],
1262
command.DenyByDefault)
1264
def test_checker(self):
1265
self.assert_command_from_args(["--checker", ":", "client"],
1269
def test_checker_empty(self):
1270
self.assert_command_from_args(["--checker", "", "client"],
1274
def test_checker_short(self):
1275
self.assert_command_from_args(["-c", ":", "client"],
1279
def test_host(self):
1280
self.assert_command_from_args(
1281
["--host", "client.example.org", "client"],
1282
command.SetHost, value_to_set="client.example.org")
1284
def test_host_short(self):
1285
self.assert_command_from_args(
1286
["-H", "client.example.org", "client"], command.SetHost,
1287
value_to_set="client.example.org")
1289
def test_secret_devnull(self):
1290
self.assert_command_from_args(["--secret", os.path.devnull,
1291
"client"], command.SetSecret,
1294
def test_secret_tempfile(self):
1295
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1296
value = b"secret\0xyzzy\nbar"
1299
self.assert_command_from_args(["--secret", f.name,
1304
def test_secret_devnull_short(self):
1305
self.assert_command_from_args(["-s", os.path.devnull,
1306
"client"], command.SetSecret,
1309
def test_secret_tempfile_short(self):
1310
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1311
value = b"secret\0xyzzy\nbar"
1314
self.assert_command_from_args(["-s", f.name, "client"],
1318
def test_timeout(self):
1319
self.assert_command_from_args(["--timeout", "PT5M", "client"],
1321
value_to_set=300000)
1323
def test_timeout_short(self):
1324
self.assert_command_from_args(["-t", "PT5M", "client"],
1326
value_to_set=300000)
1328
def test_extended_timeout(self):
1329
self.assert_command_from_args(["--extended-timeout", "PT15M",
1331
command.SetExtendedTimeout,
1332
value_to_set=900000)
1334
def test_interval(self):
1335
self.assert_command_from_args(["--interval", "PT2M",
1336
"client"], command.SetInterval,
1337
value_to_set=120000)
1339
def test_interval_short(self):
1340
self.assert_command_from_args(["-i", "PT2M", "client"],
1341
command.SetInterval,
1342
value_to_set=120000)
1344
def test_approval_delay(self):
1345
self.assert_command_from_args(["--approval-delay", "PT30S",
1347
command.SetApprovalDelay,
1350
def test_approval_duration(self):
1351
self.assert_command_from_args(["--approval-duration", "PT1S",
1353
command.SetApprovalDuration,
1356
def test_print_table(self):
1357
self.assert_command_from_args([], command.PrintTable,
1360
def test_print_table_verbose(self):
1361
self.assert_command_from_args(["--verbose"],
1365
def test_print_table_verbose_short(self):
1366
self.assert_command_from_args(["-v"], command.PrintTable,
1370
class TestCommand(unittest.TestCase):
775
1371
"""Abstract class for tests of command classes"""
776
1373
def setUp(self):
778
1375
class MockClient(object):
779
1376
def __init__(self, name, **attributes):
780
self.__dbus_object_path__ = "objpath_{}".format(name)
1377
self.__dbus_object_path__ = "/clients/{}".format(name)
781
1378
self.attributes = attributes
782
1379
self.attributes["Name"] = name
784
def Set(self, interface, property, value, dbus_interface):
785
testcase.assertEqual(interface, client_interface)
786
testcase.assertEqual(dbus_interface,
787
dbus.PROPERTIES_IFACE)
788
self.attributes[property] = value
789
self.calls.append(("Set", (interface, property, value,
791
def Get(self, interface, property, dbus_interface):
792
testcase.assertEqual(interface, client_interface)
793
testcase.assertEqual(dbus_interface,
794
dbus.PROPERTIES_IFACE)
795
self.calls.append(("Get", (interface, property,
797
return self.attributes[property]
798
def __getitem__(self, key):
799
return self.attributes[key]
800
def __setitem__(self, key, value):
801
self.attributes[key] = value
802
self.clients = collections.OrderedDict([
806
KeyID=("92ed150794387c03ce684574b1139a65"
807
"94a34f895daaaf09fd8ea90a27cddb12"),
809
Host="foo.example.org",
810
Enabled=dbus.Boolean(True),
812
LastCheckedOK="2019-02-03T00:00:00",
813
Created="2019-01-02T00:00:00",
815
Fingerprint=("778827225BA7DE539C5A"
816
"7CFA59CFF7CDBD9A5920"),
817
CheckerRunning=dbus.Boolean(False),
818
LastEnabled="2019-01-03T00:00:00",
819
ApprovalPending=dbus.Boolean(False),
820
ApprovedByDefault=dbus.Boolean(True),
821
LastApprovalRequest="",
823
ApprovalDuration=1000,
824
Checker="fping -q -- %(host)s",
825
ExtendedTimeout=900000,
826
Expires="2019-02-04T00:00:00",
827
LastCheckerStatus=0)),
831
KeyID=("0558568eedd67d622f5c83b35a115f79"
832
"6ab612cff5ad227247e46c2b020f441c"),
835
Enabled=dbus.Boolean(True),
837
LastCheckedOK="2019-02-04T00:00:00",
838
Created="2019-01-03T00:00:00",
840
Fingerprint=("3E393AEAEFB84C7E89E2"
841
"F547B3A107558FCA3A27"),
842
CheckerRunning=dbus.Boolean(True),
843
LastEnabled="2019-01-04T00:00:00",
844
ApprovalPending=dbus.Boolean(False),
845
ApprovedByDefault=dbus.Boolean(False),
846
LastApprovalRequest="2019-01-03T00:00:00",
848
ApprovalDuration=1000,
850
ExtendedTimeout=900000,
851
Expires="2019-02-05T00:00:00",
852
LastCheckerStatus=-2)),
1381
def Set(self, interface, propname, value, dbus_interface):
1382
testcase.assertEqual(client_dbus_interface, interface)
1383
testcase.assertEqual(dbus.PROPERTIES_IFACE,
1385
self.attributes[propname] = value
1386
def Approve(self, approve, dbus_interface):
1387
testcase.assertEqual(client_dbus_interface,
1389
self.calls.append(("Approve", (approve,
1391
self.client = MockClient(
1393
KeyID=("92ed150794387c03ce684574b1139a65"
1394
"94a34f895daaaf09fd8ea90a27cddb12"),
1396
Host="foo.example.org",
1397
Enabled=dbus.Boolean(True),
1399
LastCheckedOK="2019-02-03T00:00:00",
1400
Created="2019-01-02T00:00:00",
1402
Fingerprint=("778827225BA7DE539C5A"
1403
"7CFA59CFF7CDBD9A5920"),
1404
CheckerRunning=dbus.Boolean(False),
1405
LastEnabled="2019-01-03T00:00:00",
1406
ApprovalPending=dbus.Boolean(False),
1407
ApprovedByDefault=dbus.Boolean(True),
1408
LastApprovalRequest="",
1410
ApprovalDuration=1000,
1411
Checker="fping -q -- %(host)s",
1412
ExtendedTimeout=900000,
1413
Expires="2019-02-04T00:00:00",
1414
LastCheckerStatus=0)
1415
self.other_client = MockClient(
1417
KeyID=("0558568eedd67d622f5c83b35a115f79"
1418
"6ab612cff5ad227247e46c2b020f441c"),
1419
Secret=b"secretbar",
1421
Enabled=dbus.Boolean(True),
1423
LastCheckedOK="2019-02-04T00:00:00",
1424
Created="2019-01-03T00:00:00",
1426
Fingerprint=("3E393AEAEFB84C7E89E2"
1427
"F547B3A107558FCA3A27"),
1428
CheckerRunning=dbus.Boolean(True),
1429
LastEnabled="2019-01-04T00:00:00",
1430
ApprovalPending=dbus.Boolean(False),
1431
ApprovedByDefault=dbus.Boolean(False),
1432
LastApprovalRequest="2019-01-03T00:00:00",
1433
ApprovalDelay=30000,
1434
ApprovalDuration=93785000,
1436
ExtendedTimeout=900000,
1437
Expires="2019-02-05T00:00:00",
1438
LastCheckerStatus=-2)
1439
self.clients = collections.OrderedDict(
1441
(self.client.__dbus_object_path__,
1442
self.client.attributes),
1443
(self.other_client.__dbus_object_path__,
1444
self.other_client.attributes),
855
class TestPrintTableCmd(TestCmd):
856
def test_normal(self):
857
output = PrintTableCmd().output(self.clients)
858
expected_output = """
859
Name Enabled Timeout Last Successful Check
860
foo Yes 00:05:00 2019-02-03T00:00:00
861
barbar Yes 00:05:00 2019-02-04T00:00:00
863
self.assertEqual(output, expected_output)
864
def test_verbose(self):
865
output = PrintTableCmd(verbose=True).output(self.clients)
866
expected_output = """
867
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
868
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
869
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
871
self.assertEqual(output, expected_output)
872
def test_one_client(self):
873
output = PrintTableCmd().output({"foo": self.clients["foo"]})
874
expected_output = """
875
Name Enabled Timeout Last Successful Check
876
foo Yes 00:05:00 2019-02-03T00:00:00
878
self.assertEqual(output, expected_output)
880
class TestDumpJSONCmd(TestCmd):
882
self.expected_json = {
885
"KeyID": ("92ed150794387c03ce684574b1139a65"
886
"94a34f895daaaf09fd8ea90a27cddb12"),
887
"Host": "foo.example.org",
890
"LastCheckedOK": "2019-02-03T00:00:00",
891
"Created": "2019-01-02T00:00:00",
893
"Fingerprint": ("778827225BA7DE539C5A"
894
"7CFA59CFF7CDBD9A5920"),
895
"CheckerRunning": False,
896
"LastEnabled": "2019-01-03T00:00:00",
897
"ApprovalPending": False,
898
"ApprovedByDefault": True,
899
"LastApprovalRequest": "",
901
"ApprovalDuration": 1000,
902
"Checker": "fping -q -- %(host)s",
903
"ExtendedTimeout": 900000,
904
"Expires": "2019-02-04T00:00:00",
905
"LastCheckerStatus": 0,
909
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
910
"6ab612cff5ad227247e46c2b020f441c"),
914
"LastCheckedOK": "2019-02-04T00:00:00",
915
"Created": "2019-01-03T00:00:00",
917
"Fingerprint": ("3E393AEAEFB84C7E89E2"
918
"F547B3A107558FCA3A27"),
919
"CheckerRunning": True,
920
"LastEnabled": "2019-01-04T00:00:00",
921
"ApprovalPending": False,
922
"ApprovedByDefault": False,
923
"LastApprovalRequest": "2019-01-03T00:00:00",
924
"ApprovalDelay": 30000,
925
"ApprovalDuration": 1000,
927
"ExtendedTimeout": 900000,
928
"Expires": "2019-02-05T00:00:00",
929
"LastCheckerStatus": -2,
932
return super(TestDumpJSONCmd, self).setUp()
933
def test_normal(self):
934
json_data = json.loads(DumpJSONCmd().output(self.clients))
935
self.assertDictEqual(json_data, self.expected_json)
936
def test_one_client(self):
937
clients = {"foo": self.clients["foo"]}
938
json_data = json.loads(DumpJSONCmd().output(clients))
939
expected_json = {"foo": self.expected_json["foo"]}
940
self.assertDictEqual(json_data, expected_json)
942
class TestIsEnabledCmd(TestCmd):
943
def test_is_enabled(self):
944
self.assertTrue(all(IsEnabledCmd().is_enabled(client)
945
for client in self.clients.values()))
946
def test_is_enabled_does_get_attribute(self):
947
client = self.clients["foo"]
948
self.assertTrue(IsEnabledCmd().is_enabled(client))
949
self.assertListEqual(client.calls,
951
("se.recompile.Mandos.Client",
953
"org.freedesktop.DBus.Properties"))])
954
def test_is_enabled_run_exits_successfully(self):
955
client = self.clients["foo"]
1446
self.one_client = {self.client.__dbus_object_path__:
1447
self.client.attributes}
1451
class MockBus(object):
1453
def get_object(client_bus_name, path):
1454
self.assertEqual(dbus_busname, client_bus_name)
1455
# Note: "self" here is the TestCmd instance, not the
1456
# MockBus instance, since this is a static method!
1457
if path == self.client.__dbus_object_path__:
1459
elif path == self.other_client.__dbus_object_path__:
1460
return self.other_client
1464
class TestBaseCommands(TestCommand):
1466
def test_IsEnabled_exits_successfully(self):
956
1467
with self.assertRaises(SystemExit) as e:
957
IsEnabledCmd().run_on_one_client(client)
1468
command.IsEnabled().run(self.one_client)
958
1469
if e.exception.code is not None:
959
self.assertEqual(e.exception.code, 0)
1470
self.assertEqual(0, e.exception.code)
961
1472
self.assertIsNone(e.exception.code)
962
def test_is_enabled_run_exits_with_failure(self):
963
client = self.clients["foo"]
964
client["Enabled"] = dbus.Boolean(False)
1474
def test_IsEnabled_exits_with_failure(self):
1475
self.client.attributes["Enabled"] = dbus.Boolean(False)
965
1476
with self.assertRaises(SystemExit) as e:
966
IsEnabledCmd().run_on_one_client(client)
1477
command.IsEnabled().run(self.one_client)
967
1478
if isinstance(e.exception.code, int):
968
self.assertNotEqual(e.exception.code, 0)
1479
self.assertNotEqual(0, e.exception.code)
970
1481
self.assertIsNotNone(e.exception.code)
1483
def test_Approve(self):
1484
command.Approve().run(self.clients, self.bus)
1485
for clientpath in self.clients:
1486
client = self.bus.get_object(dbus_busname, clientpath)
1487
self.assertIn(("Approve", (True, client_dbus_interface)),
1490
def test_Deny(self):
1491
command.Deny().run(self.clients, self.bus)
1492
for clientpath in self.clients:
1493
client = self.bus.get_object(dbus_busname, clientpath)
1494
self.assertIn(("Approve", (False, client_dbus_interface)),
1497
def test_Remove(self):
1498
class MandosSpy(object):
1501
def RemoveClient(self, dbus_path):
1502
self.calls.append(("RemoveClient", (dbus_path,)))
1503
mandos = MandosSpy()
1504
command.Remove().run(self.clients, self.bus, mandos)
1505
for clientpath in self.clients:
1506
self.assertIn(("RemoveClient", (clientpath,)),
1512
"KeyID": ("92ed150794387c03ce684574b1139a65"
1513
"94a34f895daaaf09fd8ea90a27cddb12"),
1514
"Host": "foo.example.org",
1517
"LastCheckedOK": "2019-02-03T00:00:00",
1518
"Created": "2019-01-02T00:00:00",
1520
"Fingerprint": ("778827225BA7DE539C5A"
1521
"7CFA59CFF7CDBD9A5920"),
1522
"CheckerRunning": False,
1523
"LastEnabled": "2019-01-03T00:00:00",
1524
"ApprovalPending": False,
1525
"ApprovedByDefault": True,
1526
"LastApprovalRequest": "",
1528
"ApprovalDuration": 1000,
1529
"Checker": "fping -q -- %(host)s",
1530
"ExtendedTimeout": 900000,
1531
"Expires": "2019-02-04T00:00:00",
1532
"LastCheckerStatus": 0,
1536
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1537
"6ab612cff5ad227247e46c2b020f441c"),
1538
"Host": "192.0.2.3",
1541
"LastCheckedOK": "2019-02-04T00:00:00",
1542
"Created": "2019-01-03T00:00:00",
1544
"Fingerprint": ("3E393AEAEFB84C7E89E2"
1545
"F547B3A107558FCA3A27"),
1546
"CheckerRunning": True,
1547
"LastEnabled": "2019-01-04T00:00:00",
1548
"ApprovalPending": False,
1549
"ApprovedByDefault": False,
1550
"LastApprovalRequest": "2019-01-03T00:00:00",
1551
"ApprovalDelay": 30000,
1552
"ApprovalDuration": 93785000,
1554
"ExtendedTimeout": 900000,
1555
"Expires": "2019-02-05T00:00:00",
1556
"LastCheckerStatus": -2,
1560
def test_DumpJSON_normal(self):
1561
with self.capture_stdout_to_buffer() as buffer:
1562
command.DumpJSON().run(self.clients)
1563
json_data = json.loads(buffer.getvalue())
1564
self.assertDictEqual(self.expected_json, json_data)
1567
@contextlib.contextmanager
1568
def capture_stdout_to_buffer():
1569
capture_buffer = io.StringIO()
1570
old_stdout = sys.stdout
1571
sys.stdout = capture_buffer
1573
yield capture_buffer
1575
sys.stdout = old_stdout
1577
def test_DumpJSON_one_client(self):
1578
with self.capture_stdout_to_buffer() as buffer:
1579
command.DumpJSON().run(self.one_client)
1580
json_data = json.loads(buffer.getvalue())
1581
expected_json = {"foo": self.expected_json["foo"]}
1582
self.assertDictEqual(expected_json, json_data)
1584
def test_PrintTable_normal(self):
1585
with self.capture_stdout_to_buffer() as buffer:
1586
command.PrintTable().run(self.clients)
1587
expected_output = "\n".join((
1588
"Name Enabled Timeout Last Successful Check",
1589
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1590
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1592
self.assertEqual(expected_output, buffer.getvalue())
1594
def test_PrintTable_verbose(self):
1595
with self.capture_stdout_to_buffer() as buffer:
1596
command.PrintTable(verbose=True).run(self.clients)
1611
"Last Successful Check ",
1612
"2019-02-03T00:00:00 ",
1613
"2019-02-04T00:00:00 ",
1616
"2019-01-02T00:00:00 ",
1617
"2019-01-03T00:00:00 ",
1629
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1631
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1635
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
1636
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
1638
"Check Is Running ",
1643
"2019-01-03T00:00:00 ",
1644
"2019-01-04T00:00:00 ",
1646
"Approval Is Pending ",
1650
"Approved By Default ",
1654
"Last Approval Request ",
1656
"2019-01-03T00:00:00 ",
1662
"Approval Duration ",
1667
"fping -q -- %(host)s ",
1670
"Extended Timeout ",
1675
"2019-02-04T00:00:00 ",
1676
"2019-02-05T00:00:00 ",
1678
"Last Checker Status",
1683
num_lines = max(len(rows) for rows in columns)
1684
expected_output = ("\n".join("".join(rows[line]
1685
for rows in columns)
1686
for line in range(num_lines))
1688
self.assertEqual(expected_output, buffer.getvalue())
1690
def test_PrintTable_one_client(self):
1691
with self.capture_stdout_to_buffer() as buffer:
1692
command.PrintTable().run(self.one_client)
1693
expected_output = "\n".join((
1694
"Name Enabled Timeout Last Successful Check",
1695
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1697
self.assertEqual(expected_output, buffer.getvalue())
1700
class TestPropertySetterCmd(TestCommand):
1701
"""Abstract class for tests of command.PropertySetter classes"""
1703
if not hasattr(self, "command"):
1705
values_to_get = getattr(self, "values_to_get",
1707
for value_to_set, value_to_get in zip(self.values_to_set,
1709
for clientpath in self.clients:
1710
client = self.bus.get_object(dbus_busname, clientpath)
1711
old_value = client.attributes[self.propname]
1712
client.attributes[self.propname] = self.Unique()
1713
self.run_command(value_to_set, self.clients)
1714
for clientpath in self.clients:
1715
client = self.bus.get_object(dbus_busname, clientpath)
1716
value = client.attributes[self.propname]
1717
self.assertNotIsInstance(value, self.Unique)
1718
self.assertEqual(value_to_get, value)
1720
class Unique(object):
1721
"""Class for objects which exist only to be unique objects,
1722
since unittest.mock.sentinel only exists in Python 3.3"""
1724
def run_command(self, value, clients):
1725
self.command().run(clients, self.bus)
1728
class TestEnableCmd(TestPropertySetterCmd):
1729
command = command.Enable
1730
propname = "Enabled"
1731
values_to_set = [dbus.Boolean(True)]
1734
class TestDisableCmd(TestPropertySetterCmd):
1735
command = command.Disable
1736
propname = "Enabled"
1737
values_to_set = [dbus.Boolean(False)]
1740
class TestBumpTimeoutCmd(TestPropertySetterCmd):
1741
command = command.BumpTimeout
1742
propname = "LastCheckedOK"
1743
values_to_set = [""]
1746
class TestStartCheckerCmd(TestPropertySetterCmd):
1747
command = command.StartChecker
1748
propname = "CheckerRunning"
1749
values_to_set = [dbus.Boolean(True)]
1752
class TestStopCheckerCmd(TestPropertySetterCmd):
1753
command = command.StopChecker
1754
propname = "CheckerRunning"
1755
values_to_set = [dbus.Boolean(False)]
1758
class TestApproveByDefaultCmd(TestPropertySetterCmd):
1759
command = command.ApproveByDefault
1760
propname = "ApprovedByDefault"
1761
values_to_set = [dbus.Boolean(True)]
1764
class TestDenyByDefaultCmd(TestPropertySetterCmd):
1765
command = command.DenyByDefault
1766
propname = "ApprovedByDefault"
1767
values_to_set = [dbus.Boolean(False)]
1770
class TestPropertySetterValueCmd(TestPropertySetterCmd):
1771
"""Abstract class for tests of PropertySetterValueCmd classes"""
1774
if type(self) is TestPropertySetterValueCmd:
1776
return super(TestPropertySetterValueCmd, self).runTest()
1778
def run_command(self, value, clients):
1779
self.command(value).run(clients, self.bus)
1782
class TestSetCheckerCmd(TestPropertySetterValueCmd):
1783
command = command.SetChecker
1784
propname = "Checker"
1785
values_to_set = ["", ":", "fping -q -- %s"]
1788
class TestSetHostCmd(TestPropertySetterValueCmd):
1789
command = command.SetHost
1791
values_to_set = ["192.0.2.3", "client.example.org"]
1794
class TestSetSecretCmd(TestPropertySetterValueCmd):
1795
command = command.SetSecret
1797
values_to_set = [io.BytesIO(b""),
1798
io.BytesIO(b"secret\0xyzzy\nbar")]
1799
values_to_get = [f.getvalue() for f in values_to_set]
1802
class TestSetTimeoutCmd(TestPropertySetterValueCmd):
1803
command = command.SetTimeout
1804
propname = "Timeout"
1805
values_to_set = [datetime.timedelta(),
1806
datetime.timedelta(minutes=5),
1807
datetime.timedelta(seconds=1),
1808
datetime.timedelta(weeks=1),
1809
datetime.timedelta(weeks=52)]
1810
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1813
class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):
1814
command = command.SetExtendedTimeout
1815
propname = "ExtendedTimeout"
1816
values_to_set = [datetime.timedelta(),
1817
datetime.timedelta(minutes=5),
1818
datetime.timedelta(seconds=1),
1819
datetime.timedelta(weeks=1),
1820
datetime.timedelta(weeks=52)]
1821
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1824
class TestSetIntervalCmd(TestPropertySetterValueCmd):
1825
command = command.SetInterval
1826
propname = "Interval"
1827
values_to_set = [datetime.timedelta(),
1828
datetime.timedelta(minutes=5),
1829
datetime.timedelta(seconds=1),
1830
datetime.timedelta(weeks=1),
1831
datetime.timedelta(weeks=52)]
1832
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1835
class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):
1836
command = command.SetApprovalDelay
1837
propname = "ApprovalDelay"
1838
values_to_set = [datetime.timedelta(),
1839
datetime.timedelta(minutes=5),
1840
datetime.timedelta(seconds=1),
1841
datetime.timedelta(weeks=1),
1842
datetime.timedelta(weeks=52)]
1843
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1846
class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):
1847
command = command.SetApprovalDuration
1848
propname = "ApprovalDuration"
1849
values_to_set = [datetime.timedelta(),
1850
datetime.timedelta(minutes=5),
1851
datetime.timedelta(seconds=1),
1852
datetime.timedelta(weeks=1),
1853
datetime.timedelta(weeks=52)]
1854
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
974
1858
def should_only_run_tests():