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 1093
- compare with another revision
- download diff
- download tarball
- view history from revision 1093
- Committer: Teddy Hogeborn
- Date: 2019-03-30 21:23:59 UTC
- Revision ID: teddy@recompile.se-20190330212359-z7u9ik1lh5auybhm
mandos-ctl: Refactor: fix confusion about values_to_set/values_to_get
* mandos-ctl (TestPropertySetterCmd.runTest): Generalize to work on
any command regardless
of what combination of
values_to_set or
values_to_get attributes
it has.
(TestPropertySetterCmd.run_command): Remove.
(TestEnableCmd, TestDisableCmd, TestBumpTimeoutCmd,
TestStartCheckerCmd, TestStopCheckerCmd, TestApproveByDefaultCmd,
TestDenyByDefaultCmd): Change "values_to_set" to "values_to_get",
since that is what is intended.
(TestPropertySetterValueCmd): Remove; all inheritors changed to
inherit from TestPropertySetterCmd.
* mandos-ctl (TestPropertySetterCmd.runTest): Generalize to work on
any command regardless
of what combination of
values_to_set or
values_to_get attributes
it has.
(TestPropertySetterCmd.run_command): Remove.
(TestEnableCmd, TestDisableCmd, TestBumpTimeoutCmd,
TestStartCheckerCmd, TestStopCheckerCmd, TestApproveByDefaultCmd,
TestDenyByDefaultCmd): Change "values_to_set" to "values_to_get",
since that is what is intended.
(TestPropertySetterValueCmd): Remove; all inheritors changed to
inherit from TestPropertySetterCmd.
- files modified:
- TODO
added
removed
mandos-ctl
45
45
import io
46
46
import tempfile
47
47
import contextlib
48
import abc
48
49
49
import dbus
50
import dbus as dbus_python
50
51
51
52
# Show warnings by default
52
53
if not sys.warnoptions:
61
62
62
63
if sys.version_info.major == 2:
63
64
str = unicode
65
import StringIO
66
io.StringIO = StringIO.StringIO
64
67
65
68
locale.setlocale(locale.LC_ALL, "")
66
69
67
domain = "se.recompile"
68
busname = domain + ".Mandos"
69
server_path = "/"
70
server_interface = domain + ".Mandos"
71
client_interface = domain + ".Mandos.Client"
72
70
version = "1.8.3"
73
71
74
72
75
try:
76
dbus.OBJECT_MANAGER_IFACE
77
except AttributeError:
78
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
79
80
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))
73
def main():
74
parser = argparse.ArgumentParser()
75
add_command_line_options(parser)
76
77
options = parser.parse_args()
78
check_option_syntax(parser, options)
79
80
clientnames = options.client
81
82
if options.debug:
83
log.setLevel(logging.DEBUG)
84
85
bus = dbus_python_adapter.CachingBus(dbus_python)
86
87
try:
88
all_clients = bus.get_clients_and_properties()
89
except dbus.ConnectFailed as e:
90
log.critical("Could not connect to Mandos server: %s", e)
91
sys.exit(1)
92
except dbus.Error as e:
93
log.critical(
94
"Failed to access Mandos server through D-Bus:\n%s", e)
95
sys.exit(1)
96
97
# Compile dict of (clientpath: properties) to process
98
if not clientnames:
99
clients = all_clients
100
else:
101
clients = {}
102
for name in clientnames:
103
for objpath, properties in all_clients.items():
104
if properties["Name"] == name:
105
clients[objpath] = properties
106
break
107
else:
108
log.critical("Client not found on server: %r", name)
109
sys.exit(1)
110
111
commands = commands_from_options(options)
112
113
for command in commands:
114
command.run(clients, bus)
115
116
117
def add_command_line_options(parser):
118
parser.add_argument("--version", action="version",
119
version="%(prog)s {}".format(version),
120
help="show version number and exit")
121
parser.add_argument("-a", "--all", action="store_true",
122
help="Select all clients")
123
parser.add_argument("-v", "--verbose", action="store_true",
124
help="Print all fields")
125
parser.add_argument("-j", "--dump-json", action="store_true",
126
help="Dump client data in JSON format")
127
enable_disable = parser.add_mutually_exclusive_group()
128
enable_disable.add_argument("-e", "--enable", action="store_true",
129
help="Enable client")
130
enable_disable.add_argument("-d", "--disable",
131
action="store_true",
132
help="disable client")
133
parser.add_argument("-b", "--bump-timeout", action="store_true",
134
help="Bump timeout for client")
135
start_stop_checker = parser.add_mutually_exclusive_group()
136
start_stop_checker.add_argument("--start-checker",
137
action="store_true",
138
help="Start checker for client")
139
start_stop_checker.add_argument("--stop-checker",
140
action="store_true",
141
help="Stop checker for client")
142
parser.add_argument("-V", "--is-enabled", action="store_true",
143
help="Check if client is enabled")
144
parser.add_argument("-r", "--remove", action="store_true",
145
help="Remove client")
146
parser.add_argument("-c", "--checker",
147
help="Set checker command for client")
148
parser.add_argument("-t", "--timeout", type=string_to_delta,
149
help="Set timeout for client")
150
parser.add_argument("--extended-timeout", type=string_to_delta,
151
help="Set extended timeout for client")
152
parser.add_argument("-i", "--interval", type=string_to_delta,
153
help="Set checker interval for client")
154
approve_deny_default = parser.add_mutually_exclusive_group()
155
approve_deny_default.add_argument(
156
"--approve-by-default", action="store_true",
157
default=None, dest="approved_by_default",
158
help="Set client to be approved by default")
159
approve_deny_default.add_argument(
160
"--deny-by-default", action="store_false",
161
dest="approved_by_default",
162
help="Set client to be denied by default")
163
parser.add_argument("--approval-delay", type=string_to_delta,
164
help="Set delay before client approve/deny")
165
parser.add_argument("--approval-duration", type=string_to_delta,
166
help="Set duration of one client approval")
167
parser.add_argument("-H", "--host", help="Set host for client")
168
parser.add_argument("-s", "--secret",
169
type=argparse.FileType(mode="rb"),
170
help="Set password blob (file) for client")
171
approve_deny = parser.add_mutually_exclusive_group()
172
approve_deny.add_argument(
173
"-A", "--approve", action="store_true",
174
help="Approve any current client request")
175
approve_deny.add_argument("-D", "--deny", action="store_true",
176
help="Deny any current client request")
177
parser.add_argument("--debug", action="store_true",
178
help="Debug mode (show D-Bus commands)")
179
parser.add_argument("--check", action="store_true",
180
help="Run self-test")
181
parser.add_argument("client", nargs="*", help="Client name")
182
183
184
def string_to_delta(interval):
185
"""Parse a string and return a datetime.timedelta"""
186
187
try:
188
return rfc3339_duration_to_delta(interval)
189
except ValueError as e:
190
log.warning("%s - Parsing as pre-1.6.1 interval instead",
191
' '.join(e.args))
192
return parse_pre_1_6_1_interval(interval)
88
193
89
194
90
195
def rfc3339_duration_to_delta(duration):
110
215
>>> rfc3339_duration_to_delta("")
111
216
Traceback (most recent call last):
112
217
...
113
ValueError: Invalid RFC 3339 duration: u''
218
ValueError: Invalid RFC 3339 duration: ""
114
219
>>> # Must start with "P":
115
220
>>> rfc3339_duration_to_delta("1D")
116
221
Traceback (most recent call last):
117
222
...
118
ValueError: Invalid RFC 3339 duration: u'1D'
223
ValueError: Invalid RFC 3339 duration: "1D"
119
224
>>> # Must use correct order
120
225
>>> rfc3339_duration_to_delta("PT1S2M")
121
226
Traceback (most recent call last):
122
227
...
123
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
228
ValueError: Invalid RFC 3339 duration: "PT1S2M"
124
229
>>> # Time needs time marker
125
230
>>> rfc3339_duration_to_delta("P1H2S")
126
231
Traceback (most recent call last):
127
232
...
128
ValueError: Invalid RFC 3339 duration: u'P1H2S'
233
ValueError: Invalid RFC 3339 duration: "P1H2S"
129
234
>>> # Weeks can not be combined with anything else
130
235
>>> rfc3339_duration_to_delta("P1D2W")
131
236
Traceback (most recent call last):
132
237
...
133
ValueError: Invalid RFC 3339 duration: u'P1D2W'
238
ValueError: Invalid RFC 3339 duration: "P1D2W"
134
239
>>> rfc3339_duration_to_delta("P2W2H")
135
240
Traceback (most recent call last):
136
241
...
137
ValueError: Invalid RFC 3339 duration: u'P2W2H'
242
ValueError: Invalid RFC 3339 duration: "P2W2H"
138
243
"""
139
244
140
245
# Parsing an RFC 3339 duration with regular expressions is not
211
316
break
212
317
else:
213
318
# No currently valid tokens were found
214
raise ValueError("Invalid RFC 3339 duration: {!r}"
319
raise ValueError("Invalid RFC 3339 duration: \"{}\""
215
320
.format(duration))
216
321
# End token found
217
322
return value
218
323
219
324
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
231
325
def parse_pre_1_6_1_interval(interval):
232
326
"""Parse an interval string as documented by Mandos before 1.6.1,
233
327
and return a datetime.timedelta
271
365
return value
272
366
273
367
274
## Classes for commands.
275
276
# Abstract classes first
277
class Command(object):
278
"""Abstract class for commands"""
279
def run(self, mandos, clients):
280
"""Normal commands should implement run_on_one_client(), but
281
commands which want to operate on all clients at the same time
282
can override this run() method instead."""
283
self.mandos = mandos
284
for client, properties in clients.items():
285
self.run_on_one_client(client, properties)
286
287
class PrintCmd(Command):
288
"""Abstract class for commands printing client details"""
289
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
290
"Created", "Interval", "Host", "KeyID",
291
"Fingerprint", "CheckerRunning", "LastEnabled",
292
"ApprovalPending", "ApprovedByDefault",
293
"LastApprovalRequest", "ApprovalDelay",
294
"ApprovalDuration", "Checker", "ExtendedTimeout",
295
"Expires", "LastCheckerStatus")
296
def run(self, mandos, clients):
297
print(self.output(clients))
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
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
304
client.__dbus_object_path__,
305
dbus.PROPERTIES_IFACE, client_interface,
306
self.property, self.value_to_set
307
if not isinstance(self.value_to_set, dbus.Boolean)
308
else bool(self.value_to_set))
309
client.Set(client_interface, self.property, self.value_to_set,
310
dbus_interface=dbus.PROPERTIES_IFACE)
311
312
class ValueArgumentMixIn(object):
313
"""Mixin class for commands taking a value as argument"""
314
def __init__(self, value):
315
self.value_to_set = value
316
317
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
318
"""Mixin class for commands taking a value argument as
319
milliseconds."""
320
@property
321
def value_to_set(self):
322
return self._vts
323
@value_to_set.setter
324
def value_to_set(self, value):
325
"""When setting, convert value to a datetime.timedelta"""
326
self._vts = int(round(value.total_seconds() * 1000))
327
328
# Actual (non-abstract) command classes
329
330
class PrintTableCmd(PrintCmd):
331
def __init__(self, verbose=False):
332
self.verbose = verbose
333
334
def output(self, clients):
335
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
336
keywords = default_keywords
337
if self.verbose:
338
keywords = self.all_keywords
339
return str(self.TableOfClients(clients.values(), keywords))
340
341
class TableOfClients(object):
342
tableheaders = {
343
"Name": "Name",
344
"Enabled": "Enabled",
345
"Timeout": "Timeout",
346
"LastCheckedOK": "Last Successful Check",
347
"LastApprovalRequest": "Last Approval Request",
348
"Created": "Created",
349
"Interval": "Interval",
350
"Host": "Host",
351
"Fingerprint": "Fingerprint",
352
"KeyID": "Key ID",
353
"CheckerRunning": "Check Is Running",
354
"LastEnabled": "Last Enabled",
355
"ApprovalPending": "Approval Is Pending",
356
"ApprovedByDefault": "Approved By Default",
357
"ApprovalDelay": "Approval Delay",
358
"ApprovalDuration": "Approval Duration",
359
"Checker": "Checker",
360
"ExtendedTimeout": "Extended Timeout",
361
"Expires": "Expires",
362
"LastCheckerStatus": "Last Checker Status",
363
}
364
365
def __init__(self, clients, keywords, tableheaders=None):
366
self.clients = clients
367
self.keywords = keywords
368
if tableheaders is not None:
369
self.tableheaders = tableheaders
370
371
def __str__(self):
372
return "\n".join(self.rows())
373
374
if sys.version_info.major == 2:
375
__unicode__ = __str__
376
def __str__(self):
377
return str(self).encode(locale.getpreferredencoding())
378
379
def rows(self):
380
format_string = self.row_formatting_string()
381
rows = [self.header_line(format_string)]
382
rows.extend(self.client_line(client, format_string)
383
for client in self.clients)
384
return rows
385
386
def row_formatting_string(self):
387
"Format string used to format table rows"
388
return " ".join("{{{key}:{width}}}".format(
389
width=max(len(self.tableheaders[key]),
390
*(len(self.string_from_client(client, key))
391
for client in self.clients)),
392
key=key)
393
for key in self.keywords)
394
395
def string_from_client(self, client, key):
396
return self.valuetostring(client[key], key)
397
398
@staticmethod
399
def valuetostring(value, keyword):
400
if isinstance(value, dbus.Boolean):
401
return "Yes" if value else "No"
402
if keyword in ("Timeout", "Interval", "ApprovalDelay",
403
"ApprovalDuration", "ExtendedTimeout"):
404
return milliseconds_to_string(value)
405
return str(value)
406
407
def header_line(self, format_string):
408
return format_string.format(**self.tableheaders)
409
410
def client_line(self, client, format_string):
411
return format_string.format(
412
**{key: self.string_from_client(client, key)
413
for key in self.keywords})
414
415
416
417
class DumpJSONCmd(PrintCmd):
418
def output(self, clients):
419
data = {client["Name"]:
420
{key: self.dbus_boolean_to_bool(client[key])
421
for key in self.all_keywords}
422
for client in clients.values()}
423
return json.dumps(data, indent=4, separators=(',', ': '))
424
@staticmethod
425
def dbus_boolean_to_bool(value):
426
if isinstance(value, dbus.Boolean):
427
value = bool(value)
428
return value
429
430
class IsEnabledCmd(Command):
431
def run_on_one_client(self, client, properties):
432
if self.is_enabled(client, properties):
433
sys.exit(0)
434
sys.exit(1)
435
def is_enabled(self, client, properties):
436
return bool(properties["Enabled"])
437
438
class RemoveCmd(Command):
439
def run_on_one_client(self, client, properties):
440
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", busname,
441
server_path, server_interface,
442
str(client.__dbus_object_path__))
443
self.mandos.RemoveClient(client.__dbus_object_path__)
444
445
class ApproveCmd(Command):
446
def run_on_one_client(self, client, properties):
447
log.debug("D-Bus: %s:%s.Approve(True)",
448
client.__dbus_object_path__, client_interface)
449
client.Approve(dbus.Boolean(True),
450
dbus_interface=client_interface)
451
452
class DenyCmd(Command):
453
def run_on_one_client(self, client, properties):
454
log.debug("D-Bus: %s:%s.Approve(False)",
455
client.__dbus_object_path__, client_interface)
456
client.Approve(dbus.Boolean(False),
457
dbus_interface=client_interface)
458
459
class EnableCmd(PropertyCmd):
460
property = "Enabled"
461
value_to_set = dbus.Boolean(True)
462
463
class DisableCmd(PropertyCmd):
464
property = "Enabled"
465
value_to_set = dbus.Boolean(False)
466
467
class BumpTimeoutCmd(PropertyCmd):
468
property = "LastCheckedOK"
469
value_to_set = ""
470
471
class StartCheckerCmd(PropertyCmd):
472
property = "CheckerRunning"
473
value_to_set = dbus.Boolean(True)
474
475
class StopCheckerCmd(PropertyCmd):
476
property = "CheckerRunning"
477
value_to_set = dbus.Boolean(False)
478
479
class ApproveByDefaultCmd(PropertyCmd):
480
property = "ApprovedByDefault"
481
value_to_set = dbus.Boolean(True)
482
483
class DenyByDefaultCmd(PropertyCmd):
484
property = "ApprovedByDefault"
485
value_to_set = dbus.Boolean(False)
486
487
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
488
property = "Checker"
489
490
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
491
property = "Host"
492
493
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
494
@property
495
def value_to_set(self):
496
return self._vts
497
@value_to_set.setter
498
def value_to_set(self, value):
499
"""When setting, read data from supplied file object"""
500
self._vts = value.read()
501
value.close()
502
property = "Secret"
503
504
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
505
property = "Timeout"
506
507
class SetExtendedTimeoutCmd(PropertyCmd,
508
MillisecondsValueArgumentMixIn):
509
property = "ExtendedTimeout"
510
511
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
512
property = "Interval"
513
514
class SetApprovalDelayCmd(PropertyCmd,
515
MillisecondsValueArgumentMixIn):
516
property = "ApprovalDelay"
517
518
class SetApprovalDurationCmd(PropertyCmd,
519
MillisecondsValueArgumentMixIn):
520
property = "ApprovalDuration"
521
522
def add_command_line_options(parser):
523
parser.add_argument("--version", action="version",
524
version="%(prog)s {}".format(version),
525
help="show version number and exit")
526
parser.add_argument("-a", "--all", action="store_true",
527
help="Select all clients")
528
parser.add_argument("-v", "--verbose", action="store_true",
529
help="Print all fields")
530
parser.add_argument("-j", "--dump-json", action="store_true",
531
help="Dump client data in JSON format")
532
enable_disable = parser.add_mutually_exclusive_group()
533
enable_disable.add_argument("-e", "--enable", action="store_true",
534
help="Enable client")
535
enable_disable.add_argument("-d", "--disable",
536
action="store_true",
537
help="disable client")
538
parser.add_argument("-b", "--bump-timeout", action="store_true",
539
help="Bump timeout for client")
540
start_stop_checker = parser.add_mutually_exclusive_group()
541
start_stop_checker.add_argument("--start-checker",
542
action="store_true",
543
help="Start checker for client")
544
start_stop_checker.add_argument("--stop-checker",
545
action="store_true",
546
help="Stop checker for client")
547
parser.add_argument("-V", "--is-enabled", action="store_true",
548
help="Check if client is enabled")
549
parser.add_argument("-r", "--remove", action="store_true",
550
help="Remove client")
551
parser.add_argument("-c", "--checker",
552
help="Set checker command for client")
553
parser.add_argument("-t", "--timeout", type=string_to_delta,
554
help="Set timeout for client")
555
parser.add_argument("--extended-timeout", type=string_to_delta,
556
help="Set extended timeout for client")
557
parser.add_argument("-i", "--interval", type=string_to_delta,
558
help="Set checker interval for client")
559
approve_deny_default = parser.add_mutually_exclusive_group()
560
approve_deny_default.add_argument(
561
"--approve-by-default", action="store_true",
562
default=None, dest="approved_by_default",
563
help="Set client to be approved by default")
564
approve_deny_default.add_argument(
565
"--deny-by-default", action="store_false",
566
dest="approved_by_default",
567
help="Set client to be denied by default")
568
parser.add_argument("--approval-delay", type=string_to_delta,
569
help="Set delay before client approve/deny")
570
parser.add_argument("--approval-duration", type=string_to_delta,
571
help="Set duration of one client approval")
572
parser.add_argument("-H", "--host", help="Set host for client")
573
parser.add_argument("-s", "--secret",
574
type=argparse.FileType(mode="rb"),
575
help="Set password blob (file) for client")
576
approve_deny = parser.add_mutually_exclusive_group()
577
approve_deny.add_argument(
578
"-A", "--approve", action="store_true",
579
help="Approve any current client request")
580
approve_deny.add_argument("-D", "--deny", action="store_true",
581
help="Deny any current client request")
582
parser.add_argument("--debug", action="store_true",
583
help="Debug mode (show D-Bus commands)")
584
parser.add_argument("--check", action="store_true",
585
help="Run self-test")
586
parser.add_argument("client", nargs="*", help="Client name")
587
588
589
def commands_from_options(options):
590
591
commands = []
592
593
if options.dump_json:
594
commands.append(DumpJSONCmd())
595
596
if options.enable:
597
commands.append(EnableCmd())
598
599
if options.disable:
600
commands.append(DisableCmd())
601
602
if options.bump_timeout:
603
commands.append(BumpTimeoutCmd())
604
605
if options.start_checker:
606
commands.append(StartCheckerCmd())
607
608
if options.stop_checker:
609
commands.append(StopCheckerCmd())
610
611
if options.is_enabled:
612
commands.append(IsEnabledCmd())
613
614
if options.remove:
615
commands.append(RemoveCmd())
616
617
if options.checker is not None:
618
commands.append(SetCheckerCmd(options.checker))
619
620
if options.timeout is not None:
621
commands.append(SetTimeoutCmd(options.timeout))
622
623
if options.extended_timeout:
624
commands.append(
625
SetExtendedTimeoutCmd(options.extended_timeout))
626
627
if options.interval is not None:
628
commands.append(SetIntervalCmd(options.interval))
629
630
if options.approved_by_default is not None:
631
if options.approved_by_default:
632
commands.append(ApproveByDefaultCmd())
633
else:
634
commands.append(DenyByDefaultCmd())
635
636
if options.approval_delay is not None:
637
commands.append(SetApprovalDelayCmd(options.approval_delay))
638
639
if options.approval_duration is not None:
640
commands.append(
641
SetApprovalDurationCmd(options.approval_duration))
642
643
if options.host is not None:
644
commands.append(SetHostCmd(options.host))
645
646
if options.secret is not None:
647
commands.append(SetSecretCmd(options.secret))
648
649
if options.approve:
650
commands.append(ApproveCmd())
651
652
if options.deny:
653
commands.append(DenyCmd())
654
655
# If no command option has been given, show table of clients,
656
# optionally verbosely
657
if not commands:
658
commands.append(PrintTableCmd(verbose=options.verbose))
659
660
return commands
661
662
663
368
def check_option_syntax(parser, options):
664
369
"""Apply additional restrictions on options, not expressible in
665
370
argparse"""
695
400
parser.error("--all requires an action.")
696
401
if options.is_enabled and len(options.client) > 1:
697
402
parser.error("--is-enabled requires exactly one client")
698
699
700
def main():
701
parser = argparse.ArgumentParser()
702
703
add_command_line_options(parser)
704
705
options = parser.parse_args()
706
707
check_option_syntax(parser, options)
708
709
clientnames = options.client
710
711
if options.debug:
712
log.setLevel(logging.DEBUG)
713
714
try:
715
bus = dbus.SystemBus()
716
log.debug("D-Bus: Connect to: (name=%r, path=%r)", busname,
717
server_path)
718
mandos_dbus_objc = bus.get_object(busname, server_path)
719
except dbus.exceptions.DBusException:
720
log.critical("Could not connect to Mandos server")
721
sys.exit(1)
722
723
mandos_serv = dbus.Interface(mandos_dbus_objc,
724
dbus_interface=server_interface)
725
mandos_serv_object_manager = dbus.Interface(
726
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
727
728
# Filter out log message from dbus module
729
dbus_logger = logging.getLogger("dbus.proxies")
730
class NullFilter(logging.Filter):
731
def filter(self, record):
732
return False
733
dbus_filter = NullFilter()
734
try:
735
dbus_logger.addFilter(dbus_filter)
736
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", busname,
737
server_path, dbus.OBJECT_MANAGER_IFACE)
738
mandos_clients = {path: ifs_and_props[client_interface]
739
for path, ifs_and_props in
740
mandos_serv_object_manager
741
.GetManagedObjects().items()
742
if client_interface in ifs_and_props}
743
except dbus.exceptions.DBusException as e:
744
log.critical("Failed to access Mandos server through D-Bus:"
745
"\n%s", e)
746
sys.exit(1)
747
finally:
748
# restore dbus logger
749
dbus_logger.removeFilter(dbus_filter)
750
751
# Compile dict of (clients: properties) to process
752
clients = {}
753
754
if not clientnames:
755
clients = {bus.get_object(busname, path): properties
756
for path, properties in mandos_clients.items()}
757
else:
758
for name in clientnames:
759
for path, client in mandos_clients.items():
760
if client["Name"] == name:
761
client_objc = bus.get_object(busname, path)
762
clients[client_objc] = client
763
break
764
else:
765
log.critical("Client not found on server: %r", name)
766
sys.exit(1)
767
768
# Run all commands on clients
769
commands = commands_from_options(options)
770
for command in commands:
771
command.run(mandos_serv, clients)
403
if options.remove:
404
options.remove = False
405
if has_actions(options) and not options.deny:
406
parser.error("--remove can only be combined with --deny")
407
options.remove = True
408
409
410
411
class dbus(object):
412
413
class SystemBus(object):
414
415
object_manager_iface = "org.freedesktop.DBus.ObjectManager"
416
def get_managed_objects(self, busname, objectpath):
417
return self.call_method("GetManagedObjects", busname,
418
objectpath,
419
self.object_manager_iface)
420
421
properties_iface = "org.freedesktop.DBus.Properties"
422
def set_property(self, busname, objectpath, interface, key,
423
value):
424
self.call_method("Set", busname, objectpath,
425
self.properties_iface, interface, key,
426
value)
427
428
429
class MandosBus(SystemBus):
430
busname_domain = "se.recompile"
431
busname = busname_domain + ".Mandos"
432
server_path = "/"
433
server_interface = busname_domain + ".Mandos"
434
client_interface = busname_domain + ".Mandos.Client"
435
del busname_domain
436
437
def get_clients_and_properties(self):
438
managed_objects = self.get_managed_objects(
439
self.busname, self.server_path)
440
return {objpath: properties[self.client_interface]
441
for objpath, properties in managed_objects.items()
442
if self.client_interface in properties}
443
444
def set_client_property(self, objectpath, key, value):
445
return self.set_property(self.busname, objectpath,
446
self.client_interface, key,
447
value)
448
449
def call_client_method(self, objectpath, method, *args):
450
return self.call_method(method, self.busname, objectpath,
451
self.client_interface, *args)
452
453
def call_server_method(self, method, *args):
454
return self.call_method(method, self.busname,
455
self.server_path,
456
self.server_interface, *args)
457
458
class Error(Exception):
459
pass
460
461
class ConnectFailed(Error):
462
pass
463
464
465
class dbus_python_adapter(object):
466
467
class SystemBus(dbus.MandosBus):
468
"""Use dbus-python"""
469
470
def __init__(self, module=dbus_python):
471
self.dbus_python = module
472
self.bus = self.dbus_python.SystemBus()
473
474
@contextlib.contextmanager
475
def convert_exception(self, exception_class=dbus.Error):
476
try:
477
yield
478
except self.dbus_python.exceptions.DBusException as e:
479
# This does what "raise from" would do
480
exc = exception_class(*e.args)
481
exc.__cause__ = e
482
raise exc
483
484
def call_method(self, methodname, busname, objectpath,
485
interface, *args):
486
proxy_object = self.get_object(busname, objectpath)
487
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
488
interface, methodname,
489
", ".join(repr(a) for a in args))
490
method = getattr(proxy_object, methodname)
491
with self.convert_exception():
492
with dbus_python_adapter.SilenceLogger(
493
"dbus.proxies"):
494
value = method(*args, dbus_interface=interface)
495
return self.type_filter(value)
496
497
def get_object(self, busname, objectpath):
498
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
499
busname, objectpath)
500
with self.convert_exception(dbus.ConnectFailed):
501
return self.bus.get_object(busname, objectpath)
502
503
def type_filter(self, value):
504
"""Convert the most bothersome types to Python types"""
505
if isinstance(value, self.dbus_python.Boolean):
506
return bool(value)
507
if isinstance(value, self.dbus_python.ObjectPath):
508
return str(value)
509
# Also recurse into dictionaries
510
if isinstance(value, self.dbus_python.Dictionary):
511
return {self.type_filter(key):
512
self.type_filter(subval)
513
for key, subval in value.items()}
514
return value
515
516
517
class SilenceLogger(object):
518
"Simple context manager to silence a particular logger"
519
def __init__(self, loggername):
520
self.logger = logging.getLogger(loggername)
521
522
def __enter__(self):
523
self.logger.addFilter(self.nullfilter)
524
525
class NullFilter(logging.Filter):
526
def filter(self, record):
527
return False
528
529
nullfilter = NullFilter()
530
531
def __exit__(self, exc_type, exc_val, exc_tb):
532
self.logger.removeFilter(self.nullfilter)
533
534
535
class CachingBus(SystemBus):
536
"""A caching layer for dbus_python_adapter.SystemBus"""
537
def __init__(self, *args, **kwargs):
538
self.object_cache = {}
539
super(dbus_python_adapter.CachingBus,
540
self).__init__(*args, **kwargs)
541
def get_object(self, busname, objectpath):
542
try:
543
return self.object_cache[(busname, objectpath)]
544
except KeyError:
545
new_object = super(
546
dbus_python_adapter.CachingBus,
547
self).get_object(busname, objectpath)
548
self.object_cache[(busname, objectpath)] = new_object
549
return new_object
550
551
552
def commands_from_options(options):
553
554
commands = []
555
556
if options.is_enabled:
557
commands.append(command.IsEnabled())
558
559
if options.approve:
560
commands.append(command.Approve())
561
562
if options.deny:
563
commands.append(command.Deny())
564
565
if options.remove:
566
commands.append(command.Remove())
567
568
if options.dump_json:
569
commands.append(command.DumpJSON())
570
571
if options.enable:
572
commands.append(command.Enable())
573
574
if options.disable:
575
commands.append(command.Disable())
576
577
if options.bump_timeout:
578
commands.append(command.BumpTimeout())
579
580
if options.start_checker:
581
commands.append(command.StartChecker())
582
583
if options.stop_checker:
584
commands.append(command.StopChecker())
585
586
if options.approved_by_default is not None:
587
if options.approved_by_default:
588
commands.append(command.ApproveByDefault())
589
else:
590
commands.append(command.DenyByDefault())
591
592
if options.checker is not None:
593
commands.append(command.SetChecker(options.checker))
594
595
if options.host is not None:
596
commands.append(command.SetHost(options.host))
597
598
if options.secret is not None:
599
commands.append(command.SetSecret(options.secret))
600
601
if options.timeout is not None:
602
commands.append(command.SetTimeout(options.timeout))
603
604
if options.extended_timeout:
605
commands.append(
606
command.SetExtendedTimeout(options.extended_timeout))
607
608
if options.interval is not None:
609
commands.append(command.SetInterval(options.interval))
610
611
if options.approval_delay is not None:
612
commands.append(
613
command.SetApprovalDelay(options.approval_delay))
614
615
if options.approval_duration is not None:
616
commands.append(
617
command.SetApprovalDuration(options.approval_duration))
618
619
# If no command option has been given, show table of clients,
620
# optionally verbosely
621
if not commands:
622
commands.append(command.PrintTable(verbose=options.verbose))
623
624
return commands
625
626
627
class command(object):
628
"""A namespace for command classes"""
629
630
class Base(object):
631
"""Abstract base class for commands"""
632
def run(self, clients, bus=None):
633
"""Normal commands should implement run_on_one_client(),
634
but commands which want to operate on all clients at the same time can
635
override this run() method instead.
636
"""
637
self.bus = bus
638
for client, properties in clients.items():
639
self.run_on_one_client(client, properties)
640
641
642
class IsEnabled(Base):
643
def run(self, clients, bus=None):
644
properties = next(iter(clients.values()))
645
if properties["Enabled"]:
646
sys.exit(0)
647
sys.exit(1)
648
649
650
class Approve(Base):
651
def run_on_one_client(self, client, properties):
652
self.bus.call_client_method(client, "Approve", True)
653
654
655
class Deny(Base):
656
def run_on_one_client(self, client, properties):
657
self.bus.call_client_method(client, "Approve", False)
658
659
660
class Remove(Base):
661
def run(self, clients, bus):
662
for clientpath in frozenset(clients.keys()):
663
bus.call_server_method("RemoveClient", clientpath)
664
665
666
class Output(Base):
667
"""Abstract class for commands outputting client details"""
668
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
669
"Created", "Interval", "Host", "KeyID",
670
"Fingerprint", "CheckerRunning",
671
"LastEnabled", "ApprovalPending",
672
"ApprovedByDefault", "LastApprovalRequest",
673
"ApprovalDelay", "ApprovalDuration",
674
"Checker", "ExtendedTimeout", "Expires",
675
"LastCheckerStatus")
676
677
678
class DumpJSON(Output):
679
def run(self, clients, bus=None):
680
data = {properties["Name"]:
681
{key: properties[key]
682
for key in self.all_keywords}
683
for properties in clients.values()}
684
print(json.dumps(data, indent=4, separators=(',', ': ')))
685
686
687
class PrintTable(Output):
688
def __init__(self, verbose=False):
689
self.verbose = verbose
690
691
def run(self, clients, bus=None):
692
default_keywords = ("Name", "Enabled", "Timeout",
693
"LastCheckedOK")
694
keywords = default_keywords
695
if self.verbose:
696
keywords = self.all_keywords
697
print(self.TableOfClients(clients.values(), keywords))
698
699
class TableOfClients(object):
700
tableheaders = {
701
"Name": "Name",
702
"Enabled": "Enabled",
703
"Timeout": "Timeout",
704
"LastCheckedOK": "Last Successful Check",
705
"LastApprovalRequest": "Last Approval Request",
706
"Created": "Created",
707
"Interval": "Interval",
708
"Host": "Host",
709
"Fingerprint": "Fingerprint",
710
"KeyID": "Key ID",
711
"CheckerRunning": "Check Is Running",
712
"LastEnabled": "Last Enabled",
713
"ApprovalPending": "Approval Is Pending",
714
"ApprovedByDefault": "Approved By Default",
715
"ApprovalDelay": "Approval Delay",
716
"ApprovalDuration": "Approval Duration",
717
"Checker": "Checker",
718
"ExtendedTimeout": "Extended Timeout",
719
"Expires": "Expires",
720
"LastCheckerStatus": "Last Checker Status",
721
}
722
723
def __init__(self, clients, keywords):
724
self.clients = clients
725
self.keywords = keywords
726
727
def __str__(self):
728
return "\n".join(self.rows())
729
730
if sys.version_info.major == 2:
731
__unicode__ = __str__
732
def __str__(self):
733
return str(self).encode(
734
locale.getpreferredencoding())
735
736
def rows(self):
737
format_string = self.row_formatting_string()
738
rows = [self.header_line(format_string)]
739
rows.extend(self.client_line(client, format_string)
740
for client in self.clients)
741
return rows
742
743
def row_formatting_string(self):
744
"Format string used to format table rows"
745
return " ".join("{{{key}:{width}}}".format(
746
width=max(len(self.tableheaders[key]),
747
*(len(self.string_from_client(client,
748
key))
749
for client in self.clients)),
750
key=key)
751
for key in self.keywords)
752
753
def string_from_client(self, client, key):
754
return self.valuetostring(client[key], key)
755
756
@classmethod
757
def valuetostring(cls, value, keyword):
758
if isinstance(value, bool):
759
return "Yes" if value else "No"
760
if keyword in ("Timeout", "Interval", "ApprovalDelay",
761
"ApprovalDuration", "ExtendedTimeout"):
762
return cls.milliseconds_to_string(value)
763
return str(value)
764
765
def header_line(self, format_string):
766
return format_string.format(**self.tableheaders)
767
768
def client_line(self, client, format_string):
769
return format_string.format(
770
**{key: self.string_from_client(client, key)
771
for key in self.keywords})
772
773
@staticmethod
774
def milliseconds_to_string(ms):
775
td = datetime.timedelta(0, 0, 0, ms)
776
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
777
.format(days="{}T".format(td.days)
778
if td.days else "",
779
hours=td.seconds // 3600,
780
minutes=(td.seconds % 3600) // 60,
781
seconds=td.seconds % 60))
782
783
784
class PropertySetter(Base):
785
"Abstract class for Actions for setting one client property"
786
787
def run_on_one_client(self, client, properties=None):
788
"""Set the Client's D-Bus property"""
789
self.bus.set_client_property(client, self.propname,
790
self.value_to_set)
791
792
@property
793
def propname(self):
794
raise NotImplementedError()
795
796
797
class Enable(PropertySetter):
798
propname = "Enabled"
799
value_to_set = True
800
801
802
class Disable(PropertySetter):
803
propname = "Enabled"
804
value_to_set = False
805
806
807
class BumpTimeout(PropertySetter):
808
propname = "LastCheckedOK"
809
value_to_set = ""
810
811
812
class StartChecker(PropertySetter):
813
propname = "CheckerRunning"
814
value_to_set = True
815
816
817
class StopChecker(PropertySetter):
818
propname = "CheckerRunning"
819
value_to_set = False
820
821
822
class ApproveByDefault(PropertySetter):
823
propname = "ApprovedByDefault"
824
value_to_set = True
825
826
827
class DenyByDefault(PropertySetter):
828
propname = "ApprovedByDefault"
829
value_to_set = False
830
831
832
class PropertySetterValue(PropertySetter):
833
"""Abstract class for PropertySetter recieving a value as
834
constructor argument instead of a class attribute."""
835
def __init__(self, value):
836
self.value_to_set = value
837
838
839
class SetChecker(PropertySetterValue):
840
propname = "Checker"
841
842
843
class SetHost(PropertySetterValue):
844
propname = "Host"
845
846
847
class SetSecret(PropertySetterValue):
848
propname = "Secret"
849
850
@property
851
def value_to_set(self):
852
return self._vts
853
854
@value_to_set.setter
855
def value_to_set(self, value):
856
"""When setting, read data from supplied file object"""
857
self._vts = value.read()
858
value.close()
859
860
861
class PropertySetterValueMilliseconds(PropertySetterValue):
862
"""Abstract class for PropertySetterValue taking a value
863
argument as a datetime.timedelta() but should store it as
864
milliseconds."""
865
866
@property
867
def value_to_set(self):
868
return self._vts
869
870
@value_to_set.setter
871
def value_to_set(self, value):
872
"When setting, convert value from a datetime.timedelta"
873
self._vts = int(round(value.total_seconds() * 1000))
874
875
876
class SetTimeout(PropertySetterValueMilliseconds):
877
propname = "Timeout"
878
879
880
class SetExtendedTimeout(PropertySetterValueMilliseconds):
881
propname = "ExtendedTimeout"
882
883
884
class SetInterval(PropertySetterValueMilliseconds):
885
propname = "Interval"
886
887
888
class SetApprovalDelay(PropertySetterValueMilliseconds):
889
propname = "ApprovalDelay"
890
891
892
class SetApprovalDuration(PropertySetterValueMilliseconds):
893
propname = "ApprovalDuration"
894
772
895
773
896
774
class Test_milliseconds_to_string(unittest.TestCase):
775
def test_all(self):
776
self.assertEqual(milliseconds_to_string(93785000),
777
"1T02:03:05")
778
def test_no_days(self):
779
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
780
def test_all_zero(self):
781
self.assertEqual(milliseconds_to_string(0), "00:00:00")
782
def test_no_fractional_seconds(self):
783
self.assertEqual(milliseconds_to_string(400), "00:00:00")
784
self.assertEqual(milliseconds_to_string(900), "00:00:00")
785
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
786
787
class Test_string_to_delta(unittest.TestCase):
788
def test_handles_basic_rfc3339(self):
789
self.assertEqual(string_to_delta("PT0S"),
790
datetime.timedelta())
791
self.assertEqual(string_to_delta("P0D"),
792
datetime.timedelta())
793
self.assertEqual(string_to_delta("PT1S"),
794
datetime.timedelta(0, 1))
795
self.assertEqual(string_to_delta("PT2H"),
796
datetime.timedelta(0, 7200))
897
class TestCaseWithAssertLogs(unittest.TestCase):
898
"""unittest.TestCase.assertLogs only exists in Python 3.4"""
899
900
if not hasattr(unittest.TestCase, "assertLogs"):
901
@contextlib.contextmanager
902
def assertLogs(self, logger, level=logging.INFO):
903
capturing_handler = self.CapturingLevelHandler(level)
904
old_level = logger.level
905
old_propagate = logger.propagate
906
logger.addHandler(capturing_handler)
907
logger.setLevel(level)
908
logger.propagate = False
909
try:
910
yield capturing_handler.watcher
911
finally:
912
logger.propagate = old_propagate
913
logger.removeHandler(capturing_handler)
914
logger.setLevel(old_level)
915
self.assertGreater(len(capturing_handler.watcher.records),
916
0)
917
918
class CapturingLevelHandler(logging.Handler):
919
def __init__(self, level, *args, **kwargs):
920
logging.Handler.__init__(self, *args, **kwargs)
921
self.watcher = self.LoggingWatcher([], [])
922
def emit(self, record):
923
self.watcher.records.append(record)
924
self.watcher.output.append(self.format(record))
925
926
LoggingWatcher = collections.namedtuple("LoggingWatcher",
927
("records",
928
"output"))
929
930
931
class Unique(object):
932
"""Class for objects which exist only to be unique objects, since
933
unittest.mock.sentinel only exists in Python 3.3"""
934
935
936
class Test_string_to_delta(TestCaseWithAssertLogs):
937
# Just test basic RFC 3339 functionality here, the doc string for
938
# rfc3339_duration_to_delta() already has more comprehensive
939
# tests, which are run by doctest.
940
941
def test_rfc3339_zero_seconds(self):
942
self.assertEqual(datetime.timedelta(),
943
string_to_delta("PT0S"))
944
945
def test_rfc3339_zero_days(self):
946
self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))
947
948
def test_rfc3339_one_second(self):
949
self.assertEqual(datetime.timedelta(0, 1),
950
string_to_delta("PT1S"))
951
952
def test_rfc3339_two_hours(self):
953
self.assertEqual(datetime.timedelta(0, 7200),
954
string_to_delta("PT2H"))
955
797
956
def test_falls_back_to_pre_1_6_1_with_warning(self):
798
# assertLogs only exists in Python 3.4
799
if hasattr(self, "assertLogs"):
800
with self.assertLogs(log, logging.WARNING):
801
value = string_to_delta("2h")
802
else:
803
class WarningFilter(logging.Filter):
804
"""Don't show, but record the presence of, warnings"""
805
def filter(self, record):
806
is_warning = record.levelno >= logging.WARNING
807
self.found = is_warning or getattr(self, "found",
808
False)
809
return not is_warning
810
warning_filter = WarningFilter()
811
log.addFilter(warning_filter)
957
with self.assertLogs(log, logging.WARNING):
958
value = string_to_delta("2h")
959
self.assertEqual(datetime.timedelta(0, 7200), value)
960
961
962
class Test_check_option_syntax(unittest.TestCase):
963
def setUp(self):
964
self.parser = argparse.ArgumentParser()
965
add_command_line_options(self.parser)
966
967
def test_actions_requires_client_or_all(self):
968
for action, value in self.actions.items():
969
options = self.parser.parse_args()
970
setattr(options, action, value)
971
with self.assertParseError():
972
self.check_option_syntax(options)
973
974
# This mostly corresponds to the definition from has_actions() in
975
# check_option_syntax()
976
actions = {
977
# The actual values set here are not that important, but we do
978
# at least stick to the correct types, even though they are
979
# never used
980
"enable": True,
981
"disable": True,
982
"bump_timeout": True,
983
"start_checker": True,
984
"stop_checker": True,
985
"is_enabled": True,
986
"remove": True,
987
"checker": "x",
988
"timeout": datetime.timedelta(),
989
"extended_timeout": datetime.timedelta(),
990
"interval": datetime.timedelta(),
991
"approved_by_default": True,
992
"approval_delay": datetime.timedelta(),
993
"approval_duration": datetime.timedelta(),
994
"host": "x",
995
"secret": io.BytesIO(b"x"),
996
"approve": True,
997
"deny": True,
998
}
999
1000
@contextlib.contextmanager
1001
def assertParseError(self):
1002
with self.assertRaises(SystemExit) as e:
1003
with self.redirect_stderr_to_devnull():
1004
yield
1005
# Exit code from argparse is guaranteed to be "2". Reference:
1006
# https://docs.python.org/3/library
1007
# /argparse.html#exiting-methods
1008
self.assertEqual(2, e.exception.code)
1009
1010
@staticmethod
1011
@contextlib.contextmanager
1012
def redirect_stderr_to_devnull():
1013
old_stderr = sys.stderr
1014
with contextlib.closing(open(os.devnull, "w")) as null:
1015
sys.stderr = null
812
1016
try:
813
value = string_to_delta("2h")
1017
yield
814
1018
finally:
815
log.removeFilter(warning_filter)
816
self.assertTrue(getattr(warning_filter, "found", False))
817
self.assertEqual(value, datetime.timedelta(0, 7200))
818
819
820
class TestCmd(unittest.TestCase):
1019
sys.stderr = old_stderr
1020
1021
def check_option_syntax(self, options):
1022
check_option_syntax(self.parser, options)
1023
1024
def test_actions_all_conflicts_with_verbose(self):
1025
for action, value in self.actions.items():
1026
options = self.parser.parse_args()
1027
setattr(options, action, value)
1028
options.all = True
1029
options.verbose = True
1030
with self.assertParseError():
1031
self.check_option_syntax(options)
1032
1033
def test_actions_with_client_conflicts_with_verbose(self):
1034
for action, value in self.actions.items():
1035
options = self.parser.parse_args()
1036
setattr(options, action, value)
1037
options.verbose = True
1038
options.client = ["client"]
1039
with self.assertParseError():
1040
self.check_option_syntax(options)
1041
1042
def test_dump_json_conflicts_with_verbose(self):
1043
options = self.parser.parse_args()
1044
options.dump_json = True
1045
options.verbose = True
1046
with self.assertParseError():
1047
self.check_option_syntax(options)
1048
1049
def test_dump_json_conflicts_with_action(self):
1050
for action, value in self.actions.items():
1051
options = self.parser.parse_args()
1052
setattr(options, action, value)
1053
options.dump_json = True
1054
with self.assertParseError():
1055
self.check_option_syntax(options)
1056
1057
def test_all_can_not_be_alone(self):
1058
options = self.parser.parse_args()
1059
options.all = True
1060
with self.assertParseError():
1061
self.check_option_syntax(options)
1062
1063
def test_all_is_ok_with_any_action(self):
1064
for action, value in self.actions.items():
1065
options = self.parser.parse_args()
1066
setattr(options, action, value)
1067
options.all = True
1068
self.check_option_syntax(options)
1069
1070
def test_any_action_is_ok_with_one_client(self):
1071
for action, value in self.actions.items():
1072
options = self.parser.parse_args()
1073
setattr(options, action, value)
1074
options.client = ["client"]
1075
self.check_option_syntax(options)
1076
1077
def test_one_client_with_all_actions_except_is_enabled(self):
1078
options = self.parser.parse_args()
1079
for action, value in self.actions.items():
1080
if action == "is_enabled":
1081
continue
1082
setattr(options, action, value)
1083
options.client = ["client"]
1084
self.check_option_syntax(options)
1085
1086
def test_two_clients_with_all_actions_except_is_enabled(self):
1087
options = self.parser.parse_args()
1088
for action, value in self.actions.items():
1089
if action == "is_enabled":
1090
continue
1091
setattr(options, action, value)
1092
options.client = ["client1", "client2"]
1093
self.check_option_syntax(options)
1094
1095
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1096
for action, value in self.actions.items():
1097
if action == "is_enabled":
1098
continue
1099
options = self.parser.parse_args()
1100
setattr(options, action, value)
1101
options.client = ["client1", "client2"]
1102
self.check_option_syntax(options)
1103
1104
def test_is_enabled_fails_without_client(self):
1105
options = self.parser.parse_args()
1106
options.is_enabled = True
1107
with self.assertParseError():
1108
self.check_option_syntax(options)
1109
1110
def test_is_enabled_fails_with_two_clients(self):
1111
options = self.parser.parse_args()
1112
options.is_enabled = True
1113
options.client = ["client1", "client2"]
1114
with self.assertParseError():
1115
self.check_option_syntax(options)
1116
1117
def test_remove_can_only_be_combined_with_action_deny(self):
1118
for action, value in self.actions.items():
1119
if action in {"remove", "deny"}:
1120
continue
1121
options = self.parser.parse_args()
1122
setattr(options, action, value)
1123
options.all = True
1124
options.remove = True
1125
with self.assertParseError():
1126
self.check_option_syntax(options)
1127
1128
1129
class Test_dbus_exceptions(unittest.TestCase):
1130
1131
def test_dbus_ConnectFailed_is_Error(self):
1132
with self.assertRaises(dbus.Error):
1133
raise dbus.ConnectFailed()
1134
1135
1136
class Test_dbus_MandosBus(unittest.TestCase):
1137
1138
class MockMandosBus(dbus.MandosBus):
1139
def __init__(self):
1140
self._name = "se.recompile.Mandos"
1141
self._server_path = "/"
1142
self._server_interface = "se.recompile.Mandos"
1143
self._client_interface = "se.recompile.Mandos.Client"
1144
self.calls = []
1145
self.call_method_return = Unique()
1146
1147
def call_method(self, methodname, busname, objectpath,
1148
interface, *args):
1149
self.calls.append((methodname, busname, objectpath,
1150
interface, args))
1151
return self.call_method_return
1152
1153
def setUp(self):
1154
self.bus = self.MockMandosBus()
1155
1156
def test_set_client_property(self):
1157
self.bus.set_client_property("objectpath", "key", "value")
1158
expected_call = ("Set", self.bus._name, "objectpath",
1159
"org.freedesktop.DBus.Properties",
1160
(self.bus._client_interface, "key", "value"))
1161
self.assertIn(expected_call, self.bus.calls)
1162
1163
def test_call_client_method(self):
1164
ret = self.bus.call_client_method("objectpath", "methodname")
1165
self.assertIs(self.bus.call_method_return, ret)
1166
expected_call = ("methodname", self.bus._name, "objectpath",
1167
self.bus._client_interface, ())
1168
self.assertIn(expected_call, self.bus.calls)
1169
1170
def test_call_client_method_with_args(self):
1171
args = (Unique(), Unique())
1172
ret = self.bus.call_client_method("objectpath", "methodname",
1173
*args)
1174
self.assertIs(self.bus.call_method_return, ret)
1175
expected_call = ("methodname", self.bus._name, "objectpath",
1176
self.bus._client_interface,
1177
(args[0], args[1]))
1178
self.assertIn(expected_call, self.bus.calls)
1179
1180
def test_get_clients_and_properties(self):
1181
managed_objects = {
1182
"objectpath": {
1183
self.bus._client_interface: {
1184
"key": "value",
1185
"bool": True,
1186
},
1187
"irrelevant_interface": {
1188
"key": "othervalue",
1189
"bool": False,
1190
},
1191
},
1192
"other_objectpath": {
1193
"other_irrelevant_interface": {
1194
"key": "value 3",
1195
"bool": None,
1196
},
1197
},
1198
}
1199
expected_clients_and_properties = {
1200
"objectpath": {
1201
"key": "value",
1202
"bool": True,
1203
}
1204
}
1205
self.bus.call_method_return = managed_objects
1206
ret = self.bus.get_clients_and_properties()
1207
self.assertDictEqual(expected_clients_and_properties, ret)
1208
expected_call = ("GetManagedObjects", self.bus._name,
1209
self.bus._server_path,
1210
"org.freedesktop.DBus.ObjectManager", ())
1211
self.assertIn(expected_call, self.bus.calls)
1212
1213
def test_call_server_method(self):
1214
ret = self.bus.call_server_method("methodname")
1215
self.assertIs(self.bus.call_method_return, ret)
1216
expected_call = ("methodname", self.bus._name,
1217
self.bus._server_path,
1218
self.bus._server_interface, ())
1219
self.assertIn(expected_call, self.bus.calls)
1220
1221
def test_call_server_method_with_args(self):
1222
args = (Unique(), Unique())
1223
ret = self.bus.call_server_method("methodname", *args)
1224
self.assertIs(self.bus.call_method_return, ret)
1225
expected_call = ("methodname", self.bus._name,
1226
self.bus._server_path,
1227
self.bus._server_interface,
1228
(args[0], args[1]))
1229
self.assertIn(expected_call, self.bus.calls)
1230
1231
1232
class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):
1233
1234
def MockDBusPython_func(self, func):
1235
class mock_dbus_python(object):
1236
"""mock dbus-python module"""
1237
class exceptions(object):
1238
"""Pseudo-namespace"""
1239
class DBusException(Exception):
1240
pass
1241
class SystemBus(object):
1242
@staticmethod
1243
def get_object(busname, objectpath):
1244
DBusObject = collections.namedtuple(
1245
"DBusObject", ("methodname",))
1246
def method(*args, **kwargs):
1247
self.assertEqual({"dbus_interface":
1248
"interface"},
1249
kwargs)
1250
return func(*args)
1251
return DBusObject(methodname=method)
1252
class Boolean(object):
1253
def __init__(self, value):
1254
self.value = bool(value)
1255
def __bool__(self):
1256
return self.value
1257
if sys.version_info.major == 2:
1258
__nonzero__ = __bool__
1259
class ObjectPath(str):
1260
pass
1261
class Dictionary(dict):
1262
pass
1263
return mock_dbus_python
1264
1265
def call_method(self, bus, methodname, busname, objectpath,
1266
interface, *args):
1267
with self.assertLogs(log, logging.DEBUG):
1268
return bus.call_method(methodname, busname, objectpath,
1269
interface, *args)
1270
1271
def test_call_method_returns(self):
1272
expected_method_return = Unique()
1273
method_args = (Unique(), Unique())
1274
def func(*args):
1275
self.assertEqual(len(method_args), len(args))
1276
for marg, arg in zip(method_args, args):
1277
self.assertIs(marg, arg)
1278
return expected_method_return
1279
mock_dbus_python = self.MockDBusPython_func(func)
1280
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1281
ret = self.call_method(bus, "methodname", "busname",
1282
"objectpath", "interface",
1283
*method_args)
1284
self.assertIs(ret, expected_method_return)
1285
1286
def test_call_method_filters_bool_true(self):
1287
def func():
1288
return method_return
1289
mock_dbus_python = self.MockDBusPython_func(func)
1290
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1291
method_return = mock_dbus_python.Boolean(True)
1292
ret = self.call_method(bus, "methodname", "busname",
1293
"objectpath", "interface")
1294
self.assertTrue(ret)
1295
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1296
1297
def test_call_method_filters_bool_false(self):
1298
def func():
1299
return method_return
1300
mock_dbus_python = self.MockDBusPython_func(func)
1301
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1302
method_return = mock_dbus_python.Boolean(False)
1303
ret = self.call_method(bus, "methodname", "busname",
1304
"objectpath", "interface")
1305
self.assertFalse(ret)
1306
self.assertNotIsInstance(ret, mock_dbus_python.Boolean)
1307
1308
def test_call_method_filters_objectpath(self):
1309
def func():
1310
return method_return
1311
mock_dbus_python = self.MockDBusPython_func(func)
1312
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1313
method_return = mock_dbus_python.ObjectPath("objectpath")
1314
ret = self.call_method(bus, "methodname", "busname",
1315
"objectpath", "interface")
1316
self.assertEqual("objectpath", ret)
1317
self.assertIsNot("objectpath", ret)
1318
self.assertNotIsInstance(ret, mock_dbus_python.ObjectPath)
1319
1320
def test_call_method_filters_booleans_in_dict(self):
1321
def func():
1322
return method_return
1323
mock_dbus_python = self.MockDBusPython_func(func)
1324
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1325
method_return = mock_dbus_python.Dictionary(
1326
{mock_dbus_python.Boolean(True):
1327
mock_dbus_python.Boolean(False),
1328
mock_dbus_python.Boolean(False):
1329
mock_dbus_python.Boolean(True)})
1330
ret = self.call_method(bus, "methodname", "busname",
1331
"objectpath", "interface")
1332
expected_method_return = {True: False,
1333
False: True}
1334
self.assertEqual(expected_method_return, ret)
1335
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1336
1337
def test_call_method_filters_objectpaths_in_dict(self):
1338
def func():
1339
return method_return
1340
mock_dbus_python = self.MockDBusPython_func(func)
1341
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1342
method_return = mock_dbus_python.Dictionary(
1343
{mock_dbus_python.ObjectPath("objectpath_key_1"):
1344
mock_dbus_python.ObjectPath("objectpath_value_1"),
1345
mock_dbus_python.ObjectPath("objectpath_key_2"):
1346
mock_dbus_python.ObjectPath("objectpath_value_2")})
1347
ret = self.call_method(bus, "methodname", "busname",
1348
"objectpath", "interface")
1349
expected_method_return = {str(key): str(value)
1350
for key, value in
1351
method_return.items()}
1352
self.assertEqual(expected_method_return, ret)
1353
self.assertIsInstance(ret, dict)
1354
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1355
1356
def test_call_method_filters_dict_in_dict(self):
1357
def func():
1358
return method_return
1359
mock_dbus_python = self.MockDBusPython_func(func)
1360
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1361
method_return = mock_dbus_python.Dictionary(
1362
{"key1": mock_dbus_python.Dictionary({"key11": "value11",
1363
"key12": "value12"}),
1364
"key2": mock_dbus_python.Dictionary({"key21": "value21",
1365
"key22": "value22"})})
1366
ret = self.call_method(bus, "methodname", "busname",
1367
"objectpath", "interface")
1368
expected_method_return = {
1369
"key1": {"key11": "value11",
1370
"key12": "value12"},
1371
"key2": {"key21": "value21",
1372
"key22": "value22"},
1373
}
1374
self.assertEqual(expected_method_return, ret)
1375
self.assertIsInstance(ret, dict)
1376
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1377
for key, value in ret.items():
1378
self.assertIsInstance(value, dict)
1379
self.assertEqual(expected_method_return[key], value)
1380
self.assertNotIsInstance(value,
1381
mock_dbus_python.Dictionary)
1382
1383
def test_call_method_filters_dict_three_deep(self):
1384
def func():
1385
return method_return
1386
mock_dbus_python = self.MockDBusPython_func(func)
1387
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1388
method_return = mock_dbus_python.Dictionary(
1389
{"key1":
1390
mock_dbus_python.Dictionary(
1391
{"key2":
1392
mock_dbus_python.Dictionary(
1393
{"key3":
1394
mock_dbus_python.Boolean(True),
1395
}),
1396
}),
1397
})
1398
ret = self.call_method(bus, "methodname", "busname",
1399
"objectpath", "interface")
1400
expected_method_return = {"key1": {"key2": {"key3": True}}}
1401
self.assertEqual(expected_method_return, ret)
1402
self.assertIsInstance(ret, dict)
1403
self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)
1404
self.assertIsInstance(ret["key1"], dict)
1405
self.assertNotIsInstance(ret["key1"],
1406
mock_dbus_python.Dictionary)
1407
self.assertIsInstance(ret["key1"]["key2"], dict)
1408
self.assertNotIsInstance(ret["key1"]["key2"],
1409
mock_dbus_python.Dictionary)
1410
self.assertTrue(ret["key1"]["key2"]["key3"])
1411
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
1412
mock_dbus_python.Boolean)
1413
1414
def test_call_method_handles_exception(self):
1415
dbus_logger = logging.getLogger("dbus.proxies")
1416
1417
def func():
1418
dbus_logger.error("Test")
1419
raise mock_dbus_python.exceptions.DBusException()
1420
1421
mock_dbus_python = self.MockDBusPython_func(func)
1422
bus = dbus_python_adapter.SystemBus(mock_dbus_python)
1423
1424
class CountingHandler(logging.Handler):
1425
count = 0
1426
def emit(self, record):
1427
self.count += 1
1428
1429
counting_handler = CountingHandler()
1430
1431
dbus_logger.addHandler(counting_handler)
1432
1433
try:
1434
with self.assertRaises(dbus.Error) as e:
1435
self.call_method(bus, "methodname", "busname",
1436
"objectpath", "interface")
1437
finally:
1438
dbus_logger.removeFilter(counting_handler)
1439
1440
self.assertNotIsInstance(e, dbus.ConnectFailed)
1441
1442
# Make sure the dbus logger was suppressed
1443
self.assertEqual(0, counting_handler.count)
1444
1445
def test_get_object_converts_to_correct_exception(self):
1446
bus = dbus_python_adapter.SystemBus(
1447
self.fake_dbus_python_raises_exception_on_connect)
1448
with self.assertRaises(dbus.ConnectFailed):
1449
self.call_method(bus, "methodname", "busname",
1450
"objectpath", "interface")
1451
1452
class fake_dbus_python_raises_exception_on_connect(object):
1453
"""fake dbus-python module"""
1454
class exceptions(object):
1455
"""Pseudo-namespace"""
1456
class DBusException(Exception):
1457
pass
1458
1459
@classmethod
1460
def SystemBus(cls):
1461
def get_object(busname, objectpath):
1462
raise cls.exceptions.DBusException()
1463
Bus = collections.namedtuple("Bus", ["get_object"])
1464
return Bus(get_object=get_object)
1465
1466
1467
class Test_dbus_python_adapter_CachingBus(unittest.TestCase):
1468
class mock_dbus_python(object):
1469
"""mock dbus-python modules"""
1470
class SystemBus(object):
1471
@staticmethod
1472
def get_object(busname, objectpath):
1473
return Unique()
1474
1475
def setUp(self):
1476
self.bus = dbus_python_adapter.CachingBus(
1477
self.mock_dbus_python)
1478
1479
def test_returns_distinct_objectpaths(self):
1480
obj1 = self.bus.get_object("busname", "objectpath1")
1481
self.assertIsInstance(obj1, Unique)
1482
obj2 = self.bus.get_object("busname", "objectpath2")
1483
self.assertIsInstance(obj2, Unique)
1484
self.assertIsNot(obj1, obj2)
1485
1486
def test_returns_distinct_busnames(self):
1487
obj1 = self.bus.get_object("busname1", "objectpath")
1488
self.assertIsInstance(obj1, Unique)
1489
obj2 = self.bus.get_object("busname2", "objectpath")
1490
self.assertIsInstance(obj2, Unique)
1491
self.assertIsNot(obj1, obj2)
1492
1493
def test_returns_distinct_both(self):
1494
obj1 = self.bus.get_object("busname1", "objectpath")
1495
self.assertIsInstance(obj1, Unique)
1496
obj2 = self.bus.get_object("busname2", "objectpath")
1497
self.assertIsInstance(obj2, Unique)
1498
self.assertIsNot(obj1, obj2)
1499
1500
def test_returns_same(self):
1501
obj1 = self.bus.get_object("busname", "objectpath")
1502
self.assertIsInstance(obj1, Unique)
1503
obj2 = self.bus.get_object("busname", "objectpath")
1504
self.assertIsInstance(obj2, Unique)
1505
self.assertIs(obj1, obj2)
1506
1507
def test_returns_same_old(self):
1508
obj1 = self.bus.get_object("busname1", "objectpath1")
1509
self.assertIsInstance(obj1, Unique)
1510
obj2 = self.bus.get_object("busname2", "objectpath2")
1511
self.assertIsInstance(obj2, Unique)
1512
obj1b = self.bus.get_object("busname1", "objectpath1")
1513
self.assertIsInstance(obj1b, Unique)
1514
self.assertIsNot(obj1, obj2)
1515
self.assertIsNot(obj2, obj1b)
1516
self.assertIs(obj1, obj1b)
1517
1518
1519
class Test_commands_from_options(unittest.TestCase):
1520
1521
def setUp(self):
1522
self.parser = argparse.ArgumentParser()
1523
add_command_line_options(self.parser)
1524
1525
def test_is_enabled(self):
1526
self.assert_command_from_args(["--is-enabled", "client"],
1527
command.IsEnabled)
1528
1529
def assert_command_from_args(self, args, command_cls,
1530
**cmd_attrs):
1531
"""Assert that parsing ARGS should result in an instance of
1532
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1533
options = self.parser.parse_args(args)
1534
check_option_syntax(self.parser, options)
1535
commands = commands_from_options(options)
1536
self.assertEqual(1, len(commands))
1537
command = commands[0]
1538
self.assertIsInstance(command, command_cls)
1539
for key, value in cmd_attrs.items():
1540
self.assertEqual(value, getattr(command, key))
1541
1542
def test_is_enabled_short(self):
1543
self.assert_command_from_args(["-V", "client"],
1544
command.IsEnabled)
1545
1546
def test_approve(self):
1547
self.assert_command_from_args(["--approve", "client"],
1548
command.Approve)
1549
1550
def test_approve_short(self):
1551
self.assert_command_from_args(["-A", "client"],
1552
command.Approve)
1553
1554
def test_deny(self):
1555
self.assert_command_from_args(["--deny", "client"],
1556
command.Deny)
1557
1558
def test_deny_short(self):
1559
self.assert_command_from_args(["-D", "client"], command.Deny)
1560
1561
def test_remove(self):
1562
self.assert_command_from_args(["--remove", "client"],
1563
command.Remove)
1564
1565
def test_deny_before_remove(self):
1566
options = self.parser.parse_args(["--deny", "--remove",
1567
"client"])
1568
check_option_syntax(self.parser, options)
1569
commands = commands_from_options(options)
1570
self.assertEqual(2, len(commands))
1571
self.assertIsInstance(commands[0], command.Deny)
1572
self.assertIsInstance(commands[1], command.Remove)
1573
1574
def test_deny_before_remove_reversed(self):
1575
options = self.parser.parse_args(["--remove", "--deny",
1576
"--all"])
1577
check_option_syntax(self.parser, options)
1578
commands = commands_from_options(options)
1579
self.assertEqual(2, len(commands))
1580
self.assertIsInstance(commands[0], command.Deny)
1581
self.assertIsInstance(commands[1], command.Remove)
1582
1583
def test_remove_short(self):
1584
self.assert_command_from_args(["-r", "client"],
1585
command.Remove)
1586
1587
def test_dump_json(self):
1588
self.assert_command_from_args(["--dump-json"],
1589
command.DumpJSON)
1590
1591
def test_enable(self):
1592
self.assert_command_from_args(["--enable", "client"],
1593
command.Enable)
1594
1595
def test_enable_short(self):
1596
self.assert_command_from_args(["-e", "client"],
1597
command.Enable)
1598
1599
def test_disable(self):
1600
self.assert_command_from_args(["--disable", "client"],
1601
command.Disable)
1602
1603
def test_disable_short(self):
1604
self.assert_command_from_args(["-d", "client"],
1605
command.Disable)
1606
1607
def test_bump_timeout(self):
1608
self.assert_command_from_args(["--bump-timeout", "client"],
1609
command.BumpTimeout)
1610
1611
def test_bump_timeout_short(self):
1612
self.assert_command_from_args(["-b", "client"],
1613
command.BumpTimeout)
1614
1615
def test_start_checker(self):
1616
self.assert_command_from_args(["--start-checker", "client"],
1617
command.StartChecker)
1618
1619
def test_stop_checker(self):
1620
self.assert_command_from_args(["--stop-checker", "client"],
1621
command.StopChecker)
1622
1623
def test_approve_by_default(self):
1624
self.assert_command_from_args(["--approve-by-default",
1625
"client"],
1626
command.ApproveByDefault)
1627
1628
def test_deny_by_default(self):
1629
self.assert_command_from_args(["--deny-by-default", "client"],
1630
command.DenyByDefault)
1631
1632
def test_checker(self):
1633
self.assert_command_from_args(["--checker", ":", "client"],
1634
command.SetChecker,
1635
value_to_set=":")
1636
1637
def test_checker_empty(self):
1638
self.assert_command_from_args(["--checker", "", "client"],
1639
command.SetChecker,
1640
value_to_set="")
1641
1642
def test_checker_short(self):
1643
self.assert_command_from_args(["-c", ":", "client"],
1644
command.SetChecker,
1645
value_to_set=":")
1646
1647
def test_host(self):
1648
self.assert_command_from_args(
1649
["--host", "client.example.org", "client"],
1650
command.SetHost, value_to_set="client.example.org")
1651
1652
def test_host_short(self):
1653
self.assert_command_from_args(
1654
["-H", "client.example.org", "client"], command.SetHost,
1655
value_to_set="client.example.org")
1656
1657
def test_secret_devnull(self):
1658
self.assert_command_from_args(["--secret", os.path.devnull,
1659
"client"], command.SetSecret,
1660
value_to_set=b"")
1661
1662
def test_secret_tempfile(self):
1663
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1664
value = b"secret\0xyzzy\nbar"
1665
f.write(value)
1666
f.seek(0)
1667
self.assert_command_from_args(["--secret", f.name,
1668
"client"],
1669
command.SetSecret,
1670
value_to_set=value)
1671
1672
def test_secret_devnull_short(self):
1673
self.assert_command_from_args(["-s", os.path.devnull,
1674
"client"], command.SetSecret,
1675
value_to_set=b"")
1676
1677
def test_secret_tempfile_short(self):
1678
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1679
value = b"secret\0xyzzy\nbar"
1680
f.write(value)
1681
f.seek(0)
1682
self.assert_command_from_args(["-s", f.name, "client"],
1683
command.SetSecret,
1684
value_to_set=value)
1685
1686
def test_timeout(self):
1687
self.assert_command_from_args(["--timeout", "PT5M", "client"],
1688
command.SetTimeout,
1689
value_to_set=300000)
1690
1691
def test_timeout_short(self):
1692
self.assert_command_from_args(["-t", "PT5M", "client"],
1693
command.SetTimeout,
1694
value_to_set=300000)
1695
1696
def test_extended_timeout(self):
1697
self.assert_command_from_args(["--extended-timeout", "PT15M",
1698
"client"],
1699
command.SetExtendedTimeout,
1700
value_to_set=900000)
1701
1702
def test_interval(self):
1703
self.assert_command_from_args(["--interval", "PT2M",
1704
"client"], command.SetInterval,
1705
value_to_set=120000)
1706
1707
def test_interval_short(self):
1708
self.assert_command_from_args(["-i", "PT2M", "client"],
1709
command.SetInterval,
1710
value_to_set=120000)
1711
1712
def test_approval_delay(self):
1713
self.assert_command_from_args(["--approval-delay", "PT30S",
1714
"client"],
1715
command.SetApprovalDelay,
1716
value_to_set=30000)
1717
1718
def test_approval_duration(self):
1719
self.assert_command_from_args(["--approval-duration", "PT1S",
1720
"client"],
1721
command.SetApprovalDuration,
1722
value_to_set=1000)
1723
1724
def test_print_table(self):
1725
self.assert_command_from_args([], command.PrintTable,
1726
verbose=False)
1727
1728
def test_print_table_verbose(self):
1729
self.assert_command_from_args(["--verbose"],
1730
command.PrintTable,
1731
verbose=True)
1732
1733
def test_print_table_verbose_short(self):
1734
self.assert_command_from_args(["-v"], command.PrintTable,
1735
verbose=True)
1736
1737
1738
class TestCommand(unittest.TestCase):
821
1739
"""Abstract class for tests of command classes"""
822
def setUp(self):
823
testcase = self
824
class MockClient(object):
825
def __init__(self, name, **attributes):
826
self.__dbus_object_path__ = "objpath_{}".format(name)
827
self.attributes = attributes
828
self.attributes["Name"] = name
829
self.calls = []
830
def Set(self, interface, property, value, dbus_interface):
831
testcase.assertEqual(interface, client_interface)
832
testcase.assertEqual(dbus_interface,
833
dbus.PROPERTIES_IFACE)
834
self.attributes[property] = value
835
def Get(self, interface, property, dbus_interface):
836
testcase.assertEqual(interface, client_interface)
837
testcase.assertEqual(dbus_interface,
838
dbus.PROPERTIES_IFACE)
839
return self.attributes[property]
840
def Approve(self, approve, dbus_interface):
841
testcase.assertEqual(dbus_interface, client_interface)
842
self.calls.append(("Approve", (approve,
843
dbus_interface)))
844
self.client = MockClient(
845
"foo",
846
KeyID=("92ed150794387c03ce684574b1139a65"
847
"94a34f895daaaf09fd8ea90a27cddb12"),
848
Secret=b"secret",
849
Host="foo.example.org",
850
Enabled=dbus.Boolean(True),
851
Timeout=300000,
852
LastCheckedOK="2019-02-03T00:00:00",
853
Created="2019-01-02T00:00:00",
854
Interval=120000,
855
Fingerprint=("778827225BA7DE539C5A"
856
"7CFA59CFF7CDBD9A5920"),
857
CheckerRunning=dbus.Boolean(False),
858
LastEnabled="2019-01-03T00:00:00",
859
ApprovalPending=dbus.Boolean(False),
860
ApprovedByDefault=dbus.Boolean(True),
861
LastApprovalRequest="",
862
ApprovalDelay=0,
863
ApprovalDuration=1000,
864
Checker="fping -q -- %(host)s",
865
ExtendedTimeout=900000,
866
Expires="2019-02-04T00:00:00",
867
LastCheckerStatus=0)
868
self.other_client = MockClient(
869
"barbar",
870
KeyID=("0558568eedd67d622f5c83b35a115f79"
871
"6ab612cff5ad227247e46c2b020f441c"),
872
Secret=b"secretbar",
873
Host="192.0.2.3",
874
Enabled=dbus.Boolean(True),
875
Timeout=300000,
876
LastCheckedOK="2019-02-04T00:00:00",
877
Created="2019-01-03T00:00:00",
878
Interval=120000,
879
Fingerprint=("3E393AEAEFB84C7E89E2"
880
"F547B3A107558FCA3A27"),
881
CheckerRunning=dbus.Boolean(True),
882
LastEnabled="2019-01-04T00:00:00",
883
ApprovalPending=dbus.Boolean(False),
884
ApprovedByDefault=dbus.Boolean(False),
885
LastApprovalRequest="2019-01-03T00:00:00",
886
ApprovalDelay=30000,
887
ApprovalDuration=1000,
888
Checker=":",
889
ExtendedTimeout=900000,
890
Expires="2019-02-05T00:00:00",
891
LastCheckerStatus=-2)
892
self.clients = collections.OrderedDict(
893
[
894
(self.client, self.client.attributes),
895
(self.other_client, self.other_client.attributes),
896
])
897
self.one_client = {self.client: self.client.attributes}
898
899
class TestPrintTableCmd(TestCmd):
900
def test_normal(self):
901
output = PrintTableCmd().output(self.clients)
902
expected_output = """
903
Name Enabled Timeout Last Successful Check
904
foo Yes 00:05:00 2019-02-03T00:00:00
905
barbar Yes 00:05:00 2019-02-04T00:00:00
906
"""[1:-1]
907
self.assertEqual(output, expected_output)
908
def test_verbose(self):
909
output = PrintTableCmd(verbose=True).output(self.clients)
910
expected_output = """
911
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
912
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
913
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
914
"""[1:-1]
915
self.assertEqual(output, expected_output)
916
def test_one_client(self):
917
output = PrintTableCmd().output(self.one_client)
918
expected_output = """
919
Name Enabled Timeout Last Successful Check
920
foo Yes 00:05:00 2019-02-03T00:00:00
921
"""[1:-1]
922
self.assertEqual(output, expected_output)
923
924
class TestDumpJSONCmd(TestCmd):
925
def setUp(self):
926
self.expected_json = {
927
"foo": {
1740
1741
class FakeMandosBus(dbus.MandosBus):
1742
def __init__(self, testcase):
1743
self.client_properties = {
928
1744
"Name": "foo",
929
1745
"KeyID": ("92ed150794387c03ce684574b1139a65"
930
1746
"94a34f895daaaf09fd8ea90a27cddb12"),
1747
"Secret": b"secret",
931
1748
"Host": "foo.example.org",
932
1749
"Enabled": True,
933
1750
"Timeout": 300000,
947
1764
"ExtendedTimeout": 900000,
948
1765
"Expires": "2019-02-04T00:00:00",
949
1766
"LastCheckerStatus": 0,
950
},
951
"barbar": {
1767
}
1768
self.other_client_properties = {
952
1769
"Name": "barbar",
953
1770
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
954
1771
"6ab612cff5ad227247e46c2b020f441c"),
1772
"Secret": b"secretbar",
955
1773
"Host": "192.0.2.3",
956
1774
"Enabled": True,
957
1775
"Timeout": 300000,
966
1784
"ApprovedByDefault": False,
967
1785
"LastApprovalRequest": "2019-01-03T00:00:00",
968
1786
"ApprovalDelay": 30000,
969
"ApprovalDuration": 1000,
1787
"ApprovalDuration": 93785000,
970
1788
"Checker": ":",
971
1789
"ExtendedTimeout": 900000,
972
1790
"Expires": "2019-02-05T00:00:00",
973
1791
"LastCheckerStatus": -2,
974
},
975
}
976
return super(TestDumpJSONCmd, self).setUp()
977
def test_normal(self):
978
json_data = json.loads(DumpJSONCmd().output(self.clients))
979
self.assertDictEqual(json_data, self.expected_json)
980
def test_one_client(self):
981
clients = self.one_client
982
json_data = json.loads(DumpJSONCmd().output(clients))
983
expected_json = {"foo": self.expected_json["foo"]}
984
self.assertDictEqual(json_data, expected_json)
985
986
class TestIsEnabledCmd(TestCmd):
987
def test_is_enabled(self):
988
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
989
for client, properties in self.clients.items()))
990
def test_is_enabled_run_exits_successfully(self):
1792
}
1793
self.clients = collections.OrderedDict(
1794
[
1795
("client_objectpath", self.client_properties),
1796
("other_client_objectpath",
1797
self.other_client_properties),
1798
])
1799
self.one_client = {"client_objectpath":
1800
self.client_properties}
1801
self.testcase = testcase
1802
self.calls = []
1803
1804
def call_method(self, methodname, busname, objectpath,
1805
interface, *args):
1806
self.testcase.assertEqual("se.recompile.Mandos", busname)
1807
self.calls.append((methodname, busname, objectpath,
1808
interface, args))
1809
if interface == "org.freedesktop.DBus.Properties":
1810
if methodname == "Set":
1811
self.testcase.assertEqual(3, len(args))
1812
interface, key, value = args
1813
self.testcase.assertEqual(
1814
"se.recompile.Mandos.Client", interface)
1815
self.clients[objectpath][key] = value
1816
return
1817
elif interface == "se.recompile.Mandos":
1818
self.testcase.assertEqual("RemoveClient", methodname)
1819
self.testcase.assertEqual(1, len(args))
1820
clientpath = args[0]
1821
del self.clients[clientpath]
1822
return
1823
elif interface == "se.recompile.Mandos.Client":
1824
if methodname == "Approve":
1825
self.testcase.assertEqual(1, len(args))
1826
return
1827
raise ValueError()
1828
1829
def setUp(self):
1830
self.bus = self.FakeMandosBus(self)
1831
1832
1833
class TestBaseCommands(TestCommand):
1834
1835
def test_IsEnabled_exits_successfully(self):
991
1836
with self.assertRaises(SystemExit) as e:
992
IsEnabledCmd().run(None, self.one_client)
1837
command.IsEnabled().run(self.bus.one_client)
993
1838
if e.exception.code is not None:
994
self.assertEqual(e.exception.code, 0)
1839
self.assertEqual(0, e.exception.code)
995
1840
else:
996
1841
self.assertIsNone(e.exception.code)
997
def test_is_enabled_run_exits_with_failure(self):
998
self.client.attributes["Enabled"] = dbus.Boolean(False)
1842
1843
def test_IsEnabled_exits_with_failure(self):
1844
self.bus.client_properties["Enabled"] = False
999
1845
with self.assertRaises(SystemExit) as e:
1000
IsEnabledCmd().run(None, self.one_client)
1846
command.IsEnabled().run(self.bus.one_client)
1001
1847
if isinstance(e.exception.code, int):
1002
self.assertNotEqual(e.exception.code, 0)
1848
self.assertNotEqual(0, e.exception.code)
1003
1849
else:
1004
1850
self.assertIsNotNone(e.exception.code)
1005
1851
1006
class TestRemoveCmd(TestCmd):
1007
def test_remove(self):
1008
class MockMandos(object):
1009
def __init__(self):
1010
self.calls = []
1011
def RemoveClient(self, dbus_path):
1012
self.calls.append(("RemoveClient", (dbus_path,)))
1013
mandos = MockMandos()
1014
super(TestRemoveCmd, self).setUp()
1015
RemoveCmd().run(mandos, self.clients)
1016
self.assertEqual(len(mandos.calls), 2)
1017
for client in self.clients:
1018
self.assertIn(("RemoveClient",
1019
(client.__dbus_object_path__,)),
1020
mandos.calls)
1021
1022
class TestApproveCmd(TestCmd):
1023
def test_approve(self):
1024
ApproveCmd().run(None, self.clients)
1025
for client in self.clients:
1026
self.assertIn(("Approve", (True, client_interface)),
1027
client.calls)
1028
1029
class TestDenyCmd(TestCmd):
1030
def test_deny(self):
1031
DenyCmd().run(None, self.clients)
1032
for client in self.clients:
1033
self.assertIn(("Approve", (False, client_interface)),
1034
client.calls)
1035
1036
class TestEnableCmd(TestCmd):
1037
def test_enable(self):
1038
for client in self.clients:
1039
client.attributes["Enabled"] = False
1040
1041
EnableCmd().run(None, self.clients)
1042
1043
for client in self.clients:
1044
self.assertTrue(client.attributes["Enabled"])
1045
1046
class TestDisableCmd(TestCmd):
1047
def test_disable(self):
1048
DisableCmd().run(None, self.clients)
1049
1050
for client in self.clients:
1051
self.assertFalse(client.attributes["Enabled"])
1052
1053
class Unique(object):
1054
"""Class for objects which exist only to be unique objects, since
1055
unittest.mock.sentinel only exists in Python 3.3"""
1056
1057
class TestPropertyCmd(TestCmd):
1058
"""Abstract class for tests of PropertyCmd classes"""
1852
def test_Approve(self):
1853
busname = "se.recompile.Mandos"
1854
client_interface = "se.recompile.Mandos.Client"
1855
command.Approve().run(self.bus.clients, self.bus)
1856
for clientpath in self.bus.clients:
1857
self.assertIn(("Approve", busname, clientpath,
1858
client_interface, (True,)), self.bus.calls)
1859
1860
def test_Deny(self):
1861
busname = "se.recompile.Mandos"
1862
client_interface = "se.recompile.Mandos.Client"
1863
command.Deny().run(self.bus.clients, self.bus)
1864
for clientpath in self.bus.clients:
1865
self.assertIn(("Approve", busname, clientpath,
1866
client_interface, (False,)),
1867
self.bus.calls)
1868
1869
def test_Remove(self):
1870
command.Remove().run(self.bus.clients, self.bus)
1871
for clientpath in self.bus.clients:
1872
self.assertIn(("RemoveClient", dbus_busname,
1873
dbus_server_path, dbus_server_interface,
1874
(clientpath,)), self.bus.calls)
1875
1876
expected_json = {
1877
"foo": {
1878
"Name": "foo",
1879
"KeyID": ("92ed150794387c03ce684574b1139a65"
1880
"94a34f895daaaf09fd8ea90a27cddb12"),
1881
"Host": "foo.example.org",
1882
"Enabled": True,
1883
"Timeout": 300000,
1884
"LastCheckedOK": "2019-02-03T00:00:00",
1885
"Created": "2019-01-02T00:00:00",
1886
"Interval": 120000,
1887
"Fingerprint": ("778827225BA7DE539C5A"
1888
"7CFA59CFF7CDBD9A5920"),
1889
"CheckerRunning": False,
1890
"LastEnabled": "2019-01-03T00:00:00",
1891
"ApprovalPending": False,
1892
"ApprovedByDefault": True,
1893
"LastApprovalRequest": "",
1894
"ApprovalDelay": 0,
1895
"ApprovalDuration": 1000,
1896
"Checker": "fping -q -- %(host)s",
1897
"ExtendedTimeout": 900000,
1898
"Expires": "2019-02-04T00:00:00",
1899
"LastCheckerStatus": 0,
1900
},
1901
"barbar": {
1902
"Name": "barbar",
1903
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1904
"6ab612cff5ad227247e46c2b020f441c"),
1905
"Host": "192.0.2.3",
1906
"Enabled": True,
1907
"Timeout": 300000,
1908
"LastCheckedOK": "2019-02-04T00:00:00",
1909
"Created": "2019-01-03T00:00:00",
1910
"Interval": 120000,
1911
"Fingerprint": ("3E393AEAEFB84C7E89E2"
1912
"F547B3A107558FCA3A27"),
1913
"CheckerRunning": True,
1914
"LastEnabled": "2019-01-04T00:00:00",
1915
"ApprovalPending": False,
1916
"ApprovedByDefault": False,
1917
"LastApprovalRequest": "2019-01-03T00:00:00",
1918
"ApprovalDelay": 30000,
1919
"ApprovalDuration": 93785000,
1920
"Checker": ":",
1921
"ExtendedTimeout": 900000,
1922
"Expires": "2019-02-05T00:00:00",
1923
"LastCheckerStatus": -2,
1924
},
1925
}
1926
1927
def test_DumpJSON_normal(self):
1928
with self.capture_stdout_to_buffer() as buffer:
1929
command.DumpJSON().run(self.bus.clients)
1930
json_data = json.loads(buffer.getvalue())
1931
self.assertDictEqual(self.expected_json, json_data)
1932
1933
@staticmethod
1934
@contextlib.contextmanager
1935
def capture_stdout_to_buffer():
1936
capture_buffer = io.StringIO()
1937
old_stdout = sys.stdout
1938
sys.stdout = capture_buffer
1939
try:
1940
yield capture_buffer
1941
finally:
1942
sys.stdout = old_stdout
1943
1944
def test_DumpJSON_one_client(self):
1945
with self.capture_stdout_to_buffer() as buffer:
1946
command.DumpJSON().run(self.bus.one_client)
1947
json_data = json.loads(buffer.getvalue())
1948
expected_json = {"foo": self.expected_json["foo"]}
1949
self.assertDictEqual(expected_json, json_data)
1950
1951
def test_PrintTable_normal(self):
1952
with self.capture_stdout_to_buffer() as buffer:
1953
command.PrintTable().run(self.bus.clients)
1954
expected_output = "\n".join((
1955
"Name Enabled Timeout Last Successful Check",
1956
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1957
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1958
)) + "\n"
1959
self.assertEqual(expected_output, buffer.getvalue())
1960
1961
def test_PrintTable_verbose(self):
1962
with self.capture_stdout_to_buffer() as buffer:
1963
command.PrintTable(verbose=True).run(self.bus.clients)
1964
columns = (
1965
(
1966
"Name ",
1967
"foo ",
1968
"barbar ",
1969
),(
1970
"Enabled ",
1971
"Yes ",
1972
"Yes ",
1973
),(
1974
"Timeout ",
1975
"00:05:00 ",
1976
"00:05:00 ",
1977
),(
1978
"Last Successful Check ",
1979
"2019-02-03T00:00:00 ",
1980
"2019-02-04T00:00:00 ",
1981
),(
1982
"Created ",
1983
"2019-01-02T00:00:00 ",
1984
"2019-01-03T00:00:00 ",
1985
),(
1986
"Interval ",
1987
"00:02:00 ",
1988
"00:02:00 ",
1989
),(
1990
"Host ",
1991
"foo.example.org ",
1992
"192.0.2.3 ",
1993
),(
1994
("Key ID "
1995
" "),
1996
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1997
"ea90a27cddb12 "),
1998
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1999
"46c2b020f441c "),
2000
),(
2001
"Fingerprint ",
2002
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
2003
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
2004
),(
2005
"Check Is Running ",
2006
"No ",
2007
"Yes ",
2008
),(
2009
"Last Enabled ",
2010
"2019-01-03T00:00:00 ",
2011
"2019-01-04T00:00:00 ",
2012
),(
2013
"Approval Is Pending ",
2014
"No ",
2015
"No ",
2016
),(
2017
"Approved By Default ",
2018
"Yes ",
2019
"No ",
2020
),(
2021
"Last Approval Request ",
2022
" ",
2023
"2019-01-03T00:00:00 ",
2024
),(
2025
"Approval Delay ",
2026
"00:00:00 ",
2027
"00:00:30 ",
2028
),(
2029
"Approval Duration ",
2030
"00:00:01 ",
2031
"1T02:03:05 ",
2032
),(
2033
"Checker ",
2034
"fping -q -- %(host)s ",
2035
": ",
2036
),(
2037
"Extended Timeout ",
2038
"00:15:00 ",
2039
"00:15:00 ",
2040
),(
2041
"Expires ",
2042
"2019-02-04T00:00:00 ",
2043
"2019-02-05T00:00:00 ",
2044
),(
2045
"Last Checker Status",
2046
"0 ",
2047
"-2 ",
2048
)
2049
)
2050
num_lines = max(len(rows) for rows in columns)
2051
expected_output = ("\n".join("".join(rows[line]
2052
for rows in columns)
2053
for line in range(num_lines))
2054
+ "\n")
2055
self.assertEqual(expected_output, buffer.getvalue())
2056
2057
def test_PrintTable_one_client(self):
2058
with self.capture_stdout_to_buffer() as buffer:
2059
command.PrintTable().run(self.bus.one_client)
2060
expected_output = "\n".join((
2061
"Name Enabled Timeout Last Successful Check",
2062
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
2063
)) + "\n"
2064
self.assertEqual(expected_output, buffer.getvalue())
2065
2066
2067
class TestPropertySetterCmd(TestCommand):
2068
"""Abstract class for tests of command.PropertySetter classes"""
2069
1059
2070
def runTest(self):
1060
2071
if not hasattr(self, "command"):
1061
return
1062
values_to_get = getattr(self, "values_to_get",
1063
self.values_to_set)
1064
for value_to_set, value_to_get in zip(self.values_to_set,
1065
values_to_get):
1066
for client in self.clients:
1067
old_value = client.attributes[self.property]
1068
self.assertNotIsInstance(old_value, Unique)
1069
client.attributes[self.property] = Unique()
1070
self.run_command(value_to_set, self.clients)
1071
for client in self.clients:
1072
value = client.attributes[self.property]
2072
return # Abstract TestCase class
2073
2074
if hasattr(self, "values_to_set"):
2075
cmd_args = [(value,) for value in self.values_to_set]
2076
values_to_get = getattr(self, "values_to_get",
2077
self.values_to_set)
2078
else:
2079
cmd_args = [() for x in range(len(self.values_to_get))]
2080
values_to_get = self.values_to_get
2081
for value_to_get, cmd_arg in zip(values_to_get, cmd_args):
2082
for clientpath in self.bus.clients:
2083
self.bus.clients[clientpath][self.propname] = (
2084
Unique())
2085
self.command(*cmd_arg).run(self.bus.clients, self.bus)
2086
for clientpath in self.bus.clients:
2087
value = (self.bus.clients[clientpath]
2088
[self.propname])
1073
2089
self.assertNotIsInstance(value, Unique)
1074
self.assertEqual(value, value_to_get)
1075
def run_command(self, value, clients):
1076
self.command().run(None, clients)
1077
1078
class TestBumpTimeoutCmd(TestPropertyCmd):
1079
command = BumpTimeoutCmd
1080
property = "LastCheckedOK"
1081
values_to_set = [""]
1082
1083
class TestStartCheckerCmd(TestPropertyCmd):
1084
command = StartCheckerCmd
1085
property = "CheckerRunning"
1086
values_to_set = [dbus.Boolean(True)]
1087
1088
class TestStopCheckerCmd(TestPropertyCmd):
1089
command = StopCheckerCmd
1090
property = "CheckerRunning"
1091
values_to_set = [dbus.Boolean(False)]
1092
1093
class TestApproveByDefaultCmd(TestPropertyCmd):
1094
command = ApproveByDefaultCmd
1095
property = "ApprovedByDefault"
1096
values_to_set = [dbus.Boolean(True)]
1097
1098
class TestDenyByDefaultCmd(TestPropertyCmd):
1099
command = DenyByDefaultCmd
1100
property = "ApprovedByDefault"
1101
values_to_set = [dbus.Boolean(False)]
1102
1103
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1104
"""Abstract class for tests of PropertyCmd classes using the
1105
ValueArgumentMixIn"""
1106
def runTest(self):
1107
if type(self) is TestValueArgumentPropertyCmd:
1108
return
1109
return super(TestValueArgumentPropertyCmd, self).runTest()
1110
def run_command(self, value, clients):
1111
self.command(value).run(None, clients)
1112
1113
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1114
command = SetCheckerCmd
1115
property = "Checker"
2090
self.assertEqual(value_to_get, value)
2091
2092
2093
class TestEnableCmd(TestPropertySetterCmd):
2094
command = command.Enable
2095
propname = "Enabled"
2096
values_to_get = [True]
2097
2098
2099
class TestDisableCmd(TestPropertySetterCmd):
2100
command = command.Disable
2101
propname = "Enabled"
2102
values_to_get = [False]
2103
2104
2105
class TestBumpTimeoutCmd(TestPropertySetterCmd):
2106
command = command.BumpTimeout
2107
propname = "LastCheckedOK"
2108
values_to_get = [""]
2109
2110
2111
class TestStartCheckerCmd(TestPropertySetterCmd):
2112
command = command.StartChecker
2113
propname = "CheckerRunning"
2114
values_to_get = [True]
2115
2116
2117
class TestStopCheckerCmd(TestPropertySetterCmd):
2118
command = command.StopChecker
2119
propname = "CheckerRunning"
2120
values_to_get = [False]
2121
2122
2123
class TestApproveByDefaultCmd(TestPropertySetterCmd):
2124
command = command.ApproveByDefault
2125
propname = "ApprovedByDefault"
2126
values_to_get = [True]
2127
2128
2129
class TestDenyByDefaultCmd(TestPropertySetterCmd):
2130
command = command.DenyByDefault
2131
propname = "ApprovedByDefault"
2132
values_to_get = [False]
2133
2134
2135
class TestSetCheckerCmd(TestPropertySetterCmd):
2136
command = command.SetChecker
2137
propname = "Checker"
1116
2138
values_to_set = ["", ":", "fping -q -- %s"]
1117
2139
1118
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1119
command = SetHostCmd
1120
property = "Host"
1121
values_to_set = ["192.0.2.3", "foo.example.org"]
1122
1123
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1124
command = SetSecretCmd
1125
property = "Secret"
2140
2141
class TestSetHostCmd(TestPropertySetterCmd):
2142
command = command.SetHost
2143
propname = "Host"
2144
values_to_set = ["192.0.2.3", "client.example.org"]
2145
2146
2147
class TestSetSecretCmd(TestPropertySetterCmd):
2148
command = command.SetSecret
2149
propname = "Secret"
1126
2150
values_to_set = [io.BytesIO(b""),
1127
2151
io.BytesIO(b"secret\0xyzzy\nbar")]
1128
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1129
1130
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1131
command = SetTimeoutCmd
1132
property = "Timeout"
1133
values_to_set = [datetime.timedelta(),
1134
datetime.timedelta(minutes=5),
1135
datetime.timedelta(seconds=1),
1136
datetime.timedelta(weeks=1),
1137
datetime.timedelta(weeks=52)]
1138
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1139
1140
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1141
command = SetExtendedTimeoutCmd
1142
property = "ExtendedTimeout"
1143
values_to_set = [datetime.timedelta(),
1144
datetime.timedelta(minutes=5),
1145
datetime.timedelta(seconds=1),
1146
datetime.timedelta(weeks=1),
1147
datetime.timedelta(weeks=52)]
1148
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1149
1150
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1151
command = SetIntervalCmd
1152
property = "Interval"
1153
values_to_set = [datetime.timedelta(),
1154
datetime.timedelta(minutes=5),
1155
datetime.timedelta(seconds=1),
1156
datetime.timedelta(weeks=1),
1157
datetime.timedelta(weeks=52)]
1158
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1159
1160
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1161
command = SetApprovalDelayCmd
1162
property = "ApprovalDelay"
1163
values_to_set = [datetime.timedelta(),
1164
datetime.timedelta(minutes=5),
1165
datetime.timedelta(seconds=1),
1166
datetime.timedelta(weeks=1),
1167
datetime.timedelta(weeks=52)]
1168
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1169
1170
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1171
command = SetApprovalDurationCmd
1172
property = "ApprovalDuration"
1173
values_to_set = [datetime.timedelta(),
1174
datetime.timedelta(minutes=5),
1175
datetime.timedelta(seconds=1),
1176
datetime.timedelta(weeks=1),
1177
datetime.timedelta(weeks=52)]
1178
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1179
1180
class Test_command_from_options(unittest.TestCase):
1181
def setUp(self):
1182
self.parser = argparse.ArgumentParser()
1183
add_command_line_options(self.parser)
1184
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1185
"""Assert that parsing ARGS should result in an instance of
1186
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1187
options = self.parser.parse_args(args)
1188
check_option_syntax(self.parser, options)
1189
commands = commands_from_options(options)
1190
self.assertEqual(len(commands), 1)
1191
command = commands[0]
1192
self.assertIsInstance(command, command_cls)
1193
for key, value in cmd_attrs.items():
1194
self.assertEqual(getattr(command, key), value)
1195
def test_print_table(self):
1196
self.assert_command_from_args([], PrintTableCmd,
1197
verbose=False)
1198
1199
def test_print_table_verbose(self):
1200
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1201
verbose=True)
1202
1203
def test_print_table_verbose_short(self):
1204
self.assert_command_from_args(["-v"], PrintTableCmd,
1205
verbose=True)
1206
1207
def test_enable(self):
1208
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1209
1210
def test_enable_short(self):
1211
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1212
1213
def test_disable(self):
1214
self.assert_command_from_args(["--disable", "foo"],
1215
DisableCmd)
1216
1217
def test_disable_short(self):
1218
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1219
1220
def test_bump_timeout(self):
1221
self.assert_command_from_args(["--bump-timeout", "foo"],
1222
BumpTimeoutCmd)
1223
1224
def test_bump_timeout_short(self):
1225
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1226
1227
def test_start_checker(self):
1228
self.assert_command_from_args(["--start-checker", "foo"],
1229
StartCheckerCmd)
1230
1231
def test_stop_checker(self):
1232
self.assert_command_from_args(["--stop-checker", "foo"],
1233
StopCheckerCmd)
1234
1235
def test_remove(self):
1236
self.assert_command_from_args(["--remove", "foo"],
1237
RemoveCmd)
1238
1239
def test_remove_short(self):
1240
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1241
1242
def test_checker(self):
1243
self.assert_command_from_args(["--checker", ":", "foo"],
1244
SetCheckerCmd, value_to_set=":")
1245
1246
def test_checker_empty(self):
1247
self.assert_command_from_args(["--checker", "", "foo"],
1248
SetCheckerCmd, value_to_set="")
1249
1250
def test_checker_short(self):
1251
self.assert_command_from_args(["-c", ":", "foo"],
1252
SetCheckerCmd, value_to_set=":")
1253
1254
def test_timeout(self):
1255
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1256
SetTimeoutCmd,
1257
value_to_set=300000)
1258
1259
def test_timeout_short(self):
1260
self.assert_command_from_args(["-t", "PT5M", "foo"],
1261
SetTimeoutCmd,
1262
value_to_set=300000)
1263
1264
def test_extended_timeout(self):
1265
self.assert_command_from_args(["--extended-timeout", "PT15M",
1266
"foo"],
1267
SetExtendedTimeoutCmd,
1268
value_to_set=900000)
1269
1270
def test_interval(self):
1271
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1272
SetIntervalCmd,
1273
value_to_set=120000)
1274
1275
def test_interval_short(self):
1276
self.assert_command_from_args(["-i", "PT2M", "foo"],
1277
SetIntervalCmd,
1278
value_to_set=120000)
1279
1280
def test_approve_by_default(self):
1281
self.assert_command_from_args(["--approve-by-default", "foo"],
1282
ApproveByDefaultCmd)
1283
1284
def test_deny_by_default(self):
1285
self.assert_command_from_args(["--deny-by-default", "foo"],
1286
DenyByDefaultCmd)
1287
1288
def test_approval_delay(self):
1289
self.assert_command_from_args(["--approval-delay", "PT30S",
1290
"foo"], SetApprovalDelayCmd,
1291
value_to_set=30000)
1292
1293
def test_approval_duration(self):
1294
self.assert_command_from_args(["--approval-duration", "PT1S",
1295
"foo"], SetApprovalDurationCmd,
1296
value_to_set=1000)
1297
1298
def test_host(self):
1299
self.assert_command_from_args(["--host", "foo.example.org",
1300
"foo"], SetHostCmd,
1301
value_to_set="foo.example.org")
1302
1303
def test_host_short(self):
1304
self.assert_command_from_args(["-H", "foo.example.org",
1305
"foo"], SetHostCmd,
1306
value_to_set="foo.example.org")
1307
1308
def test_secret_devnull(self):
1309
self.assert_command_from_args(["--secret", os.path.devnull,
1310
"foo"], SetSecretCmd,
1311
value_to_set=b"")
1312
1313
def test_secret_tempfile(self):
1314
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1315
value = b"secret\0xyzzy\nbar"
1316
f.write(value)
1317
f.seek(0)
1318
self.assert_command_from_args(["--secret", f.name,
1319
"foo"], SetSecretCmd,
1320
value_to_set=value)
1321
1322
def test_secret_devnull_short(self):
1323
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1324
SetSecretCmd, value_to_set=b"")
1325
1326
def test_secret_tempfile_short(self):
1327
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1328
value = b"secret\0xyzzy\nbar"
1329
f.write(value)
1330
f.seek(0)
1331
self.assert_command_from_args(["-s", f.name, "foo"],
1332
SetSecretCmd,
1333
value_to_set=value)
1334
1335
def test_approve(self):
1336
self.assert_command_from_args(["--approve", "foo"],
1337
ApproveCmd)
1338
1339
def test_approve_short(self):
1340
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1341
1342
def test_deny(self):
1343
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1344
1345
def test_deny_short(self):
1346
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1347
1348
def test_dump_json(self):
1349
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1350
1351
def test_is_enabled(self):
1352
self.assert_command_from_args(["--is-enabled", "foo"],
1353
IsEnabledCmd)
1354
1355
def test_is_enabled_short(self):
1356
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1357
1358
1359
class Test_check_option_syntax(unittest.TestCase):
1360
# This mostly corresponds to the definition from has_actions() in
1361
# check_option_syntax()
1362
actions = {
1363
# The actual values set here are not that important, but we do
1364
# at least stick to the correct types, even though they are
1365
# never used
1366
"enable": True,
1367
"disable": True,
1368
"bump_timeout": True,
1369
"start_checker": True,
1370
"stop_checker": True,
1371
"is_enabled": True,
1372
"remove": True,
1373
"checker": "x",
1374
"timeout": datetime.timedelta(),
1375
"extended_timeout": datetime.timedelta(),
1376
"interval": datetime.timedelta(),
1377
"approved_by_default": True,
1378
"approval_delay": datetime.timedelta(),
1379
"approval_duration": datetime.timedelta(),
1380
"host": "x",
1381
"secret": io.BytesIO(b"x"),
1382
"approve": True,
1383
"deny": True,
1384
}
1385
1386
def setUp(self):
1387
self.parser = argparse.ArgumentParser()
1388
add_command_line_options(self.parser)
1389
1390
@contextlib.contextmanager
1391
def assertParseError(self):
1392
with self.assertRaises(SystemExit) as e:
1393
with self.temporarily_suppress_stderr():
1394
yield
1395
# Exit code from argparse is guaranteed to be "2". Reference:
1396
# https://docs.python.org/3/library/argparse.html#exiting-methods
1397
self.assertEqual(e.exception.code, 2)
1398
1399
@staticmethod
1400
@contextlib.contextmanager
1401
def temporarily_suppress_stderr():
1402
null = os.open(os.path.devnull, os.O_RDWR)
1403
stderrcopy = os.dup(sys.stderr.fileno())
1404
os.dup2(null, sys.stderr.fileno())
1405
os.close(null)
1406
try:
1407
yield
1408
finally:
1409
# restore stderr
1410
os.dup2(stderrcopy, sys.stderr.fileno())
1411
os.close(stderrcopy)
1412
1413
def check_option_syntax(self, options):
1414
check_option_syntax(self.parser, options)
1415
1416
def test_actions_requires_client_or_all(self):
1417
for action, value in self.actions.items():
1418
options = self.parser.parse_args()
1419
setattr(options, action, value)
1420
with self.assertParseError():
1421
self.check_option_syntax(options)
1422
1423
def test_actions_conflicts_with_verbose(self):
1424
for action, value in self.actions.items():
1425
options = self.parser.parse_args()
1426
setattr(options, action, value)
1427
options.verbose = True
1428
with self.assertParseError():
1429
self.check_option_syntax(options)
1430
1431
def test_dump_json_conflicts_with_verbose(self):
1432
options = self.parser.parse_args()
1433
options.dump_json = True
1434
options.verbose = True
1435
with self.assertParseError():
1436
self.check_option_syntax(options)
1437
1438
def test_dump_json_conflicts_with_action(self):
1439
for action, value in self.actions.items():
1440
options = self.parser.parse_args()
1441
setattr(options, action, value)
1442
options.dump_json = True
1443
with self.assertParseError():
1444
self.check_option_syntax(options)
1445
1446
def test_all_can_not_be_alone(self):
1447
options = self.parser.parse_args()
1448
options.all = True
1449
with self.assertParseError():
1450
self.check_option_syntax(options)
1451
1452
def test_all_is_ok_with_any_action(self):
1453
for action, value in self.actions.items():
1454
options = self.parser.parse_args()
1455
setattr(options, action, value)
1456
options.all = True
1457
self.check_option_syntax(options)
1458
1459
def test_is_enabled_fails_without_client(self):
1460
options = self.parser.parse_args()
1461
options.is_enabled = True
1462
with self.assertParseError():
1463
self.check_option_syntax(options)
1464
1465
def test_is_enabled_works_with_one_client(self):
1466
options = self.parser.parse_args()
1467
options.is_enabled = True
1468
options.client = ["foo"]
1469
self.check_option_syntax(options)
1470
1471
def test_is_enabled_fails_with_two_clients(self):
1472
options = self.parser.parse_args()
1473
options.is_enabled = True
1474
options.client = ["foo", "barbar"]
1475
with self.assertParseError():
1476
self.check_option_syntax(options)
2152
values_to_get = [f.getvalue() for f in values_to_set]
2153
2154
2155
class TestSetTimeoutCmd(TestPropertySetterCmd):
2156
command = command.SetTimeout
2157
propname = "Timeout"
2158
values_to_set = [datetime.timedelta(),
2159
datetime.timedelta(minutes=5),
2160
datetime.timedelta(seconds=1),
2161
datetime.timedelta(weeks=1),
2162
datetime.timedelta(weeks=52)]
2163
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2164
2165
2166
class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):
2167
command = command.SetExtendedTimeout
2168
propname = "ExtendedTimeout"
2169
values_to_set = [datetime.timedelta(),
2170
datetime.timedelta(minutes=5),
2171
datetime.timedelta(seconds=1),
2172
datetime.timedelta(weeks=1),
2173
datetime.timedelta(weeks=52)]
2174
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2175
2176
2177
class TestSetIntervalCmd(TestPropertySetterCmd):
2178
command = command.SetInterval
2179
propname = "Interval"
2180
values_to_set = [datetime.timedelta(),
2181
datetime.timedelta(minutes=5),
2182
datetime.timedelta(seconds=1),
2183
datetime.timedelta(weeks=1),
2184
datetime.timedelta(weeks=52)]
2185
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2186
2187
2188
class TestSetApprovalDelayCmd(TestPropertySetterCmd):
2189
command = command.SetApprovalDelay
2190
propname = "ApprovalDelay"
2191
values_to_set = [datetime.timedelta(),
2192
datetime.timedelta(minutes=5),
2193
datetime.timedelta(seconds=1),
2194
datetime.timedelta(weeks=1),
2195
datetime.timedelta(weeks=52)]
2196
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2197
2198
2199
class TestSetApprovalDurationCmd(TestPropertySetterCmd):
2200
command = command.SetApprovalDuration
2201
propname = "ApprovalDuration"
2202
values_to_set = [datetime.timedelta(),
2203
datetime.timedelta(minutes=5),
2204
datetime.timedelta(seconds=1),
2205
datetime.timedelta(weeks=1),
2206
datetime.timedelta(weeks=52)]
2207
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1477
2208
1478
2209
1479
2210
1494
2225
return tests
1495
2226
1496
2227
if __name__ == "__main__":
1497
if should_only_run_tests():
1498
# Call using ./tdd-python-script --check [--verbose]
1499
unittest.main()
1500
else:
1501
main()
2228
try:
2229
if should_only_run_tests():
2230
# Call using ./tdd-python-script --check [--verbose]
2231
unittest.main()
2232
else:
2233
main()
2234
finally:
2235
logging.shutdown()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0