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