/mandos/release

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

* mandos-ctl (main): Use D-Bus properties instead of methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
279
279
    else:
280
280
        # Process each client in the list by all selected options
281
281
        for client in clients:
 
282
            def set_client_prop(prop, value):
 
283
                """Set a Client D-Bus property"""
 
284
                client.Set(client_interface, prop, value,
 
285
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
286
            def set_client_prop_ms(prop, value):
 
287
                """Set a Client D-Bus property, converted
 
288
                from a string to milliseconds."""
 
289
                set_client_prop(prop,
 
290
                                timedelta_to_milliseconds
 
291
                                (string_to_delta(value)))
282
292
            if options.remove:
283
293
                mandos_serv.RemoveClient(client.__dbus_object_path__)
284
294
            if options.enable:
285
 
                client.Enable(dbus_interface=client_interface)
 
295
                set_client_prop("Enabled", dbus.Boolean(True))
286
296
            if options.disable:
287
 
                client.Disable(dbus_interface=client_interface)
 
297
                set_client_prop("Enabled", dbus.Boolean(False))
288
298
            if options.bump_timeout:
289
 
                client.CheckedOK(dbus_interface=client_interface)
 
299
                set_client_prop("LastCheckedOK", "")
290
300
            if options.start_checker:
291
 
                client.StartChecker(dbus_interface=client_interface)
 
301
                set_client_prop("CheckerRunning", dbus.Boolean(True))
292
302
            if options.stop_checker:
293
 
                client.StopChecker(dbus_interface=client_interface)
 
303
                set_client_prop("CheckerRunning", dbus.Boolean(False))
294
304
            if options.is_enabled:
295
305
                sys.exit(0 if client.Get(client_interface,
296
306
                                         "Enabled",
298
308
                                         dbus.PROPERTIES_IFACE)
299
309
                         else 1)
300
310
            if options.checker is not None:
301
 
                client.Set(client_interface, "Checker",
302
 
                           options.checker,
303
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
311
                set_client_prop("Checker", options.checker)
304
312
            if options.host is not None:
305
 
                client.Set(client_interface, "Host", options.host,
306
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
313
                set_client_prop("Host", options.host)
307
314
            if options.interval is not None:
308
 
                client.Set(client_interface, "Interval",
309
 
                           timedelta_to_milliseconds
310
 
                           (string_to_delta(options.interval)),
311
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
315
                set_client_prop_ms("Interval", options.interval)
312
316
            if options.approval_delay is not None:
313
 
                client.Set(client_interface, "ApprovalDelay",
314
 
                           timedelta_to_milliseconds
315
 
                           (string_to_delta(options.
316
 
                                            approval_delay)),
317
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
317
                set_client_prop_ms("ApprovalDelay",
 
318
                                   options.approval_delay)
318
319
            if options.approval_duration is not None:
319
 
                client.Set(client_interface, "ApprovalDuration",
320
 
                           timedelta_to_milliseconds
321
 
                           (string_to_delta(options.
322
 
                                            approval_duration)),
323
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
320
                set_client_prop_ms("ApprovalDuration",
 
321
                                   options.approval_duration)
324
322
            if options.timeout is not None:
325
 
                client.Set(client_interface, "Timeout",
326
 
                           timedelta_to_milliseconds
327
 
                           (string_to_delta(options.timeout)),
328
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
323
                set_client_prop_ms("Timeout", options.timeout)
329
324
            if options.extended_timeout is not None:
330
 
                client.Set(client_interface, "ExtendedTimeout",
331
 
                           timedelta_to_milliseconds
332
 
                           (string_to_delta(options.extended_timeout)),
333
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
325
                set_client_prop_ms("ExtendedTimeout",
 
326
                                   options.extended_timeout)
334
327
            if options.secret is not None:
335
 
                client.Set(client_interface, "Secret",
336
 
                           dbus.ByteArray(options.secret.read()),
337
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
328
                set_client_prop("Secret",
 
329
                                dbus.ByteArray(options.secret.read()))
338
330
            if options.approved_by_default is not None:
339
 
                client.Set(client_interface, "ApprovedByDefault",
340
 
                           dbus.Boolean(options
341
 
                                        .approved_by_default),
342
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
331
                set_client_prop("ApprovedByDefault",
 
332
                                dbus.Boolean(options
 
333
                                             .approved_by_default))
343
334
            if options.approve:
344
335
                client.Approve(dbus.Boolean(True),
345
336
                               dbus_interface=client_interface)