To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 237.7.16
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.16
- Committer: Teddy Hogeborn
- Date: 2011-02-27 17:46:47 UTC
- mto: (237.12.2 mandos-persistent) (24.1.171 mandos) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 282.
- Revision ID: teddy@fukt.bsnet.se-20110227174647-oc7prq1d63lfkn2e
* debian/control (mandos-client): Fix syntax of conflicts line.
- files removed:
- bugs.xml
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-ctl
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2008-2016 Teddy Hogeborn
7
# Copyright © 2008-2016 Björn Påhlsson
6
# Copyright © 2008-2010 Teddy Hogeborn
7
# Copyright © 2008-2010 Björn Påhlsson
8
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
17
17
# GNU General Public License for more details.
18
18
#
19
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
21
#
23
# Contact the authors at <mandos@recompile.se>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
24
23
#
25
24
26
25
from __future__ import (division, absolute_import, print_function,
27
26
unicode_literals)
28
27
29
try:
30
from future_builtins import *
31
except ImportError:
32
pass
33
34
28
import sys
35
import argparse
29
import dbus
30
from optparse import OptionParser
36
31
import locale
37
32
import datetime
38
33
import re
39
34
import os
40
import collections
41
import doctest
42
import json
43
44
import dbus
45
46
if sys.version_info.major == 2:
47
str = unicode
48
35
49
36
locale.setlocale(locale.LC_ALL, "")
50
37
65
52
"ApprovalDelay": "Approval Delay",
66
53
"ApprovalDuration": "Approval Duration",
67
54
"Checker": "Checker",
68
"ExtendedTimeout": "Extended Timeout"
69
}
55
}
70
56
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
71
domain = "se.recompile"
57
domain = "se.bsnet.fukt"
72
58
busname = domain + ".Mandos"
73
59
server_path = "/"
74
60
server_interface = domain + ".Mandos"
75
61
client_interface = domain + ".Mandos.Client"
76
version = "1.7.10"
77
78
79
try:
80
dbus.OBJECT_MANAGER_IFACE
81
except AttributeError:
82
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
62
version = "1.2.3"
63
64
def timedelta_to_milliseconds(td):
65
"""Convert a datetime.timedelta object to milliseconds"""
66
return ((td.days * 24 * 60 * 60 * 1000)
67
+ (td.seconds * 1000)
68
+ (td.microseconds // 1000))
83
69
84
70
def milliseconds_to_string(ms):
85
71
td = datetime.timedelta(0, 0, 0, ms)
86
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
87
days = "{}T".format(td.days) if td.days else "",
88
hours = td.seconds // 3600,
89
minutes = (td.seconds % 3600) // 60,
90
seconds = td.seconds % 60))
91
92
93
def rfc3339_duration_to_delta(duration):
94
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
95
96
>>> rfc3339_duration_to_delta("P7D")
97
datetime.timedelta(7)
98
>>> rfc3339_duration_to_delta("PT60S")
99
datetime.timedelta(0, 60)
100
>>> rfc3339_duration_to_delta("PT60M")
101
datetime.timedelta(0, 3600)
102
>>> rfc3339_duration_to_delta("PT24H")
103
datetime.timedelta(1)
104
>>> rfc3339_duration_to_delta("P1W")
105
datetime.timedelta(7)
106
>>> rfc3339_duration_to_delta("PT5M30S")
107
datetime.timedelta(0, 330)
108
>>> rfc3339_duration_to_delta("P1DT3M20S")
109
datetime.timedelta(1, 200)
110
"""
111
112
# Parsing an RFC 3339 duration with regular expressions is not
113
# possible - there would have to be multiple places for the same
114
# values, like seconds. The current code, while more esoteric, is
115
# cleaner without depending on a parsing library. If Python had a
116
# built-in library for parsing we would use it, but we'd like to
117
# avoid excessive use of external libraries.
118
119
# New type for defining tokens, syntax, and semantics all-in-one
120
Token = collections.namedtuple("Token", (
121
"regexp", # To match token; if "value" is not None, must have
122
# a "group" containing digits
123
"value", # datetime.timedelta or None
124
"followers")) # Tokens valid after this token
125
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
126
# the "duration" ABNF definition in RFC 3339, Appendix A.
127
token_end = Token(re.compile(r"$"), None, frozenset())
128
token_second = Token(re.compile(r"(\d+)S"),
129
datetime.timedelta(seconds=1),
130
frozenset((token_end, )))
131
token_minute = Token(re.compile(r"(\d+)M"),
132
datetime.timedelta(minutes=1),
133
frozenset((token_second, token_end)))
134
token_hour = Token(re.compile(r"(\d+)H"),
135
datetime.timedelta(hours=1),
136
frozenset((token_minute, token_end)))
137
token_time = Token(re.compile(r"T"),
138
None,
139
frozenset((token_hour, token_minute,
140
token_second)))
141
token_day = Token(re.compile(r"(\d+)D"),
142
datetime.timedelta(days=1),
143
frozenset((token_time, token_end)))
144
token_month = Token(re.compile(r"(\d+)M"),
145
datetime.timedelta(weeks=4),
146
frozenset((token_day, token_end)))
147
token_year = Token(re.compile(r"(\d+)Y"),
148
datetime.timedelta(weeks=52),
149
frozenset((token_month, token_end)))
150
token_week = Token(re.compile(r"(\d+)W"),
151
datetime.timedelta(weeks=1),
152
frozenset((token_end, )))
153
token_duration = Token(re.compile(r"P"), None,
154
frozenset((token_year, token_month,
155
token_day, token_time,
156
token_week)))
157
# Define starting values
158
value = datetime.timedelta() # Value so far
159
found_token = None
160
followers = frozenset((token_duration, )) # Following valid tokens
161
s = duration # String left to parse
162
# Loop until end token is found
163
while found_token is not token_end:
164
# Search for any currently valid tokens
165
for token in followers:
166
match = token.regexp.match(s)
167
if match is not None:
168
# Token found
169
if token.value is not None:
170
# Value found, parse digits
171
factor = int(match.group(1), 10)
172
# Add to value so far
173
value += factor * token.value
174
# Strip token from string
175
s = token.regexp.sub("", s, 1)
176
# Go to found token
177
found_token = token
178
# Set valid next tokens
179
followers = found_token.followers
180
break
181
else:
182
# No currently valid tokens were found
183
raise ValueError("Invalid RFC 3339 duration: {!r}"
184
.format(duration))
185
# End token found
186
return value
72
return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
73
% { "days": "%dT" % td.days if td.days else "",
74
"hours": td.seconds // 3600,
75
"minutes": (td.seconds % 3600) // 60,
76
"seconds": td.seconds % 60,
77
})
187
78
188
79
189
80
def string_to_delta(interval):
190
81
"""Parse a string and return a datetime.timedelta
191
192
>>> string_to_delta('7d')
82
83
>>> string_to_delta("7d")
193
84
datetime.timedelta(7)
194
>>> string_to_delta('60s')
85
>>> string_to_delta("60s")
195
86
datetime.timedelta(0, 60)
196
>>> string_to_delta('60m')
87
>>> string_to_delta("60m")
197
88
datetime.timedelta(0, 3600)
198
>>> string_to_delta('24h')
89
>>> string_to_delta("24h")
199
90
datetime.timedelta(1)
200
>>> string_to_delta('1w')
91
>>> string_to_delta("1w")
201
92
datetime.timedelta(7)
202
>>> string_to_delta('5m 30s')
93
>>> string_to_delta("5m 30s")
203
94
datetime.timedelta(0, 330)
204
95
"""
205
206
try:
207
return rfc3339_duration_to_delta(interval)
208
except ValueError:
209
pass
210
211
value = datetime.timedelta(0)
212
regexp = re.compile(r"(\d+)([dsmhw]?)")
213
214
for num, suffix in regexp.findall(interval):
215
if suffix == "d":
216
value += datetime.timedelta(int(num))
217
elif suffix == "s":
218
value += datetime.timedelta(0, int(num))
219
elif suffix == "m":
220
value += datetime.timedelta(0, 0, 0, 0, int(num))
221
elif suffix == "h":
222
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
223
elif suffix == "w":
224
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
225
elif suffix == "":
226
value += datetime.timedelta(0, 0, 0, int(num))
227
return value
228
96
timevalue = datetime.timedelta(0)
97
regexp = re.compile("\d+[dsmhw]")
98
99
for s in regexp.findall(interval):
100
try:
101
suffix = unicode(s[-1])
102
value = int(s[:-1])
103
if suffix == "d":
104
delta = datetime.timedelta(value)
105
elif suffix == "s":
106
delta = datetime.timedelta(0, value)
107
elif suffix == "m":
108
delta = datetime.timedelta(0, 0, 0, 0, value)
109
elif suffix == "h":
110
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
111
elif suffix == "w":
112
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
113
else:
114
raise ValueError
115
except (ValueError, IndexError):
116
raise ValueError
117
timevalue += delta
118
return timevalue
229
119
230
120
def print_clients(clients, keywords):
231
121
def valuetostring(value, keyword):
232
122
if type(value) is dbus.Boolean:
233
123
return "Yes" if value else "No"
234
124
if keyword in ("Timeout", "Interval", "ApprovalDelay",
235
"ApprovalDuration", "ExtendedTimeout"):
125
"ApprovalDuration"):
236
126
return milliseconds_to_string(value)
237
return str(value)
127
return unicode(value)
238
128
239
129
# Create format string to print table rows
240
format_string = " ".join("{{{key}:{width}}}".format(
241
width = max(len(tablewords[key]),
242
max(len(valuetostring(client[key], key))
243
for client in clients)),
244
key = key)
130
format_string = " ".join("%%-%ds" %
131
max(len(tablewords[key]),
132
max(len(valuetostring(client[key],
133
key))
134
for client in
135
clients))
245
136
for key in keywords)
246
137
# Print header line
247
print(format_string.format(**tablewords))
138
print(format_string % tuple(tablewords[key] for key in keywords))
248
139
for client in clients:
249
print(format_string.format(**{
250
key: valuetostring(client[key], key)
251
for key in keywords }))
252
140
print(format_string % tuple(valuetostring(client[key], key)
141
for key in keywords))
253
142
254
143
def has_actions(options):
255
144
return any((options.enable,
261
150
options.remove,
262
151
options.checker is not None,
263
152
options.timeout is not None,
264
options.extended_timeout is not None,
265
153
options.interval is not None,
266
154
options.approved_by_default is not None,
267
155
options.approval_delay is not None,
270
158
options.secret is not None,
271
159
options.approve,
272
160
options.deny))
273
274
161
275
162
def main():
276
parser = argparse.ArgumentParser()
277
parser.add_argument("--version", action="version",
278
version = "%(prog)s {}".format(version),
279
help="show version number and exit")
280
parser.add_argument("-a", "--all", action="store_true",
281
help="Select all clients")
282
parser.add_argument("-v", "--verbose", action="store_true",
283
help="Print all fields")
284
parser.add_argument("-j", "--dump-json", action="store_true",
285
help="Dump client data in JSON format")
286
parser.add_argument("-e", "--enable", action="store_true",
287
help="Enable client")
288
parser.add_argument("-d", "--disable", action="store_true",
289
help="disable client")
290
parser.add_argument("-b", "--bump-timeout", action="store_true",
291
help="Bump timeout for client")
292
parser.add_argument("--start-checker", action="store_true",
293
help="Start checker for client")
294
parser.add_argument("--stop-checker", action="store_true",
295
help="Stop checker for client")
296
parser.add_argument("-V", "--is-enabled", action="store_true",
297
help="Check if client is enabled")
298
parser.add_argument("-r", "--remove", action="store_true",
299
help="Remove client")
300
parser.add_argument("-c", "--checker",
301
help="Set checker command for client")
302
parser.add_argument("-t", "--timeout",
303
help="Set timeout for client")
304
parser.add_argument("--extended-timeout",
305
help="Set extended timeout for client")
306
parser.add_argument("-i", "--interval",
307
help="Set checker interval for client")
308
parser.add_argument("--approve-by-default", action="store_true",
309
default=None, dest="approved_by_default",
310
help="Set client to be approved by default")
311
parser.add_argument("--deny-by-default", action="store_false",
312
dest="approved_by_default",
313
help="Set client to be denied by default")
314
parser.add_argument("--approval-delay",
315
help="Set delay before client approve/deny")
316
parser.add_argument("--approval-duration",
317
help="Set duration of one client approval")
318
parser.add_argument("-H", "--host", help="Set host for client")
319
parser.add_argument("-s", "--secret",
320
type=argparse.FileType(mode="rb"),
321
help="Set password blob (file) for client")
322
parser.add_argument("-A", "--approve", action="store_true",
323
help="Approve any current client request")
324
parser.add_argument("-D", "--deny", action="store_true",
325
help="Deny any current client request")
326
parser.add_argument("--check", action="store_true",
327
help="Run self-test")
328
parser.add_argument("client", nargs="*", help="Client name")
329
options = parser.parse_args()
330
331
if has_actions(options) and not (options.client or options.all):
332
parser.error("Options require clients names or --all.")
333
if options.verbose and has_actions(options):
334
parser.error("--verbose can only be used alone.")
335
if options.dump_json and (options.verbose or has_actions(options)):
336
parser.error("--dump-json can only be used alone.")
337
if options.all and not has_actions(options):
338
parser.error("--all requires an action.")
339
340
if options.check:
341
fail_count, test_count = doctest.testmod()
342
sys.exit(os.EX_OK if fail_count == 0 else 1)
343
344
try:
345
bus = dbus.SystemBus()
346
mandos_dbus_objc = bus.get_object(busname, server_path)
347
except dbus.exceptions.DBusException:
348
print("Could not connect to Mandos server", file=sys.stderr)
349
sys.exit(1)
350
351
mandos_serv = dbus.Interface(mandos_dbus_objc,
352
dbus_interface = server_interface)
353
mandos_serv_object_manager = dbus.Interface(
354
mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
355
356
#block stderr since dbus library prints to stderr
357
null = os.open(os.path.devnull, os.O_RDWR)
358
stderrcopy = os.dup(sys.stderr.fileno())
359
os.dup2(null, sys.stderr.fileno())
360
os.close(null)
361
try:
362
try:
363
mandos_clients = { path: ifs_and_props[client_interface]
364
for path, ifs_and_props in
365
mandos_serv_object_manager
366
.GetManagedObjects().items()
367
if client_interface in ifs_and_props }
368
finally:
369
#restore stderr
370
os.dup2(stderrcopy, sys.stderr.fileno())
371
os.close(stderrcopy)
372
except dbus.exceptions.DBusException as e:
373
print("Access denied: Accessing mandos server through D-Bus: {}"
374
.format(e), file=sys.stderr)
375
sys.exit(1)
376
377
# Compile dict of (clients: properties) to process
378
clients={}
379
380
if options.all or not options.client:
381
clients = { bus.get_object(busname, path): properties
382
for path, properties in mandos_clients.items() }
383
else:
384
for name in options.client:
385
for path, client in mandos_clients.items():
386
if client["Name"] == name:
387
client_objc = bus.get_object(busname, path)
388
clients[client_objc] = client
389
break
163
parser = OptionParser(version = "%%prog %s" % version)
164
parser.add_option("-a", "--all", action="store_true",
165
help="Select all clients")
166
parser.add_option("-v", "--verbose", action="store_true",
167
help="Print all fields")
168
parser.add_option("-e", "--enable", action="store_true",
169
help="Enable client")
170
parser.add_option("-d", "--disable", action="store_true",
171
help="disable client")
172
parser.add_option("-b", "--bump-timeout", action="store_true",
173
help="Bump timeout for client")
174
parser.add_option("--start-checker", action="store_true",
175
help="Start checker for client")
176
parser.add_option("--stop-checker", action="store_true",
177
help="Stop checker for client")
178
parser.add_option("-V", "--is-enabled", action="store_true",
179
help="Check if client is enabled")
180
parser.add_option("-r", "--remove", action="store_true",
181
help="Remove client")
182
parser.add_option("-c", "--checker", type="string",
183
help="Set checker command for client")
184
parser.add_option("-t", "--timeout", type="string",
185
help="Set timeout for client")
186
parser.add_option("-i", "--interval", type="string",
187
help="Set checker interval for client")
188
parser.add_option("--approve-by-default", action="store_true",
189
dest="approved_by_default",
190
help="Set client to be approved by default")
191
parser.add_option("--deny-by-default", action="store_false",
192
dest="approved_by_default",
193
help="Set client to be denied by default")
194
parser.add_option("--approval-delay", type="string",
195
help="Set delay before client approve/deny")
196
parser.add_option("--approval-duration", type="string",
197
help="Set duration of one client approval")
198
parser.add_option("-H", "--host", type="string",
199
help="Set host for client")
200
parser.add_option("-s", "--secret", type="string",
201
help="Set password blob (file) for client")
202
parser.add_option("-A", "--approve", action="store_true",
203
help="Approve any current client request")
204
parser.add_option("-D", "--deny", action="store_true",
205
help="Deny any current client request")
206
options, client_names = parser.parse_args()
207
208
if has_actions(options) and not client_names and not options.all:
209
parser.error("Options require clients names or --all.")
210
if options.verbose and has_actions(options):
211
parser.error("--verbose can only be used alone or with"
212
" --all.")
213
if options.all and not has_actions(options):
214
parser.error("--all requires an action.")
215
216
try:
217
bus = dbus.SystemBus()
218
mandos_dbus_objc = bus.get_object(busname, server_path)
219
except dbus.exceptions.DBusException:
220
print("Could not connect to Mandos server",
221
file=sys.stderr)
222
sys.exit(1)
223
224
mandos_serv = dbus.Interface(mandos_dbus_objc,
225
dbus_interface = server_interface)
226
227
#block stderr since dbus library prints to stderr
228
null = os.open(os.path.devnull, os.O_RDWR)
229
stderrcopy = os.dup(sys.stderr.fileno())
230
os.dup2(null, sys.stderr.fileno())
231
os.close(null)
232
try:
233
try:
234
mandos_clients = mandos_serv.GetAllClientsWithProperties()
235
finally:
236
#restore stderr
237
os.dup2(stderrcopy, sys.stderr.fileno())
238
os.close(stderrcopy)
239
except dbus.exceptions.DBusException, e:
240
print("Access denied: Accessing mandos server through dbus.",
241
file=sys.stderr)
242
sys.exit(1)
243
244
# Compile dict of (clients: properties) to process
245
clients={}
246
247
if options.all or not client_names:
248
clients = dict((bus.get_object(busname, path), properties)
249
for path, properties in
250
mandos_clients.iteritems())
251
else:
252
for name in client_names:
253
for path, client in mandos_clients.iteritems():
254
if client["Name"] == name:
255
client_objc = bus.get_object(busname, path)
256
clients[client_objc] = client
257
break
258
else:
259
print("Client not found on server: %r" % name,
260
file=sys.stderr)
261
sys.exit(1)
262
263
if not has_actions(options) and clients:
264
if options.verbose:
265
keywords = ("Name", "Enabled", "Timeout",
266
"LastCheckedOK", "Created", "Interval",
267
"Host", "Fingerprint", "CheckerRunning",
268
"LastEnabled", "ApprovalPending",
269
"ApprovedByDefault",
270
"LastApprovalRequest", "ApprovalDelay",
271
"ApprovalDuration", "Checker")
390
272
else:
391
print("Client not found on server: {!r}"
392
.format(name), file=sys.stderr)
393
sys.exit(1)
394
395
if not has_actions(options) and clients:
396
if options.verbose or options.dump_json:
397
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
398
"Created", "Interval", "Host", "Fingerprint",
399
"CheckerRunning", "LastEnabled",
400
"ApprovalPending", "ApprovedByDefault",
401
"LastApprovalRequest", "ApprovalDelay",
402
"ApprovalDuration", "Checker",
403
"ExtendedTimeout")
404
else:
405
keywords = defaultkeywords
406
407
if options.dump_json:
408
json.dump({client["Name"]: {key: client[key]
409
for key in keywords }
410
for client in clients.values() },
411
fp = sys.stdout, indent = 4,
412
separators = (',', ': '))
413
print()
414
else:
415
print_clients(clients.values(), keywords)
416
else:
417
# Process each client in the list by all selected options
418
for client in clients:
419
420
def set_client_prop(prop, value):
421
"""Set a Client D-Bus property"""
422
client.Set(client_interface, prop, value,
423
dbus_interface=dbus.PROPERTIES_IFACE)
424
425
def set_client_prop_ms(prop, value):
426
"""Set a Client D-Bus property, converted
427
from a string to milliseconds."""
428
set_client_prop(prop,
429
string_to_delta(value).total_seconds()
430
* 1000)
431
432
if options.remove:
433
mandos_serv.RemoveClient(client.__dbus_object_path__)
434
if options.enable:
435
set_client_prop("Enabled", dbus.Boolean(True))
436
if options.disable:
437
set_client_prop("Enabled", dbus.Boolean(False))
438
if options.bump_timeout:
439
set_client_prop("LastCheckedOK", "")
440
if options.start_checker:
441
set_client_prop("CheckerRunning", dbus.Boolean(True))
442
if options.stop_checker:
443
set_client_prop("CheckerRunning", dbus.Boolean(False))
444
if options.is_enabled:
445
sys.exit(0 if client.Get(client_interface,
446
"Enabled",
447
dbus_interface=
448
dbus.PROPERTIES_IFACE)
449
else 1)
450
if options.checker is not None:
451
set_client_prop("Checker", options.checker)
452
if options.host is not None:
453
set_client_prop("Host", options.host)
454
if options.interval is not None:
455
set_client_prop_ms("Interval", options.interval)
456
if options.approval_delay is not None:
457
set_client_prop_ms("ApprovalDelay",
458
options.approval_delay)
459
if options.approval_duration is not None:
460
set_client_prop_ms("ApprovalDuration",
461
options.approval_duration)
462
if options.timeout is not None:
463
set_client_prop_ms("Timeout", options.timeout)
464
if options.extended_timeout is not None:
465
set_client_prop_ms("ExtendedTimeout",
466
options.extended_timeout)
467
if options.secret is not None:
468
set_client_prop("Secret",
469
dbus.ByteArray(options.secret.read()))
470
if options.approved_by_default is not None:
471
set_client_prop("ApprovedByDefault",
472
dbus.Boolean(options
473
.approved_by_default))
474
if options.approve:
475
client.Approve(dbus.Boolean(True),
476
dbus_interface=client_interface)
477
elif options.deny:
478
client.Approve(dbus.Boolean(False),
479
dbus_interface=client_interface)
480
273
keywords = defaultkeywords
274
275
print_clients(clients.values(), keywords)
276
else:
277
# Process each client in the list by all selected options
278
for client in clients:
279
if options.remove:
280
mandos_serv.RemoveClient(client.__dbus_object_path__)
281
if options.enable:
282
client.Enable(dbus_interface=client_interface)
283
if options.disable:
284
client.Disable(dbus_interface=client_interface)
285
if options.bump_timeout:
286
client.CheckedOK(dbus_interface=client_interface)
287
if options.start_checker:
288
client.StartChecker(dbus_interface=client_interface)
289
if options.stop_checker:
290
client.StopChecker(dbus_interface=client_interface)
291
if options.is_enabled:
292
sys.exit(0 if client.Get(client_interface,
293
"Enabled",
294
dbus_interface=dbus.PROPERTIES_IFACE)
295
else 1)
296
if options.checker:
297
client.Set(client_interface, "Checker", options.checker,
298
dbus_interface=dbus.PROPERTIES_IFACE)
299
if options.host:
300
client.Set(client_interface, "Host", options.host,
301
dbus_interface=dbus.PROPERTIES_IFACE)
302
if options.interval:
303
client.Set(client_interface, "Interval",
304
timedelta_to_milliseconds
305
(string_to_delta(options.interval)),
306
dbus_interface=dbus.PROPERTIES_IFACE)
307
if options.approval_delay:
308
client.Set(client_interface, "ApprovalDelay",
309
timedelta_to_milliseconds
310
(string_to_delta(options.
311
approval_delay)),
312
dbus_interface=dbus.PROPERTIES_IFACE)
313
if options.approval_duration:
314
client.Set(client_interface, "ApprovalDuration",
315
timedelta_to_milliseconds
316
(string_to_delta(options.
317
approval_duration)),
318
dbus_interface=dbus.PROPERTIES_IFACE)
319
if options.timeout:
320
client.Set(client_interface, "Timeout",
321
timedelta_to_milliseconds
322
(string_to_delta(options.timeout)),
323
dbus_interface=dbus.PROPERTIES_IFACE)
324
if options.secret:
325
client.Set(client_interface, "Secret",
326
dbus.ByteArray(open(options.secret,
327
"rb").read()),
328
dbus_interface=dbus.PROPERTIES_IFACE)
329
if options.approved_by_default is not None:
330
client.Set(client_interface, "ApprovedByDefault",
331
dbus.Boolean(options
332
.approved_by_default),
333
dbus_interface=dbus.PROPERTIES_IFACE)
334
if options.approve:
335
client.Approve(dbus.Boolean(True),
336
dbus_interface=client_interface)
337
elif options.deny:
338
client.Approve(dbus.Boolean(False),
339
dbus_interface=client_interface)
481
340
482
341
if __name__ == "__main__":
483
342
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0