/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2010-09-13 05:56:48 UTC
  • mfrom: (420.1.1 mandos-local)
  • Revision ID: teddy@fukt.bsnet.se-20100913055648-v92t4egg6xubyqqo
Merge Makefile change.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
1
1
#!/usr/bin/python
 
2
# -*- mode: python; coding: utf-8 -*-
2
3
 
 
4
from __future__ import division
 
5
import sys
3
6
import dbus
4
7
from optparse import OptionParser
 
8
import locale
 
9
import datetime
 
10
import re
 
11
 
 
12
locale.setlocale(locale.LC_ALL, u'')
5
13
 
6
14
tablewords = {
7
 
    'name': 'Name',
8
 
    'enabled': 'Enabled',
9
 
    'timeout': 'Timeout',
10
 
    'last_checked_ok': 'Last Successful Check',
11
 
    'created': 'Created',
12
 
    'interval': 'Interval',
13
 
    'host': 'Host',
14
 
    'fingerprint': 'Fingerprint',
15
 
    'checker_running': 'Check Is Running',
16
 
    'last_enabled': 'Last Enabled',
17
 
    'checker': 'Checker',
 
15
    'Name': u'Name',
 
16
    'Enabled': u'Enabled',
 
17
    'Timeout': u'Timeout',
 
18
    'LastCheckedOK': u'Last Successful Check',
 
19
    'Created': u'Created',
 
20
    'Interval': u'Interval',
 
21
    'Host': u'Host',
 
22
    'Fingerprint': u'Fingerprint',
 
23
    'CheckerRunning': u'Check Is Running',
 
24
    'LastEnabled': u'Last Enabled',
 
25
    'Checker': u'Checker',
18
26
    }
19
 
busname = 'org.mandos-system.Mandos'
20
 
object_path = '/Mandos'
21
 
interface = 'org.mandos_system.Mandos'
22
 
version = "1.0.0"
23
 
defaultkeywords = ('name', 'enabled', 'timeout', 'last_checked_ok', 'checker')
 
27
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
 
28
domain = 'se.bsnet.fukt'
 
29
busname = domain + '.Mandos'
 
30
server_path = '/'
 
31
server_interface = domain + '.Mandos'
 
32
client_interface = domain + '.Mandos.Client'
 
33
version = "1.0.14"
 
34
try:
 
35
    bus = dbus.SystemBus()
 
36
    mandos_dbus_objc = bus.get_object(busname, server_path)
 
37
except dbus.exceptions.DBusException:
 
38
    sys.exit(1)
 
39
    
 
40
mandos_serv = dbus.Interface(mandos_dbus_objc,
 
41
                             dbus_interface = server_interface)
 
42
mandos_clients = mandos_serv.GetAllClientsWithProperties()
 
43
 
 
44
def timedelta_to_milliseconds(td):
 
45
    "Convert a datetime.timedelta object to milliseconds"
 
