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