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,
271
class TableOfClients(object):
274
"Enabled": "Enabled",
275
"Timeout": "Timeout",
276
"LastCheckedOK": "Last Successful Check",
277
"LastApprovalRequest": "Last Approval Request",
278
"Created": "Created",
279
"Interval": "Interval",
281
"Fingerprint": "Fingerprint",
283
"CheckerRunning": "Check Is Running",
284
"LastEnabled": "Last Enabled",
285
"ApprovalPending": "Approval Is Pending",
286
"ApprovedByDefault": "Approved By Default",
287
"ApprovalDelay": "Approval Delay",
288
"ApprovalDuration": "Approval Duration",
289
"Checker": "Checker",
290
"ExtendedTimeout": "Extended Timeout",
291
"Expires": "Expires",
292
"LastCheckerStatus": "Last Checker Status",
295
def __init__(self, clients, keywords, tableheaders=None):
296
self.clients = clients
297
self.keywords = keywords
298
if tableheaders is not None:
299
self.tableheaders = tableheaders
302
return "\n".join(self.rows())
304
if sys.version_info.major == 2:
305
__unicode__ = __str__
307
return str(self).encode(locale.getpreferredencoding())
310
format_string = self.row_formatting_string()
311
rows = [self.header_line(format_string)]
312
rows.extend(self.client_line(client, format_string)
313
for client in self.clients)
316
def row_formatting_string(self):
317
"Format string used to format table rows"
318
return " ".join("{{{key}:{width}}}".format(
319
width=max(len(self.tableheaders[key]),
320
*(len(self.string_from_client(client, key))
321
for client in self.clients)),
323
for key in self.keywords)
325
def string_from_client(self, client, key):
326
return self.valuetostring(client[key], key)
329
def valuetostring(value, keyword):
330
if isinstance(value, dbus.Boolean):
331
return "Yes" if value else "No"
332
if keyword in ("Timeout", "Interval", "ApprovalDelay",
333
"ApprovalDuration", "ExtendedTimeout"):
334
return milliseconds_to_string(value)
337
def header_line(self, format_string):
338
return format_string.format(**self.tableheaders)
340
def client_line(self, client, format_string):
341
return format_string.format(
342
**{key: self.string_from_client(client, key)
343
for key in self.keywords})
346
## Classes for commands.
348
# Abstract classes first
349
class Command(object):
350
"""Abstract class for commands"""
351
def run(self, mandos, clients):
352
"""Normal commands should implement run_on_one_client(), but
353
commands which want to operate on all clients at the same time
354
can override this run() method instead."""
356
for client in clients:
357
self.run_on_one_client(client)
359
class PrintCmd(Command):
360
"""Abstract class for commands printing client details"""
361
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
362
"Created", "Interval", "Host", "KeyID",
363
"Fingerprint", "CheckerRunning", "LastEnabled",
364
"ApprovalPending", "ApprovedByDefault",
365
"LastApprovalRequest", "ApprovalDelay",
366
"ApprovalDuration", "Checker", "ExtendedTimeout",
367
"Expires", "LastCheckerStatus")
368
def run(self, mandos, clients):
369
print(self.output(clients))
371
class PropertyCmd(Command):
372
"""Abstract class for Actions for setting one client property"""
373
def run_on_one_client(self, client):
374
"""Set the Client's D-Bus property"""
375
client.Set(client_interface, self.property, self.value_to_set,
376
dbus_interface=dbus.PROPERTIES_IFACE)
378
class ValueArgumentMixIn(object):
379
"""Mixin class for commands taking a value as argument"""
380
def __init__(self, value):
381
self.value_to_set = value
383
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
384
"""Mixin class for commands taking a value argument as
387
def value_to_set(self):
390
def value_to_set(self, value):
391
"""When setting, convert value to a datetime.timedelta"""
392
self._vts = string_to_delta(value).total_seconds() * 1000
394
# Actual (non-abstract) command classes
396
class PrintTableCmd(PrintCmd):
397
def __init__(self, verbose=False):
398
self.verbose = verbose
399
def output(self, clients):
401
keywords = self.all_keywords
403
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
404
return str(TableOfClients(clients.values(), keywords))
406
class DumpJSONCmd(PrintCmd):
407
def output(self, clients):
408
data = {client["Name"]:
409
{key: self.dbus_boolean_to_bool(client[key])
410
for key in self.all_keywords}
411
for client in clients.values()}
412
return json.dumps(data, indent=4, separators=(',', ': '))
414
def dbus_boolean_to_bool(value):
415
if isinstance(value, dbus.Boolean):
419
class IsEnabledCmd(Command):
420
def run_on_one_client(self, client):
421
if self.is_enabled(client):
424
def is_enabled(self, client):
425
return client.Get(client_interface, "Enabled",
426
dbus_interface=dbus.PROPERTIES_IFACE)
428
class RemoveCmd(Command):
429
def run_on_one_client(self, client):
430
self.mandos.RemoveClient(client.__dbus_object_path__)
432
class ApproveCmd(Command):
433
def run_on_one_client(self, client):
434
client.Approve(dbus.Boolean(True),
435
dbus_interface=client_interface)
437
class DenyCmd(Command):
438
def run_on_one_client(self, client):
439
client.Approve(dbus.Boolean(False),
440
dbus_interface=client_interface)
442
class EnableCmd(PropertyCmd):
444
value_to_set = dbus.Boolean(True)
446
class DisableCmd(PropertyCmd):
448
value_to_set = dbus.Boolean(False)
450
class BumpTimeoutCmd(PropertyCmd):
451
property = "LastCheckedOK"
454
class StartCheckerCmd(PropertyCmd):
455
property = "CheckerRunning"
456
value_to_set = dbus.Boolean(True)
458
class StopCheckerCmd(PropertyCmd):
459
property = "CheckerRunning"
460
value_to_set = dbus.Boolean(False)
462
class ApproveByDefaultCmd(PropertyCmd):
463
property = "ApprovedByDefault"
464
value_to_set = dbus.Boolean(True)
466
class DenyByDefaultCmd(PropertyCmd):
467
property = "ApprovedByDefault"
468
value_to_set = dbus.Boolean(False)
470
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
473
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
476
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
479
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
482
class SetExtendedTimeoutCmd(PropertyCmd,
483
MillisecondsValueArgumentMixIn):
484
property = "ExtendedTimeout"
486
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
487
property = "Interval"
489
class SetApprovalDelayCmd(PropertyCmd,
490
MillisecondsValueArgumentMixIn):
491
property = "ApprovalDelay"
493
class SetApprovalDurationCmd(PropertyCmd,
494
MillisecondsValueArgumentMixIn):
495
property = "ApprovalDuration"
497
def has_actions(options):
498
return any((options.enable,
500
options.bump_timeout,
501
options.start_checker,
502
options.stop_checker,
505
options.checker is not None,
506
options.timeout is not None,
507
options.extended_timeout is not None,
508
options.interval is not None,
509
options.approved_by_default is not None,
510
options.approval_delay is not None,
511
options.approval_duration is not None,
512
options.host is not None,
513
options.secret is not None,
518
def commands_and_clients_from_options(args=None):
521
parser = argparse.ArgumentParser()
522
parser.add_argument("--version", action="version",
523
version="%(prog)s {}".format(version),
524
help="show version number and exit")
525
parser.add_argument("-a", "--all", action="store_true",
526
help="Select all clients")
527
parser.add_argument("-v", "--verbose", action="store_true",
528
help="Print all fields")
529
parser.add_argument("-j", "--dump-json", action="store_true",
530
help="Dump client data in JSON format")
531
enable_disable = parser.add_mutually_exclusive_group()
532
enable_disable.add_argument("-e", "--enable", action="store_true",
533
help="Enable client")
534
enable_disable.add_argument("-d", "--disable",
536
help="disable client")
537
parser.add_argument("-b", "--bump-timeout", action="store_true",
538
help="Bump timeout for client")
539
start_stop_checker = parser.add_mutually_exclusive_group()
540
start_stop_checker.add_argument("--start-checker",
542
help="Start checker for client")
543
start_stop_checker.add_argument("--stop-checker",
545
help="Stop checker for client")
546
parser.add_argument("-V", "--is-enabled", action="store_true",
547
help="Check if client is enabled")
548
parser.add_argument("-r", "--remove", action="store_true",
549
help="Remove client")
550
parser.add_argument("-c", "--checker",
551
help="Set checker command for client")
552
parser.add_argument("-t", "--timeout",
553
help="Set timeout for client")
554
parser.add_argument("--extended-timeout",
555
help="Set extended timeout for client")
556
parser.add_argument("-i", "--interval",
557
help="Set checker interval for client")
558
approve_deny_default = parser.add_mutually_exclusive_group()
559
approve_deny_default.add_argument(
560
"--approve-by-default", action="store_true",
561
default=None, dest="approved_by_default",
562
help="Set client to be approved by default")
563
approve_deny_default.add_argument(
564
"--deny-by-default", action="store_false",
565
dest="approved_by_default",
566
help="Set client to be denied by default")
567
parser.add_argument("--approval-delay",
568
help="Set delay before client approve/deny")
569
parser.add_argument("--approval-duration",
570
help="Set duration of one client approval")
571
parser.add_argument("-H", "--host", help="Set host for client")
572
parser.add_argument("-s", "--secret",
573
type=argparse.FileType(mode="rb"),
574
help="Set password blob (file) for client")
575
approve_deny = parser.add_mutually_exclusive_group()
576
approve_deny.add_argument(
577
"-A", "--approve", action="store_true",
578
help="Approve any current client request")
579
approve_deny.add_argument("-D", "--deny", action="store_true",
580
help="Deny any current client request")
581
parser.add_argument("--check", action="store_true",
582
help="Run self-test")
583
parser.add_argument("client", nargs="*", help="Client name")
584
options = parser.parse_args(args=args)
409
586
if has_actions(options) and not (options.client or options.all):
410
587
parser.error("Options require clients names or --all.")
416
593
if options.all and not has_actions(options):
417
594
parser.error("--all requires an action.")
418
595
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)
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)
465
class NullFilter(logging.Filter):
466
def filter(self, record):
469
nullfilter = NullFilter()
471
def __exit__(self, exc_type, exc_val, exc_tb):
472
self.logger.removeFilter(self.nullfilter)
475
def commands_from_options(options):
596
parser.error("--is-enabled requires exactly one client")
479
if options.is_enabled:
480
commands.append(command.IsEnabled())
483
commands.append(command.Approve())
486
commands.append(command.Deny())
489
commands.append(command.Remove())
491
600
if options.dump_json:
492
commands.append(command.DumpJSON())
601
commands.append(DumpJSONCmd())
494
603
if options.enable:
495
commands.append(command.Enable())
604
commands.append(EnableCmd())
497
606
if options.disable:
498
commands.append(command.Disable())
607
commands.append(DisableCmd())
500
609
if options.bump_timeout:
501
commands.append(command.BumpTimeout())
610
commands.append(BumpTimeoutCmd(options.bump_timeout))
503
612
if options.start_checker:
504
commands.append(command.StartChecker())
613
commands.append(StartCheckerCmd())
506
615
if options.stop_checker:
507
commands.append(command.StopChecker())
509
if options.approved_by_default is not None:
510
if options.approved_by_default:
511
commands.append(command.ApproveByDefault())
513
commands.append(command.DenyByDefault())
616
commands.append(StopCheckerCmd())
618
if options.is_enabled:
619
commands.append(IsEnabledCmd())
622
commands.append(RemoveCmd())
515
624
if options.checker is not None:
516
commands.append(command.SetChecker(options.checker))
518
if options.host is not None:
519
commands.append(command.SetHost(options.host))
521
if options.secret is not None:
522
commands.append(command.SetSecret(options.secret))
625
commands.append(SetCheckerCmd())
524
627
if options.timeout is not None:
525
commands.append(command.SetTimeout(options.timeout))
628
commands.append(SetTimeoutCmd(options.timeout))
527
630
if options.extended_timeout:
529
command.SetExtendedTimeout(options.extended_timeout))
632
SetExtendedTimeoutCmd(options.extended_timeout))
531
634
if options.interval is not None:
532
commands.append(command.SetInterval(options.interval))
635
command.append(SetIntervalCmd(options.interval))
637
if options.approved_by_default is not None:
638
if options.approved_by_default:
639
command.append(ApproveByDefaultCmd())
641
command.append(DenyByDefaultCmd())
534
643
if options.approval_delay is not None:
536
command.SetApprovalDelay(options.approval_delay))
644
command.append(SetApprovalDelayCmd(options.approval_delay))
538
646
if options.approval_duration is not None:
540
command.SetApprovalDuration(options.approval_duration))
648
SetApprovalDurationCmd(options.approval_duration))
650
if options.host is not None:
651
command.append(SetHostCmd(options.host))
653
if options.secret is not None:
654
command.append(SetSecretCmd(options.secret))
657
commands.append(ApproveCmd())
660
commands.append(DenyCmd())
542
662
# If no command option has been given, show table of clients,
543
663
# optionally verbosely
545
commands.append(command.PrintTable(verbose=options.verbose))
550
class command(object):
551
"""A namespace for command classes"""
554
"""Abstract base class for commands"""
555
def run(self, clients, bus=None, mandos=None):
556
"""Normal commands should implement run_on_one_client(),
557
but commands which want to operate on all clients at the same time can
558
override this run() method instead.
561
for clientpath, properties in clients.items():
562
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
563
dbus_busname, str(clientpath))
564
client = bus.get_object(dbus_busname, clientpath)
565
self.run_on_one_client(client, properties)
568
class IsEnabled(Base):
569
def run(self, clients, bus=None, mandos=None):
570
client, properties = next(iter(clients.items()))
571
if self.is_enabled(client, properties):
574
def is_enabled(self, client, properties):
575
return properties["Enabled"]
579
def run_on_one_client(self, client, properties):
580
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
581
client.__dbus_object_path__,
582
client_dbus_interface)
583
client.Approve(dbus.Boolean(True),
584
dbus_interface=client_dbus_interface)
588
def run_on_one_client(self, client, properties):
589
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
590
client.__dbus_object_path__,
591
client_dbus_interface)
592
client.Approve(dbus.Boolean(False),
593
dbus_interface=client_dbus_interface)
597
def run_on_one_client(self, client, properties):
598
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)",
599
dbus_busname, server_dbus_path,
600
server_dbus_interface,
601
str(client.__dbus_object_path__))
602
self.mandos.RemoveClient(client.__dbus_object_path__)
606
"""Abstract class for commands outputting client details"""
607
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
608
"Created", "Interval", "Host", "KeyID",
609
"Fingerprint", "CheckerRunning",
610
"LastEnabled", "ApprovalPending",
611
"ApprovedByDefault", "LastApprovalRequest",
612
"ApprovalDelay", "ApprovalDuration",
613
"Checker", "ExtendedTimeout", "Expires",
616
def run(self, clients, bus=None, mandos=None):
617
print(self.output(clients.values()))
619
def output(self, clients):
620
raise NotImplementedError()
623
class DumpJSON(Output):
624
def output(self, clients):
625
data = {client["Name"]:
626
{key: self.dbus_boolean_to_bool(client[key])
627
for key in self.all_keywords}
628
for client in clients}
629
return json.dumps(data, indent=4, separators=(',', ': '))
632
def dbus_boolean_to_bool(value):
633
if isinstance(value, dbus.Boolean):
638
class PrintTable(Output):
639
def __init__(self, verbose=False):
640
self.verbose = verbose
642
def output(self, clients):
643
default_keywords = ("Name", "Enabled", "Timeout",
645
keywords = default_keywords
647
keywords = self.all_keywords
648
return str(self.TableOfClients(clients, keywords))
650
class TableOfClients(object):
653
"Enabled": "Enabled",
654
"Timeout": "Timeout",
655
"LastCheckedOK": "Last Successful Check",
656
"LastApprovalRequest": "Last Approval Request",
657
"Created": "Created",
658
"Interval": "Interval",
660
"Fingerprint": "Fingerprint",
662
"CheckerRunning": "Check Is Running",
663
"LastEnabled": "Last Enabled",
664
"ApprovalPending": "Approval Is Pending",
665
"ApprovedByDefault": "Approved By Default",
666
"ApprovalDelay": "Approval Delay",
667
"ApprovalDuration": "Approval Duration",
668
"Checker": "Checker",
669
"ExtendedTimeout": "Extended Timeout",
670
"Expires": "Expires",
671
"LastCheckerStatus": "Last Checker Status",
674
def __init__(self, clients, keywords):
675
self.clients = clients
676
self.keywords = keywords
679
return "\n".join(self.rows())
681
if sys.version_info.major == 2:
682
__unicode__ = __str__
684
return str(self).encode(
685
locale.getpreferredencoding())
688
format_string = self.row_formatting_string()
689
rows = [self.header_line(format_string)]
690
rows.extend(self.client_line(client, format_string)
691
for client in self.clients)
694
def row_formatting_string(self):
695
"Format string used to format table rows"
696
return " ".join("{{{key}:{width}}}".format(
697
width=max(len(self.tableheaders[key]),
698
*(len(self.string_from_client(client,
700
for client in self.clients)),
702
for key in self.keywords)
704
def string_from_client(self, client, key):
705
return self.valuetostring(client[key], key)
708
def valuetostring(cls, value, keyword):
709
if isinstance(value, dbus.Boolean):
710
return "Yes" if value else "No"
711
if keyword in ("Timeout", "Interval", "ApprovalDelay",
712
"ApprovalDuration", "ExtendedTimeout"):
713
return cls.milliseconds_to_string(value)
716
def header_line(self, format_string):
717
return format_string.format(**self.tableheaders)
719
def client_line(self, client, format_string):
720
return format_string.format(
721
**{key: self.string_from_client(client, key)
722
for key in self.keywords})
725
def milliseconds_to_string(ms):
726
td = datetime.timedelta(0, 0, 0, ms)
727
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
728
.format(days="{}T".format(td.days)
730
hours=td.seconds // 3600,
731
minutes=(td.seconds % 3600) // 60,
732
seconds=td.seconds % 60))
735
class Property(Base):
736
"Abstract class for Actions for setting one client property"
738
def run_on_one_client(self, client, properties):
739
"""Set the Client's D-Bus property"""
740
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
741
client.__dbus_object_path__,
742
dbus.PROPERTIES_IFACE, client_dbus_interface,
743
self.propname, self.value_to_set
744
if not isinstance(self.value_to_set,
746
else bool(self.value_to_set))
747
client.Set(client_dbus_interface, self.propname,
749
dbus_interface=dbus.PROPERTIES_IFACE)
753
raise NotImplementedError()
756
class Enable(Property):
758
value_to_set = dbus.Boolean(True)
761
class Disable(Property):
763
value_to_set = dbus.Boolean(False)
766
class BumpTimeout(Property):
767
propname = "LastCheckedOK"
771
class StartChecker(Property):
772
propname = "CheckerRunning"
773
value_to_set = dbus.Boolean(True)
776
class StopChecker(Property):
777
propname = "CheckerRunning"
778
value_to_set = dbus.Boolean(False)
781
class ApproveByDefault(Property):
782
propname = "ApprovedByDefault"
783
value_to_set = dbus.Boolean(True)
786
class DenyByDefault(Property):
787
propname = "ApprovedByDefault"
788
value_to_set = dbus.Boolean(False)
791
class PropertyValue(Property):
792
"Abstract class for Property recieving a value as argument"
793
def __init__(self, value):
794
self.value_to_set = value
797
class SetChecker(PropertyValue):
801
class SetHost(PropertyValue):
805
class SetSecret(PropertyValue):
809
def value_to_set(self):
813
def value_to_set(self, value):
814
"""When setting, read data from supplied file object"""
815
self._vts = value.read()
819
class MillisecondsPropertyValueArgument(PropertyValue):
820
"""Abstract class for PropertyValue taking a value argument as
821
a datetime.timedelta() but should store it as milliseconds."""
824
def value_to_set(self):
828
def value_to_set(self, value):
829
"When setting, convert value from a datetime.timedelta"
830
self._vts = int(round(value.total_seconds() * 1000))
833
class SetTimeout(MillisecondsPropertyValueArgument):
837
class SetExtendedTimeout(MillisecondsPropertyValueArgument):
838
propname = "ExtendedTimeout"
841
class SetInterval(MillisecondsPropertyValueArgument):
842
propname = "Interval"
845
class SetApprovalDelay(MillisecondsPropertyValueArgument):
846
propname = "ApprovalDelay"
849
class SetApprovalDuration(MillisecondsPropertyValueArgument):
850
propname = "ApprovalDuration"
665
commands.append(PrintTableCmd(verbose=options.verbose))
667
return commands, options.client
671
commands, clientnames = commands_and_clients_from_options()
674
bus = dbus.SystemBus()
675
mandos_dbus_objc = bus.get_object(busname, server_path)
676
except dbus.exceptions.DBusException:
677
log.critical("Could not connect to Mandos server")
680
mandos_serv = dbus.Interface(mandos_dbus_objc,
681
dbus_interface=server_interface)
682
mandos_serv_object_manager = dbus.Interface(
683
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
685
# Filter out log message from dbus module
686
dbus_logger = logging.getLogger("dbus.proxies")
687
class NullFilter(logging.Filter):
688
def filter(self, record):
690
dbus_filter = NullFilter()
691
dbus_logger.addFilter(dbus_filter)
694
mandos_clients = {path: ifs_and_props[client_interface]
695
for path, ifs_and_props in
696
mandos_serv_object_manager
697
.GetManagedObjects().items()
698
if client_interface in ifs_and_props}
700
# restore dbus logger
701
dbus_logger.removeFilter(dbus_filter)
702
except dbus.exceptions.DBusException as e:
703
log.critical("Failed to access Mandos server through D-Bus:"
707
# Compile dict of (clients: properties) to process
711
clients = {bus.get_object(busname, path): properties
712
for path, properties in mandos_clients.items()}
714
for name in clientnames:
715
for path, client in mandos_clients.items():
716
if client["Name"] == name:
717
client_objc = bus.get_object(busname, path)
718
clients[client_objc] = client
721
log.critical("Client not found on server: %r", name)
724
# Run all commands on clients
725
for command in commands:
726
command.run(mandos_serv, clients)
854
class TestCaseWithAssertLogs(unittest.TestCase):
855
"""unittest.TestCase.assertLogs only exists in Python 3.4"""
857
if not hasattr(unittest.TestCase, "assertLogs"):
858
@contextlib.contextmanager
859
def assertLogs(self, logger, level=logging.INFO):
860
capturing_handler = self.CapturingLevelHandler(level)
861
old_level = logger.level
862
old_propagate = logger.propagate
863
logger.addHandler(capturing_handler)
864
logger.setLevel(level)
865
logger.propagate = False
867
yield capturing_handler.watcher
869
logger.propagate = old_propagate
870
logger.removeHandler(capturing_handler)
871
logger.setLevel(old_level)
872
self.assertGreater(len(capturing_handler.watcher.records),
875
class CapturingLevelHandler(logging.Handler):
876
def __init__(self, level, *args, **kwargs):
877
logging.Handler.__init__(self, *args, **kwargs)
878
self.watcher = self.LoggingWatcher([], [])
879
def emit(self, record):
880
self.watcher.records.append(record)
881
self.watcher.output.append(self.format(record))
883
LoggingWatcher = collections.namedtuple("LoggingWatcher",
888
class Test_string_to_delta(TestCaseWithAssertLogs):
889
# Just test basic RFC 3339 functionality here, the doc string for
890
# rfc3339_duration_to_delta() already has more comprehensive
891
# tests, which is run by doctest.
893
def test_rfc3339_zero_seconds(self):
894
self.assertEqual(datetime.timedelta(),
895
string_to_delta("PT0S"))
897
def test_rfc3339_zero_days(self):
898
self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))
900
def test_rfc3339_one_second(self):
901
self.assertEqual(datetime.timedelta(0, 1),
902
string_to_delta("PT1S"))
904
def test_rfc3339_two_hours(self):
905
self.assertEqual(datetime.timedelta(0, 7200),
906
string_to_delta("PT2H"))
729
class Test_milliseconds_to_string(unittest.TestCase):
731
self.assertEqual(milliseconds_to_string(93785000),
733
def test_no_days(self):
734
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
735
def test_all_zero(self):
736
self.assertEqual(milliseconds_to_string(0), "00:00:00")
737
def test_no_fractional_seconds(self):
738
self.assertEqual(milliseconds_to_string(400), "00:00:00")
739
self.assertEqual(milliseconds_to_string(900), "00:00:00")
740
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
742
class Test_string_to_delta(unittest.TestCase):
743
def test_handles_basic_rfc3339(self):
744
self.assertEqual(string_to_delta("PT2H"),
745
datetime.timedelta(0, 7200))
908
746
def test_falls_back_to_pre_1_6_1_with_warning(self):
909
with self.assertLogs(log, logging.WARNING):
910
value = string_to_delta("2h")
911
self.assertEqual(datetime.timedelta(0, 7200), value)
914
class Test_check_option_syntax(unittest.TestCase):
916
self.parser = argparse.ArgumentParser()
917
add_command_line_options(self.parser)
919
def test_actions_requires_client_or_all(self):
920
for action, value in self.actions.items():
921
options = self.parser.parse_args()
922
setattr(options, action, value)
923
with self.assertParseError():
924
self.check_option_syntax(options)
926
# This mostly corresponds to the definition from has_actions() in
927
# check_option_syntax()
929
# The actual values set here are not that important, but we do
930
# at least stick to the correct types, even though they are
934
"bump_timeout": True,
935
"start_checker": True,
936
"stop_checker": True,
940
"timeout": datetime.timedelta(),
941
"extended_timeout": datetime.timedelta(),
942
"interval": datetime.timedelta(),
943
"approved_by_default": True,
944
"approval_delay": datetime.timedelta(),
945
"approval_duration": datetime.timedelta(),
947
"secret": io.BytesIO(b"x"),
952
@contextlib.contextmanager
953
def assertParseError(self):
954
with self.assertRaises(SystemExit) as e:
955
with self.redirect_stderr_to_devnull():
957
# Exit code from argparse is guaranteed to be "2". Reference:
958
# https://docs.python.org/3/library
959
# /argparse.html#exiting-methods
960
self.assertEqual(2, e.exception.code)
963
@contextlib.contextmanager
964
def redirect_stderr_to_devnull():
965
old_stderr = sys.stderr
966
with contextlib.closing(open(os.devnull, "w")) as null:
747
# assertLogs only exists in Python 3.4
748
if hasattr(self, "assertLogs"):
749
with self.assertLogs(log, logging.WARNING):
750
value = string_to_delta("2h")
752
class WarningFilter(logging.Filter):
753
"""Don't show, but record the presence of, warnings"""
754
def filter(self, record):
755
is_warning = record.levelno >= logging.WARNING
756
self.found = is_warning or getattr(self, "found",
758
return not is_warning
759
warning_filter = WarningFilter()
760
log.addFilter(warning_filter)
762
value = string_to_delta("2h")
971
sys.stderr = old_stderr
973
def check_option_syntax(self, options):
974
check_option_syntax(self.parser, options)
976
def test_actions_all_conflicts_with_verbose(self):
977
for action, value in self.actions.items():
978
options = self.parser.parse_args()
979
setattr(options, action, value)
981
options.verbose = True
982
with self.assertParseError():
983
self.check_option_syntax(options)
985
def test_actions_with_client_conflicts_with_verbose(self):
986
for action, value in self.actions.items():
987
options = self.parser.parse_args()
988
setattr(options, action, value)
989
options.verbose = True
990
options.client = ["foo"]
991
with self.assertParseError():
992
self.check_option_syntax(options)
994
def test_dump_json_conflicts_with_verbose(self):
995
options = self.parser.parse_args()
996
options.dump_json = True
997
options.verbose = True
998
with self.assertParseError():
999
self.check_option_syntax(options)
1001
def test_dump_json_conflicts_with_action(self):
1002
for action, value in self.actions.items():
1003
options = self.parser.parse_args()
1004
setattr(options, action, value)
1005
options.dump_json = True
1006
with self.assertParseError():
1007
self.check_option_syntax(options)
1009
def test_all_can_not_be_alone(self):
1010
options = self.parser.parse_args()
1012
with self.assertParseError():
1013
self.check_option_syntax(options)
1015
def test_all_is_ok_with_any_action(self):
1016
for action, value in self.actions.items():
1017
options = self.parser.parse_args()
1018
setattr(options, action, value)
1020
self.check_option_syntax(options)
1022
def test_any_action_is_ok_with_one_client(self):
1023
for action, value in self.actions.items():
1024
options = self.parser.parse_args()
1025
setattr(options, action, value)
1026
options.client = ["foo"]
1027
self.check_option_syntax(options)
1029
def test_one_client_with_all_actions_except_is_enabled(self):
1030
options = self.parser.parse_args()
1031
for action, value in self.actions.items():
1032
if action == "is_enabled":
1034
setattr(options, action, value)
1035
options.client = ["foo"]
1036
self.check_option_syntax(options)
1038
def test_two_clients_with_all_actions_except_is_enabled(self):
1039
options = self.parser.parse_args()
1040
for action, value in self.actions.items():
1041
if action == "is_enabled":
1043
setattr(options, action, value)
1044
options.client = ["foo", "barbar"]
1045
self.check_option_syntax(options)
1047
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1048
for action, value in self.actions.items():
1049
if action == "is_enabled":
1051
options = self.parser.parse_args()
1052
setattr(options, action, value)
1053
options.client = ["foo", "barbar"]
1054
self.check_option_syntax(options)
1056
def test_is_enabled_fails_without_client(self):
1057
options = self.parser.parse_args()
1058
options.is_enabled = True
1059
with self.assertParseError():
1060
self.check_option_syntax(options)
1062
def test_is_enabled_fails_with_two_clients(self):
1063
options = self.parser.parse_args()
1064
options.is_enabled = True
1065
options.client = ["foo", "barbar"]
1066
with self.assertParseError():
1067
self.check_option_syntax(options)
1069
def test_remove_can_only_be_combined_with_action_deny(self):
1070
for action, value in self.actions.items():
1071
if action in {"remove", "deny"}:
1073
options = self.parser.parse_args()
1074
setattr(options, action, value)
1076
options.remove = True
1077
with self.assertParseError():
1078
self.check_option_syntax(options)
1081
class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):
1082
def test_calls_and_returns_get_object_on_bus(self):
1083
class MockBus(object):
1085
def get_object(mockbus_self, busname, dbus_path):
1086
# Note that "self" is still the testcase instance,
1087
# this MockBus instance is in "mockbus_self".
1088
self.assertEqual(dbus_busname, busname)
1089
self.assertEqual(server_dbus_path, dbus_path)
1090
mockbus_self.called = True
1093
mockbus = get_mandos_dbus_object(bus=MockBus())
1094
self.assertIsInstance(mockbus, MockBus)
1095
self.assertTrue(mockbus.called)
1097
def test_logs_and_exits_on_dbus_error(self):
1098
class MockBusFailing(object):
1099
def get_object(self, busname, dbus_path):
1100
raise dbus.exceptions.DBusException("Test")
1102
with self.assertLogs(log, logging.CRITICAL):
1103
with self.assertRaises(SystemExit) as e:
1104
bus = get_mandos_dbus_object(bus=MockBusFailing())
1106
if isinstance(e.exception.code, int):
1107
self.assertNotEqual(0, e.exception.code)
1109
self.assertIsNotNone(e.exception.code)
1112
class Test_get_managed_objects(TestCaseWithAssertLogs):
1113
def test_calls_and_returns_GetManagedObjects(self):
1114
managed_objects = {"/clients/foo": { "Name": "foo"}}
1115
class MockObjectManager(object):
1116
def GetManagedObjects(self):
1117
return managed_objects
1118
retval = get_managed_objects(MockObjectManager())
1119
self.assertDictEqual(managed_objects, retval)
1121
def test_logs_and_exits_on_dbus_error(self):
1122
dbus_logger = logging.getLogger("dbus.proxies")
1124
class MockObjectManagerFailing(object):
1125
def GetManagedObjects(self):
1126
dbus_logger.error("Test")
1127
raise dbus.exceptions.DBusException("Test")
1129
class CountingHandler(logging.Handler):
1131
def emit(self, record):
1134
counting_handler = CountingHandler()
1136
dbus_logger.addHandler(counting_handler)
1139
with self.assertLogs(log, logging.CRITICAL) as watcher:
1140
with self.assertRaises(SystemExit) as e:
1141
get_managed_objects(MockObjectManagerFailing())
1143
dbus_logger.removeFilter(counting_handler)
1145
# Make sure the dbus logger was suppressed
1146
self.assertEqual(0, counting_handler.count)
1148
# Test that the dbus_logger still works
1149
with self.assertLogs(dbus_logger, logging.ERROR):
1150
dbus_logger.error("Test")
1152
if isinstance(e.exception.code, int):
1153
self.assertNotEqual(0, e.exception.code)
1155
self.assertIsNotNone(e.exception.code)
1158
class Test_commands_from_options(unittest.TestCase):
1160
self.parser = argparse.ArgumentParser()
1161
add_command_line_options(self.parser)
1163
def test_is_enabled(self):
1164
self.assert_command_from_args(["--is-enabled", "foo"],
1167
def assert_command_from_args(self, args, command_cls,
1169
"""Assert that parsing ARGS should result in an instance of
1170
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1171
options = self.parser.parse_args(args)
1172
check_option_syntax(self.parser, options)
1173
commands = commands_from_options(options)
1174
self.assertEqual(1, len(commands))
1175
command = commands[0]
1176
self.assertIsInstance(command, command_cls)
1177
for key, value in cmd_attrs.items():
1178
self.assertEqual(value, getattr(command, key))
1180
def test_is_enabled_short(self):
1181
self.assert_command_from_args(["-V", "foo"],
1184
def test_approve(self):
1185
self.assert_command_from_args(["--approve", "foo"],
1188
def test_approve_short(self):
1189
self.assert_command_from_args(["-A", "foo"], command.Approve)
1191
def test_deny(self):
1192
self.assert_command_from_args(["--deny", "foo"], command.Deny)
1194
def test_deny_short(self):
1195
self.assert_command_from_args(["-D", "foo"], command.Deny)
1197
def test_remove(self):
1198
self.assert_command_from_args(["--remove", "foo"],
1201
def test_deny_before_remove(self):
1202
options = self.parser.parse_args(["--deny", "--remove",
1204
check_option_syntax(self.parser, options)
1205
commands = commands_from_options(options)
1206
self.assertEqual(2, len(commands))
1207
self.assertIsInstance(commands[0], command.Deny)
1208
self.assertIsInstance(commands[1], command.Remove)
1210
def test_deny_before_remove_reversed(self):
1211
options = self.parser.parse_args(["--remove", "--deny",
1213
check_option_syntax(self.parser, options)
1214
commands = commands_from_options(options)
1215
self.assertEqual(2, len(commands))
1216
self.assertIsInstance(commands[0], command.Deny)
1217
self.assertIsInstance(commands[1], command.Remove)
1219
def test_remove_short(self):
1220
self.assert_command_from_args(["-r", "foo"], command.Remove)
1222
def test_dump_json(self):
1223
self.assert_command_from_args(["--dump-json"],
1226
def test_enable(self):
1227
self.assert_command_from_args(["--enable", "foo"],
1230
def test_enable_short(self):
1231
self.assert_command_from_args(["-e", "foo"], command.Enable)
1233
def test_disable(self):
1234
self.assert_command_from_args(["--disable", "foo"],
1237
def test_disable_short(self):
1238
self.assert_command_from_args(["-d", "foo"], command.Disable)
1240
def test_bump_timeout(self):
1241
self.assert_command_from_args(["--bump-timeout", "foo"],
1242
command.BumpTimeout)
1244
def test_bump_timeout_short(self):
1245
self.assert_command_from_args(["-b", "foo"],
1246
command.BumpTimeout)
1248
def test_start_checker(self):
1249
self.assert_command_from_args(["--start-checker", "foo"],
1250
command.StartChecker)
1252
def test_stop_checker(self):
1253
self.assert_command_from_args(["--stop-checker", "foo"],
1254
command.StopChecker)
1256
def test_approve_by_default(self):
1257
self.assert_command_from_args(["--approve-by-default", "foo"],
1258
command.ApproveByDefault)
1260
def test_deny_by_default(self):
1261
self.assert_command_from_args(["--deny-by-default", "foo"],
1262
command.DenyByDefault)
1264
def test_checker(self):
1265
self.assert_command_from_args(["--checker", ":", "foo"],
1269
def test_checker_empty(self):
1270
self.assert_command_from_args(["--checker", "", "foo"],
1274
def test_checker_short(self):
1275
self.assert_command_from_args(["-c", ":", "foo"],
1279
def test_host(self):
1280
self.assert_command_from_args(["--host", "foo.example.org",
1281
"foo"], command.SetHost,
1282
value_to_set="foo.example.org")
1284
def test_host_short(self):
1285
self.assert_command_from_args(["-H", "foo.example.org",
1286
"foo"], command.SetHost,
1287
value_to_set="foo.example.org")
1289
def test_secret_devnull(self):
1290
self.assert_command_from_args(["--secret", os.path.devnull,
1291
"foo"], 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,
1300
"foo"], command.SetSecret,
1303
def test_secret_devnull_short(self):
1304
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1308
def test_secret_tempfile_short(self):
1309
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1310
value = b"secret\0xyzzy\nbar"
1313
self.assert_command_from_args(["-s", f.name, "foo"],
1317
def test_timeout(self):
1318
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1320
value_to_set=300000)
1322
def test_timeout_short(self):
1323
self.assert_command_from_args(["-t", "PT5M", "foo"],
1325
value_to_set=300000)
1327
def test_extended_timeout(self):
1328
self.assert_command_from_args(["--extended-timeout", "PT15M",
1330
command.SetExtendedTimeout,
1331
value_to_set=900000)
1333
def test_interval(self):
1334
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1335
command.SetInterval,
1336
value_to_set=120000)
1338
def test_interval_short(self):
1339
self.assert_command_from_args(["-i", "PT2M", "foo"],
1340
command.SetInterval,
1341
value_to_set=120000)
1343
def test_approval_delay(self):
1344
self.assert_command_from_args(["--approval-delay", "PT30S",
1346
command.SetApprovalDelay,
1349
def test_approval_duration(self):
1350
self.assert_command_from_args(["--approval-duration", "PT1S",
1352
command.SetApprovalDuration,
1355
def test_print_table(self):
1356
self.assert_command_from_args([], command.PrintTable,
1359
def test_print_table_verbose(self):
1360
self.assert_command_from_args(["--verbose"],
1364
def test_print_table_verbose_short(self):
1365
self.assert_command_from_args(["-v"], command.PrintTable,
1369
class TestCommand(unittest.TestCase):
1370
"""Abstract class for tests of command classes"""
1374
class MockClient(object):
1375
def __init__(self, name, **attributes):
1376
self.__dbus_object_path__ = "/clients/{}".format(name)
1377
self.attributes = attributes
1378
self.attributes["Name"] = name
1380
def Set(self, interface, propname, value, dbus_interface):
1381
testcase.assertEqual(client_dbus_interface, interface)
1382
testcase.assertEqual(dbus.PROPERTIES_IFACE,
1384
self.attributes[propname] = value
1385
def Approve(self, approve, dbus_interface):
1386
testcase.assertEqual(client_dbus_interface,
1388
self.calls.append(("Approve", (approve,
1390
self.client = MockClient(
1392
KeyID=("92ed150794387c03ce684574b1139a65"
1393
"94a34f895daaaf09fd8ea90a27cddb12"),
1395
Host="foo.example.org",
1396
Enabled=dbus.Boolean(True),
1398
LastCheckedOK="2019-02-03T00:00:00",
1399
Created="2019-01-02T00:00:00",
1401
Fingerprint=("778827225BA7DE539C5A"
1402
"7CFA59CFF7CDBD9A5920"),
1403
CheckerRunning=dbus.Boolean(False),
1404
LastEnabled="2019-01-03T00:00:00",
1405
ApprovalPending=dbus.Boolean(False),
1406
ApprovedByDefault=dbus.Boolean(True),
1407
LastApprovalRequest="",
1409
ApprovalDuration=1000,
1410
Checker="fping -q -- %(host)s",
1411
ExtendedTimeout=900000,
1412
Expires="2019-02-04T00:00:00",
1413
LastCheckerStatus=0)
1414
self.other_client = MockClient(
1416
KeyID=("0558568eedd67d622f5c83b35a115f79"
1417
"6ab612cff5ad227247e46c2b020f441c"),
1418
Secret=b"secretbar",
1420
Enabled=dbus.Boolean(True),
1422
LastCheckedOK="2019-02-04T00:00:00",
1423
Created="2019-01-03T00:00:00",
1425
Fingerprint=("3E393AEAEFB84C7E89E2"
1426
"F547B3A107558FCA3A27"),
1427
CheckerRunning=dbus.Boolean(True),
1428
LastEnabled="2019-01-04T00:00:00",
1429
ApprovalPending=dbus.Boolean(False),
1430
ApprovedByDefault=dbus.Boolean(False),
1431
LastApprovalRequest="2019-01-03T00:00:00",
1432
ApprovalDelay=30000,
1433
ApprovalDuration=93785000,
1435
ExtendedTimeout=900000,
1436
Expires="2019-02-05T00:00:00",
1437
LastCheckerStatus=-2)
1438
self.clients = collections.OrderedDict(
1440
("/clients/foo", self.client.attributes),
1441
("/clients/barbar", self.other_client.attributes),
1443
self.one_client = {"/clients/foo": self.client.attributes}
1449
def get_object(client_bus_name, path):
1450
self.assertEqual(dbus_busname, client_bus_name)
1452
# Note: "self" here is the TestCmd instance, not
1453
# the Bus instance, since this is a static method!
1454
"/clients/foo": self.client,
1455
"/clients/barbar": self.other_client,
1460
class TestBaseCommands(TestCommand):
1462
def test_IsEnabled_exits_successfully(self):
1463
with self.assertRaises(SystemExit) as e:
1464
command.IsEnabled().run(self.one_client)
1465
if e.exception.code is not None:
1466
self.assertEqual(0, e.exception.code)
1468
self.assertIsNone(e.exception.code)
1470
def test_IsEnabled_exits_with_failure(self):
1471
self.client.attributes["Enabled"] = dbus.Boolean(False)
1472
with self.assertRaises(SystemExit) as e:
1473
command.IsEnabled().run(self.one_client)
1474
if isinstance(e.exception.code, int):
1475
self.assertNotEqual(0, e.exception.code)
1477
self.assertIsNotNone(e.exception.code)
1479
def test_Approve(self):
1480
command.Approve().run(self.clients, self.bus)
1481
for clientpath in self.clients:
1482
client = self.bus.get_object(dbus_busname, clientpath)
1483
self.assertIn(("Approve", (True, client_dbus_interface)),
1486
def test_Deny(self):
1487
command.Deny().run(self.clients, self.bus)
1488
for clientpath in self.clients:
1489
client = self.bus.get_object(dbus_busname, clientpath)
1490
self.assertIn(("Approve", (False, client_dbus_interface)),
1493
def test_Remove(self):
1494
class MockMandos(object):
1497
def RemoveClient(self, dbus_path):
1498
self.calls.append(("RemoveClient", (dbus_path,)))
1499
mandos = MockMandos()
1500
command.Remove().run(self.clients, self.bus, mandos)
1501
for clientpath in self.clients:
1502
self.assertIn(("RemoveClient", (clientpath,)),
1508
"KeyID": ("92ed150794387c03ce684574b1139a65"
1509
"94a34f895daaaf09fd8ea90a27cddb12"),
1510
"Host": "foo.example.org",
1513
"LastCheckedOK": "2019-02-03T00:00:00",
1514
"Created": "2019-01-02T00:00:00",
1516
"Fingerprint": ("778827225BA7DE539C5A"
1517
"7CFA59CFF7CDBD9A5920"),
1518
"CheckerRunning": False,
1519
"LastEnabled": "2019-01-03T00:00:00",
1520
"ApprovalPending": False,
1521
"ApprovedByDefault": True,
1522
"LastApprovalRequest": "",
1524
"ApprovalDuration": 1000,
1525
"Checker": "fping -q -- %(host)s",
1526
"ExtendedTimeout": 900000,
1527
"Expires": "2019-02-04T00:00:00",
1528
"LastCheckerStatus": 0,
1532
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1533
"6ab612cff5ad227247e46c2b020f441c"),
1534
"Host": "192.0.2.3",
1537
"LastCheckedOK": "2019-02-04T00:00:00",
1538
"Created": "2019-01-03T00:00:00",
1540
"Fingerprint": ("3E393AEAEFB84C7E89E2"
1541
"F547B3A107558FCA3A27"),
1542
"CheckerRunning": True,
1543
"LastEnabled": "2019-01-04T00:00:00",
1544
"ApprovalPending": False,
1545
"ApprovedByDefault": False,
1546
"LastApprovalRequest": "2019-01-03T00:00:00",
1547
"ApprovalDelay": 30000,
1548
"ApprovalDuration": 93785000,
1550
"ExtendedTimeout": 900000,
1551
"Expires": "2019-02-05T00:00:00",
1552
"LastCheckerStatus": -2,
1556
def test_DumpJSON_normal(self):
1557
with self.capture_stdout_to_buffer() as buffer:
1558
command.DumpJSON().run(self.clients)
1559
json_data = json.loads(buffer.getvalue())
1560
self.assertDictEqual(self.expected_json, json_data)
1563
@contextlib.contextmanager
1564
def capture_stdout_to_buffer():
1565
capture_buffer = io.StringIO()
1566
old_stdout = sys.stdout
1567
sys.stdout = capture_buffer
1569
yield capture_buffer
1571
sys.stdout = old_stdout
1573
def test_DumpJSON_one_client(self):
1574
with self.capture_stdout_to_buffer() as buffer:
1575
command.DumpJSON().run(self.one_client)
1576
json_data = json.loads(buffer.getvalue())
1577
expected_json = {"foo": self.expected_json["foo"]}
1578
self.assertDictEqual(expected_json, json_data)
1580
def test_PrintTable_normal(self):
1581
with self.capture_stdout_to_buffer() as buffer:
1582
command.PrintTable().run(self.clients)
1583
expected_output = "\n".join((
1584
"Name Enabled Timeout Last Successful Check",
1585
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1586
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1588
self.assertEqual(expected_output, buffer.getvalue())
1590
def test_PrintTable_verbose(self):
1591
with self.capture_stdout_to_buffer() as buffer:
1592
command.PrintTable(verbose=True).run(self.clients)
1607
"Last Successful Check ",
1608
"2019-02-03T00:00:00 ",
1609
"2019-02-04T00:00:00 ",
1612
"2019-01-02T00:00:00 ",
1613
"2019-01-03T00:00:00 ",
1625
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1627
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1631
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
1632
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
1634
"Check Is Running ",
1639
"2019-01-03T00:00:00 ",
1640
"2019-01-04T00:00:00 ",
1642
"Approval Is Pending ",
1646
"Approved By Default ",
1650
"Last Approval Request ",
1652
"2019-01-03T00:00:00 ",
1658
"Approval Duration ",
1663
"fping -q -- %(host)s ",
1666
"Extended Timeout ",
1671
"2019-02-04T00:00:00 ",
1672
"2019-02-05T00:00:00 ",
1674
"Last Checker Status",
1679
num_lines = max(len(rows) for rows in columns)
1680
expected_output = ("\n".join("".join(rows[line]
1681
for rows in columns)
1682
for line in range(num_lines))
1684
self.assertEqual(expected_output, buffer.getvalue())
1686
def test_PrintTable_one_client(self):
1687
with self.capture_stdout_to_buffer() as buffer:
1688
command.PrintTable().run(self.one_client)
1689
expected_output = "\n".join((
1690
"Name Enabled Timeout Last Successful Check",
1691
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1693
self.assertEqual(expected_output, buffer.getvalue())
1696
class TestPropertyCmd(TestCommand):
1697
"""Abstract class for tests of command.Property classes"""
1699
if not hasattr(self, "command"):
1701
values_to_get = getattr(self, "values_to_get",
1703
for value_to_set, value_to_get in zip(self.values_to_set,
1705
for clientpath in self.clients:
1706
client = self.bus.get_object(dbus_busname, clientpath)
1707
old_value = client.attributes[self.propname]
1708
client.attributes[self.propname] = self.Unique()
1709
self.run_command(value_to_set, self.clients)
1710
for clientpath in self.clients:
1711
client = self.bus.get_object(dbus_busname, clientpath)
1712
value = client.attributes[self.propname]
1713
self.assertNotIsInstance(value, self.Unique)
1714
self.assertEqual(value_to_get, value)
1716
class Unique(object):
1717
"""Class for objects which exist only to be unique objects,
1718
since unittest.mock.sentinel only exists in Python 3.3"""
1720
def run_command(self, value, clients):
1721
self.command().run(clients, self.bus)
1724
class TestEnableCmd(TestPropertyCmd):
1725
command = command.Enable
1726
propname = "Enabled"
1727
values_to_set = [dbus.Boolean(True)]
1730
class TestDisableCmd(TestPropertyCmd):
1731
command = command.Disable
1732
propname = "Enabled"
1733
values_to_set = [dbus.Boolean(False)]
1736
class TestBumpTimeoutCmd(TestPropertyCmd):
1737
command = command.BumpTimeout
1738
propname = "LastCheckedOK"
1739
values_to_set = [""]
1742
class TestStartCheckerCmd(TestPropertyCmd):
1743
command = command.StartChecker
1744
propname = "CheckerRunning"
1745
values_to_set = [dbus.Boolean(True)]
1748
class TestStopCheckerCmd(TestPropertyCmd):
1749
command = command.StopChecker
1750
propname = "CheckerRunning"
1751
values_to_set = [dbus.Boolean(False)]
1754
class TestApproveByDefaultCmd(TestPropertyCmd):
1755
command = command.ApproveByDefault
1756
propname = "ApprovedByDefault"
1757
values_to_set = [dbus.Boolean(True)]
1760
class TestDenyByDefaultCmd(TestPropertyCmd):
1761
command = command.DenyByDefault
1762
propname = "ApprovedByDefault"
1763
values_to_set = [dbus.Boolean(False)]
1766
class TestPropertyValueCmd(TestPropertyCmd):
1767
"""Abstract class for tests of PropertyValueCmd classes"""
1770
if type(self) is TestPropertyValueCmd:
1772
return super(TestPropertyValueCmd, self).runTest()
1774
def run_command(self, value, clients):
1775
self.command(value).run(clients, self.bus)
1778
class TestSetCheckerCmd(TestPropertyValueCmd):
1779
command = command.SetChecker
1780
propname = "Checker"
1781
values_to_set = ["", ":", "fping -q -- %s"]
1784
class TestSetHostCmd(TestPropertyValueCmd):
1785
command = command.SetHost
1787
values_to_set = ["192.0.2.3", "foo.example.org"]
1790
class TestSetSecretCmd(TestPropertyValueCmd):
1791
command = command.SetSecret
1793
values_to_set = [io.BytesIO(b""),
1794
io.BytesIO(b"secret\0xyzzy\nbar")]
1795
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1798
class TestSetTimeoutCmd(TestPropertyValueCmd):
1799
command = command.SetTimeout
1800
propname = "Timeout"
1801
values_to_set = [datetime.timedelta(),
1802
datetime.timedelta(minutes=5),
1803
datetime.timedelta(seconds=1),
1804
datetime.timedelta(weeks=1),
1805
datetime.timedelta(weeks=52)]
1806
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1809
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
1810
command = command.SetExtendedTimeout
1811
propname = "ExtendedTimeout"
1812
values_to_set = [datetime.timedelta(),
1813
datetime.timedelta(minutes=5),
1814
datetime.timedelta(seconds=1),
1815
datetime.timedelta(weeks=1),
1816
datetime.timedelta(weeks=52)]
1817
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1820
class TestSetIntervalCmd(TestPropertyValueCmd):
1821
command = command.SetInterval
1822
propname = "Interval"
1823
values_to_set = [datetime.timedelta(),
1824
datetime.timedelta(minutes=5),
1825
datetime.timedelta(seconds=1),
1826
datetime.timedelta(weeks=1),
1827
datetime.timedelta(weeks=52)]
1828
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1831
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
1832
command = command.SetApprovalDelay
1833
propname = "ApprovalDelay"
1834
values_to_set = [datetime.timedelta(),
1835
datetime.timedelta(minutes=5),
1836
datetime.timedelta(seconds=1),
1837
datetime.timedelta(weeks=1),
1838
datetime.timedelta(weeks=52)]
1839
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1842
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
1843
command = command.SetApprovalDuration
1844
propname = "ApprovalDuration"
1845
values_to_set = [datetime.timedelta(),
1846
datetime.timedelta(minutes=5),
1847
datetime.timedelta(seconds=1),
1848
datetime.timedelta(weeks=1),
1849
datetime.timedelta(weeks=52)]
1850
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
764
log.removeFilter(warning_filter)
765
self.assertTrue(getattr(warning_filter, "found", False))
766
self.assertEqual(value, datetime.timedelta(0, 7200))
768
class Test_TableOfClients(unittest.TestCase):
770
self.tableheaders = {
774
"Bool": "A D-BUS Boolean",
775
"NonDbusBoolean": "A Non-D-BUS Boolean",
776
"Integer": "An Integer",
777
"Timeout": "Timedelta 1",
778
"Interval": "Timedelta 2",
779
"ApprovalDelay": "Timedelta 3",
780
"ApprovalDuration": "Timedelta 4",
781
"ExtendedTimeout": "Timedelta 5",
782
"String": "A String",
784
self.keywords = ["Attr1", "AttrTwo"]
790
"Bool": dbus.Boolean(False),
791
"NonDbusBoolean": False,
795
"ApprovalDelay": 2000,
796
"ApprovalDuration": 3000,
797
"ExtendedTimeout": 4000,
804
"Bool": dbus.Boolean(True),
805
"NonDbusBoolean": True,
808
"Interval": 93786000,
809
"ApprovalDelay": 93787000,
810
"ApprovalDuration": 93788000,
811
"ExtendedTimeout": 93789000,
812
"String": "A huge string which will not fit," * 10,
815
def test_short_header(self):
816
text = str(TableOfClients(self.clients, self.keywords,
823
self.assertEqual(text, expected_text)
824
def test_booleans(self):
825
keywords = ["Bool", "NonDbusBoolean"]
826
text = str(TableOfClients(self.clients, keywords,
829
A D-BUS Boolean A Non-D-BUS Boolean
833
self.assertEqual(text, expected_text)
834
def test_milliseconds_detection(self):
835
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
836
"ApprovalDuration", "ExtendedTimeout"]
837
text = str(TableOfClients(self.clients, keywords,
840
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
841
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
842
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
844
self.assertEqual(text, expected_text)
845
def test_empty_and_long_string_values(self):
846
keywords = ["String"]
847
text = str(TableOfClients(self.clients, keywords,
852
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
854
self.assertEqual(text, expected_text)