46
    return ((td.days * 24 * 60 * 60 * 1000)
 
47
            + (td.seconds * 1000)
 
48
            + (td.microseconds // 1000))
 
49
 
 
50
def milliseconds_to_string(ms):
 
51
    td = datetime.timedelta(0, 0, 0, ms)
 
52
    return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
 
53
            % { "days": "%dT" % td.days if td.days else "",
 
54
                "hours": td.seconds // 3600,
 
55
                "minutes": (td.seconds % 3600) // 60,
 
56
                "seconds": td.seconds % 60,
 
57
                })
 
58
 
 
59
 
 
60
def string_to_delta(interval):
 
61
    """Parse a string and return a datetime.timedelta
 
62
 
 
63
    >>> string_to_delta('7d')
 
64
    datetime.timedelta(7)
 
65
    >>> string_to_delta('60s')
 
66
    datetime.timedelta(0, 60)
 
67
    >>> string_to_delta('60m')
 
68
    datetime.timedelta(0, 3600)
 
69
    >>> string_to_delta('24h')
 
70
    datetime.timedelta(1)
 
71
    >>> string_to_delta(u'1w')
 
72
    datetime.timedelta(7)
 
73
    >>> string_to_delta('5m 30s')
 
74
    datetime.timedelta(0, 330)
 
75
    """
 
76
    timevalue = datetime.timedelta(0)
 
77
    regexp = re.compile("\d+[dsmhw]")
 
78
    
 
79
    for s in regexp.findall(interval):
 
80
        try:
 
81
            suffix = unicode(s[-1])
 
82
            value = int(s[:-1])
 
83
            if suffix == u"d":
 
84
                delta = datetime.timedelta(value)
 
85
            elif suffix == u"s":
 
86
                delta = datetime.timedelta(0, value)
 
87
            elif suffix == u"m":
 
88
                delta = datetime.timedelta(0, 0, 0, 0, value)
 
89
            elif suffix == u"h":
 
90
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
91
            elif suffix == u"w":
 
92
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
93
            else:
 
94
                raise ValueError
 
95
        except (ValueError, IndexError):
 
96
            raise ValueError
 
97
        timevalue += delta
 
98
    return timevalue
 
99
 
 
100
def print_clients(clients):
 
101
    def valuetostring(value, keyword):
 
102
        if type(value) is dbus.Boolean:
 
103
            return u"Yes" if value else u"No"
 
104
        if keyword in (u"timeout", u"interval"):
 
105
            return milliseconds_to_string(value)
 
106
        return unicode(value)
 
107
    
 
108
    # Create format string to print table rows
 
109
    format_string = u' '.join(u'%%-%ds' %
 
110
                              max(len(tablewords[key]),
 
111
                                  max(len(valuetostring(client[key],
 
112
                                                        key))
 
113
                                      for client in
 
114
                                      clients))
 
115
                              for key in keywords)
 
116
    # Print header line
 
117
    print format_string % tuple(tablewords[key] for key in keywords)
 
118
    for client in clients:
 
119
        print format_string % tuple(valuetostring(client[key], key)
 
120
                                    for key in keywords)
24
121
 
25
122
parser = OptionParser(version = "%%prog %s" % version)
26
 
parser.add_option("-a", "--all", action="store_true", default=False,
27
 
                      help="Print all fields")
28
 
options = parser.parse_args()[0]
29
 
if options.all:
30
 
    keywords = ( 'name', 'enabled', 'timeout', 'last_checked_ok',
31
 
                 'created', 'interval', 'host', 'fingerprint',
32
 
                 'checker_running', 'last_enabled', 'checker' )
33
 
else:
 
123
parser.add_option("-a", "--all", action="store_true",
 
124
                  help="Print all fields")
 
125
parser.add_option("-e", "--enable", action="store_true",
 
126
                  help="Enable client")
 
127
parser.add_option("-d", "--disable", action="store_true",
 
128
                  help="disable client")
 
129
parser.add_option("-b", "--bump-timeout", action="store_true",
 
130
                  help="Bump timeout for client")
 
131
parser.add_option("--start-checker", action="store_true",
 
132
                  help="Start checker for client")
 
133
parser.add_option("--stop-checker", action="store_true",
 
134
                  help="Stop checker for client")
 
135
parser.add_option("-V", "--is-enabled", action="store_true",
 
136
                  help="Check if client is enabled")
 
137
parser.add_option("-r", "--remove", action="store_true",
 
138
                  help="Remove client")
 
139
parser.add_option("-c", "--checker", type="string",
 
140
                  help="Set checker command for client")
 
141
parser.add_option("-t", "--timeout", type="string",
 
142
                  help="Set timeout for client")
 
143
parser.add_option("-i", "--interval", type="string",
 
144
                  help="Set checker interval for client")
 
145
parser.add_option("-H", "--host", type="string",
 
146
                  help="Set host for client")
 
147
parser.add_option("-s", "--secret", type="string",
 
148
                  help="Set password blob (file) for client")
 
149
parser.add_option("-A", "--approve", action="store_true",
 
150
                  help="Approve any current client request")
 
151
parser.add_option("-D", "--deny", action="store_true",
 
152
                  help="Deny any current client request")
 
153
options, client_names = parser.parse_args()
 
154
 
 
155
# Compile list of clients to process
 
156
clients=[]
 
157
for name in client_names:
 
158
    for path, client in mandos_clients.iteritems():
 
159
        if client['name'] == name:
 
160
            client_objc = bus.get_object(busname, path)
 
161
            clients.append(client_objc)
 
162
            break
 
163
    else:
 
164
        print >> sys.stderr, "Client not found on server: %r" % name
 
165
        sys.exit(1)
 
166
 
 
167
if not clients and mandos_clients.values():
34
168
    keywords = defaultkeywords
35
 
 
36
 
 
37
 
bus = dbus.SystemBus()
38
 
mandos_dbus_objc = bus.get_object(busname, object_path)
39
 
mandos_serv = dbus.Interface(mandos_dbus_objc, dbus_interface = interface)
40
 
mandos_clients = mandos_serv.GetAllClientsWithProperties()
41
 
 
42
 
def valuetostring(x):
43
 
    if type(x) is dbus.Boolean:
44
 
        return "Yes" if x else "No"
45
 
    else:
46
 
        return str(x)
47
 
 
48
 
format_string = ' '.join('%%-%ds'
49
 
                         % max(len(tablewords[key]),
50
 
                               max(len(valuetostring(client[key]))
51
 
                                   for client
52
 
                                   in mandos_clients.itervalues()))
53
 
                         for key in keywords)
54
 
print format_string % tuple(tablewords[key] for key in keywords) 
55
 
for client in mandos_clients.itervalues():
56
 
    print format_string % tuple(valuetostring(client[key]) for key in keywords)
57
 
 
58
 
 
 
169
    if options.all:
 
170
        keywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK',
 
171
                    'Created', 'Interval', 'Host', 'Fingerprint',
 
172
                    'CheckerRunning', 'LastEnabled', 'Checker')
 
