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