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 237.7.1
- compare with another revision
- compare with revision 75
- download diff
- download tarball
- view history from revision 237.7.1
- Committer: Teddy Hogeborn
- Date: 2012-05-20 13:17:37 UTC
- mfrom: (585 trunk)
- mto: (237.4.31 release)
- mto: This revision was merged to the branch mainline in revision 586.
- Revision ID: teddy@recompile.se-20120520131737-p1toj7kaxgs3wki3
merge from trunk
added
removed
mandos-ctl
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 <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
21
22
#
22
23
# Contact the authors at <mandos@recompile.se>.
23
24
#
25
26
from __future__ import (division, absolute_import, print_function,
26
27
unicode_literals)
27
28
29
from future_builtins import *
30
28
31
import sys
29
32
import dbus
30
33
import argparse
70
73
71
74
def milliseconds_to_string(ms):
72
75
td = datetime.timedelta(0, 0, 0, ms)
73
return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
74
% { "days": "%dT" % td.days if td.days else "",
75
"hours": td.seconds // 3600,
76
"minutes": (td.seconds % 3600) // 60,
77
"seconds": td.seconds % 60,
78
})
76
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
77
.format(days = "{0}T".format(td.days) if td.days else "",
78
hours = td.seconds // 3600,
79
minutes = (td.seconds % 3600) // 60,
80
seconds = td.seconds % 60,
81
))
79
82
80
83
def string_to_delta(interval):
81
84
"""Parse a string and return a datetime.timedelta
116
119
if type(value) is dbus.Boolean:
117
120
return "Yes" if value else "No"
118
121
if keyword in ("Timeout", "Interval", "ApprovalDelay",
119
"ApprovalDuration"):
122
"ApprovalDuration", "ExtendedTimeout"):
120
123
return milliseconds_to_string(value)
121
124
return unicode(value)
122
125
123
126
# Create format string to print table rows
124
format_string = " ".join("%%-%ds" %
125
max(len(tablewords[key]),
126
max(len(valuetostring(client[key],
127
key))
128
for client in
129
clients))
130
for key in keywords)
127
format_string = " ".join("{{{key}:{width}}}".format(
128
width = max(len(tablewords[key]),
129
max(len(valuetostring(client[key],
130
key))
131
for client in
132
clients)),
133
key = key) for key in keywords)
131
134
# Print header line
132
print(format_string % tuple(tablewords[key] for key in keywords))
135
print(format_string.format(**tablewords))
133
136
for client in clients:
134
print(format_string % tuple(valuetostring(client[key], key)
135
for key in keywords))
137
print(format_string.format(**dict((key,
138
valuetostring(client[key],
139
key))
140
for key in keywords)))
136
141
137
142
def has_actions(options):
138
143
return any((options.enable,
157
162
def main():
158
163
parser = argparse.ArgumentParser()
159
164
parser.add_argument("--version", action="version",
160
version = "%%prog %s" % version,
165
version = "%(prog)s {0}".format(version),
161
166
help="show version number and exit")
162
167
parser.add_argument("-a", "--all", action="store_true",
163
168
help="Select all clients")
205
210
parser.add_argument("client", nargs="*", help="Client name")
206
211
options = parser.parse_args()
207
212
208
if has_actions(options) and not options.client and not options.all:
213
if has_actions(options) and not (options.client or options.all):
209
214
parser.error("Options require clients names or --all.")
210
215
if options.verbose and has_actions(options):
211
216
parser.error("--verbose can only be used alone or with"
256
261
clients[client_objc] = client
257
262
break
258
263
else:
259
print("Client not found on server: %r" % name,
260
file=sys.stderr)
264
print("Client not found on server: {0!r}"
265
.format(name), file=sys.stderr)
261
266
sys.exit(1)
262
267
263
268
if not has_actions(options) and clients:
277
282
else:
278
283
# Process each client in the list by all selected options
279
284
for client in clients:
285
def set_client_prop(prop, value):
286
"""Set a Client D-Bus property"""
287
client.Set(client_interface, prop, value,
288
dbus_interface=dbus.PROPERTIES_IFACE)
289
def set_client_prop_ms(prop, value):
290
"""Set a Client D-Bus property, converted
291
from a string to milliseconds."""
292
set_client_prop(prop,
293
timedelta_to_milliseconds
294
(string_to_delta(value)))
280
295
if options.remove:
281
296
mandos_serv.RemoveClient(client.__dbus_object_path__)
282
297
if options.enable:
283
client.Enable(dbus_interface=client_interface)
298
set_client_prop("Enabled", dbus.Boolean(True))
284
299
if options.disable:
285
client.Disable(dbus_interface=client_interface)
300
set_client_prop("Enabled", dbus.Boolean(False))
286
301
if options.bump_timeout:
287
client.CheckedOK(dbus_interface=client_interface)
302
set_client_prop("LastCheckedOK", "")
288
303
if options.start_checker:
289
client.StartChecker(dbus_interface=client_interface)
304
set_client_prop("CheckerRunning", dbus.Boolean(True))
290
305
if options.stop_checker:
291
client.StopChecker(dbus_interface=client_interface)
306
set_client_prop("CheckerRunning", dbus.Boolean(False))
292
307
if options.is_enabled:
293
308
sys.exit(0 if client.Get(client_interface,
294
309
"Enabled",
296
311
dbus.PROPERTIES_IFACE)
297
312
else 1)
298
313
if options.checker is not None:
299
client.Set(client_interface, "Checker",
300
options.checker,
301
dbus_interface=dbus.PROPERTIES_IFACE)
314
set_client_prop("Checker", options.checker)
302
315
if options.host is not None:
303
client.Set(client_interface, "Host", options.host,
304
dbus_interface=dbus.PROPERTIES_IFACE)
316
set_client_prop("Host", options.host)
305
317
if options.interval is not None:
306
client.Set(client_interface, "Interval",
307
timedelta_to_milliseconds
308
(string_to_delta(options.interval)),
309
dbus_interface=dbus.PROPERTIES_IFACE)
318
set_client_prop_ms("Interval", options.interval)
310
319
if options.approval_delay is not None:
311
client.Set(client_interface, "ApprovalDelay",
312
timedelta_to_milliseconds
313
(string_to_delta(options.
314
approval_delay)),
315
dbus_interface=dbus.PROPERTIES_IFACE)
320
set_client_prop_ms("ApprovalDelay",
321
options.approval_delay)
316
322
if options.approval_duration is not None:
317
client.Set(client_interface, "ApprovalDuration",
318
timedelta_to_milliseconds
319
(string_to_delta(options.
320
approval_duration)),
321
dbus_interface=dbus.PROPERTIES_IFACE)
323
set_client_prop_ms("ApprovalDuration",
324
options.approval_duration)
322
325
if options.timeout is not None:
323
client.Set(client_interface, "Timeout",
324
timedelta_to_milliseconds
325
(string_to_delta(options.timeout)),
326
dbus_interface=dbus.PROPERTIES_IFACE)
326
set_client_prop_ms("Timeout", options.timeout)
327
327
if options.extended_timeout is not None:
328
client.Set(client_interface, "ExtendedTimeout",
329
timedelta_to_milliseconds
330
(string_to_delta(options.extended_timeout)),
331
dbus_interface=dbus.PROPERTIES_IFACE)
328
set_client_prop_ms("ExtendedTimeout",
329
options.extended_timeout)
332
330
if options.secret is not None:
333
client.Set(client_interface, "Secret",
334
dbus.ByteArray(options.secret.read()),
335
dbus_interface=dbus.PROPERTIES_IFACE)
331
set_client_prop("Secret",
332
dbus.ByteArray(options.secret.read()))
336
333
if options.approved_by_default is not None:
337
client.Set(client_interface, "ApprovedByDefault",
338
dbus.Boolean(options
339
.approved_by_default),
340
dbus_interface=dbus.PROPERTIES_IFACE)
334
set_client_prop("ApprovedByDefault",
335
dbus.Boolean(options
336
.approved_by_default))
341
337
if options.approve:
342
338
client.Approve(dbus.Boolean(True),
343
339
dbus_interface=client_interface)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0