173
    print_clients(mandos_clients.values())
 
174
 
 
175
# Process each client in the list by all selected options
 
176
for client in clients:
 
177
    if options.remove:
 
178
        mandos_serv.RemoveClient(client.__dbus_object_path__)
 
179
    if options.enable:
 
180
        client.Enable(dbus_interface=client_interface)
 
181
    if options.disable:
 
182
        client.Disable(dbus_interface=client_interface)
 
183
    if options.bump_timeout:
 
184
        client.CheckedOK(dbus_interface=client_interface)
 
185
    if options.start_checker:
 
186
        client.StartChecker(dbus_interface=client_interface)
 
187
    if options.stop_checker:
 
188
        client.StopChecker(dbus_interface=client_interface)
 
189
    if options.is_enabled:
 
190
        sys.exit(0 if client.Get(client_interface,
 
191
                                 u"Enabled",
 
192
                                 dbus_interface=dbus.PROPERTIES_IFACE)
 
193
                 else 1)
 
194
    if options.checker:
 
195
        client.Set(client_interface, u"Checker", options.checker,
 
196
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
197
    if options.host:
 
198
        client.Set(client_interface, u"Host", options.host,
 
199
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
200
    if options.interval:
 
201
        client.Set(client_interface, u"Interval",
 
202
                   timedelta_to_milliseconds
 
203
                   (string_to_delta(options.interval)),
 
204
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
205
    if options.timeout:
 
206
        client.Set(client_interface, u"Timeout",
 
207
                   timedelta_to_milliseconds(string_to_delta
 
208
                                             (options.timeout)),
 
209
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
210
    if options.secret:
 
211
        client.Set(client_interface, u"Secret",
 
212
                   dbus.ByteArray(open(options.secret, u'rb').read()),
 
213
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
214
    if options.approve:
 
215
        client.Approve(dbus.Boolean(True),
 
216
                       dbus_interface=client_interface)
 
217
    if options.deny:
 
218
        client.Approve(dbus.Boolean(False),
 
219
                       dbus_interface=client_interface)