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.98
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.98
- Committer: Teddy Hogeborn
- Date: 2012-01-01 20:45:53 UTC
- mto: (237.7.109 trunk) (299.1.1 release) (300.1.1 release) (301.1.1 release)
- mto: This revision was merged to the branch mainline in revision 292.
- 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
#
61
60
server_path = "/"
62
61
server_interface = domain + ".Mandos"
63
62
client_interface = domain + ".Mandos.Client"
64
version = "1.5.3"
63
version = "1.5.0"
65
64
66
65
def timedelta_to_milliseconds(td):
67
66
"""Convert a datetime.timedelta object to milliseconds"""
71
70
72
71
def milliseconds_to_string(ms):
73
72
td = datetime.timedelta(0, 0, 0, ms)
74
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
75
.format(days = "{0}T".format(td.days) if td.days else "",
76
hours = td.seconds // 3600,
77
minutes = (td.seconds % 3600) // 60,
78
seconds = td.seconds % 60,
79
))
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
})
80
79
81
80
def string_to_delta(interval):
82
81
"""Parse a string and return a datetime.timedelta
117
116
if type(value) is dbus.Boolean:
118
117
return "Yes" if value else "No"
119
118
if keyword in ("Timeout", "Interval", "ApprovalDelay",
120
"ApprovalDuration", "ExtendedTimeout"):
119
"ApprovalDuration"):
121
120
return milliseconds_to_string(value)
122
121
return unicode(value)
123
122
124
123
# Create format string to print table rows
125
format_string = " ".join("{{{key}:{width}}}".format(
126
width = max(len(tablewords[key]),
127
max(len(valuetostring(client[key],
128
key))
129
for client in
130
clients)),
131
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)
132
131
# Print header line
133
print(format_string.format(**tablewords))
132
print(format_string % tuple(tablewords[key] for key in keywords))
134
133
for client in clients:
135
print(format_string.format(**dict((key,
136
valuetostring(client[key],
137
key))
138
for key in keywords)))
134
print(format_string % tuple(valuetostring(client[key], key)
135
for key in keywords))
139
136
140
137
def has_actions(options):
141
138
return any((options.enable,
160
157
def main():
161
158
parser = argparse.ArgumentParser()
162
159
parser.add_argument("--version", action="version",
163
version = "%(prog)s {0}".format(version),
160
version = "%%prog %s" % version,
164
161
help="show version number and exit")
165
162
parser.add_argument("-a", "--all", action="store_true",
166
163
help="Select all clients")
208
205
parser.add_argument("client", nargs="*", help="Client name")
209
206
options = parser.parse_args()
210
207
211
if has_actions(options) and not (options.client or options.all):
208
if has_actions(options) and not options.client and not options.all:
212
209
parser.error("Options require clients names or --all.")
213
210
if options.verbose and has_actions(options):
214
211
parser.error("--verbose can only be used alone or with"
259
256
clients[client_objc] = client
260
257
break
261
258
else:
262
print("Client not found on server: {0!r}"
263
.format(name), file=sys.stderr)
259
print("Client not found on server: %r" % name,
260
file=sys.stderr)
264
261
sys.exit(1)
265
262
266
263
if not has_actions(options) and clients:
280
277
else:
281
278
# Process each client in the list by all selected options
282
279
for client in clients:
283
def set_client_prop(prop, value):
284
"""Set a Client D-Bus property"""
285
client.Set(client_interface, prop, value,
286
dbus_interface=dbus.PROPERTIES_IFACE)
287
def set_client_prop_ms(prop, value):
288
"""Set a Client D-Bus property, converted
289
from a string to milliseconds."""
290
set_client_prop(prop,
291
timedelta_to_milliseconds
292
(string_to_delta(value)))
293
280
if options.remove:
294
281
mandos_serv.RemoveClient(client.__dbus_object_path__)
295
282
if options.enable:
296
set_client_prop("Enabled", dbus.Boolean(True))
283
client.Enable(dbus_interface=client_interface)
297
284
if options.disable:
298
set_client_prop("Enabled", dbus.Boolean(False))
285
client.Disable(dbus_interface=client_interface)
299
286
if options.bump_timeout:
300
set_client_prop("LastCheckedOK", "")
287
client.CheckedOK(dbus_interface=client_interface)
301
288
if options.start_checker:
302
set_client_prop("CheckerRunning", dbus.Boolean(True))
289
client.StartChecker(dbus_interface=client_interface)
303
290
if options.stop_checker:
304
set_client_prop("CheckerRunning", dbus.Boolean(False))
291
client.StopChecker(dbus_interface=client_interface)
305
292
if options.is_enabled:
306
293
sys.exit(0 if client.Get(client_interface,
307
294
"Enabled",
309
296
dbus.PROPERTIES_IFACE)
310
297
else 1)
311
298
if options.checker is not None:
312
set_client_prop("Checker", options.checker)
299
client.Set(client_interface, "Checker",
300
options.checker,
301
dbus_interface=dbus.PROPERTIES_IFACE)
313
302
if options.host is not None:
314
set_client_prop("Host", options.host)
303
client.Set(client_interface, "Host", options.host,
304
dbus_interface=dbus.PROPERTIES_IFACE)
315
305
if options.interval is not None:
316
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)
317
310
if options.approval_delay is not None:
318
set_client_prop_ms("ApprovalDelay",
319
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)
320
316
if options.approval_duration is not None:
321
set_client_prop_ms("ApprovalDuration",
322
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)
323
322
if options.timeout is not None:
324
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)
325
327
if options.extended_timeout is not None:
326
set_client_prop_ms("ExtendedTimeout",
327
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)
328
332
if options.secret is not None:
329
set_client_prop("Secret",
330
dbus.ByteArray(options.secret.read()))
333
client.Set(client_interface, "Secret",
334
dbus.ByteArray(options.secret.read()),
335
dbus_interface=dbus.PROPERTIES_IFACE)
331
336
if options.approved_by_default is not None:
332
set_client_prop("ApprovedByDefault",
333
dbus.Boolean(options
334
.approved_by_default))
337
client.Set(client_interface, "ApprovedByDefault",
338
dbus.Boolean(options
339
.approved_by_default),
340
dbus_interface=dbus.PROPERTIES_IFACE)
335
341
if options.approve:
336
342
client.Approve(dbus.Boolean(True),
337
343
dbus_interface=client_interface)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0