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