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; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-
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
#
46
46
import tempfile
47
47
import contextlib
48
48
49
import dbus
49
if sys.version_info.major == 2:
50
__metaclass__ = type
51
str = unicode
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
50
74
51
75
# Show warnings by default
52
76
if not sys.warnoptions:
60
84
logging.captureWarnings(True) # Show warnings via the logging system
61
85
62
86
if sys.version_info.major == 2:
63
str = unicode
87
import StringIO
88
io.StringIO = StringIO.StringIO
64
89
65
90
locale.setlocale(locale.LC_ALL, "")
66
91
67
dbus_busname_domain = "se.recompile"
68
dbus_busname = dbus_busname_domain + ".Mandos"
69
server_dbus_path = "/"
70
server_dbus_interface = dbus_busname_domain + ".Mandos"
71
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
72
del dbus_busname_domain
73
version = "1.8.3"
74
75
76
try:
77
dbus.OBJECT_MANAGER_IFACE
78
except AttributeError:
79
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
92
version = "1.8.9"
80
93
81
94
82
95
def main():
83
96
parser = argparse.ArgumentParser()
84
85
97
add_command_line_options(parser)
86
98
87
99
options = parser.parse_args()
88
89
100
check_option_syntax(parser, options)
90
101
91
102
clientnames = options.client
93
104
if options.debug:
94
105
log.setLevel(logging.DEBUG)
95
106
96
try:
97
bus = dbus.SystemBus()
98
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
99
dbus_busname, server_dbus_path)
100
mandos_dbus_objc = bus.get_object(dbus_busname,
101
server_dbus_path)
102
except dbus.exceptions.DBusException:
103
log.critical("Could not connect to Mandos server")
104
sys.exit(1)
105
106
mandos_serv = dbus.Interface(mandos_dbus_objc,
107
dbus_interface=server_dbus_interface)
108
mandos_serv_object_manager = dbus.Interface(
109
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
110
111
# Filter out log message from dbus module
112
dbus_logger = logging.getLogger("dbus.proxies")
113
class NullFilter(logging.Filter):
114
def filter(self, record):
115
return False
116
dbus_filter = NullFilter()
117
try:
118
dbus_logger.addFilter(dbus_filter)
119
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
120
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
121
mandos_clients = {path: ifs_and_props[client_dbus_interface]
122
for path, ifs_and_props in
123
mandos_serv_object_manager
124
.GetManagedObjects().items()
125
if client_dbus_interface in ifs_and_props}
126
except dbus.exceptions.DBusException as e:
127
log.critical("Failed to access Mandos server through D-Bus:"
128
"\n%s", e)
129
sys.exit(1)
130
finally:
131
# restore dbus logger
132
dbus_logger.removeFilter(dbus_filter)
133
134
# Compile dict of (clients: properties) to process
135
clients = {}
136
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
137
125
if not clientnames:
138
clients = {objpath: properties
139
for objpath, properties in mandos_clients.items()}
126
clients = all_clients
140
127
else:
128
clients = {}
141
129
for name in clientnames:
142
for objpath, properties in mandos_clients.items():
130
for objpath, properties in all_clients.items():
143
131
if properties["Name"] == name:
144
132
clients[objpath] = properties
145
133
break
147
135
log.critical("Client not found on server: %r", name)
148
136
sys.exit(1)
149
137
150
# Run all commands on clients
151
138
commands = commands_from_options(options)
139
152
140
for command in commands:
153
command.run(clients, bus, mandos_serv)
141
command.run(clients, bus)
154
142
155
143
156
144
def add_command_line_options(parser):
161
149
help="Select all clients")
162
150
parser.add_argument("-v", "--verbose", action="store_true",
163
151
help="Print all fields")
164
parser.add_argument("-j", "--dump-json", action="store_true",
152
parser.add_argument("-j", "--dump-json", dest="commands",
153
action="append_const", default=[],
154
const=command.DumpJSON(),
165
155
help="Dump client data in JSON format")
166
156
enable_disable = parser.add_mutually_exclusive_group()
167
enable_disable.add_argument("-e", "--enable", action="store_true",
157
enable_disable.add_argument("-e", "--enable", dest="commands",
158
action="append_const", default=[],
159
const=command.Enable(),
168
160
help="Enable client")
169
enable_disable.add_argument("-d", "--disable",
170
action="store_true",
161
enable_disable.add_argument("-d", "--disable", dest="commands",
162
action="append_const", default=[],
163
const=command.Disable(),
171
164
help="disable client")
172
parser.add_argument("-b", "--bump-timeout", action="store_true",
165
parser.add_argument("-b", "--bump-timeout", dest="commands",
166
action="append_const", default=[],
167
const=command.BumpTimeout(),
173
168
help="Bump timeout for client")
174
169
start_stop_checker = parser.add_mutually_exclusive_group()
175
170
start_stop_checker.add_argument("--start-checker",
176
action="store_true",
171
dest="commands",
172
action="append_const", default=[],
173
const=command.StartChecker(),
177
174
help="Start checker for client")
178
start_stop_checker.add_argument("--stop-checker",
179
action="store_true",
175
start_stop_checker.add_argument("--stop-checker", dest="commands",
176
action="append_const", default=[],
177
const=command.StopChecker(),
180
178
help="Stop checker for client")
181
parser.add_argument("-V", "--is-enabled", action="store_true",
179
parser.add_argument("-V", "--is-enabled", dest="commands",
180
action="append_const", default=[],
181
const=command.IsEnabled(),
182
182
help="Check if client is enabled")
183
parser.add_argument("-r", "--remove", action="store_true",
183
parser.add_argument("-r", "--remove", dest="commands",
184
action="append_const", default=[],
185
const=command.Remove(),
184
186
help="Remove client")
185
parser.add_argument("-c", "--checker",
187
parser.add_argument("-c", "--checker", dest="commands",
188
action="append", default=[],
189
metavar="COMMAND", type=command.SetChecker,
186
190
help="Set checker command for client")
187
parser.add_argument("-t", "--timeout", type=string_to_delta,
188
help="Set timeout for client")
189
parser.add_argument("--extended-timeout", type=string_to_delta,
190
help="Set extended timeout for client")
191
parser.add_argument("-i", "--interval", type=string_to_delta,
192
help="Set checker interval 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")
193
206
approve_deny_default = parser.add_mutually_exclusive_group()
194
207
approve_deny_default.add_argument(
195
"--approve-by-default", action="store_true",
196
default=None, dest="approved_by_default",
208
"--approve-by-default", dest="commands",
209
action="append_const", default=[],
210
const=command.ApproveByDefault(),
197
211
help="Set client to be approved by default")
198
212
approve_deny_default.add_argument(
199
"--deny-by-default", action="store_false",
200
dest="approved_by_default",
213
"--deny-by-default", dest="commands",
214
action="append_const", default=[],
215
const=command.DenyByDefault(),
201
216
help="Set client to be denied by default")
202
parser.add_argument("--approval-delay", type=string_to_delta,
203
help="Set delay before client approve/deny")
204
parser.add_argument("--approval-duration", type=string_to_delta,
205
help="Set duration of one client approval")
206
parser.add_argument("-H", "--host", help="Set host for client")
207
parser.add_argument("-s", "--secret",
208
type=argparse.FileType(mode="rb"),
209
help="Set password blob (file) for client")
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")
210
236
approve_deny = parser.add_mutually_exclusive_group()
211
237
approve_deny.add_argument(
212
"-A", "--approve", action="store_true",
238
"-A", "--approve", dest="commands", action="append_const",
239
default=[], const=command.Approve(),
213
240
help="Approve any current client request")
214
approve_deny.add_argument("-D", "--deny", action="store_true",
241
approve_deny.add_argument("-D", "--deny", dest="commands",
242
action="append_const", default=[],
243
const=command.Deny(),
215
244
help="Deny any current client request")
216
245
parser.add_argument("--debug", action="store_true",
217
246
help="Debug mode (show D-Bus commands)")
234
263
def rfc3339_duration_to_delta(duration):
235
264
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
236
265
237
>>> rfc3339_duration_to_delta("P7D")
238
datetime.timedelta(7)
239
>>> rfc3339_duration_to_delta("PT60S")
240
datetime.timedelta(0, 60)
241
>>> rfc3339_duration_to_delta("PT60M")
242
datetime.timedelta(0, 3600)
243
>>> rfc3339_duration_to_delta("P60M")
244
datetime.timedelta(1680)
245
>>> rfc3339_duration_to_delta("PT24H")
246
datetime.timedelta(1)
247
>>> rfc3339_duration_to_delta("P1W")
248
datetime.timedelta(7)
249
>>> rfc3339_duration_to_delta("PT5M30S")
250
datetime.timedelta(0, 330)
251
>>> rfc3339_duration_to_delta("P1DT3M20S")
252
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
253
283
>>> # Can not be empty:
254
284
>>> rfc3339_duration_to_delta("")
255
285
Traceback (most recent call last):
256
286
...
257
ValueError: Invalid RFC 3339 duration: u''
287
ValueError: Invalid RFC 3339 duration: ""
258
288
>>> # Must start with "P":
259
289
>>> rfc3339_duration_to_delta("1D")
260
290
Traceback (most recent call last):
261
291
...
262
ValueError: Invalid RFC 3339 duration: u'1D'
292
ValueError: Invalid RFC 3339 duration: "1D"
263
293
>>> # Must use correct order
264
294
>>> rfc3339_duration_to_delta("PT1S2M")
265
295
Traceback (most recent call last):
266
296
...
267
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
297
ValueError: Invalid RFC 3339 duration: "PT1S2M"
268
298
>>> # Time needs time marker
269
299
>>> rfc3339_duration_to_delta("P1H2S")
270
300
Traceback (most recent call last):
271
301
...
272
ValueError: Invalid RFC 3339 duration: u'P1H2S'
302
ValueError: Invalid RFC 3339 duration: "P1H2S"
273
303
>>> # Weeks can not be combined with anything else
274
304
>>> rfc3339_duration_to_delta("P1D2W")
275
305
Traceback (most recent call last):
276
306
...
277
ValueError: Invalid RFC 3339 duration: u'P1D2W'
307
ValueError: Invalid RFC 3339 duration: "P1D2W"
278
308
>>> rfc3339_duration_to_delta("P2W2H")
279
309
Traceback (most recent call last):
280
310
...
281
ValueError: Invalid RFC 3339 duration: u'P2W2H'
311
ValueError: Invalid RFC 3339 duration: "P2W2H"
282
312
"""
283
313
284
314
# Parsing an RFC 3339 duration with regular expressions is not
355
385
break
356
386
else:
357
387
# No currently valid tokens were found
358
raise ValueError("Invalid RFC 3339 duration: {!r}"
388
raise ValueError("Invalid RFC 3339 duration: \"{}\""
359
389
.format(duration))
360
390
# End token found
361
391
return value
365
395
"""Parse an interval string as documented by Mandos before 1.6.1,
366
396
and return a datetime.timedelta
367
397
368
>>> parse_pre_1_6_1_interval('7d')
369
datetime.timedelta(7)
370
>>> parse_pre_1_6_1_interval('60s')
371
datetime.timedelta(0, 60)
372
>>> parse_pre_1_6_1_interval('60m')
373
datetime.timedelta(0, 3600)
374
>>> parse_pre_1_6_1_interval('24h')
375
datetime.timedelta(1)
376
>>> parse_pre_1_6_1_interval('1w')
377
datetime.timedelta(7)
378
>>> parse_pre_1_6_1_interval('5m 30s')
379
datetime.timedelta(0, 330)
380
>>> parse_pre_1_6_1_interval('')
381
datetime.timedelta(0)
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
382
412
>>> # Ignore unknown characters, allow any order and repetitions
383
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
384
datetime.timedelta(2, 480, 18000)
413
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m') == datetime.timedelta(2, 480, 18000)
414
True
385
415
386
416
"""
387
417
408
438
"""Apply additional restrictions on options, not expressible in
409
439
argparse"""
410
440
411
def has_actions(options):
412
return any((options.enable,
413
options.disable,
414
options.bump_timeout,
415
options.start_checker,
416
options.stop_checker,
417
options.is_enabled,
418
options.remove,
419
options.checker is not None,
420
options.timeout is not None,
421
options.extended_timeout is not None,
422
options.interval is not None,
423
options.approved_by_default is not None,
424
options.approval_delay is not None,
425
options.approval_duration is not None,
426
options.host is not None,
427
options.secret is not None,
428
options.approve,
429
options.deny))
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)
430
464
431
if has_actions(options) and not (options.client or options.all):
465
if has_commands(options) and not (options.client or options.all):
432
466
parser.error("Options require clients names or --all.")
433
if options.verbose and has_actions(options):
467
if options.verbose and has_commands(options):
434
468
parser.error("--verbose can only be used alone.")
435
if options.dump_json and (options.verbose
436
or has_actions(options)):
469
if (has_commands(options, (command.DumpJSON,))
470
and (options.verbose or len(options.commands) > 1)):
437
471
parser.error("--dump-json can only be used alone.")
438
if options.all and not has_actions(options):
472
if options.all and not has_commands(options):
439
473
parser.error("--all requires an action.")
440
if options.is_enabled and len(options.client) > 1:
474
if (has_commands(options, (command.IsEnabled,))
475
and len(options.client) > 1):
441
476
parser.error("--is-enabled requires exactly one client")
442
if options.remove:
443
options.remove = False
444
if has_actions(options) and not options.deny:
445
parser.error("--remove can only be combined with --deny")
446
options.remove = True
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
447
780
448
781
449
782
def commands_from_options(options):
450
783
451
commands = []
452
453
if options.is_enabled:
454
commands.append(IsEnabledCmd())
455
456
if options.approve:
457
commands.append(ApproveCmd())
458
459
if options.deny:
460
commands.append(DenyCmd())
461
462
if options.remove:
463
commands.append(RemoveCmd())
464
465
if options.dump_json:
466
commands.append(DumpJSONCmd())
467
468
if options.enable:
469
commands.append(EnableCmd())
470
471
if options.disable:
472
commands.append(DisableCmd())
473
474
if options.bump_timeout:
475
commands.append(BumpTimeoutCmd())
476
477
if options.start_checker:
478
commands.append(StartCheckerCmd())
479
480
if options.stop_checker:
481
commands.append(StopCheckerCmd())
482
483
if options.approved_by_default is not None:
484
if options.approved_by_default:
485
commands.append(ApproveByDefaultCmd())
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)
486
802
else:
487
commands.append(DenyByDefaultCmd())
488
489
if options.checker is not None:
490
commands.append(SetCheckerCmd(options.checker))
491
492
if options.host is not None:
493
commands.append(SetHostCmd(options.host))
494
495
if options.secret is not None:
496
commands.append(SetSecretCmd(options.secret))
497
498
if options.timeout is not None:
499
commands.append(SetTimeoutCmd(options.timeout))
500
501
if options.extended_timeout:
502
commands.append(
503
SetExtendedTimeoutCmd(options.extended_timeout))
504
505
if options.interval is not None:
506
commands.append(SetIntervalCmd(options.interval))
507
508
if options.approval_delay is not None:
509
commands.append(SetApprovalDelayCmd(options.approval_delay))
510
511
if options.approval_duration is not None:
512
commands.append(
513
SetApprovalDurationCmd(options.approval_duration))
803
cleaned_after.append(cmd)
804
if cleaned_after != after_remove:
805
commands = before_remove + cleaned_after
514
806
515
807
# If no command option has been given, show table of clients,
516
808
# optionally verbosely
517
809
if not commands:
518
commands.append(PrintTableCmd(verbose=options.verbose))
810
commands.append(command.PrintTable(verbose=options.verbose))
519
811
520
812
return commands
521
813
522
814
523
class Command(object):
524
"""Abstract class for commands"""
525
def run(self, clients, bus=None, mandos=None):
526
"""Normal commands should implement run_on_one_client(), but
527
commands which want to operate on all clients at the same time
528
can override this run() method instead."""
529
self.mandos = mandos
530
for clientpath, properties in clients.items():
531
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
532
dbus_busname, str(clientpath))
533
client = bus.get_object(dbus_busname, clientpath)
534
self.run_on_one_client(client, properties)
535
536
537
class IsEnabledCmd(Command):
538
def run(self, clients, bus=None, mandos=None):
539
client, properties = next(iter(clients.items()))
540
if self.is_enabled(client, properties):
541
sys.exit(0)
542
sys.exit(1)
543
def is_enabled(self, client, properties):
544
return properties["Enabled"]
545
546
547
class ApproveCmd(Command):
548
def run_on_one_client(self, client, properties):
549
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
550
client.__dbus_object_path__, client_dbus_interface)
551
client.Approve(dbus.Boolean(True),
552
dbus_interface=client_dbus_interface)
553
554
555
class DenyCmd(Command):
556
def run_on_one_client(self, client, properties):
557
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
558
client.__dbus_object_path__, client_dbus_interface)
559
client.Approve(dbus.Boolean(False),
560
dbus_interface=client_dbus_interface)
561
562
563
class RemoveCmd(Command):
564
def run_on_one_client(self, client, properties):
565
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,
566
server_dbus_path, server_dbus_interface,
567
str(client.__dbus_object_path__))
568
self.mandos.RemoveClient(client.__dbus_object_path__)
569
570
571
class OutputCmd(Command):
572
"""Abstract class for commands outputting client details"""
573
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
574
"Created", "Interval", "Host", "KeyID",
575
"Fingerprint", "CheckerRunning", "LastEnabled",
576
"ApprovalPending", "ApprovedByDefault",
577
"LastApprovalRequest", "ApprovalDelay",
578
"ApprovalDuration", "Checker", "ExtendedTimeout",
579
"Expires", "LastCheckerStatus")
580
581
def run(self, clients, bus=None, mandos=None):
582
print(self.output(clients.values()))
583
584
def output(self, clients):
585
raise NotImplementedError()
586
587
588
class DumpJSONCmd(OutputCmd):
589
def output(self, clients):
590
data = {client["Name"]:
591
{key: self.dbus_boolean_to_bool(client[key])
592
for key in self.all_keywords}
593
for client in clients}
594
return json.dumps(data, indent=4, separators=(',', ': '))
595
596
@staticmethod
597
def dbus_boolean_to_bool(value):
598
if isinstance(value, dbus.Boolean):
599
value = bool(value)
600
return value
601
602
603
class PrintTableCmd(OutputCmd):
604
def __init__(self, verbose=False):
605
self.verbose = verbose
606
607
def output(self, clients):
608
default_keywords = ("Name", "Enabled", "Timeout",
609
"LastCheckedOK")
610
keywords = default_keywords
611
if self.verbose:
612
keywords = self.all_keywords
613
return str(self.TableOfClients(clients, keywords))
614
615
class TableOfClients(object):
616
tableheaders = {
617
"Name": "Name",
618
"Enabled": "Enabled",
619
"Timeout": "Timeout",
620
"LastCheckedOK": "Last Successful Check",
621
"LastApprovalRequest": "Last Approval Request",
622
"Created": "Created",
623
"Interval": "Interval",
624
"Host": "Host",
625
"Fingerprint": "Fingerprint",
626
"KeyID": "Key ID",
627
"CheckerRunning": "Check Is Running",
628
"LastEnabled": "Last Enabled",
629
"ApprovalPending": "Approval Is Pending",
630
"ApprovedByDefault": "Approved By Default",
631
"ApprovalDelay": "Approval Delay",
632
"ApprovalDuration": "Approval Duration",
633
"Checker": "Checker",
634
"ExtendedTimeout": "Extended Timeout",
635
"Expires": "Expires",
636
"LastCheckerStatus": "Last Checker Status",
637
}
638
639
def __init__(self, clients, keywords):
640
self.clients = clients
641
self.keywords = keywords
642
643
def __str__(self):
644
return "\n".join(self.rows())
645
646
if sys.version_info.major == 2:
647
__unicode__ = __str__
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",
857
"Created", "Interval", "Host", "KeyID",
858
"Fingerprint", "CheckerRunning",
859
"LastEnabled", "ApprovalPending",
860
"ApprovedByDefault", "LastApprovalRequest",
861
"ApprovalDelay", "ApprovalDuration",
862
"Checker", "ExtendedTimeout", "Expires",
863
"LastCheckerStatus")
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
648
915
def __str__(self):
649
return str(self).encode(locale.getpreferredencoding())
650
651
def rows(self):
652
format_string = self.row_formatting_string()
653
rows = [self.header_line(format_string)]
654
rows.extend(self.client_line(client, format_string)
655
for client in self.clients)
656
return rows
657
658
def row_formatting_string(self):
659
"Format string used to format table rows"
660
return " ".join("{{{key}:{width}}}".format(
661
width=max(len(self.tableheaders[key]),
662
*(len(self.string_from_client(client, key))
663
for client in self.clients)),
664
key=key)
665
for key in self.keywords)
666
667
def string_from_client(self, client, key):
668
return self.valuetostring(client[key], key)
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
669
1025
670
1026
@classmethod
671
def valuetostring(cls, value, keyword):
672
if isinstance(value, dbus.Boolean):
673
return "Yes" if value else "No"
674
if keyword in ("Timeout", "Interval", "ApprovalDelay",
675
"ApprovalDuration", "ExtendedTimeout"):
676
return cls.milliseconds_to_string(value)
677
return str(value)
678
679
def header_line(self, format_string):
680
return format_string.format(**self.tableheaders)
681
682
def client_line(self, client, format_string):
683
return format_string.format(
684
**{key: self.string_from_client(client, key)
685
for key in self.keywords})
686
687
@staticmethod
688
def milliseconds_to_string(ms):
689
td = datetime.timedelta(0, 0, 0, ms)
690
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
691
.format(days="{}T".format(td.days)
692
if td.days else "",
693
hours=td.seconds // 3600,
694
minutes=(td.seconds % 3600) // 60,
695
seconds=td.seconds % 60))
696
697
698
class PropertyCmd(Command):
699
"""Abstract class for Actions for setting one client property"""
700
701
def run_on_one_client(self, client, properties):
702
"""Set the Client's D-Bus property"""
703
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
704
client.__dbus_object_path__,
705
dbus.PROPERTIES_IFACE, client_dbus_interface,
706
self.propname, self.value_to_set
707
if not isinstance(self.value_to_set, dbus.Boolean)
708
else bool(self.value_to_set))
709
client.Set(client_dbus_interface, self.propname,
710
self.value_to_set,
711
dbus_interface=dbus.PROPERTIES_IFACE)
712
713
@property
714
def propname(self):
715
raise NotImplementedError()
716
717
718
class EnableCmd(PropertyCmd):
719
propname = "Enabled"
720
value_to_set = dbus.Boolean(True)
721
722
723
class DisableCmd(PropertyCmd):
724
propname = "Enabled"
725
value_to_set = dbus.Boolean(False)
726
727
728
class BumpTimeoutCmd(PropertyCmd):
729
propname = "LastCheckedOK"
730
value_to_set = ""
731
732
733
class StartCheckerCmd(PropertyCmd):
734
propname = "CheckerRunning"
735
value_to_set = dbus.Boolean(True)
736
737
738
class StopCheckerCmd(PropertyCmd):
739
propname = "CheckerRunning"
740
value_to_set = dbus.Boolean(False)
741
742
743
class ApproveByDefaultCmd(PropertyCmd):
744
propname = "ApprovedByDefault"
745
value_to_set = dbus.Boolean(True)
746
747
748
class DenyByDefaultCmd(PropertyCmd):
749
propname = "ApprovedByDefault"
750
value_to_set = dbus.Boolean(False)
751
752
753
class PropertyValueCmd(PropertyCmd):
754
"""Abstract class for PropertyCmd recieving a value as argument"""
755
def __init__(self, value):
756
self.value_to_set = value
757
758
759
class SetCheckerCmd(PropertyValueCmd):
760
propname = "Checker"
761
762
763
class SetHostCmd(PropertyValueCmd):
764
propname = "Host"
765
766
767
class SetSecretCmd(PropertyValueCmd):
768
propname = "Secret"
769
770
@property
771
def value_to_set(self):
772
return self._vts
773
774
@value_to_set.setter
775
def value_to_set(self, value):
776
"""When setting, read data from supplied file object"""
777
self._vts = value.read()
778
value.close()
779
780
781
class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):
782
"""Abstract class for PropertyValueCmd taking a value argument as
783
a datetime.timedelta() but should store it as milliseconds."""
784
785
@property
786
def value_to_set(self):
787
return self._vts
788
789
@value_to_set.setter
790
def value_to_set(self, value):
791
"""When setting, convert value from a datetime.timedelta"""
792
self._vts = int(round(value.total_seconds() * 1000))
793
794
795
class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
796
propname = "Timeout"
797
798
799
class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
800
propname = "ExtendedTimeout"
801
802
803
class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):
804
propname = "Interval"
805
806
807
class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):
808
propname = "ApprovalDelay"
809
810
811
class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):
812
propname = "ApprovalDuration"
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"
813
1087
814
1088
815
1089
816
class Test_string_to_delta(unittest.TestCase):
817
def test_handles_basic_rfc3339(self):
818
self.assertEqual(string_to_delta("PT0S"),
819
datetime.timedelta())
820
self.assertEqual(string_to_delta("P0D"),
821
datetime.timedelta())
822
self.assertEqual(string_to_delta("PT1S"),
823
datetime.timedelta(0, 1))
824
self.assertEqual(string_to_delta("PT2H"),
825
datetime.timedelta(0, 7200))
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"))
826
1148
827
1149
def test_falls_back_to_pre_1_6_1_with_warning(self):
828
# assertLogs only exists in Python 3.4
829
if hasattr(self, "assertLogs"):
830
with self.assertLogs(log, logging.WARNING):
831
value = string_to_delta("2h")
832
else:
833
class WarningFilter(logging.Filter):
834
"""Don't show, but record the presence of, warnings"""
835
def filter(self, record):
836
is_warning = record.levelno >= logging.WARNING
837
self.found = is_warning or getattr(self, "found",
838
False)
839
return not is_warning
840
warning_filter = WarningFilter()
841
log.addFilter(warning_filter)
842
try:
843
value = string_to_delta("2h")
844
finally:
845
log.removeFilter(warning_filter)
846
self.assertTrue(getattr(warning_filter, "found", False))
847
self.assertEqual(value, datetime.timedelta(0, 7200))
1150
with self.assertLogs(log, logging.WARNING):
1151
value = string_to_delta("2h")
1152
self.assertEqual(datetime.timedelta(0, 7200), value)
848
1153
849
1154
850
1155
class Test_check_option_syntax(unittest.TestCase):
854
1159
855
1160
def test_actions_requires_client_or_all(self):
856
1161
for action, value in self.actions.items():
857
options = self.parser.parse_args()
858
setattr(options, action, value)
1162
args = self.actionargs(action, value)
859
1163
with self.assertParseError():
860
self.check_option_syntax(options)
1164
self.parse_args(args)
861
1165
862
# This mostly corresponds to the definition from has_actions() in
1166
# This mostly corresponds to the definition from has_commands() in
863
1167
# check_option_syntax()
864
1168
actions = {
865
# The actual values set here are not that important, but we do
866
# at least stick to the correct types, even though they are
867
# never used
868
"enable": True,
869
"disable": True,
870
"bump_timeout": True,
871
"start_checker": True,
872
"stop_checker": True,
873
"is_enabled": True,
874
"remove": True,
875
"checker": "x",
876
"timeout": datetime.timedelta(),
877
"extended_timeout": datetime.timedelta(),
878
"interval": datetime.timedelta(),
879
"approved_by_default": True,
880
"approval_delay": datetime.timedelta(),
881
"approval_duration": datetime.timedelta(),
882
"host": "x",
883
"secret": io.BytesIO(b"x"),
884
"approve": True,
885
"deny": True,
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,
886
1188
}
887
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
888
1197
@contextlib.contextmanager
889
1198
def assertParseError(self):
890
1199
with self.assertRaises(SystemExit) as e:
891
with self.temporarily_suppress_stderr():
1200
with self.redirect_stderr_to_devnull():
892
1201
yield
893
1202
# Exit code from argparse is guaranteed to be "2". Reference:
894
1203
# https://docs.python.org/3/library
895
1204
# /argparse.html#exiting-methods
896
self.assertEqual(e.exception.code, 2)
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)
897
1210
898
1211
@staticmethod
899
1212
@contextlib.contextmanager
900
def temporarily_suppress_stderr():
901
null = os.open(os.path.devnull, os.O_RDWR)
902
stderrcopy = os.dup(sys.stderr.fileno())
903
os.dup2(null, sys.stderr.fileno())
904
os.close(null)
905
try:
906
yield
907
finally:
908
# restore stderr
909
os.dup2(stderrcopy, sys.stderr.fileno())
910
os.close(stderrcopy)
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
911
1221
912
1222
def check_option_syntax(self, options):
913
1223
check_option_syntax(self.parser, options)
914
1224
915
def test_actions_conflicts_with_verbose(self):
916
for action, value in self.actions.items():
917
options = self.parser.parse_args()
918
setattr(options, action, value)
919
options.verbose = True
920
with self.assertParseError():
921
self.check_option_syntax(options)
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)
922
1238
923
1239
def test_dump_json_conflicts_with_verbose(self):
924
options = self.parser.parse_args()
925
options.dump_json = True
926
options.verbose = True
1240
args = ["--dump-json", "--verbose"]
927
1241
with self.assertParseError():
928
self.check_option_syntax(options)
1242
self.parse_args(args)
929
1243
930
1244
def test_dump_json_conflicts_with_action(self):
931
1245
for action, value in self.actions.items():
932
options = self.parser.parse_args()
933
setattr(options, action, value)
934
options.dump_json = True
1246
args = self.actionargs(action, value, "--dump-json")
935
1247
with self.assertParseError():
936
self.check_option_syntax(options)
1248
self.parse_args(args)
937
1249
938
1250
def test_all_can_not_be_alone(self):
939
options = self.parser.parse_args()
940
options.all = True
1251
args = ["--all"]
941
1252
with self.assertParseError():
942
self.check_option_syntax(options)
1253
self.parse_args(args)
943
1254
944
1255
def test_all_is_ok_with_any_action(self):
945
1256
for action, value in self.actions.items():
946
options = self.parser.parse_args()
947
setattr(options, action, value)
948
options.all = True
949
self.check_option_syntax(options)
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)
950
1287
951
1288
def test_is_enabled_fails_without_client(self):
952
options = self.parser.parse_args()
953
options.is_enabled = True
1289
args = ["--is-enabled"]
954
1290
with self.assertParseError():
955
self.check_option_syntax(options)
956
957
def test_is_enabled_works_with_one_client(self):
958
options = self.parser.parse_args()
959
options.is_enabled = True
960
options.client = ["foo"]
961
self.check_option_syntax(options)
1291
self.parse_args(args)
962
1292
963
1293
def test_is_enabled_fails_with_two_clients(self):
964
options = self.parser.parse_args()
965
options.is_enabled = True
966
options.client = ["foo", "barbar"]
1294
args = ["--is-enabled", "client1", "client2"]
967
1295
with self.assertParseError():
968
self.check_option_syntax(options)
1296
self.parse_args(args)
969
1297
970
1298
def test_remove_can_only_be_combined_with_action_deny(self):
971
1299
for action, value in self.actions.items():
972
if action in {"remove", "deny"}:
1300
if action in {"--remove", "--deny"}:
973
1301
continue
974
options = self.parser.parse_args()
975
setattr(options, action, value)
976
options.all = True
977
options.remove = True
1302
args = self.actionargs(action, value, "--all",
1303
"--remove")
978
1304
with self.assertParseError():
979
self.check_option_syntax(options)
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")
980
2054
981
2055
982
2056
class Test_commands_from_options(unittest.TestCase):
2057
983
2058
def setUp(self):
984
2059
self.parser = argparse.ArgumentParser()
985
2060
add_command_line_options(self.parser)
986
2061
987
2062
def test_is_enabled(self):
988
self.assert_command_from_args(["--is-enabled", "foo"],
989
IsEnabledCmd)
2063
self.assert_command_from_args(["--is-enabled", "client"],
2064
command.IsEnabled)
990
2065
991
def assert_command_from_args(self, args, command_cls,
992
**cmd_attrs):
2066
def assert_command_from_args(self, args, command_cls, length=1,
2067
clients=None, **cmd_attrs):
993
2068
"""Assert that parsing ARGS should result in an instance of
994
2069
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
995
2070
options = self.parser.parse_args(args)
996
2071
check_option_syntax(self.parser, options)
997
2072
commands = commands_from_options(options)
998
self.assertEqual(len(commands), 1)
999
command = commands[0]
1000
self.assertIsInstance(command, command_cls)
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)
1001
2081
for key, value in cmd_attrs.items():
1002
self.assertEqual(getattr(command, key), value)
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)
1003
2089
1004
2090
def test_is_enabled_short(self):
1005
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
2091
self.assert_command_from_args(["-V", "client"],
2092
command.IsEnabled)
1006
2093
1007
2094
def test_approve(self):
1008
self.assert_command_from_args(["--approve", "foo"],
1009
ApproveCmd)
2095
self.assert_command_from_args(["--approve", "client"],
2096
command.Approve)
1010
2097
1011
2098
def test_approve_short(self):
1012
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
2099
self.assert_command_from_args(["-A", "client"],
2100
command.Approve)
1013
2101
1014
2102
def test_deny(self):
1015
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
2103
self.assert_command_from_args(["--deny", "client"],
2104
command.Deny)
1016
2105
1017
2106
def test_deny_short(self):
1018
self.assert_command_from_args(["-D", "foo"], DenyCmd)
2107
self.assert_command_from_args(["-D", "client"], command.Deny)
1019
2108
1020
2109
def test_remove(self):
1021
self.assert_command_from_args(["--remove", "foo"],
1022
RemoveCmd)
2110
self.assert_command_from_args(["--remove", "client"],
2111
command.Remove)
1023
2112
1024
2113
def test_deny_before_remove(self):
1025
2114
options = self.parser.parse_args(["--deny", "--remove",
1026
"foo"])
2115
"client"])
1027
2116
check_option_syntax(self.parser, options)
1028
2117
commands = commands_from_options(options)
1029
self.assertEqual(len(commands), 2)
1030
self.assertIsInstance(commands[0], DenyCmd)
1031
self.assertIsInstance(commands[1], RemoveCmd)
2118
self.assertEqual(2, len(commands))
2119
self.assertIsInstance(commands[0], command.Deny)
2120
self.assertIsInstance(commands[1], command.Remove)
1032
2121
1033
2122
def test_deny_before_remove_reversed(self):
1034
2123
options = self.parser.parse_args(["--remove", "--deny",
1035
2124
"--all"])
1036
2125
check_option_syntax(self.parser, options)
1037
2126
commands = commands_from_options(options)
1038
self.assertEqual(len(commands), 2)
1039
self.assertIsInstance(commands[0], DenyCmd)
1040
self.assertIsInstance(commands[1], RemoveCmd)
2127
self.assertEqual(2, len(commands))
2128
self.assertIsInstance(commands[0], command.Deny)
2129
self.assertIsInstance(commands[1], command.Remove)
1041
2130
1042
2131
def test_remove_short(self):
1043
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
2132
self.assert_command_from_args(["-r", "client"],
2133
command.Remove)
1044
2134
1045
2135
def test_dump_json(self):
1046
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
2136
self.assert_command_from_args(["--dump-json"],
2137
command.DumpJSON)
1047
2138
1048
2139
def test_enable(self):
1049
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
2140
self.assert_command_from_args(["--enable", "client"],
2141
command.Enable)
1050
2142
1051
2143
def test_enable_short(self):
1052
self.assert_command_from_args(["-e", "foo"], EnableCmd)
2144
self.assert_command_from_args(["-e", "client"],
2145
command.Enable)
1053
2146
1054
2147
def test_disable(self):
1055
self.assert_command_from_args(["--disable", "foo"],
1056
DisableCmd)
2148
self.assert_command_from_args(["--disable", "client"],
2149
command.Disable)
1057
2150
1058
2151
def test_disable_short(self):
1059
self.assert_command_from_args(["-d", "foo"], DisableCmd)
2152
self.assert_command_from_args(["-d", "client"],
2153
command.Disable)
1060
2154
1061
2155
def test_bump_timeout(self):
1062
self.assert_command_from_args(["--bump-timeout", "foo"],
1063
BumpTimeoutCmd)
2156
self.assert_command_from_args(["--bump-timeout", "client"],
2157
command.BumpTimeout)
1064
2158
1065
2159
def test_bump_timeout_short(self):
1066
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
2160
self.assert_command_from_args(["-b", "client"],
2161
command.BumpTimeout)
1067
2162
1068
2163
def test_start_checker(self):
1069
self.assert_command_from_args(["--start-checker", "foo"],
1070
StartCheckerCmd)
2164
self.assert_command_from_args(["--start-checker", "client"],
2165
command.StartChecker)
1071
2166
1072
2167
def test_stop_checker(self):
1073
self.assert_command_from_args(["--stop-checker", "foo"],
1074
StopCheckerCmd)
2168
self.assert_command_from_args(["--stop-checker", "client"],
2169
command.StopChecker)
1075
2170
1076
2171
def test_approve_by_default(self):
1077
self.assert_command_from_args(["--approve-by-default", "foo"],
1078
ApproveByDefaultCmd)
2172
self.assert_command_from_args(["--approve-by-default",
2173
"client"],
2174
command.ApproveByDefault)
1079
2175
1080
2176
def test_deny_by_default(self):
1081
self.assert_command_from_args(["--deny-by-default", "foo"],
1082
DenyByDefaultCmd)
2177
self.assert_command_from_args(["--deny-by-default", "client"],
2178
command.DenyByDefault)
1083
2179
1084
2180
def test_checker(self):
1085
self.assert_command_from_args(["--checker", ":", "foo"],
1086
SetCheckerCmd, value_to_set=":")
2181
self.assert_command_from_args(["--checker", ":", "client"],
2182
command.SetChecker,
2183
value_to_set=":")
1087
2184
1088
2185
def test_checker_empty(self):
1089
self.assert_command_from_args(["--checker", "", "foo"],
1090
SetCheckerCmd, value_to_set="")
2186
self.assert_command_from_args(["--checker", "", "client"],
2187
command.SetChecker,
2188
value_to_set="")
1091
2189
1092
2190
def test_checker_short(self):
1093
self.assert_command_from_args(["-c", ":", "foo"],
1094
SetCheckerCmd, value_to_set=":")
2191
self.assert_command_from_args(["-c", ":", "client"],
2192
command.SetChecker,
2193
value_to_set=":")
1095
2194
1096
2195
def test_host(self):
1097
self.assert_command_from_args(["--host", "foo.example.org",
1098
"foo"], SetHostCmd,
1099
value_to_set="foo.example.org")
2196
self.assert_command_from_args(
2197
["--host", "client.example.org", "client"],
2198
command.SetHost, value_to_set="client.example.org")
1100
2199
1101
2200
def test_host_short(self):
1102
self.assert_command_from_args(["-H", "foo.example.org",
1103
"foo"], SetHostCmd,
1104
value_to_set="foo.example.org")
2201
self.assert_command_from_args(
2202
["-H", "client.example.org", "client"], command.SetHost,
2203
value_to_set="client.example.org")
1105
2204
1106
2205
def test_secret_devnull(self):
1107
2206
self.assert_command_from_args(["--secret", os.path.devnull,
1108
"foo"], SetSecretCmd,
2207
"client"], command.SetSecret,
1109
2208
value_to_set=b"")
1110
2209
1111
2210
def test_secret_tempfile(self):
1114
2213
f.write(value)
1115
2214
f.seek(0)
1116
2215
self.assert_command_from_args(["--secret", f.name,
1117
"foo"], SetSecretCmd,
2216
"client"],
2217
command.SetSecret,
1118
2218
value_to_set=value)
1119
2219
1120
2220
def test_secret_devnull_short(self):
1121
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1122
SetSecretCmd, value_to_set=b"")
2221
self.assert_command_from_args(["-s", os.path.devnull,
2222
"client"], command.SetSecret,
2223
value_to_set=b"")
1123
2224
1124
2225
def test_secret_tempfile_short(self):
1125
2226
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1126
2227
value = b"secret\0xyzzy\nbar"
1127
2228
f.write(value)
1128
2229
f.seek(0)
1129
self.assert_command_from_args(["-s", f.name, "foo"],
1130
SetSecretCmd,
2230
self.assert_command_from_args(["-s", f.name, "client"],
2231
command.SetSecret,
1131
2232
value_to_set=value)
1132
2233
1133
2234
def test_timeout(self):
1134
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1135
SetTimeoutCmd,
2235
self.assert_command_from_args(["--timeout", "PT5M", "client"],
2236
command.SetTimeout,
1136
2237
value_to_set=300000)
1137
2238
1138
2239
def test_timeout_short(self):
1139
self.assert_command_from_args(["-t", "PT5M", "foo"],
1140
SetTimeoutCmd,
2240
self.assert_command_from_args(["-t", "PT5M", "client"],
2241
command.SetTimeout,
1141
2242
value_to_set=300000)
1142
2243
1143
2244
def test_extended_timeout(self):
1144
2245
self.assert_command_from_args(["--extended-timeout", "PT15M",
1145
"foo"],
1146
SetExtendedTimeoutCmd,
2246
"client"],
2247
command.SetExtendedTimeout,
1147
2248
value_to_set=900000)
1148
2249
1149
2250
def test_interval(self):
1150
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1151
SetIntervalCmd,
2251
self.assert_command_from_args(["--interval", "PT2M",
2252
"client"], command.SetInterval,
1152
2253
value_to_set=120000)
1153
2254
1154
2255
def test_interval_short(self):
1155
self.assert_command_from_args(["-i", "PT2M", "foo"],
1156
SetIntervalCmd,
2256
self.assert_command_from_args(["-i", "PT2M", "client"],
2257
command.SetInterval,
1157
2258
value_to_set=120000)
1158
2259
1159
2260
def test_approval_delay(self):
1160
2261
self.assert_command_from_args(["--approval-delay", "PT30S",
1161
"foo"], SetApprovalDelayCmd,
2262
"client"],
2263
command.SetApprovalDelay,
1162
2264
value_to_set=30000)
1163
2265
1164
2266
def test_approval_duration(self):
1165
2267
self.assert_command_from_args(["--approval-duration", "PT1S",
1166
"foo"], SetApprovalDurationCmd,
2268
"client"],
2269
command.SetApprovalDuration,
1167
2270
value_to_set=1000)
1168
2271
1169
2272
def test_print_table(self):
1170
self.assert_command_from_args([], PrintTableCmd,
2273
self.assert_command_from_args([], command.PrintTable,
1171
2274
verbose=False)
1172
2275
1173
2276
def test_print_table_verbose(self):
1174
self.assert_command_from_args(["--verbose"], PrintTableCmd,
2277
self.assert_command_from_args(["--verbose"],
2278
command.PrintTable,
1175
2279
verbose=True)
1176
2280
1177
2281
def test_print_table_verbose_short(self):
1178
self.assert_command_from_args(["-v"], PrintTableCmd,
2282
self.assert_command_from_args(["-v"], command.PrintTable,
1179
2283
verbose=True)
1180
2284
1181
2285
1182
class TestCmd(unittest.TestCase):
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):
1183
2318
"""Abstract class for tests of command classes"""
1184
2319
1185
def setUp(self):
1186
testcase = self
1187
class MockClient(object):
1188
def __init__(self, name, **attributes):
1189
self.__dbus_object_path__ = "/clients/{}".format(name)
1190
self.attributes = attributes
1191
self.attributes["Name"] = name
1192
self.calls = []
1193
def Set(self, interface, propname, value, dbus_interface):
1194
testcase.assertEqual(interface, client_dbus_interface)
1195
testcase.assertEqual(dbus_interface,
1196
dbus.PROPERTIES_IFACE)
1197
self.attributes[propname] = value
1198
def Get(self, interface, propname, dbus_interface):
1199
testcase.assertEqual(interface, client_dbus_interface)
1200
testcase.assertEqual(dbus_interface,
1201
dbus.PROPERTIES_IFACE)
1202
return self.attributes[propname]
1203
def Approve(self, approve, dbus_interface):
1204
testcase.assertEqual(dbus_interface,
1205
client_dbus_interface)
1206
self.calls.append(("Approve", (approve,
1207
dbus_interface)))
1208
self.client = MockClient(
1209
"foo",
1210
KeyID=("92ed150794387c03ce684574b1139a65"
1211
"94a34f895daaaf09fd8ea90a27cddb12"),
1212
Secret=b"secret",
1213
Host="foo.example.org",
1214
Enabled=dbus.Boolean(True),
1215
Timeout=300000,
1216
LastCheckedOK="2019-02-03T00:00:00",
1217
Created="2019-01-02T00:00:00",
1218
Interval=120000,
1219
Fingerprint=("778827225BA7DE539C5A"
1220
"7CFA59CFF7CDBD9A5920"),
1221
CheckerRunning=dbus.Boolean(False),
1222
LastEnabled="2019-01-03T00:00:00",
1223
ApprovalPending=dbus.Boolean(False),
1224
ApprovedByDefault=dbus.Boolean(True),
1225
LastApprovalRequest="",
1226
ApprovalDelay=0,
1227
ApprovalDuration=1000,
1228
Checker="fping -q -- %(host)s",
1229
ExtendedTimeout=900000,
1230
Expires="2019-02-04T00:00:00",
1231
LastCheckerStatus=0)
1232
self.other_client = MockClient(
1233
"barbar",
1234
KeyID=("0558568eedd67d622f5c83b35a115f79"
1235
"6ab612cff5ad227247e46c2b020f441c"),
1236
Secret=b"secretbar",
1237
Host="192.0.2.3",
1238
Enabled=dbus.Boolean(True),
1239
Timeout=300000,
1240
LastCheckedOK="2019-02-04T00:00:00",
1241
Created="2019-01-03T00:00:00",
1242
Interval=120000,
1243
Fingerprint=("3E393AEAEFB84C7E89E2"
1244
"F547B3A107558FCA3A27"),
1245
CheckerRunning=dbus.Boolean(True),
1246
LastEnabled="2019-01-04T00:00:00",
1247
ApprovalPending=dbus.Boolean(False),
1248
ApprovedByDefault=dbus.Boolean(False),
1249
LastApprovalRequest="2019-01-03T00:00:00",
1250
ApprovalDelay=30000,
1251
ApprovalDuration=93785000,
1252
Checker=":",
1253
ExtendedTimeout=900000,
1254
Expires="2019-02-05T00:00:00",
1255
LastCheckerStatus=-2)
1256
self.clients = collections.OrderedDict(
1257
[
1258
("/clients/foo", self.client.attributes),
1259
("/clients/barbar", self.other_client.attributes),
1260
])
1261
self.one_client = {"/clients/foo": self.client.attributes}
1262
1263
@property
1264
def bus(self):
1265
class Bus(object):
1266
@staticmethod
1267
def get_object(client_bus_name, path):
1268
self.assertEqual(client_bus_name, dbus_busname)
1269
return {
1270
# Note: "self" here is the TestCmd instance, not
1271
# the Bus instance, since this is a static method!
1272
"/clients/foo": self.client,
1273
"/clients/barbar": self.other_client,
1274
}[path]
1275
return Bus()
1276
1277
1278
class TestIsEnabledCmd(TestCmd):
1279
def test_is_enabled(self):
1280
self.assertTrue(all(IsEnabledCmd().is_enabled(client,
1281
properties)
1282
for client, properties
1283
in self.clients.items()))
1284
1285
def test_is_enabled_run_exits_successfully(self):
1286
with self.assertRaises(SystemExit) as e:
1287
IsEnabledCmd().run(self.one_client)
1288
if e.exception.code is not None:
1289
self.assertEqual(e.exception.code, 0)
1290
else:
1291
self.assertIsNone(e.exception.code)
1292
1293
def test_is_enabled_run_exits_with_failure(self):
1294
self.client.attributes["Enabled"] = dbus.Boolean(False)
1295
with self.assertRaises(SystemExit) as e:
1296
IsEnabledCmd().run(self.one_client)
1297
if isinstance(e.exception.code, int):
1298
self.assertNotEqual(e.exception.code, 0)
1299
else:
1300
self.assertIsNotNone(e.exception.code)
1301
1302
1303
class TestApproveCmd(TestCmd):
1304
def test_approve(self):
1305
ApproveCmd().run(self.clients, self.bus)
1306
for clientpath in self.clients:
1307
client = self.bus.get_object(dbus_busname, clientpath)
1308
self.assertIn(("Approve", (True, client_dbus_interface)),
1309
client.calls)
1310
1311
1312
class TestDenyCmd(TestCmd):
1313
def test_deny(self):
1314
DenyCmd().run(self.clients, self.bus)
1315
for clientpath in self.clients:
1316
client = self.bus.get_object(dbus_busname, clientpath)
1317
self.assertIn(("Approve", (False, client_dbus_interface)),
1318
client.calls)
1319
1320
1321
class TestRemoveCmd(TestCmd):
1322
def test_remove(self):
1323
class MockMandos(object):
1324
def __init__(self):
1325
self.calls = []
1326
def RemoveClient(self, dbus_path):
1327
self.calls.append(("RemoveClient", (dbus_path,)))
1328
mandos = MockMandos()
1329
super(TestRemoveCmd, self).setUp()
1330
RemoveCmd().run(self.clients, self.bus, mandos)
1331
self.assertEqual(len(mandos.calls), 2)
1332
for clientpath in self.clients:
1333
self.assertIn(("RemoveClient", (clientpath,)),
1334
mandos.calls)
1335
1336
1337
class TestDumpJSONCmd(TestCmd):
1338
def setUp(self):
1339
self.expected_json = {
1340
"foo": {
2320
class FakeMandosBus(dbus.MandosBus):
2321
def __init__(self, testcase):
2322
self.client_properties = {
1341
2323
"Name": "foo",
1342
2324
"KeyID": ("92ed150794387c03ce684574b1139a65"
1343
2325
"94a34f895daaaf09fd8ea90a27cddb12"),
2326
"Secret": b"secret",
1344
2327
"Host": "foo.example.org",
1345
2328
"Enabled": True,
1346
2329
"Timeout": 300000,
1360
2343
"ExtendedTimeout": 900000,
1361
2344
"Expires": "2019-02-04T00:00:00",
1362
2345
"LastCheckerStatus": 0,
1363
},
1364
"barbar": {
2346
}
2347
self.other_client_properties = {
1365
2348
"Name": "barbar",
1366
2349
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1367
2350
"6ab612cff5ad227247e46c2b020f441c"),
2351
"Secret": b"secretbar",
1368
2352
"Host": "192.0.2.3",
1369
2353
"Enabled": True,
1370
2354
"Timeout": 300000,
1384
2368
"ExtendedTimeout": 900000,
1385
2369
"Expires": "2019-02-05T00:00:00",
1386
2370
"LastCheckerStatus": -2,
1387
},
1388
}
1389
return super(TestDumpJSONCmd, self).setUp()
1390
1391
def test_normal(self):
1392
output = DumpJSONCmd().output(self.clients.values())
1393
json_data = json.loads(output)
1394
self.assertDictEqual(json_data, self.expected_json)
1395
1396
def test_one_client(self):
1397
output = DumpJSONCmd().output(self.one_client.values())
1398
json_data = json.loads(output)
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())
1399
2527
expected_json = {"foo": self.expected_json["foo"]}
1400
self.assertDictEqual(json_data, expected_json)
1401
1402
1403
class TestPrintTableCmd(TestCmd):
1404
def test_normal(self):
1405
output = PrintTableCmd().output(self.clients.values())
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)
1406
2533
expected_output = "\n".join((
1407
2534
"Name Enabled Timeout Last Successful Check",
1408
2535
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1409
2536
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1410
))
1411
self.assertEqual(output, expected_output)
2537
)) + "\n"
2538
self.assertEqual(expected_output, buffer.getvalue())
1412
2539
1413
def test_verbose(self):
1414
output = PrintTableCmd(verbose=True).output(
1415
self.clients.values())
2540
def test_PrintTable_verbose(self):
2541
with self.capture_stdout_to_buffer() as buffer:
2542
command.PrintTable(verbose=True).run(self.bus.clients)
1416
2543
columns = (
1417
2544
(
1418
2545
"Name ",
1500
2627
)
1501
2628
)
1502
2629
num_lines = max(len(rows) for rows in columns)
1503
expected_output = "\n".join("".join(rows[line]
1504
for rows in columns)
1505
for line in range(num_lines))
1506
self.assertEqual(output, expected_output)
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())
1507
2635
1508
def test_one_client(self):
1509
output = PrintTableCmd().output(self.one_client.values())
2636
def test_PrintTable_one_client(self):
2637
with self.capture_stdout_to_buffer() as buffer:
2638
command.PrintTable().run(self.bus.one_client)
1510
2639
expected_output = "\n".join((
1511
2640
"Name Enabled Timeout Last Successful Check",
1512
2641
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1513
))
1514
self.assertEqual(output, expected_output)
1515
1516
1517
class TestPropertyCmd(TestCmd):
1518
"""Abstract class for tests of PropertyCmd classes"""
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
1519
2649
def runTest(self):
1520
2650
if not hasattr(self, "command"):
1521
return
1522
values_to_get = getattr(self, "values_to_get",
1523
self.values_to_set)
1524
for value_to_set, value_to_get in zip(self.values_to_set,
1525
values_to_get):
1526
for clientpath in self.clients:
1527
client = self.bus.get_object(dbus_busname, clientpath)
1528
old_value = client.attributes[self.propname]
1529
self.assertNotIsInstance(old_value, self.Unique)
1530
client.attributes[self.propname] = self.Unique()
1531
self.run_command(value_to_set, self.clients)
1532
for clientpath in self.clients:
1533
client = self.bus.get_object(dbus_busname, clientpath)
1534
value = client.attributes[self.propname]
1535
self.assertNotIsInstance(value, self.Unique)
1536
self.assertEqual(value, value_to_get)
1537
1538
class Unique(object):
1539
"""Class for objects which exist only to be unique objects,
1540
since unittest.mock.sentinel only exists in Python 3.3"""
1541
1542
def run_command(self, value, clients):
1543
self.command().run(clients, self.bus)
1544
1545
1546
class TestEnableCmd(TestPropertyCmd):
1547
command = EnableCmd
1548
propname = "Enabled"
1549
values_to_set = [dbus.Boolean(True)]
1550
1551
1552
class TestDisableCmd(TestPropertyCmd):
1553
command = DisableCmd
1554
propname = "Enabled"
1555
values_to_set = [dbus.Boolean(False)]
1556
1557
1558
class TestBumpTimeoutCmd(TestPropertyCmd):
1559
command = BumpTimeoutCmd
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
1560
2686
propname = "LastCheckedOK"
1561
values_to_set = [""]
1562
1563
1564
class TestStartCheckerCmd(TestPropertyCmd):
1565
command = StartCheckerCmd
1566
propname = "CheckerRunning"
1567
values_to_set = [dbus.Boolean(True)]
1568
1569
1570
class TestStopCheckerCmd(TestPropertyCmd):
1571
command = StopCheckerCmd
1572
propname = "CheckerRunning"
1573
values_to_set = [dbus.Boolean(False)]
1574
1575
1576
class TestApproveByDefaultCmd(TestPropertyCmd):
1577
command = ApproveByDefaultCmd
1578
propname = "ApprovedByDefault"
1579
values_to_set = [dbus.Boolean(True)]
1580
1581
1582
class TestDenyByDefaultCmd(TestPropertyCmd):
1583
command = DenyByDefaultCmd
1584
propname = "ApprovedByDefault"
1585
values_to_set = [dbus.Boolean(False)]
1586
1587
1588
class TestPropertyValueCmd(TestPropertyCmd):
1589
"""Abstract class for tests of PropertyValueCmd classes"""
1590
1591
def runTest(self):
1592
if type(self) is TestPropertyValueCmd:
1593
return
1594
return super(TestPropertyValueCmd, self).runTest()
1595
1596
def run_command(self, value, clients):
1597
self.command(value).run(clients, self.bus)
1598
1599
1600
class TestSetCheckerCmd(TestPropertyValueCmd):
1601
command = SetCheckerCmd
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
1602
2716
propname = "Checker"
1603
2717
values_to_set = ["", ":", "fping -q -- %s"]
1604
2718
1605
2719
1606
class TestSetHostCmd(TestPropertyValueCmd):
1607
command = SetHostCmd
2720
class TestSetHostCmd(TestPropertySetterCmd):
2721
command = command.SetHost
1608
2722
propname = "Host"
1609
values_to_set = ["192.0.2.3", "foo.example.org"]
1610
1611
1612
class TestSetSecretCmd(TestPropertyValueCmd):
1613
command = SetSecretCmd
2723
values_to_set = ["192.0.2.3", "client.example.org"]
2724
2725
2726
class TestSetSecretCmd(TestPropertySetterCmd):
2727
command = command.SetSecret
1614
2728
propname = "Secret"
1615
2729
values_to_set = [io.BytesIO(b""),
1616
2730
io.BytesIO(b"secret\0xyzzy\nbar")]
1617
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1618
1619
1620
class TestSetTimeoutCmd(TestPropertyValueCmd):
1621
command = SetTimeoutCmd
2731
values_to_get = [f.getvalue() for f in values_to_set]
2732
2733
2734
class TestSetTimeoutCmd(TestPropertySetterCmd):
2735
command = command.SetTimeout
1622
2736
propname = "Timeout"
1623
2737
values_to_set = [datetime.timedelta(),
1624
2738
datetime.timedelta(minutes=5),
1625
2739
datetime.timedelta(seconds=1),
1626
2740
datetime.timedelta(weeks=1),
1627
2741
datetime.timedelta(weeks=52)]
1628
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1629
1630
1631
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
1632
command = SetExtendedTimeoutCmd
2742
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2743
2744
2745
class TestSetExtendedTimeoutCmd(TestPropertySetterCmd):
2746
command = command.SetExtendedTimeout
1633
2747
propname = "ExtendedTimeout"
1634
2748
values_to_set = [datetime.timedelta(),
1635
2749
datetime.timedelta(minutes=5),
1636
2750
datetime.timedelta(seconds=1),
1637
2751
datetime.timedelta(weeks=1),
1638
2752
datetime.timedelta(weeks=52)]
1639
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1640
1641
1642
class TestSetIntervalCmd(TestPropertyValueCmd):
1643
command = SetIntervalCmd
2753
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2754
2755
2756
class TestSetIntervalCmd(TestPropertySetterCmd):
2757
command = command.SetInterval
1644
2758
propname = "Interval"
1645
2759
values_to_set = [datetime.timedelta(),
1646
2760
datetime.timedelta(minutes=5),
1647
2761
datetime.timedelta(seconds=1),
1648
2762
datetime.timedelta(weeks=1),
1649
2763
datetime.timedelta(weeks=52)]
1650
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1651
1652
1653
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
1654
command = SetApprovalDelayCmd
2764
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2765
2766
2767
class TestSetApprovalDelayCmd(TestPropertySetterCmd):
2768
command = command.SetApprovalDelay
1655
2769
propname = "ApprovalDelay"
1656
2770
values_to_set = [datetime.timedelta(),
1657
2771
datetime.timedelta(minutes=5),
1658
2772
datetime.timedelta(seconds=1),
1659
2773
datetime.timedelta(weeks=1),
1660
2774
datetime.timedelta(weeks=52)]
1661
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1662
1663
1664
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
1665
command = SetApprovalDurationCmd
2775
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
2776
2777
2778
class TestSetApprovalDurationCmd(TestPropertySetterCmd):
2779
command = command.SetApprovalDuration
1666
2780
propname = "ApprovalDuration"
1667
2781
values_to_set = [datetime.timedelta(),
1668
2782
datetime.timedelta(minutes=5),
1669
2783
datetime.timedelta(seconds=1),
1670
2784
datetime.timedelta(weeks=1),
1671
2785
datetime.timedelta(weeks=52)]
1672
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
2786
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1673
2787
1674
2788
1675
2789
1690
2804
return tests
1691
2805
1692
2806
if __name__ == "__main__":
1693
if should_only_run_tests():
1694
# Call using ./tdd-python-script --check [--verbose]
1695
unittest.main()
1696
else:
1697
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