To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 1042
- compare with another revision
- download diff
- download tarball
- view history from revision 1042
- Committer: Teddy Hogeborn
- Date: 2019-03-08 22:57:26 UTC
- Revision ID: teddy@recompile.se-20190308225726-9tmoaw98l7dmzteh
mandos-ctl: Bug fix: close an open file
* mandos-ctl (TestSetSecretCmd): Don't open /dev/null in the class
definition.
* mandos-ctl (TestSetSecretCmd): Don't open /dev/null in the class
definition.
- files modified:
- mandos-ctl
added
removed
mandos-ctl
64
64
65
65
locale.setlocale(locale.LC_ALL, "")
66
66
67
dbus_busname_domain = "se.recompile"
68
dbus_busname = dbus_busname_domain + ".Mandos"
69
server_dbus_path = "/"
70
server_dbus_interface = dbus_busname_domain + ".Mandos"
71
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
72
del dbus_busname_domain
67
domain = "se.recompile"
68
busname = domain + ".Mandos"
69
server_path = "/"
70
server_interface = domain + ".Mandos"
71
client_interface = domain + ".Mandos.Client"
73
72
version = "1.8.3"
74
73
75
74
79
78
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
80
79
81
80
82
def main():
83
parser = argparse.ArgumentParser()
84
85
add_command_line_options(parser)
86
87
options = parser.parse_args()
88
89
check_option_syntax(parser, options)
90
91
clientnames = options.client
92
93
if options.debug:
94
log.setLevel(logging.DEBUG)
95
96
try:
97
bus = dbus.SystemBus()
98
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
99
dbus_busname, server_dbus_path)
100
mandos_dbus_objc = bus.get_object(dbus_busname,
101
server_dbus_path)
102
except dbus.exceptions.DBusException:
103
log.critical("Could not connect to Mandos server")
104
sys.exit(1)
105
106
mandos_serv = dbus.Interface(mandos_dbus_objc,
107
dbus_interface=server_dbus_interface)
108
mandos_serv_object_manager = dbus.Interface(
109
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
110
111
# Filter out log message from dbus module
112
dbus_logger = logging.getLogger("dbus.proxies")
113
class NullFilter(logging.Filter):
114
def filter(self, record):
115
return False
116
dbus_filter = NullFilter()
117
try:
118
dbus_logger.addFilter(dbus_filter)
119
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
120
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
121
all_clients = {path: ifs_and_props[client_dbus_interface]
122
for path, ifs_and_props in
123
mandos_serv_object_manager
124
.GetManagedObjects().items()
125
if client_dbus_interface in ifs_and_props}
126
except dbus.exceptions.DBusException as e:
127
log.critical("Failed to access Mandos server through D-Bus:"
128
"\n%s", e)
129
sys.exit(1)
130
finally:
131
# restore dbus logger
132
dbus_logger.removeFilter(dbus_filter)
133
134
# Compile dict of (clients: properties) to process
135
clients = {}
136
137
if not clientnames:
138
clients = all_clients
139
else:
140
for name in clientnames:
141
for objpath, properties in all_clients.items():
142
if properties["Name"] == name:
143
clients[objpath] = properties
144
break
145
else:
146
log.critical("Client not found on server: %r", name)
147
sys.exit(1)
148
149
# Run all commands on clients
150
commands = commands_from_options(options)
151
for command in commands:
152
command.run(clients, bus, mandos_serv)
153
154
155
def add_command_line_options(parser):
156
parser.add_argument("--version", action="version",
157
version="%(prog)s {}".format(version),
158
help="show version number and exit")
159
parser.add_argument("-a", "--all", action="store_true",
160
help="Select all clients")
161
parser.add_argument("-v", "--verbose", action="store_true",
162
help="Print all fields")
163
parser.add_argument("-j", "--dump-json", action="store_true",
164
help="Dump client data in JSON format")
165
enable_disable = parser.add_mutually_exclusive_group()
166
enable_disable.add_argument("-e", "--enable", action="store_true",
167
help="Enable client")
168
enable_disable.add_argument("-d", "--disable",
169
action="store_true",
170
help="disable client")
171
parser.add_argument("-b", "--bump-timeout", action="store_true",
172
help="Bump timeout for client")
173
start_stop_checker = parser.add_mutually_exclusive_group()
174
start_stop_checker.add_argument("--start-checker",
175
action="store_true",
176
help="Start checker for client")
177
start_stop_checker.add_argument("--stop-checker",
178
action="store_true",
179
help="Stop checker for client")
180
parser.add_argument("-V", "--is-enabled", action="store_true",
181
help="Check if client is enabled")
182
parser.add_argument("-r", "--remove", action="store_true",
183
help="Remove client")
184
parser.add_argument("-c", "--checker",
185
help="Set checker command for client")
186
parser.add_argument("-t", "--timeout", type=string_to_delta,
187
help="Set timeout for client")
188
parser.add_argument("--extended-timeout", type=string_to_delta,
189
help="Set extended timeout for client")
190
parser.add_argument("-i", "--interval", type=string_to_delta,
191
help="Set checker interval for client")
192
approve_deny_default = parser.add_mutually_exclusive_group()
193
approve_deny_default.add_argument(
194
"--approve-by-default", action="store_true",
195
default=None, dest="approved_by_default",
196
help="Set client to be approved by default")
197
approve_deny_default.add_argument(
198
"--deny-by-default", action="store_false",
199
dest="approved_by_default",
200
help="Set client to be denied by default")
201
parser.add_argument("--approval-delay", type=string_to_delta,
202
help="Set delay before client approve/deny")
203
parser.add_argument("--approval-duration", type=string_to_delta,
204
help="Set duration of one client approval")
205
parser.add_argument("-H", "--host", help="Set host for client")
206
parser.add_argument("-s", "--secret",
207
type=argparse.FileType(mode="rb"),
208
help="Set password blob (file) for client")
209
approve_deny = parser.add_mutually_exclusive_group()
210
approve_deny.add_argument(
211
"-A", "--approve", action="store_true",
212
help="Approve any current client request")
213
approve_deny.add_argument("-D", "--deny", action="store_true",
214
help="Deny any current client request")
215
parser.add_argument("--debug", action="store_true",
216
help="Debug mode (show D-Bus commands)")
217
parser.add_argument("--check", action="store_true",
218
help="Run self-test")
219
parser.add_argument("client", nargs="*", help="Client name")
220
221
222
def string_to_delta(interval):
223
"""Parse a string and return a datetime.timedelta"""
224
225
try:
226
return rfc3339_duration_to_delta(interval)
227
except ValueError as e:
228
log.warning("%s - Parsing as pre-1.6.1 interval instead",
229
' '.join(e.args))
230
return parse_pre_1_6_1_interval(interval)
81
def milliseconds_to_string(ms):
82
td = datetime.timedelta(0, 0, 0, ms)
83
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
84
.format(days="{}T".format(td.days) if td.days else "",
85
hours=td.seconds // 3600,
86
minutes=(td.seconds % 3600) // 60,
87
seconds=td.seconds % 60))
231
88
232
89
233
90
def rfc3339_duration_to_delta(duration):
360
217
return value
361
218
362
219
220
def string_to_delta(interval):
221
"""Parse a string and return a datetime.timedelta"""
222
223
try:
224
return rfc3339_duration_to_delta(interval)
225
except ValueError as e:
226
log.warning("%s - Parsing as pre-1.6.1 interval instead",
227
' '.join(e.args))
228
return parse_pre_1_6_1_interval(interval)
229
230
363
231
def parse_pre_1_6_1_interval(interval):
364
232
"""Parse an interval string as documented by Mandos before 1.6.1,
365
233
and return a datetime.timedelta
403
271
return value
404
272
405
273
406
def check_option_syntax(parser, options):
407
"""Apply additional restrictions on options, not expressible in
408
argparse"""
409
410
def has_actions(options):
411
return any((options.enable,
412
options.disable,
413
options.bump_timeout,
414
options.start_checker,
415
options.stop_checker,
416
options.is_enabled,
417
options.remove,
418
options.checker is not None,
419
options.timeout is not None,
420
options.extended_timeout is not None,
421
options.interval is not None,
422
options.approved_by_default is not None,
423
options.approval_delay is not None,
424
options.approval_duration is not None,
425
options.host is not None,
426
options.secret is not None,
427
options.approve,
428
options.deny))
429
430
if has_actions(options) and not (options.client or options.all):
431
parser.error("Options require clients names or --all.")
432
if options.verbose and has_actions(options):
433
parser.error("--verbose can only be used alone.")
434
if options.dump_json and (options.verbose
435
or has_actions(options)):
436
parser.error("--dump-json can only be used alone.")
437
if options.all and not has_actions(options):
438
parser.error("--all requires an action.")
439
if options.is_enabled and len(options.client) > 1:
440
parser.error("--is-enabled requires exactly one client")
441
if options.remove:
442
options.remove = False
443
if has_actions(options) and not options.deny:
444
parser.error("--remove can only be combined with --deny")
445
options.remove = True
446
447
448
def commands_from_options(options):
449
450
commands = []
451
452
if options.is_enabled:
453
commands.append(IsEnabledCmd())
454
455
if options.approve:
456
commands.append(ApproveCmd())
457
458
if options.deny:
459
commands.append(DenyCmd())
460
461
if options.remove:
462
commands.append(RemoveCmd())
463
464
if options.dump_json:
465
commands.append(DumpJSONCmd())
466
467
if options.enable:
468
commands.append(EnableCmd())
469
470
if options.disable:
471
commands.append(DisableCmd())
472
473
if options.bump_timeout:
474
commands.append(BumpTimeoutCmd())
475
476
if options.start_checker:
477
commands.append(StartCheckerCmd())
478
479
if options.stop_checker:
480
commands.append(StopCheckerCmd())
481
482
if options.approved_by_default is not None:
483
if options.approved_by_default:
484
commands.append(ApproveByDefaultCmd())
485
else:
486
commands.append(DenyByDefaultCmd())
487
488
if options.checker is not None:
489
commands.append(SetCheckerCmd(options.checker))
490
491
if options.host is not None:
492
commands.append(SetHostCmd(options.host))
493
494
if options.secret is not None:
495
commands.append(SetSecretCmd(options.secret))
496
497
if options.timeout is not None:
498
commands.append(SetTimeoutCmd(options.timeout))
499
500
if options.extended_timeout:
501
commands.append(
502
SetExtendedTimeoutCmd(options.extended_timeout))
503
504
if options.interval is not None:
505
commands.append(SetIntervalCmd(options.interval))
506
507
if options.approval_delay is not None:
508
commands.append(SetApprovalDelayCmd(options.approval_delay))
509
510
if options.approval_duration is not None:
511
commands.append(
512
SetApprovalDurationCmd(options.approval_duration))
513
514
# If no command option has been given, show table of clients,
515
# optionally verbosely
516
if not commands:
517
commands.append(PrintTableCmd(verbose=options.verbose))
518
519
return commands
520
521
274
## Classes for commands.
275
276
# Abstract classes first
522
277
class Command(object):
523
278
"""Abstract class for commands"""
524
def run(self, clients, bus=None, mandos=None):
279
def run(self, mandos, clients):
525
280
"""Normal commands should implement run_on_one_client(), but
526
281
commands which want to operate on all clients at the same time
527
282
can override this run() method instead."""
528
283
self.mandos = mandos
529
for clientpath, properties in clients.items():
530
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
531
dbus_busname, str(clientpath))
532
client = bus.get_object(dbus_busname, clientpath)
284
for client, properties in clients.items():
533
285
self.run_on_one_client(client, properties)
534
286
535
536
class IsEnabledCmd(Command):
537
def run(self, clients, bus=None, mandos=None):
538
client, properties = next(iter(clients.items()))
539
if self.is_enabled(client, properties):
540
sys.exit(0)
541
sys.exit(1)
542
def is_enabled(self, client, properties):
543
return properties["Enabled"]
544
545
546
class ApproveCmd(Command):
547
def run_on_one_client(self, client, properties):
548
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
549
client.__dbus_object_path__, client_dbus_interface)
550
client.Approve(dbus.Boolean(True),
551
dbus_interface=client_dbus_interface)
552
553
554
class DenyCmd(Command):
555
def run_on_one_client(self, client, properties):
556
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
557
client.__dbus_object_path__, client_dbus_interface)
558
client.Approve(dbus.Boolean(False),
559
dbus_interface=client_dbus_interface)
560
561
562
class RemoveCmd(Command):
563
def run_on_one_client(self, client, properties):
564
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,
565
server_dbus_path, server_dbus_interface,
566
str(client.__dbus_object_path__))
567
self.mandos.RemoveClient(client.__dbus_object_path__)
568
569
570
class OutputCmd(Command):
571
"""Abstract class for commands outputting client details"""
287
class PrintCmd(Command):
288
"""Abstract class for commands printing client details"""
572
289
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
573
290
"Created", "Interval", "Host", "KeyID",
574
291
"Fingerprint", "CheckerRunning", "LastEnabled",
576
293
"LastApprovalRequest", "ApprovalDelay",
577
294
"ApprovalDuration", "Checker", "ExtendedTimeout",
578
295
"Expires", "LastCheckerStatus")
579
580
def run(self, clients, bus=None, mandos=None):
581
print(self.output(clients.values()))
582
583
def output(self, clients):
584
raise NotImplementedError()
585
586
587
class DumpJSONCmd(OutputCmd):
588
def output(self, clients):
589
data = {client["Name"]:
590
{key: self.dbus_boolean_to_bool(client[key])
591
for key in self.all_keywords}
592
for client in clients}
593
return json.dumps(data, indent=4, separators=(',', ': '))
594
595
@staticmethod
596
def dbus_boolean_to_bool(value):
597
if isinstance(value, dbus.Boolean):
598
value = bool(value)
599
return value
600
601
602
class PrintTableCmd(OutputCmd):
296
def run(self, mandos, clients):
297
print(self.output(clients))
298
299
class PropertyCmd(Command):
300
"""Abstract class for Actions for setting one client property"""
301
def run_on_one_client(self, client, properties):
302
"""Set the Client's D-Bus property"""
303
client.Set(client_interface, self.property, self.value_to_set,
304
dbus_interface=dbus.PROPERTIES_IFACE)
305
306
class ValueArgumentMixIn(object):
307
"""Mixin class for commands taking a value as argument"""
308
def __init__(self, value):
309
self.value_to_set = value
310
311
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
312
"""Mixin class for commands taking a value argument as
313
milliseconds."""
314
@property
315
def value_to_set(self):
316
return self._vts
317
@value_to_set.setter
318
def value_to_set(self, value):
319
"""When setting, convert value to a datetime.timedelta"""
320
self._vts = int(round(value.total_seconds() * 1000))
321
322
# Actual (non-abstract) command classes
323
324
class PrintTableCmd(PrintCmd):
603
325
def __init__(self, verbose=False):
604
326
self.verbose = verbose
605
327
606
328
def output(self, clients):
607
default_keywords = ("Name", "Enabled", "Timeout",
608
"LastCheckedOK")
329
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
609
330
keywords = default_keywords
610
331
if self.verbose:
611
332
keywords = self.all_keywords
612
return str(self.TableOfClients(clients, keywords))
333
return str(self.TableOfClients(clients.values(), keywords))
613
334
614
335
class TableOfClients(object):
615
336
tableheaders = {
635
356
"LastCheckerStatus": "Last Checker Status",
636
357
}
637
358
638
def __init__(self, clients, keywords):
359
def __init__(self, clients, keywords, tableheaders=None):
639
360
self.clients = clients
640
361
self.keywords = keywords
362
if tableheaders is not None:
363
self.tableheaders = tableheaders
641
364
642
365
def __str__(self):
643
366
return "\n".join(self.rows())
666
389
def string_from_client(self, client, key):
667
390
return self.valuetostring(client[key], key)
668
391
669
@classmethod
670
def valuetostring(cls, value, keyword):
392
@staticmethod
393
def valuetostring(value, keyword):
671
394
if isinstance(value, dbus.Boolean):
672
395
return "Yes" if value else "No"
673
396
if keyword in ("Timeout", "Interval", "ApprovalDelay",
674
397
"ApprovalDuration", "ExtendedTimeout"):
675
return cls.milliseconds_to_string(value)
398
return milliseconds_to_string(value)
676
399
return str(value)
677
400
678
401
def header_line(self, format_string):
683
406
**{key: self.string_from_client(client, key)
684
407
for key in self.keywords})
685
408
686
@staticmethod
687
def milliseconds_to_string(ms):
688
td = datetime.timedelta(0, 0, 0, ms)
689
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
690
.format(days="{}T".format(td.days)
691
if td.days else "",
692
hours=td.seconds // 3600,
693
minutes=(td.seconds % 3600) // 60,
694
seconds=td.seconds % 60))
695
696
697
class PropertyCmd(Command):
698
"""Abstract class for Actions for setting one client property"""
699
700
def run_on_one_client(self, client, properties):
701
"""Set the Client's D-Bus property"""
702
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
703
client.__dbus_object_path__,
704
dbus.PROPERTIES_IFACE, client_dbus_interface,
705
self.propname, self.value_to_set
706
if not isinstance(self.value_to_set, dbus.Boolean)
707
else bool(self.value_to_set))
708
client.Set(client_dbus_interface, self.propname,
709
self.value_to_set,
710
dbus_interface=dbus.PROPERTIES_IFACE)
711
712
@property
713
def propname(self):
714
raise NotImplementedError()
715
409
410
411
class DumpJSONCmd(PrintCmd):
412
def output(self, clients):
413
data = {client["Name"]:
414
{key: self.dbus_boolean_to_bool(client[key])
415
for key in self.all_keywords}
416
for client in clients.values()}
417
return json.dumps(data, indent=4, separators=(',', ': '))
418
@staticmethod
419
def dbus_boolean_to_bool(value):
420
if isinstance(value, dbus.Boolean):
421
value = bool(value)
422
return value
423
424
class IsEnabledCmd(Command):
425
def run_on_one_client(self, client, properties):
426
if self.is_enabled(client, properties):
427
sys.exit(0)
428
sys.exit(1)
429
def is_enabled(self, client, properties):
430
return bool(properties["Enabled"])
431
432
class RemoveCmd(Command):
433
def run_on_one_client(self, client, properties):
434
self.mandos.RemoveClient(client.__dbus_object_path__)
435
436
class ApproveCmd(Command):
437
def run_on_one_client(self, client, properties):
438
client.Approve(dbus.Boolean(True),
439
dbus_interface=client_interface)
440
441
class DenyCmd(Command):
442
def run_on_one_client(self, client, properties):
443
client.Approve(dbus.Boolean(False),
444
dbus_interface=client_interface)
716
445
717
446
class EnableCmd(PropertyCmd):
718
propname = "Enabled"
447
property = "Enabled"
719
448
value_to_set = dbus.Boolean(True)
720
449
721
722
450
class DisableCmd(PropertyCmd):
723
propname = "Enabled"
451
property = "Enabled"
724
452
value_to_set = dbus.Boolean(False)
725
453
726
727
454
class BumpTimeoutCmd(PropertyCmd):
728
propname = "LastCheckedOK"
455
property = "LastCheckedOK"
729
456
value_to_set = ""
730
457
731
732
458
class StartCheckerCmd(PropertyCmd):
733
propname = "CheckerRunning"
459
property = "CheckerRunning"
734
460
value_to_set = dbus.Boolean(True)
735
461
736
737
462
class StopCheckerCmd(PropertyCmd):
738
propname = "CheckerRunning"
463
property = "CheckerRunning"
739
464
value_to_set = dbus.Boolean(False)
740
465
741
742
466
class ApproveByDefaultCmd(PropertyCmd):
743
propname = "ApprovedByDefault"
467
property = "ApprovedByDefault"
744
468
value_to_set = dbus.Boolean(True)
745
469
746
747
470
class DenyByDefaultCmd(PropertyCmd):
748
propname = "ApprovedByDefault"
471
property = "ApprovedByDefault"
749
472
value_to_set = dbus.Boolean(False)
750
473
751
752
class PropertyValueCmd(PropertyCmd):
753
"""Abstract class for PropertyCmd recieving a value as argument"""
754
def __init__(self, value):
755
self.value_to_set = value
756
757
758
class SetCheckerCmd(PropertyValueCmd):
759
propname = "Checker"
760
761
762
class SetHostCmd(PropertyValueCmd):
763
propname = "Host"
764
765
766
class SetSecretCmd(PropertyValueCmd):
767
propname = "Secret"
768
474
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
475
property = "Checker"
476
477
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
478
property = "Host"
479
480
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
769
481
@property
770
482
def value_to_set(self):
771
483
return self._vts
772
773
484
@value_to_set.setter
774
485
def value_to_set(self, value):
775
486
"""When setting, read data from supplied file object"""
776
487
self._vts = value.read()
777
488
value.close()
778
779
780
class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):
781
"""Abstract class for PropertyValueCmd taking a value argument as
782
a datetime.timedelta() but should store it as milliseconds."""
783
784
@property
785
def value_to_set(self):
786
return self._vts
787
788
@value_to_set.setter
789
def value_to_set(self, value):
790
"""When setting, convert value from a datetime.timedelta"""
791
self._vts = int(round(value.total_seconds() * 1000))
792
793
794
class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
795
propname = "Timeout"
796
797
798
class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
799
propname = "ExtendedTimeout"
800
801
802
class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):
803
propname = "Interval"
804
805
806
class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):
807
propname = "ApprovalDelay"
808
809
810
class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):
811
propname = "ApprovalDuration"
812
489
property = "Secret"
490
491
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
492
property = "Timeout"
493
494
class SetExtendedTimeoutCmd(PropertyCmd,
495
MillisecondsValueArgumentMixIn):
496
property = "ExtendedTimeout"
497
498
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
499
property = "Interval"
500
501
class SetApprovalDelayCmd(PropertyCmd,
502
MillisecondsValueArgumentMixIn):
503
property = "ApprovalDelay"
504
505
class SetApprovalDurationCmd(PropertyCmd,
506
MillisecondsValueArgumentMixIn):
507
property = "ApprovalDuration"
508
509
def add_command_line_options(parser):
510
parser.add_argument("--version", action="version",
511
version="%(prog)s {}".format(version),
512
help="show version number and exit")
513
parser.add_argument("-a", "--all", action="store_true",
514
help="Select all clients")
515
parser.add_argument("-v", "--verbose", action="store_true",
516
help="Print all fields")
517
parser.add_argument("-j", "--dump-json", action="store_true",
518
help="Dump client data in JSON format")
519
enable_disable = parser.add_mutually_exclusive_group()
520
enable_disable.add_argument("-e", "--enable", action="store_true",
521
help="Enable client")
522
enable_disable.add_argument("-d", "--disable",
523
action="store_true",
524
help="disable client")
525
parser.add_argument("-b", "--bump-timeout", action="store_true",
526
help="Bump timeout for client")
527
start_stop_checker = parser.add_mutually_exclusive_group()
528
start_stop_checker.add_argument("--start-checker",
529
action="store_true",
530
help="Start checker for client")
531
start_stop_checker.add_argument("--stop-checker",
532
action="store_true",
533
help="Stop checker for client")
534
parser.add_argument("-V", "--is-enabled", action="store_true",
535
help="Check if client is enabled")
536
parser.add_argument("-r", "--remove", action="store_true",
537
help="Remove client")
538
parser.add_argument("-c", "--checker",
539
help="Set checker command for client")
540
parser.add_argument("-t", "--timeout", type=string_to_delta,
541
help="Set timeout for client")
542
parser.add_argument("--extended-timeout", type=string_to_delta,
543
help="Set extended timeout for client")
544
parser.add_argument("-i", "--interval", type=string_to_delta,
545
help="Set checker interval for client")
546
approve_deny_default = parser.add_mutually_exclusive_group()
547
approve_deny_default.add_argument(
548
"--approve-by-default", action="store_true",
549
default=None, dest="approved_by_default",
550
help="Set client to be approved by default")
551
approve_deny_default.add_argument(
552
"--deny-by-default", action="store_false",
553
dest="approved_by_default",
554
help="Set client to be denied by default")
555
parser.add_argument("--approval-delay", type=string_to_delta,
556
help="Set delay before client approve/deny")
557
parser.add_argument("--approval-duration", type=string_to_delta,
558
help="Set duration of one client approval")
559
parser.add_argument("-H", "--host", help="Set host for client")
560
parser.add_argument("-s", "--secret",
561
type=argparse.FileType(mode="rb"),
562
help="Set password blob (file) for client")
563
approve_deny = parser.add_mutually_exclusive_group()
564
approve_deny.add_argument(
565
"-A", "--approve", action="store_true",
566
help="Approve any current client request")
567
approve_deny.add_argument("-D", "--deny", action="store_true",
568
help="Deny any current client request")
569
parser.add_argument("--check", action="store_true",
570
help="Run self-test")
571
parser.add_argument("client", nargs="*", help="Client name")
572
573
574
def commands_from_options(options):
575
576
commands = []
577
578
if options.dump_json:
579
commands.append(DumpJSONCmd())
580
581
if options.enable:
582
commands.append(EnableCmd())
583
584
if options.disable:
585
commands.append(DisableCmd())
586
587
if options.bump_timeout:
588
commands.append(BumpTimeoutCmd())
589
590
if options.start_checker:
591
commands.append(StartCheckerCmd())
592
593
if options.stop_checker:
594
commands.append(StopCheckerCmd())
595
596
if options.is_enabled:
597
commands.append(IsEnabledCmd())
598
599
if options.remove:
600
commands.append(RemoveCmd())
601
602
if options.checker is not None:
603
commands.append(SetCheckerCmd(options.checker))
604
605
if options.timeout is not None:
606
commands.append(SetTimeoutCmd(options.timeout))
607
608
if options.extended_timeout:
609
commands.append(
610
SetExtendedTimeoutCmd(options.extended_timeout))
611
612
if options.interval is not None:
613
commands.append(SetIntervalCmd(options.interval))
614
615
if options.approved_by_default is not None:
616
if options.approved_by_default:
617
commands.append(ApproveByDefaultCmd())
618
else:
619
commands.append(DenyByDefaultCmd())
620
621
if options.approval_delay is not None:
622
commands.append(SetApprovalDelayCmd(options.approval_delay))
623
624
if options.approval_duration is not None:
625
commands.append(
626
SetApprovalDurationCmd(options.approval_duration))
627
628
if options.host is not None:
629
commands.append(SetHostCmd(options.host))
630
631
if options.secret is not None:
632
commands.append(SetSecretCmd(options.secret))
633
634
if options.approve:
635
commands.append(ApproveCmd())
636
637
if options.deny:
638
commands.append(DenyCmd())
639
640
# If no command option has been given, show table of clients,
641
# optionally verbosely
642
if not commands:
643
commands.append(PrintTableCmd(verbose=options.verbose))
644
645
return commands
646
647
648
def check_option_syntax(parser, options):
649
"""Apply additional restrictions on options, not expressible in
650
argparse"""
651
652
def has_actions(options):
653
return any((options.enable,
654
options.disable,
655
options.bump_timeout,
656
options.start_checker,
657
options.stop_checker,
658
options.is_enabled,
659
options.remove,
660
options.checker is not None,
661
options.timeout is not None,
662
options.extended_timeout is not None,
663
options.interval is not None,
664
options.approved_by_default is not None,
665
options.approval_delay is not None,
666
options.approval_duration is not None,
667
options.host is not None,
668
options.secret is not None,
669
options.approve,
670
options.deny))
671
672
if has_actions(options) and not (options.client or options.all):
673
parser.error("Options require clients names or --all.")
674
if options.verbose and has_actions(options):
675
parser.error("--verbose can only be used alone.")
676
if options.dump_json and (options.verbose
677
or has_actions(options)):
678
parser.error("--dump-json can only be used alone.")
679
if options.all and not has_actions(options):
680
parser.error("--all requires an action.")
681
if options.is_enabled and len(options.client) > 1:
682
parser.error("--is-enabled requires exactly one client")
683
684
685
def main():
686
parser = argparse.ArgumentParser()
687
688
add_command_line_options(parser)
689
690
options = parser.parse_args()
691
692
check_option_syntax(parser, options)
693
694
clientnames = options.client
695
696
try:
697
bus = dbus.SystemBus()
698
mandos_dbus_objc = bus.get_object(busname, server_path)
699
except dbus.exceptions.DBusException:
700
log.critical("Could not connect to Mandos server")
701
sys.exit(1)
702
703
mandos_serv = dbus.Interface(mandos_dbus_objc,
704
dbus_interface=server_interface)
705
mandos_serv_object_manager = dbus.Interface(
706
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
707
708
# Filter out log message from dbus module
709
dbus_logger = logging.getLogger("dbus.proxies")
710
class NullFilter(logging.Filter):
711
def filter(self, record):
712
return False
713
dbus_filter = NullFilter()
714
try:
715
dbus_logger.addFilter(dbus_filter)
716
mandos_clients = {path: ifs_and_props[client_interface]
717
for path, ifs_and_props in
718
mandos_serv_object_manager
719
.GetManagedObjects().items()
720
if client_interface in ifs_and_props}
721
except dbus.exceptions.DBusException as e:
722
log.critical("Failed to access Mandos server through D-Bus:"
723
"\n%s", e)
724
sys.exit(1)
725
finally:
726
# restore dbus logger
727
dbus_logger.removeFilter(dbus_filter)
728
729
# Compile dict of (clients: properties) to process
730
clients = {}
731
732
if not clientnames:
733
clients = {bus.get_object(busname, path): properties
734
for path, properties in mandos_clients.items()}
735
else:
736
for name in clientnames:
737
for path, client in mandos_clients.items():
738
if client["Name"] == name:
739
client_objc = bus.get_object(busname, path)
740
clients[client_objc] = client
741
break
742
else:
743
log.critical("Client not found on server: %r", name)
744
sys.exit(1)
745
746
# Run all commands on clients
747
commands = commands_from_options(options)
748
for command in commands:
749
command.run(mandos_serv, clients)
813
750
814
751
752
class Test_milliseconds_to_string(unittest.TestCase):
753
def test_all(self):
754
self.assertEqual(milliseconds_to_string(93785000),
755
"1T02:03:05")
756
def test_no_days(self):
757
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
758
def test_all_zero(self):
759
self.assertEqual(milliseconds_to_string(0), "00:00:00")
760
def test_no_fractional_seconds(self):
761
self.assertEqual(milliseconds_to_string(400), "00:00:00")
762
self.assertEqual(milliseconds_to_string(900), "00:00:00")
763
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
764
815
765
class Test_string_to_delta(unittest.TestCase):
816
766
def test_handles_basic_rfc3339(self):
817
767
self.assertEqual(string_to_delta("PT0S"),
822
772
datetime.timedelta(0, 1))
823
773
self.assertEqual(string_to_delta("PT2H"),
824
774
datetime.timedelta(0, 7200))
825
826
775
def test_falls_back_to_pre_1_6_1_with_warning(self):
827
776
# assertLogs only exists in Python 3.4
828
777
if hasattr(self, "assertLogs"):
846
795
self.assertEqual(value, datetime.timedelta(0, 7200))
847
796
848
797
849
class Test_check_option_syntax(unittest.TestCase):
850
def setUp(self):
851
self.parser = argparse.ArgumentParser()
852
add_command_line_options(self.parser)
853
854
def test_actions_requires_client_or_all(self):
855
for action, value in self.actions.items():
856
options = self.parser.parse_args()
857
setattr(options, action, value)
858
with self.assertParseError():
859
self.check_option_syntax(options)
860
861
# This mostly corresponds to the definition from has_actions() in
862
# check_option_syntax()
863
actions = {
864
# The actual values set here are not that important, but we do
865
# at least stick to the correct types, even though they are
866
# never used
867
"enable": True,
868
"disable": True,
869
"bump_timeout": True,
870
"start_checker": True,
871
"stop_checker": True,
872
"is_enabled": True,
873
"remove": True,
874
"checker": "x",
875
"timeout": datetime.timedelta(),
876
"extended_timeout": datetime.timedelta(),
877
"interval": datetime.timedelta(),
878
"approved_by_default": True,
879
"approval_delay": datetime.timedelta(),
880
"approval_duration": datetime.timedelta(),
881
"host": "x",
882
"secret": io.BytesIO(b"x"),
883
"approve": True,
884
"deny": True,
885
}
886
887
@contextlib.contextmanager
888
def assertParseError(self):
889
with self.assertRaises(SystemExit) as e:
890
with self.temporarily_suppress_stderr():
891
yield
892
# Exit code from argparse is guaranteed to be "2". Reference:
893
# https://docs.python.org/3/library
894
# /argparse.html#exiting-methods
895
self.assertEqual(e.exception.code, 2)
896
897
@staticmethod
898
@contextlib.contextmanager
899
def temporarily_suppress_stderr():
900
null = os.open(os.path.devnull, os.O_RDWR)
901
stderrcopy = os.dup(sys.stderr.fileno())
902
os.dup2(null, sys.stderr.fileno())
903
os.close(null)
904
try:
905
yield
906
finally:
907
# restore stderr
908
os.dup2(stderrcopy, sys.stderr.fileno())
909
os.close(stderrcopy)
910
911
def check_option_syntax(self, options):
912
check_option_syntax(self.parser, options)
913
914
def test_actions_conflicts_with_verbose(self):
915
for action, value in self.actions.items():
916
options = self.parser.parse_args()
917
setattr(options, action, value)
918
options.verbose = True
919
with self.assertParseError():
920
self.check_option_syntax(options)
921
922
def test_dump_json_conflicts_with_verbose(self):
923
options = self.parser.parse_args()
924
options.dump_json = True
925
options.verbose = True
926
with self.assertParseError():
927
self.check_option_syntax(options)
928
929
def test_dump_json_conflicts_with_action(self):
930
for action, value in self.actions.items():
931
options = self.parser.parse_args()
932
setattr(options, action, value)
933
options.dump_json = True
934
with self.assertParseError():
935
self.check_option_syntax(options)
936
937
def test_all_can_not_be_alone(self):
938
options = self.parser.parse_args()
939
options.all = True
940
with self.assertParseError():
941
self.check_option_syntax(options)
942
943
def test_all_is_ok_with_any_action(self):
944
for action, value in self.actions.items():
945
options = self.parser.parse_args()
946
setattr(options, action, value)
947
options.all = True
948
self.check_option_syntax(options)
949
950
def test_is_enabled_fails_without_client(self):
951
options = self.parser.parse_args()
952
options.is_enabled = True
953
with self.assertParseError():
954
self.check_option_syntax(options)
955
956
def test_is_enabled_works_with_one_client(self):
957
options = self.parser.parse_args()
958
options.is_enabled = True
959
options.client = ["foo"]
960
self.check_option_syntax(options)
961
962
def test_is_enabled_fails_with_two_clients(self):
963
options = self.parser.parse_args()
964
options.is_enabled = True
965
options.client = ["foo", "barbar"]
966
with self.assertParseError():
967
self.check_option_syntax(options)
968
969
def test_remove_can_only_be_combined_with_action_deny(self):
970
for action, value in self.actions.items():
971
if action in {"remove", "deny"}:
972
continue
973
options = self.parser.parse_args()
974
setattr(options, action, value)
975
options.all = True
976
options.remove = True
977
with self.assertParseError():
978
self.check_option_syntax(options)
979
980
981
class Test_commands_from_options(unittest.TestCase):
982
def setUp(self):
983
self.parser = argparse.ArgumentParser()
984
add_command_line_options(self.parser)
985
986
def test_is_enabled(self):
987
self.assert_command_from_args(["--is-enabled", "foo"],
988
IsEnabledCmd)
989
990
def assert_command_from_args(self, args, command_cls,
991
**cmd_attrs):
992
"""Assert that parsing ARGS should result in an instance of
993
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
994
options = self.parser.parse_args(args)
995
check_option_syntax(self.parser, options)
996
commands = commands_from_options(options)
997
self.assertEqual(len(commands), 1)
998
command = commands[0]
999
self.assertIsInstance(command, command_cls)
1000
for key, value in cmd_attrs.items():
1001
self.assertEqual(getattr(command, key), value)
1002
1003
def test_is_enabled_short(self):
1004
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1005
1006
def test_approve(self):
1007
self.assert_command_from_args(["--approve", "foo"],
1008
ApproveCmd)
1009
1010
def test_approve_short(self):
1011
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1012
1013
def test_deny(self):
1014
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1015
1016
def test_deny_short(self):
1017
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1018
1019
def test_remove(self):
1020
self.assert_command_from_args(["--remove", "foo"],
1021
RemoveCmd)
1022
1023
def test_deny_before_remove(self):
1024
options = self.parser.parse_args(["--deny", "--remove",
1025
"foo"])
1026
check_option_syntax(self.parser, options)
1027
commands = commands_from_options(options)
1028
self.assertEqual(len(commands), 2)
1029
self.assertIsInstance(commands[0], DenyCmd)
1030
self.assertIsInstance(commands[1], RemoveCmd)
1031
1032
def test_deny_before_remove_reversed(self):
1033
options = self.parser.parse_args(["--remove", "--deny",
1034
"--all"])
1035
check_option_syntax(self.parser, options)
1036
commands = commands_from_options(options)
1037
self.assertEqual(len(commands), 2)
1038
self.assertIsInstance(commands[0], DenyCmd)
1039
self.assertIsInstance(commands[1], RemoveCmd)
1040
1041
def test_remove_short(self):
1042
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1043
1044
def test_dump_json(self):
1045
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1046
1047
def test_enable(self):
1048
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1049
1050
def test_enable_short(self):
1051
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1052
1053
def test_disable(self):
1054
self.assert_command_from_args(["--disable", "foo"],
1055
DisableCmd)
1056
1057
def test_disable_short(self):
1058
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1059
1060
def test_bump_timeout(self):
1061
self.assert_command_from_args(["--bump-timeout", "foo"],
1062
BumpTimeoutCmd)
1063
1064
def test_bump_timeout_short(self):
1065
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1066
1067
def test_start_checker(self):
1068
self.assert_command_from_args(["--start-checker", "foo"],
1069
StartCheckerCmd)
1070
1071
def test_stop_checker(self):
1072
self.assert_command_from_args(["--stop-checker", "foo"],
1073
StopCheckerCmd)
1074
1075
def test_approve_by_default(self):
1076
self.assert_command_from_args(["--approve-by-default", "foo"],
1077
ApproveByDefaultCmd)
1078
1079
def test_deny_by_default(self):
1080
self.assert_command_from_args(["--deny-by-default", "foo"],
1081
DenyByDefaultCmd)
1082
1083
def test_checker(self):
1084
self.assert_command_from_args(["--checker", ":", "foo"],
1085
SetCheckerCmd, value_to_set=":")
1086
1087
def test_checker_empty(self):
1088
self.assert_command_from_args(["--checker", "", "foo"],
1089
SetCheckerCmd, value_to_set="")
1090
1091
def test_checker_short(self):
1092
self.assert_command_from_args(["-c", ":", "foo"],
1093
SetCheckerCmd, value_to_set=":")
1094
1095
def test_host(self):
1096
self.assert_command_from_args(["--host", "foo.example.org",
1097
"foo"], SetHostCmd,
1098
value_to_set="foo.example.org")
1099
1100
def test_host_short(self):
1101
self.assert_command_from_args(["-H", "foo.example.org",
1102
"foo"], SetHostCmd,
1103
value_to_set="foo.example.org")
1104
1105
def test_secret_devnull(self):
1106
self.assert_command_from_args(["--secret", os.path.devnull,
1107
"foo"], SetSecretCmd,
1108
value_to_set=b"")
1109
1110
def test_secret_tempfile(self):
1111
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1112
value = b"secret\0xyzzy\nbar"
1113
f.write(value)
1114
f.seek(0)
1115
self.assert_command_from_args(["--secret", f.name,
1116
"foo"], SetSecretCmd,
1117
value_to_set=value)
1118
1119
def test_secret_devnull_short(self):
1120
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1121
SetSecretCmd, value_to_set=b"")
1122
1123
def test_secret_tempfile_short(self):
1124
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1125
value = b"secret\0xyzzy\nbar"
1126
f.write(value)
1127
f.seek(0)
1128
self.assert_command_from_args(["-s", f.name, "foo"],
1129
SetSecretCmd,
1130
value_to_set=value)
1131
1132
def test_timeout(self):
1133
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1134
SetTimeoutCmd,
1135
value_to_set=300000)
1136
1137
def test_timeout_short(self):
1138
self.assert_command_from_args(["-t", "PT5M", "foo"],
1139
SetTimeoutCmd,
1140
value_to_set=300000)
1141
1142
def test_extended_timeout(self):
1143
self.assert_command_from_args(["--extended-timeout", "PT15M",
1144
"foo"],
1145
SetExtendedTimeoutCmd,
1146
value_to_set=900000)
1147
1148
def test_interval(self):
1149
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1150
SetIntervalCmd,
1151
value_to_set=120000)
1152
1153
def test_interval_short(self):
1154
self.assert_command_from_args(["-i", "PT2M", "foo"],
1155
SetIntervalCmd,
1156
value_to_set=120000)
1157
1158
def test_approval_delay(self):
1159
self.assert_command_from_args(["--approval-delay", "PT30S",
1160
"foo"], SetApprovalDelayCmd,
1161
value_to_set=30000)
1162
1163
def test_approval_duration(self):
1164
self.assert_command_from_args(["--approval-duration", "PT1S",
1165
"foo"], SetApprovalDurationCmd,
1166
value_to_set=1000)
1167
1168
def test_print_table(self):
1169
self.assert_command_from_args([], PrintTableCmd,
1170
verbose=False)
1171
1172
def test_print_table_verbose(self):
1173
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1174
verbose=True)
1175
1176
def test_print_table_verbose_short(self):
1177
self.assert_command_from_args(["-v"], PrintTableCmd,
1178
verbose=True)
1179
1180
1181
798
class TestCmd(unittest.TestCase):
1182
799
"""Abstract class for tests of command classes"""
1183
1184
800
def setUp(self):
1185
801
testcase = self
1186
802
class MockClient(object):
1187
803
def __init__(self, name, **attributes):
1188
self.__dbus_object_path__ = "/clients/{}".format(name)
804
self.__dbus_object_path__ = "objpath_{}".format(name)
1189
805
self.attributes = attributes
1190
806
self.attributes["Name"] = name
1191
807
self.calls = []
1192
def Set(self, interface, propname, value, dbus_interface):
1193
testcase.assertEqual(interface, client_dbus_interface)
1194
testcase.assertEqual(dbus_interface,
1195
dbus.PROPERTIES_IFACE)
1196
self.attributes[propname] = value
1197
def Get(self, interface, propname, dbus_interface):
1198
testcase.assertEqual(interface, client_dbus_interface)
1199
testcase.assertEqual(dbus_interface,
1200
dbus.PROPERTIES_IFACE)
1201
return self.attributes[propname]
808
def Set(self, interface, property, value, dbus_interface):
809
testcase.assertEqual(interface, client_interface)
810
testcase.assertEqual(dbus_interface,
811
dbus.PROPERTIES_IFACE)
812
self.attributes[property] = value
813
def Get(self, interface, property, dbus_interface):
814
testcase.assertEqual(interface, client_interface)
815
testcase.assertEqual(dbus_interface,
816
dbus.PROPERTIES_IFACE)
817
return self.attributes[property]
1202
818
def Approve(self, approve, dbus_interface):
1203
testcase.assertEqual(dbus_interface,
1204
client_dbus_interface)
819
testcase.assertEqual(dbus_interface, client_interface)
1205
820
self.calls.append(("Approve", (approve,
1206
821
dbus_interface)))
1207
822
self.client = MockClient(
1247
862
ApprovedByDefault=dbus.Boolean(False),
1248
863
LastApprovalRequest="2019-01-03T00:00:00",
1249
864
ApprovalDelay=30000,
1250
ApprovalDuration=93785000,
865
ApprovalDuration=1000,
1251
866
Checker=":",
1252
867
ExtendedTimeout=900000,
1253
868
Expires="2019-02-05T00:00:00",
1254
869
LastCheckerStatus=-2)
1255
870
self.clients = collections.OrderedDict(
1256
871
[
1257
("/clients/foo", self.client.attributes),
1258
("/clients/barbar", self.other_client.attributes),
872
(self.client, self.client.attributes),
873
(self.other_client, self.other_client.attributes),
1259
874
])
1260
self.one_client = {"/clients/foo": self.client.attributes}
1261
1262
@property
1263
def bus(self):
1264
class Bus(object):
1265
@staticmethod
1266
def get_object(client_bus_name, path):
1267
self.assertEqual(client_bus_name, dbus_busname)
1268
return {
1269
# Note: "self" here is the TestCmd instance, not
1270
# the Bus instance, since this is a static method!
1271
"/clients/foo": self.client,
1272
"/clients/barbar": self.other_client,
1273
}[path]
1274
return Bus()
1275
1276
1277
class TestIsEnabledCmd(TestCmd):
1278
def test_is_enabled(self):
1279
self.assertTrue(all(IsEnabledCmd().is_enabled(client,
1280
properties)
1281
for client, properties
1282
in self.clients.items()))
1283
1284
def test_is_enabled_run_exits_successfully(self):
1285
with self.assertRaises(SystemExit) as e:
1286
IsEnabledCmd().run(self.one_client)
1287
if e.exception.code is not None:
1288
self.assertEqual(e.exception.code, 0)
1289
else:
1290
self.assertIsNone(e.exception.code)
1291
1292
def test_is_enabled_run_exits_with_failure(self):
1293
self.client.attributes["Enabled"] = dbus.Boolean(False)
1294
with self.assertRaises(SystemExit) as e:
1295
IsEnabledCmd().run(self.one_client)
1296
if isinstance(e.exception.code, int):
1297
self.assertNotEqual(e.exception.code, 0)
1298
else:
1299
self.assertIsNotNone(e.exception.code)
1300
1301
1302
class TestApproveCmd(TestCmd):
1303
def test_approve(self):
1304
ApproveCmd().run(self.clients, self.bus)
1305
for clientpath in self.clients:
1306
client = self.bus.get_object(dbus_busname, clientpath)
1307
self.assertIn(("Approve", (True, client_dbus_interface)),
1308
client.calls)
1309
1310
1311
class TestDenyCmd(TestCmd):
1312
def test_deny(self):
1313
DenyCmd().run(self.clients, self.bus)
1314
for clientpath in self.clients:
1315
client = self.bus.get_object(dbus_busname, clientpath)
1316
self.assertIn(("Approve", (False, client_dbus_interface)),
1317
client.calls)
1318
1319
1320
class TestRemoveCmd(TestCmd):
1321
def test_remove(self):
1322
class MockMandos(object):
1323
def __init__(self):
1324
self.calls = []
1325
def RemoveClient(self, dbus_path):
1326
self.calls.append(("RemoveClient", (dbus_path,)))
1327
mandos = MockMandos()
1328
super(TestRemoveCmd, self).setUp()
1329
RemoveCmd().run(self.clients, self.bus, mandos)
1330
self.assertEqual(len(mandos.calls), 2)
1331
for clientpath in self.clients:
1332
self.assertIn(("RemoveClient", (clientpath,)),
1333
mandos.calls)
1334
875
self.one_client = {self.client: self.client.attributes}
876
877
class TestPrintTableCmd(TestCmd):
878
def test_normal(self):
879
output = PrintTableCmd().output(self.clients)
880
expected_output = """
881
Name Enabled Timeout Last Successful Check
882
foo Yes 00:05:00 2019-02-03T00:00:00
883
barbar Yes 00:05:00 2019-02-04T00:00:00
884
"""[1:-1]
885
self.assertEqual(output, expected_output)
886
def test_verbose(self):
887
output = PrintTableCmd(verbose=True).output(self.clients)
888
expected_output = """
889
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
890
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
891
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
892
"""[1:-1]
893
self.assertEqual(output, expected_output)
894
def test_one_client(self):
895
output = PrintTableCmd().output(self.one_client)
896
expected_output = """
897
Name Enabled Timeout Last Successful Check
898
foo Yes 00:05:00 2019-02-03T00:00:00
899
"""[1:-1]
900
self.assertEqual(output, expected_output)
1335
901
1336
902
class TestDumpJSONCmd(TestCmd):
1337
903
def setUp(self):
1378
944
"ApprovedByDefault": False,
1379
945
"LastApprovalRequest": "2019-01-03T00:00:00",
1380
946
"ApprovalDelay": 30000,
1381
"ApprovalDuration": 93785000,
947
"ApprovalDuration": 1000,
1382
948
"Checker": ":",
1383
949
"ExtendedTimeout": 900000,
1384
950
"Expires": "2019-02-05T00:00:00",
1386
952
},
1387
953
}
1388
954
return super(TestDumpJSONCmd, self).setUp()
1389
1390
955
def test_normal(self):
1391
output = DumpJSONCmd().output(self.clients.values())
1392
json_data = json.loads(output)
956
json_data = json.loads(DumpJSONCmd().output(self.clients))
1393
957
self.assertDictEqual(json_data, self.expected_json)
1394
1395
958
def test_one_client(self):
1396
output = DumpJSONCmd().output(self.one_client.values())
1397
json_data = json.loads(output)
959
clients = self.one_client
960
json_data = json.loads(DumpJSONCmd().output(clients))
1398
961
expected_json = {"foo": self.expected_json["foo"]}
1399
962
self.assertDictEqual(json_data, expected_json)
1400
963
1401
1402
class TestPrintTableCmd(TestCmd):
1403
def test_normal(self):
1404
output = PrintTableCmd().output(self.clients.values())
1405
expected_output = "\n".join((
1406
"Name Enabled Timeout Last Successful Check",
1407
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1408
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1409
))
1410
self.assertEqual(output, expected_output)
1411
1412
def test_verbose(self):
1413
output = PrintTableCmd(verbose=True).output(
1414
self.clients.values())
1415
columns = (
1416
(
1417
"Name ",
1418
"foo ",
1419
"barbar ",
1420
),(
1421
"Enabled ",
1422
"Yes ",
1423
"Yes ",
1424
),(
1425
"Timeout ",
1426
"00:05:00 ",
1427
"00:05:00 ",
1428
),(
1429
"Last Successful Check ",
1430
"2019-02-03T00:00:00 ",
1431
"2019-02-04T00:00:00 ",
1432
),(
1433
"Created ",
1434
"2019-01-02T00:00:00 ",
1435
"2019-01-03T00:00:00 ",
1436
),(
1437
"Interval ",
1438
"00:02:00 ",
1439
"00:02:00 ",
1440
),(
1441
"Host ",
1442
"foo.example.org ",
1443
"192.0.2.3 ",
1444
),(
1445
("Key ID "
1446
" "),
1447
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1448
"ea90a27cddb12 "),
1449
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1450
"46c2b020f441c "),
1451
),(
1452
"Fingerprint ",
1453
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
1454
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
1455
),(
1456
"Check Is Running ",
1457
"No ",
1458
"Yes ",
1459
),(
1460
"Last Enabled ",
1461
"2019-01-03T00:00:00 ",
1462
"2019-01-04T00:00:00 ",
1463
),(
1464
"Approval Is Pending ",
1465
"No ",
1466
"No ",
1467
),(
1468
"Approved By Default ",
1469
"Yes ",
1470
"No ",
1471
),(
1472
"Last Approval Request ",
1473
" ",
1474
"2019-01-03T00:00:00 ",
1475
),(
1476
"Approval Delay ",
1477
"00:00:00 ",
1478
"00:00:30 ",
1479
),(
1480
"Approval Duration ",
1481
"00:00:01 ",
1482
"1T02:03:05 ",
1483
),(
1484
"Checker ",
1485
"fping -q -- %(host)s ",
1486
": ",
1487
),(
1488
"Extended Timeout ",
1489
"00:15:00 ",
1490
"00:15:00 ",
1491
),(
1492
"Expires ",
1493
"2019-02-04T00:00:00 ",
1494
"2019-02-05T00:00:00 ",
1495
),(
1496
"Last Checker Status",
1497
"0 ",
1498
"-2 ",
1499
)
1500
)
1501
num_lines = max(len(rows) for rows in columns)
1502
expected_output = "\n".join("".join(rows[line]
1503
for rows in columns)
1504
for line in range(num_lines))
1505
self.assertEqual(output, expected_output)
1506
1507
def test_one_client(self):
1508
output = PrintTableCmd().output(self.one_client.values())
1509
expected_output = "\n".join((
1510
"Name Enabled Timeout Last Successful Check",
1511
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1512
))
1513
self.assertEqual(output, expected_output)
1514
964
class TestIsEnabledCmd(TestCmd):
965
def test_is_enabled(self):
966
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
967
for client, properties in self.clients.items()))
968
def test_is_enabled_run_exits_successfully(self):
969
with self.assertRaises(SystemExit) as e:
970
IsEnabledCmd().run(None, self.one_client)
971
if e.exception.code is not None:
972
self.assertEqual(e.exception.code, 0)
973
else:
974
self.assertIsNone(e.exception.code)
975
def test_is_enabled_run_exits_with_failure(self):
976
self.client.attributes["Enabled"] = dbus.Boolean(False)
977
with self.assertRaises(SystemExit) as e:
978
IsEnabledCmd().run(None, self.one_client)
979
if isinstance(e.exception.code, int):
980
self.assertNotEqual(e.exception.code, 0)
981
else:
982
self.assertIsNotNone(e.exception.code)
983
984
class TestRemoveCmd(TestCmd):
985
def test_remove(self):
986
class MockMandos(object):
987
def __init__(self):
988
self.calls = []
989
def RemoveClient(self, dbus_path):
990
self.calls.append(("RemoveClient", (dbus_path,)))
991
mandos = MockMandos()
992
super(TestRemoveCmd, self).setUp()
993
RemoveCmd().run(mandos, self.clients)
994
self.assertEqual(len(mandos.calls), 2)
995
for client in self.clients:
996
self.assertIn(("RemoveClient",
997
(client.__dbus_object_path__,)),
998
mandos.calls)
999
1000
class TestApproveCmd(TestCmd):
1001
def test_approve(self):
1002
ApproveCmd().run(None, self.clients)
1003
for client in self.clients:
1004
self.assertIn(("Approve", (True, client_interface)),
1005
client.calls)
1006
1007
class TestDenyCmd(TestCmd):
1008
def test_deny(self):
1009
DenyCmd().run(None, self.clients)
1010
for client in self.clients:
1011
self.assertIn(("Approve", (False, client_interface)),
1012
client.calls)
1013
1014
class TestEnableCmd(TestCmd):
1015
def test_enable(self):
1016
for client in self.clients:
1017
client.attributes["Enabled"] = False
1018
1019
EnableCmd().run(None, self.clients)
1020
1021
for client in self.clients:
1022
self.assertTrue(client.attributes["Enabled"])
1023
1024
class TestDisableCmd(TestCmd):
1025
def test_disable(self):
1026
DisableCmd().run(None, self.clients)
1027
1028
for client in self.clients:
1029
self.assertFalse(client.attributes["Enabled"])
1030
1031
class Unique(object):
1032
"""Class for objects which exist only to be unique objects, since
1033
unittest.mock.sentinel only exists in Python 3.3"""
1515
1034
1516
1035
class TestPropertyCmd(TestCmd):
1517
1036
"""Abstract class for tests of PropertyCmd classes"""
1522
1041
self.values_to_set)
1523
1042
for value_to_set, value_to_get in zip(self.values_to_set,
1524
1043
values_to_get):
1525
for clientpath in self.clients:
1526
client = self.bus.get_object(dbus_busname, clientpath)
1527
old_value = client.attributes[self.propname]
1528
self.assertNotIsInstance(old_value, self.Unique)
1529
client.attributes[self.propname] = self.Unique()
1044
for client in self.clients:
1045
old_value = client.attributes[self.property]
1046
self.assertNotIsInstance(old_value, Unique)
1047
client.attributes[self.property] = Unique()
1530
1048
self.run_command(value_to_set, self.clients)
1531
for clientpath in self.clients:
1532
client = self.bus.get_object(dbus_busname, clientpath)
1533
value = client.attributes[self.propname]
1534
self.assertNotIsInstance(value, self.Unique)
1049
for client in self.clients:
1050
value = client.attributes[self.property]
1051
self.assertNotIsInstance(value, Unique)
1535
1052
self.assertEqual(value, value_to_get)
1536
1537
class Unique(object):
1538
"""Class for objects which exist only to be unique objects,
1539
since unittest.mock.sentinel only exists in Python 3.3"""
1540
1541
1053
def run_command(self, value, clients):
1542
self.command().run(clients, self.bus)
1543
1544
1545
class TestEnableCmd(TestPropertyCmd):
1546
command = EnableCmd
1547
propname = "Enabled"
1548
values_to_set = [dbus.Boolean(True)]
1549
1550
1551
class TestDisableCmd(TestPropertyCmd):
1552
command = DisableCmd
1553
propname = "Enabled"
1554
values_to_set = [dbus.Boolean(False)]
1555
1054
self.command().run(None, clients)
1556
1055
1557
1056
class TestBumpTimeoutCmd(TestPropertyCmd):
1558
1057
command = BumpTimeoutCmd
1559
propname = "LastCheckedOK"
1058
property = "LastCheckedOK"
1560
1059
values_to_set = [""]
1561
1060
1562
1563
1061
class TestStartCheckerCmd(TestPropertyCmd):
1564
1062
command = StartCheckerCmd
1565
propname = "CheckerRunning"
1063
property = "CheckerRunning"
1566
1064
values_to_set = [dbus.Boolean(True)]
1567
1065
1568
1569
1066
class TestStopCheckerCmd(TestPropertyCmd):
1570
1067
command = StopCheckerCmd
1571
propname = "CheckerRunning"
1068
property = "CheckerRunning"
1572
1069
values_to_set = [dbus.Boolean(False)]
1573
1070
1574
1575
1071
class TestApproveByDefaultCmd(TestPropertyCmd):
1576
1072
command = ApproveByDefaultCmd
1577
propname = "ApprovedByDefault"
1073
property = "ApprovedByDefault"
1578
1074
values_to_set = [dbus.Boolean(True)]
1579
1075
1580
1581
1076
class TestDenyByDefaultCmd(TestPropertyCmd):
1582
1077
command = DenyByDefaultCmd
1583
propname = "ApprovedByDefault"
1078
property = "ApprovedByDefault"
1584
1079
values_to_set = [dbus.Boolean(False)]
1585
1080
1586
1587
class TestPropertyValueCmd(TestPropertyCmd):
1588
"""Abstract class for tests of PropertyValueCmd classes"""
1589
1081
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1082
"""Abstract class for tests of PropertyCmd classes using the
1083
ValueArgumentMixIn"""
1590
1084
def runTest(self):
1591
if type(self) is TestPropertyValueCmd:
1085
if type(self) is TestValueArgumentPropertyCmd:
1592
1086
return
1593
return super(TestPropertyValueCmd, self).runTest()
1594
1087
return super(TestValueArgumentPropertyCmd, self).runTest()
1595
1088
def run_command(self, value, clients):
1596
self.command(value).run(clients, self.bus)
1597
1598
1599
class TestSetCheckerCmd(TestPropertyValueCmd):
1089
self.command(value).run(None, clients)
1090
1091
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1600
1092
command = SetCheckerCmd
1601
propname = "Checker"
1093
property = "Checker"
1602
1094
values_to_set = ["", ":", "fping -q -- %s"]
1603
1095
1604
1605
class TestSetHostCmd(TestPropertyValueCmd):
1096
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1606
1097
command = SetHostCmd
1607
propname = "Host"
1098
property = "Host"
1608
1099
values_to_set = ["192.0.2.3", "foo.example.org"]
1609
1100
1610
1611
class TestSetSecretCmd(TestPropertyValueCmd):
1101
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1612
1102
command = SetSecretCmd
1613
propname = "Secret"
1103
property = "Secret"
1614
1104
values_to_set = [io.BytesIO(b""),
1615
1105
io.BytesIO(b"secret\0xyzzy\nbar")]
1616
1106
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1617
1107
1618
1619
class TestSetTimeoutCmd(TestPropertyValueCmd):
1108
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1620
1109
command = SetTimeoutCmd
1621
propname = "Timeout"
1110
property = "Timeout"
1622
1111
values_to_set = [datetime.timedelta(),
1623
1112
datetime.timedelta(minutes=5),
1624
1113
datetime.timedelta(seconds=1),
1626
1115
datetime.timedelta(weeks=52)]
1627
1116
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1628
1117
1629
1630
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
1118
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1631
1119
command = SetExtendedTimeoutCmd
1632
propname = "ExtendedTimeout"
1120
property = "ExtendedTimeout"
1633
1121
values_to_set = [datetime.timedelta(),
1634
1122
datetime.timedelta(minutes=5),
1635
1123
datetime.timedelta(seconds=1),
1637
1125
datetime.timedelta(weeks=52)]
1638
1126
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1639
1127
1640
1641
class TestSetIntervalCmd(TestPropertyValueCmd):
1128
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1642
1129
command = SetIntervalCmd
1643
propname = "Interval"
1130
property = "Interval"
1644
1131
values_to_set = [datetime.timedelta(),
1645
1132
datetime.timedelta(minutes=5),
1646
1133
datetime.timedelta(seconds=1),
1648
1135
datetime.timedelta(weeks=52)]
1649
1136
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1650
1137
1651
1652
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
1138
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1653
1139
command = SetApprovalDelayCmd
1654
propname = "ApprovalDelay"
1140
property = "ApprovalDelay"
1655
1141
values_to_set = [datetime.timedelta(),
1656
1142
datetime.timedelta(minutes=5),
1657
1143
datetime.timedelta(seconds=1),
1659
1145
datetime.timedelta(weeks=52)]
1660
1146
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1661
1147
1662
1663
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
1148
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1664
1149
command = SetApprovalDurationCmd
1665
propname = "ApprovalDuration"
1150
property = "ApprovalDuration"
1666
1151
values_to_set = [datetime.timedelta(),
1667
1152
datetime.timedelta(minutes=5),
1668
1153
datetime.timedelta(seconds=1),
1670
1155
datetime.timedelta(weeks=52)]
1671
1156
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1672
1157
1158
class Test_command_from_options(unittest.TestCase):
1159
def setUp(self):
1160
self.parser = argparse.ArgumentParser()
1161
add_command_line_options(self.parser)
1162
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
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(len(commands), 1)
1169
command = commands[0]
1170
self.assertIsInstance(command, command_cls)
1171
for key, value in cmd_attrs.items():
1172
self.assertEqual(getattr(command, key), value)
1173
def test_print_table(self):
1174
self.assert_command_from_args([], PrintTableCmd,
1175
verbose=False)
1176
1177
def test_print_table_verbose(self):
1178
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1179
verbose=True)
1180
1181
def test_print_table_verbose_short(self):
1182
self.assert_command_from_args(["-v"], PrintTableCmd,
1183
verbose=True)
1184
1185
def test_enable(self):
1186
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1187
1188
def test_enable_short(self):
1189
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1190
1191
def test_disable(self):
1192
self.assert_command_from_args(["--disable", "foo"],
1193
DisableCmd)
1194
1195
def test_disable_short(self):
1196
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1197
1198
def test_bump_timeout(self):
1199
self.assert_command_from_args(["--bump-timeout", "foo"],
1200
BumpTimeoutCmd)
1201
1202
def test_bump_timeout_short(self):
1203
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1204
1205
def test_start_checker(self):
1206
self.assert_command_from_args(["--start-checker", "foo"],
1207
StartCheckerCmd)
1208
1209
def test_stop_checker(self):
1210
self.assert_command_from_args(["--stop-checker", "foo"],
1211
StopCheckerCmd)
1212
1213
def test_remove(self):
1214
self.assert_command_from_args(["--remove", "foo"],
1215
RemoveCmd)
1216
1217
def test_remove_short(self):
1218
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1219
1220
def test_checker(self):
1221
self.assert_command_from_args(["--checker", ":", "foo"],
1222
SetCheckerCmd, value_to_set=":")
1223
1224
def test_checker_empty(self):
1225
self.assert_command_from_args(["--checker", "", "foo"],
1226
SetCheckerCmd, value_to_set="")
1227
1228
def test_checker_short(self):
1229
self.assert_command_from_args(["-c", ":", "foo"],
1230
SetCheckerCmd, value_to_set=":")
1231
1232
def test_timeout(self):
1233
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1234
SetTimeoutCmd,
1235
value_to_set=300000)
1236
1237
def test_timeout_short(self):
1238
self.assert_command_from_args(["-t", "PT5M", "foo"],
1239
SetTimeoutCmd,
1240
value_to_set=300000)
1241
1242
def test_extended_timeout(self):
1243
self.assert_command_from_args(["--extended-timeout", "PT15M",
1244
"foo"],
1245
SetExtendedTimeoutCmd,
1246
value_to_set=900000)
1247
1248
def test_interval(self):
1249
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1250
SetIntervalCmd,
1251
value_to_set=120000)
1252
1253
def test_interval_short(self):
1254
self.assert_command_from_args(["-i", "PT2M", "foo"],
1255
SetIntervalCmd,
1256
value_to_set=120000)
1257
1258
def test_approve_by_default(self):
1259
self.assert_command_from_args(["--approve-by-default", "foo"],
1260
ApproveByDefaultCmd)
1261
1262
def test_deny_by_default(self):
1263
self.assert_command_from_args(["--deny-by-default", "foo"],
1264
DenyByDefaultCmd)
1265
1266
def test_approval_delay(self):
1267
self.assert_command_from_args(["--approval-delay", "PT30S",
1268
"foo"], SetApprovalDelayCmd,
1269
value_to_set=30000)
1270
1271
def test_approval_duration(self):
1272
self.assert_command_from_args(["--approval-duration", "PT1S",
1273
"foo"], SetApprovalDurationCmd,
1274
value_to_set=1000)
1275
1276
def test_host(self):
1277
self.assert_command_from_args(["--host", "foo.example.org",
1278
"foo"], SetHostCmd,
1279
value_to_set="foo.example.org")
1280
1281
def test_host_short(self):
1282
self.assert_command_from_args(["-H", "foo.example.org",
1283
"foo"], SetHostCmd,
1284
value_to_set="foo.example.org")
1285
1286
def test_secret_devnull(self):
1287
self.assert_command_from_args(["--secret", os.path.devnull,
1288
"foo"], SetSecretCmd,
1289
value_to_set=b"")
1290
1291
def test_secret_tempfile(self):
1292
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1293
value = b"secret\0xyzzy\nbar"
1294
f.write(value)
1295
f.seek(0)
1296
self.assert_command_from_args(["--secret", f.name,
1297
"foo"], SetSecretCmd,
1298
value_to_set=value)
1299
1300
def test_secret_devnull_short(self):
1301
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1302
SetSecretCmd, value_to_set=b"")
1303
1304
def test_secret_tempfile_short(self):
1305
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1306
value = b"secret\0xyzzy\nbar"
1307
f.write(value)
1308
f.seek(0)
1309
self.assert_command_from_args(["-s", f.name, "foo"],
1310
SetSecretCmd,
1311
value_to_set=value)
1312
1313
def test_approve(self):
1314
self.assert_command_from_args(["--approve", "foo"],
1315
ApproveCmd)
1316
1317
def test_approve_short(self):
1318
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1319
1320
def test_deny(self):
1321
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1322
1323
def test_deny_short(self):
1324
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1325
1326
def test_dump_json(self):
1327
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1328
1329
def test_is_enabled(self):
1330
self.assert_command_from_args(["--is-enabled", "foo"],
1331
IsEnabledCmd)
1332
1333
def test_is_enabled_short(self):
1334
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1335
1336
1337
class Test_check_option_syntax(unittest.TestCase):
1338
# This mostly corresponds to the definition from has_actions() in
1339
# check_option_syntax()
1340
actions = {
1341
# The actual values set here are not that important, but we do
1342
# at least stick to the correct types, even though they are
1343
# never used
1344
"enable": True,
1345
"disable": True,
1346
"bump_timeout": True,
1347
"start_checker": True,
1348
"stop_checker": True,
1349
"is_enabled": True,
1350
"remove": True,
1351
"checker": "x",
1352
"timeout": datetime.timedelta(),
1353
"extended_timeout": datetime.timedelta(),
1354
"interval": datetime.timedelta(),
1355
"approved_by_default": True,
1356
"approval_delay": datetime.timedelta(),
1357
"approval_duration": datetime.timedelta(),
1358
"host": "x",
1359
"secret": io.BytesIO(b"x"),
1360
"approve": True,
1361
"deny": True,
1362
}
1363
1364
def setUp(self):
1365
self.parser = argparse.ArgumentParser()
1366
add_command_line_options(self.parser)
1367
1368
@contextlib.contextmanager
1369
def assertParseError(self):
1370
with self.assertRaises(SystemExit) as e:
1371
with self.temporarily_suppress_stderr():
1372
yield
1373
# Exit code from argparse is guaranteed to be "2". Reference:
1374
# https://docs.python.org/3/library/argparse.html#exiting-methods
1375
self.assertEqual(e.exception.code, 2)
1376
1377
@staticmethod
1378
@contextlib.contextmanager
1379
def temporarily_suppress_stderr():
1380
null = os.open(os.path.devnull, os.O_RDWR)
1381
stderrcopy = os.dup(sys.stderr.fileno())
1382
os.dup2(null, sys.stderr.fileno())
1383
os.close(null)
1384
try:
1385
yield
1386
finally:
1387
# restore stderr
1388
os.dup2(stderrcopy, sys.stderr.fileno())
1389
os.close(stderrcopy)
1390
1391
def check_option_syntax(self, options):
1392
check_option_syntax(self.parser, options)
1393
1394
def test_actions_requires_client_or_all(self):
1395
for action, value in self.actions.items():
1396
options = self.parser.parse_args()
1397
setattr(options, action, value)
1398
with self.assertParseError():
1399
self.check_option_syntax(options)
1400
1401
def test_actions_conflicts_with_verbose(self):
1402
for action, value in self.actions.items():
1403
options = self.parser.parse_args()
1404
setattr(options, action, value)
1405
options.verbose = True
1406
with self.assertParseError():
1407
self.check_option_syntax(options)
1408
1409
def test_dump_json_conflicts_with_verbose(self):
1410
options = self.parser.parse_args()
1411
options.dump_json = True
1412
options.verbose = True
1413
with self.assertParseError():
1414
self.check_option_syntax(options)
1415
1416
def test_dump_json_conflicts_with_action(self):
1417
for action, value in self.actions.items():
1418
options = self.parser.parse_args()
1419
setattr(options, action, value)
1420
options.dump_json = True
1421
with self.assertParseError():
1422
self.check_option_syntax(options)
1423
1424
def test_all_can_not_be_alone(self):
1425
options = self.parser.parse_args()
1426
options.all = True
1427
with self.assertParseError():
1428
self.check_option_syntax(options)
1429
1430
def test_all_is_ok_with_any_action(self):
1431
for action, value in self.actions.items():
1432
options = self.parser.parse_args()
1433
setattr(options, action, value)
1434
options.all = True
1435
self.check_option_syntax(options)
1436
1437
def test_is_enabled_fails_without_client(self):
1438
options = self.parser.parse_args()
1439
options.is_enabled = True
1440
with self.assertParseError():
1441
self.check_option_syntax(options)
1442
1443
def test_is_enabled_works_with_one_client(self):
1444
options = self.parser.parse_args()
1445
options.is_enabled = True
1446
options.client = ["foo"]
1447
self.check_option_syntax(options)
1448
1449
def test_is_enabled_fails_with_two_clients(self):
1450
options = self.parser.parse_args()
1451
options.is_enabled = True
1452
options.client = ["foo", "barbar"]
1453
with self.assertParseError():
1454
self.check_option_syntax(options)
1455
1673
1456
1674
1457
1675
1458
def should_only_run_tests():
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0