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