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