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 994
- compare with another revision
- download diff
- download tarball
- view history from revision 994
- Committer: Teddy Hogeborn
- Date: 2019-03-02 01:28:12 UTC
- Revision ID: teddy@recompile.se-20190302012812-3ymo5liufbe9jr6o
mandos-ctl: Add tests for table_rows_of_clients()
* mandos-ctl (class Test_table_rows_of_clients): New.
* mandos-ctl (class Test_table_rows_of_clients): New.
- files added:
- bugs.xml
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
mandos-ctl
1
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
4
from __future__ import division
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
#
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
15
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
20
#
21
# 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
#
24
# Contact the authors at <mandos@recompile.se>.
25
#
26
27
from __future__ import (division, absolute_import, print_function,
28
unicode_literals)
29
30
try:
31
from future_builtins import *
32
except ImportError:
33
pass
34
5
35
import sys
6
import dbus
7
from optparse import OptionParser
36
import argparse
8
37
import locale
9
38
import datetime
10
39
import re
11
12
locale.setlocale(locale.LC_ALL, u'')
40
import os
41
import collections
42
import json
43
import unittest
44
import logging
45
46
import dbus
47
48
# Show warnings by default
49
if not sys.warnoptions:
50
import warnings
51
warnings.simplefilter("default")
52
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
56
57
logging.captureWarnings(True) # Show warnings via the logging system
58
59
if sys.version_info.major == 2:
60
str = unicode
61
62
locale.setlocale(locale.LC_ALL, "")
13
63
14
64
tablewords = {
15
'Name': u'Name',
16
'Enabled': u'Enabled',
17
'Timeout': u'Timeout',
18
'LastCheckedOK': u'Last Successful Check',
19
'Created': u'Created',
20
'Interval': u'Interval',
21
'Host': u'Host',
22
'Fingerprint': u'Fingerprint',
23
'CheckerRunning': u'Check Is Running',
24
'LastEnabled': u'Last Enabled',
25
'Checker': u'Checker',
26
}
27
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
28
domain = 'se.bsnet.fukt'
29
busname = domain + '.Mandos'
30
server_path = '/'
31
server_interface = domain + '.Mandos'
32
client_interface = domain + '.Mandos.Client'
33
version = "1.0.14"
65
"Name": "Name",
66
"Enabled": "Enabled",
67
"Timeout": "Timeout",
68
"LastCheckedOK": "Last Successful Check",
69
"LastApprovalRequest": "Last Approval Request",
70
"Created": "Created",
71
"Interval": "Interval",
72
"Host": "Host",
73
"Fingerprint": "Fingerprint",
74
"KeyID": "Key ID",
75
"CheckerRunning": "Check Is Running",
76
"LastEnabled": "Last Enabled",
77
"ApprovalPending": "Approval Is Pending",
78
"ApprovedByDefault": "Approved By Default",
79
"ApprovalDelay": "Approval Delay",
80
"ApprovalDuration": "Approval Duration",
81
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
83
"Expires": "Expires",
84
"LastCheckerStatus": "Last Checker Status",
85
}
86
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
domain = "se.recompile"
88
busname = domain + ".Mandos"
89
server_path = "/"
90
server_interface = domain + ".Mandos"
91
client_interface = domain + ".Mandos.Client"
92
version = "1.8.3"
93
94
34
95
try:
35
bus = dbus.SystemBus()
36
mandos_dbus_objc = bus.get_object(busname, server_path)
37
except dbus.exceptions.DBusException:
38
sys.exit(1)
39
40
mandos_serv = dbus.Interface(mandos_dbus_objc,
41
dbus_interface = server_interface)
42
mandos_clients = mandos_serv.GetAllClientsWithProperties()
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
43
99
44
def timedelta_to_milliseconds(td):
45
"Convert a datetime.timedelta object to milliseconds"
46
return ((td.days * 24 * 60 * 60 * 1000)
47
+ (td.seconds * 1000)
48
+ (td.microseconds // 1000))
49
100
50
101
def milliseconds_to_string(ms):
51
102
td = datetime.timedelta(0, 0, 0, ms)
52
return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
53
% { "days": "%dT" % td.days if td.days else "",
54
"hours": td.seconds // 3600,
55
"minutes": (td.seconds % 3600) // 60,
56
"seconds": td.seconds % 60,
57
})
103
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
104
.format(days="{}T".format(td.days) if td.days else "",
105
hours=td.seconds // 3600,
106
minutes=(td.seconds % 3600) // 60,
107
seconds=td.seconds % 60))
108
109
110
def rfc3339_duration_to_delta(duration):
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
112
113
>>> rfc3339_duration_to_delta("P7D")
114
datetime.timedelta(7)
115
>>> rfc3339_duration_to_delta("PT60S")
116
datetime.timedelta(0, 60)
117
>>> rfc3339_duration_to_delta("PT60M")
118
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
>>> rfc3339_duration_to_delta("PT24H")
122
datetime.timedelta(1)
123
>>> rfc3339_duration_to_delta("P1W")
124
datetime.timedelta(7)
125
>>> rfc3339_duration_to_delta("PT5M30S")
126
datetime.timedelta(0, 330)
127
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
datetime.timedelta(1, 200)
129
>>> # Can not be empty:
130
>>> rfc3339_duration_to_delta("")
131
Traceback (most recent call last):
132
...
133
ValueError: Invalid RFC 3339 duration: u''
134
>>> # Must start with "P":
135
>>> rfc3339_duration_to_delta("1D")
136
Traceback (most recent call last):
137
...
138
ValueError: Invalid RFC 3339 duration: u'1D'
139
>>> # Must use correct order
140
>>> rfc3339_duration_to_delta("PT1S2M")
141
Traceback (most recent call last):
142
...
143
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
144
>>> # Time needs time marker
145
>>> rfc3339_duration_to_delta("P1H2S")
146
Traceback (most recent call last):
147
...
148
ValueError: Invalid RFC 3339 duration: u'P1H2S'
149
>>> # Weeks can not be combined with anything else
150
>>> rfc3339_duration_to_delta("P1D2W")
151
Traceback (most recent call last):
152
...
153
ValueError: Invalid RFC 3339 duration: u'P1D2W'
154
>>> rfc3339_duration_to_delta("P2W2H")
155
Traceback (most recent call last):
156
...
157
ValueError: Invalid RFC 3339 duration: u'P2W2H'
158
"""
159
160
# Parsing an RFC 3339 duration with regular expressions is not
161
# possible - there would have to be multiple places for the same
162
# values, like seconds. The current code, while more esoteric, is
163
# cleaner without depending on a parsing library. If Python had a
164
# built-in library for parsing we would use it, but we'd like to
165
# avoid excessive use of external libraries.
166
167
# New type for defining tokens, syntax, and semantics all-in-one
168
Token = collections.namedtuple("Token", (
169
"regexp", # To match token; if "value" is not None, must have
170
# a "group" containing digits
171
"value", # datetime.timedelta or None
172
"followers")) # Tokens valid after this token
173
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
174
# the "duration" ABNF definition in RFC 3339, Appendix A.
175
token_end = Token(re.compile(r"$"), None, frozenset())
176
token_second = Token(re.compile(r"(\d+)S"),
177
datetime.timedelta(seconds=1),
178
frozenset((token_end, )))
179
token_minute = Token(re.compile(r"(\d+)M"),
180
datetime.timedelta(minutes=1),
181
frozenset((token_second, token_end)))
182
token_hour = Token(re.compile(r"(\d+)H"),
183
datetime.timedelta(hours=1),
184
frozenset((token_minute, token_end)))
185
token_time = Token(re.compile(r"T"),
186
None,
187
frozenset((token_hour, token_minute,
188
token_second)))
189
token_day = Token(re.compile(r"(\d+)D"),
190
datetime.timedelta(days=1),
191
frozenset((token_time, token_end)))
192
token_month = Token(re.compile(r"(\d+)M"),
193
datetime.timedelta(weeks=4),
194
frozenset((token_day, token_end)))
195
token_year = Token(re.compile(r"(\d+)Y"),
196
datetime.timedelta(weeks=52),
197
frozenset((token_month, token_end)))
198
token_week = Token(re.compile(r"(\d+)W"),
199
datetime.timedelta(weeks=1),
200
frozenset((token_end, )))
201
token_duration = Token(re.compile(r"P"), None,
202
frozenset((token_year, token_month,
203
token_day, token_time,
204
token_week)))
205
# Define starting values:
206
# Value so far
207
value = datetime.timedelta()
208
found_token = None
209
# Following valid tokens
210
followers = frozenset((token_duration, ))
211
# String left to parse
212
s = duration
213
# Loop until end token is found
214
while found_token is not token_end:
215
# Search for any currently valid tokens
216
for token in followers:
217
match = token.regexp.match(s)
218
if match is not None:
219
# Token found
220
if token.value is not None:
221
# Value found, parse digits
222
factor = int(match.group(1), 10)
223
# Add to value so far
224
value += factor * token.value
225
# Strip token from string
226
s = token.regexp.sub("", s, 1)
227
# Go to found token
228
found_token = token
229
# Set valid next tokens
230
followers = found_token.followers
231
break
232
else:
233
# No currently valid tokens were found
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
235
.format(duration))
236
# End token found
237
return value
58
238
59
239
60
240
def string_to_delta(interval):
61
241
"""Parse a string and return a datetime.timedelta
62
63
>>> string_to_delta('7d')
242
"""
243
244
try:
245
return rfc3339_duration_to_delta(interval)
246
except ValueError as e:
247
log.warning("%s - Parsing as pre-1.6.1 interval instead",
248
' '.join(e.args))
249
return parse_pre_1_6_1_interval(interval)
250
251
252
def parse_pre_1_6_1_interval(interval):
253
"""Parse an interval string as documented by Mandos before 1.6.1, and
254
return a datetime.timedelta
255
>>> parse_pre_1_6_1_interval('7d')
64
256
datetime.timedelta(7)
65
>>> string_to_delta('60s')
257
>>> parse_pre_1_6_1_interval('60s')
66
258
datetime.timedelta(0, 60)
67
>>> string_to_delta('60m')
259
>>> parse_pre_1_6_1_interval('60m')
68
260
datetime.timedelta(0, 3600)
69
>>> string_to_delta('24h')
261
>>> parse_pre_1_6_1_interval('24h')
70
262
datetime.timedelta(1)
71
>>> string_to_delta(u'1w')
263
>>> parse_pre_1_6_1_interval('1w')
72
264
datetime.timedelta(7)
73
>>> string_to_delta('5m 30s')
265
>>> parse_pre_1_6_1_interval('5m 30s')
74
266
datetime.timedelta(0, 330)
267
>>> parse_pre_1_6_1_interval('')
268
datetime.timedelta(0)
269
>>> # Ignore unknown characters, allow any order and repetitions
270
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
271
datetime.timedelta(2, 480, 18000)
272
75
273
"""
76
timevalue = datetime.timedelta(0)
77
regexp = re.compile("\d+[dsmhw]")
78
79
for s in regexp.findall(interval):
80
try:
81
suffix = unicode(s[-1])
82
value = int(s[:-1])
83
if suffix == u"d":
84
delta = datetime.timedelta(value)
85
elif suffix == u"s":
86
delta = datetime.timedelta(0, value)
87
elif suffix == u"m":
88
delta = datetime.timedelta(0, 0, 0, 0, value)
89
elif suffix == u"h":
90
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
91
elif suffix == u"w":
92
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
93
else:
94
raise ValueError
95
except (ValueError, IndexError):
96
raise ValueError
97
timevalue += delta
98
return timevalue
99
100
def print_clients(clients):
274
275
value = datetime.timedelta(0)
276
regexp = re.compile(r"(\d+)([dsmhw]?)")
277
278
for num, suffix in regexp.findall(interval):
279
if suffix == "d":
280
value += datetime.timedelta(int(num))
281
elif suffix == "s":
282
value += datetime.timedelta(0, int(num))
283
elif suffix == "m":
284
value += datetime.timedelta(0, 0, 0, 0, int(num))
285
elif suffix == "h":
286
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
287
elif suffix == "w":
288
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
289
elif suffix == "":
290
value += datetime.timedelta(0, 0, 0, int(num))
291
return value
292
293
294
def print_clients(clients, keywords):
295
print('\n'.join(table_rows_of_clients(clients, keywords)))
296
297
def table_rows_of_clients(clients, keywords):
101
298
def valuetostring(value, keyword):
102
if type(value) is dbus.Boolean:
103
return u"Yes" if value else u"No"
104
if keyword in (u"timeout", u"interval"):
299
if isinstance(value, dbus.Boolean):
300
return "Yes" if value else "No"
301
if keyword in ("Timeout", "Interval", "ApprovalDelay",
302
"ApprovalDuration", "ExtendedTimeout"):
105
303
return milliseconds_to_string(value)
106
return unicode(value)
107
304
return str(value)
305
108
306
# Create format string to print table rows
109
format_string = u' '.join(u'%%-%ds' %
110
max(len(tablewords[key]),
111
max(len(valuetostring(client[key],
112
key))
113
for client in
114
clients))
115
for key in keywords)
116
# Print header line
117
print format_string % tuple(tablewords[key] for key in keywords)
307
format_string = " ".join("{{{key}:{width}}}".format(
308
width=max(len(tablewords[key]),
309
max(len(valuetostring(client[key], key))
310
for client in clients)),
311
key=key)
312
for key in keywords)
313
# Start with header line
314
rows = [format_string.format(**tablewords)]
118
315
for client in clients:
119
print format_string % tuple(valuetostring(client[key], key)
120
for key in keywords)
121
122
parser = OptionParser(version = "%%prog %s" % version)
123
parser.add_option("-a", "--all", action="store_true",
124
help="Print all fields")
125
parser.add_option("-e", "--enable", action="store_true",
126
help="Enable client")
127
parser.add_option("-d", "--disable", action="store_true",
128
help="disable client")
129
parser.add_option("-b", "--bump-timeout", action="store_true",
130
help="Bump timeout for client")
131
parser.add_option("--start-checker", action="store_true",
132
help="Start checker for client")
133
parser.add_option("--stop-checker", action="store_true",
134
help="Stop checker for client")
135
parser.add_option("-V", "--is-enabled", action="store_true",
136
help="Check if client is enabled")
137
parser.add_option("-r", "--remove", action="store_true",
138
help="Remove client")
139
parser.add_option("-c", "--checker", type="string",
140
help="Set checker command for client")
141
parser.add_option("-t", "--timeout", type="string",
142
help="Set timeout for client")
143
parser.add_option("-i", "--interval", type="string",
144
help="Set checker interval for client")
145
parser.add_option("-H", "--host", type="string",
146
help="Set host for client")
147
parser.add_option("-s", "--secret", type="string",
148
help="Set password blob (file) for client")
149
parser.add_option("-A", "--approve", action="store_true",
150
help="Approve any current client request")
151
parser.add_option("-D", "--deny", action="store_true",
152
help="Deny any current client request")
153
options, client_names = parser.parse_args()
154
155
# Compile list of clients to process
156
clients=[]
157
for name in client_names:
158
for path, client in mandos_clients.iteritems():
159
if client['name'] == name:
160
client_objc = bus.get_object(busname, path)
161
clients.append(client_objc)
162
break
163
else:
164
print >> sys.stderr, "Client not found on server: %r" % name
165
sys.exit(1)
166
167
if not clients and mandos_clients.values():
168
keywords = defaultkeywords
169
if options.all:
170
keywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK',
171
'Created', 'Interval', 'Host', 'Fingerprint',
172
'CheckerRunning', 'LastEnabled', 'Checker')
173
print_clients(mandos_clients.values())
174
175
# Process each client in the list by all selected options
176
for client in clients:
177
if options.remove:
178
mandos_serv.RemoveClient(client.__dbus_object_path__)
179
if options.enable:
180
client.Enable(dbus_interface=client_interface)
181
if options.disable:
182
client.Disable(dbus_interface=client_interface)
183
if options.bump_timeout:
184
client.CheckedOK(dbus_interface=client_interface)
185
if options.start_checker:
186
client.StartChecker(dbus_interface=client_interface)
187
if options.stop_checker:
188
client.StopChecker(dbus_interface=client_interface)
189
if options.is_enabled:
190
sys.exit(0 if client.Get(client_interface,
191
u"Enabled",
192
dbus_interface=dbus.PROPERTIES_IFACE)
193
else 1)
194
if options.checker:
195
client.Set(client_interface, u"Checker", options.checker,
196
dbus_interface=dbus.PROPERTIES_IFACE)
197
if options.host:
198
client.Set(client_interface, u"Host", options.host,
199
dbus_interface=dbus.PROPERTIES_IFACE)
200
if options.interval:
201
client.Set(client_interface, u"Interval",
202
timedelta_to_milliseconds
203
(string_to_delta(options.interval)),
204
dbus_interface=dbus.PROPERTIES_IFACE)
205
if options.timeout:
206
client.Set(client_interface, u"Timeout",
207
timedelta_to_milliseconds(string_to_delta
208
(options.timeout)),
209
dbus_interface=dbus.PROPERTIES_IFACE)
210
if options.secret:
211
client.Set(client_interface, u"Secret",
212
dbus.ByteArray(open(options.secret, u'rb').read()),
213
dbus_interface=dbus.PROPERTIES_IFACE)
214
if options.approve:
215
client.Approve(dbus.Boolean(True),
216
dbus_interface=client_interface)
217
if options.deny:
218
client.Approve(dbus.Boolean(False),
219
dbus_interface=client_interface)
316
rows.append(format_string
317
.format(**{key: valuetostring(client[key], key)
318
for key in keywords}))
319
return rows
320
321
322
def has_actions(options):
323
return any((options.enable,
324
options.disable,
325
options.bump_timeout,
326
options.start_checker,
327
options.stop_checker,
328
options.is_enabled,
329
options.remove,
330
options.checker is not None,
331
options.timeout is not None,
332
options.extended_timeout is not None,
333
options.interval is not None,
334
options.approved_by_default is not None,
335
options.approval_delay is not None,
336
options.approval_duration is not None,
337
options.host is not None,
338
options.secret is not None,
339
options.approve,
340
options.deny))
341
342
343
def main():
344
parser = argparse.ArgumentParser()
345
parser.add_argument("--version", action="version",
346
version="%(prog)s {}".format(version),
347
help="show version number and exit")
348
parser.add_argument("-a", "--all", action="store_true",
349
help="Select all clients")
350
parser.add_argument("-v", "--verbose", action="store_true",
351
help="Print all fields")
352
parser.add_argument("-j", "--dump-json", action="store_true",
353
help="Dump client data in JSON format")
354
parser.add_argument("-e", "--enable", action="store_true",
355
help="Enable client")
356
parser.add_argument("-d", "--disable", action="store_true",
357
help="disable client")
358
parser.add_argument("-b", "--bump-timeout", action="store_true",
359
help="Bump timeout for client")
360
parser.add_argument("--start-checker", action="store_true",
361
help="Start checker for client")
362
parser.add_argument("--stop-checker", action="store_true",
363
help="Stop checker for client")
364
parser.add_argument("-V", "--is-enabled", action="store_true",
365
help="Check if client is enabled")
366
parser.add_argument("-r", "--remove", action="store_true",
367
help="Remove client")
368
parser.add_argument("-c", "--checker",
369
help="Set checker command for client")
370
parser.add_argument("-t", "--timeout",
371
help="Set timeout for client")
372
parser.add_argument("--extended-timeout",
373
help="Set extended timeout for client")
374
parser.add_argument("-i", "--interval",
375
help="Set checker interval for client")
376
parser.add_argument("--approve-by-default", action="store_true",
377
default=None, dest="approved_by_default",
378
help="Set client to be approved by default")
379
parser.add_argument("--deny-by-default", action="store_false",
380
dest="approved_by_default",
381
help="Set client to be denied by default")
382
parser.add_argument("--approval-delay",
383
help="Set delay before client approve/deny")
384
parser.add_argument("--approval-duration",
385
help="Set duration of one client approval")
386
parser.add_argument("-H", "--host", help="Set host for client")
387
parser.add_argument("-s", "--secret",
388
type=argparse.FileType(mode="rb"),
389
help="Set password blob (file) for client")
390
parser.add_argument("-A", "--approve", action="store_true",
391
help="Approve any current client request")
392
parser.add_argument("-D", "--deny", action="store_true",
393
help="Deny any current client request")
394
parser.add_argument("--check", action="store_true",
395
help="Run self-test")
396
parser.add_argument("client", nargs="*", help="Client name")
397
options = parser.parse_args()
398
399
if has_actions(options) and not (options.client or options.all):
400
parser.error("Options require clients names or --all.")
401
if options.verbose and has_actions(options):
402
parser.error("--verbose can only be used alone.")
403
if options.dump_json and (options.verbose
404
or has_actions(options)):
405
parser.error("--dump-json can only be used alone.")
406
if options.all and not has_actions(options):
407
parser.error("--all requires an action.")
408
409
try:
410
bus = dbus.SystemBus()
411
mandos_dbus_objc = bus.get_object(busname, server_path)
412
except dbus.exceptions.DBusException:
413
log.critical("Could not connect to Mandos server")
414
sys.exit(1)
415
416
mandos_serv = dbus.Interface(mandos_dbus_objc,
417
dbus_interface=server_interface)
418
mandos_serv_object_manager = dbus.Interface(
419
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
420
421
# block stderr since dbus library prints to stderr
422
null = os.open(os.path.devnull, os.O_RDWR)
423
stderrcopy = os.dup(sys.stderr.fileno())
424
os.dup2(null, sys.stderr.fileno())
425
os.close(null)
426
try:
427
try:
428
mandos_clients = {path: ifs_and_props[client_interface]
429
for path, ifs_and_props in
430
mandos_serv_object_manager
431
.GetManagedObjects().items()
432
if client_interface in ifs_and_props}
433
finally:
434
# restore stderr
435
os.dup2(stderrcopy, sys.stderr.fileno())
436
os.close(stderrcopy)
437
except dbus.exceptions.DBusException as e:
438
log.critical("Failed to access Mandos server through D-Bus:"
439
"\n%s", e)
440
sys.exit(1)
441
442
# Compile dict of (clients: properties) to process
443
clients = {}
444
445
if options.all or not options.client:
446
clients = {bus.get_object(busname, path): properties
447
for path, properties in mandos_clients.items()}
448
else:
449
for name in options.client:
450
for path, client in mandos_clients.items():
451
if client["Name"] == name:
452
client_objc = bus.get_object(busname, path)
453
clients[client_objc] = client
454
break
455
else:
456
log.critical("Client not found on server: %r", name)
457
sys.exit(1)
458
459
if not has_actions(options) and clients:
460
if options.verbose or options.dump_json:
461
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
462
"Created", "Interval", "Host", "KeyID",
463
"Fingerprint", "CheckerRunning",
464
"LastEnabled", "ApprovalPending",
465
"ApprovedByDefault", "LastApprovalRequest",
466
"ApprovalDelay", "ApprovalDuration",
467
"Checker", "ExtendedTimeout", "Expires",
468
"LastCheckerStatus")
469
else:
470
keywords = defaultkeywords
471
472
if options.dump_json:
473
json.dump({client["Name"]: {key:
474
bool(client[key])
475
if isinstance(client[key],
476
dbus.Boolean)
477
else client[key]
478
for key in keywords}
479
for client in clients.values()},
480
fp=sys.stdout, indent=4,
481
separators=(',', ': '))
482
print()
483
else:
484
print_clients(clients.values(), keywords)
485
else:
486
# Process each client in the list by all selected options
487
for client in clients:
488
489
def set_client_prop(prop, value):
490
"""Set a Client D-Bus property"""
491
client.Set(client_interface, prop, value,
492
dbus_interface=dbus.PROPERTIES_IFACE)
493
494
def set_client_prop_ms(prop, value):
495
"""Set a Client D-Bus property, converted
496
from a string to milliseconds."""
497
set_client_prop(prop,
498
string_to_delta(value).total_seconds()
499
* 1000)
500
501
if options.remove:
502
mandos_serv.RemoveClient(client.__dbus_object_path__)
503
if options.enable:
504
set_client_prop("Enabled", dbus.Boolean(True))
505
if options.disable:
506
set_client_prop("Enabled", dbus.Boolean(False))
507
if options.bump_timeout:
508
set_client_prop("LastCheckedOK", "")
509
if options.start_checker:
510
set_client_prop("CheckerRunning", dbus.Boolean(True))
511
if options.stop_checker:
512
set_client_prop("CheckerRunning", dbus.Boolean(False))
513
if options.is_enabled:
514
if client.Get(client_interface, "Enabled",
515
dbus_interface=dbus.PROPERTIES_IFACE):
516
sys.exit(0)
517
else:
518
sys.exit(1)
519
if options.checker is not None:
520
set_client_prop("Checker", options.checker)
521
if options.host is not None:
522
set_client_prop("Host", options.host)
523
if options.interval is not None:
524
set_client_prop_ms("Interval", options.interval)
525
if options.approval_delay is not None:
526
set_client_prop_ms("ApprovalDelay",
527
options.approval_delay)
528
if options.approval_duration is not None:
529
set_client_prop_ms("ApprovalDuration",
530
options.approval_duration)
531
if options.timeout is not None:
532
set_client_prop_ms("Timeout", options.timeout)
533
if options.extended_timeout is not None:
534
set_client_prop_ms("ExtendedTimeout",
535
options.extended_timeout)
536
if options.secret is not None:
537
set_client_prop("Secret",
538
dbus.ByteArray(options.secret.read()))
539
if options.approved_by_default is not None:
540
set_client_prop("ApprovedByDefault",
541
dbus.Boolean(options
542
.approved_by_default))
543
if options.approve:
544
client.Approve(dbus.Boolean(True),
545
dbus_interface=client_interface)
546
elif options.deny:
547
client.Approve(dbus.Boolean(False),
548
dbus_interface=client_interface)
549
550
551
class Test_milliseconds_to_string(unittest.TestCase):
552
def test_all(self):
553
self.assertEqual(milliseconds_to_string(93785000),
554
"1T02:03:05")
555
def test_no_days(self):
556
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
557
def test_all_zero(self):
558
self.assertEqual(milliseconds_to_string(0), "00:00:00")
559
def test_no_fractional_seconds(self):
560
self.assertEqual(milliseconds_to_string(400), "00:00:00")
561
self.assertEqual(milliseconds_to_string(900), "00:00:00")
562
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
563
564
class Test_string_to_delta(unittest.TestCase):
565
def test_handles_basic_rfc3339(self):
566
self.assertEqual(string_to_delta("PT2H"),
567
datetime.timedelta(0, 7200))
568
def test_falls_back_to_pre_1_6_1_with_warning(self):
569
# assertLogs only exists in Python 3.4
570
if hasattr(self, "assertLogs"):
571
with self.assertLogs(log, logging.WARNING):
572
value = string_to_delta("2h")
573
else:
574
value = string_to_delta("2h")
575
self.assertEqual(value, datetime.timedelta(0, 7200))
576
577
class Test_table_rows_of_clients(unittest.TestCase):
578
def setUp(self):
579
global tablewords
580
self.old_tablewords = tablewords
581
tablewords = {
582
"Attr1": "X",
583
"AttrTwo": "Yy",
584
"AttrThree": "Zzz",
585
"Bool": "A D-BUS Boolean",
586
"NonDbusBoolean": "A Non-D-BUS Boolean",
587
"Integer": "An Integer",
588
"Timeout": "Timedelta 1",
589
"Interval": "Timedelta 2",
590
"ApprovalDelay": "Timedelta 3",
591
"ApprovalDuration": "Timedelta 4",
592
"ExtendedTimeout": "Timedelta 5",
593
"String": "A String",
594
}
595
self.keywords = ["Attr1", "AttrTwo"]
596
self.clients = [
597
{
598
"Attr1": "x1",
599
"AttrTwo": "y1",
600
"AttrThree": "z1",
601
"Bool": dbus.Boolean(False),
602
"NonDbusBoolean": False,
603
"Integer": 0,
604
"Timeout": 0,
605
"Interval": 1000,
606
"ApprovalDelay": 2000,
607
"ApprovalDuration": 3000,
608
"ExtendedTimeout": 4000,
609
"String": "",
610
},
611
{
612
"Attr1": "x2",
613
"AttrTwo": "y2",
614
"AttrThree": "z2",
615
"Bool": dbus.Boolean(True),
616
"NonDbusBoolean": True,
617
"Integer": 1,
618
"Timeout": 93785000,
619
"Interval": 93786000,
620
"ApprovalDelay": 93787000,
621
"ApprovalDuration": 93788000,
622
"ExtendedTimeout": 93789000,
623
"String": "A huge string which will not fit," * 10,
624
},
625
]
626
def tearDown(self):
627
global tablewords
628
tablewords = self.old_tablewords
629
def test_short_header(self):
630
rows = table_rows_of_clients(self.clients, self.keywords)
631
expected_rows = [
632
"X Yy",
633
"x1 y1",
634
"x2 y2"]
635
self.assertEqual(rows, expected_rows)
636
def test_booleans(self):
637
keywords = ["Bool", "NonDbusBoolean"]
638
rows = table_rows_of_clients(self.clients, keywords)
639
expected_rows = [
640
"A D-BUS Boolean A Non-D-BUS Boolean",
641
"No False ",
642
"Yes True ",
643
]
644
self.assertEqual(rows, expected_rows)
645
def test_milliseconds_detection(self):
646
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
647
"ApprovalDuration", "ExtendedTimeout"]
648
rows = table_rows_of_clients(self.clients, keywords)
649
expected_rows = ("""
650
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
651
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
652
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
653
"""
654
).splitlines()[1:]
655
self.assertEqual(rows, expected_rows)
656
def test_empty_and_long_string_values(self):
657
keywords = ["String"]
658
rows = table_rows_of_clients(self.clients, keywords)
659
expected_rows = ("""
660
A String
661
662
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
663
"""
664
).splitlines()[1:]
665
self.assertEqual(rows, expected_rows)
666
667
668
669
def should_only_run_tests():
670
parser = argparse.ArgumentParser(add_help=False)
671
parser.add_argument("--check", action='store_true')
672
args, unknown_args = parser.parse_known_args()
673
run_tests = args.check
674
if run_tests:
675
# Remove --check argument from sys.argv
676
sys.argv[1:] = unknown_args
677
return run_tests
678
679
# Add all tests from doctest strings
680
def load_tests(loader, tests, none):
681
import doctest
682
tests.addTests(doctest.DocTestSuite())
683
return tests
684
685
if __name__ == "__main__":
686
if should_only_run_tests():
687
# Call using ./tdd-python-script --check [--verbose]
688
unittest.main()
689
else:
690
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0