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 1089
- compare with another revision
- download diff
- download tarball
- view history from revision 1089
- Committer: Teddy Hogeborn
- Date: 2019-03-23 16:00:26 UTC
- Revision ID: teddy@recompile.se-20190323160026-u82ba6lkh7jeq0zj
mandos-ctl: Eliminate unnecessary D-Bus call
* mandos-ctl (command.Base.run): Don't set self.mandos.
(command.Remove): Implement .run() instead of .run_on_one_client()
to avoid the command.Base.run() unnecessarily
connecting to a client object.
* mandos-ctl (command.Base.run): Don't set self.mandos.
(command.Remove): Implement .run() instead of .run_on_one_client()
to avoid the command.Base.run() unnecessarily
connecting to a client object.
- files modified:
- TODO
added
removed
mandos-ctl
44
44
import logging
45
45
import io
46
46
import tempfile
47
import contextlib
47
48
48
49
import dbus
49
50
60
61
61
62
if sys.version_info.major == 2:
62
63
str = unicode
64
import StringIO
65
io.StringIO = StringIO.StringIO
63
66
64
67
locale.setlocale(locale.LC_ALL, "")
65
68
66
domain = "se.recompile"
67
busname = domain + ".Mandos"
68
server_path = "/"
69
server_interface = domain + ".Mandos"
70
client_interface = domain + ".Mandos.Client"
69
dbus_busname_domain = "se.recompile"
70
dbus_busname = dbus_busname_domain + ".Mandos"
71
server_dbus_path = "/"
72
server_dbus_interface = dbus_busname_domain + ".Mandos"
73
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
74
del dbus_busname_domain
71
75
version = "1.8.3"
72
76
73
77
77
81
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
78
82
79
83
80
def milliseconds_to_string(ms):
81
td = datetime.timedelta(0, 0, 0, ms)
82
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
83
.format(days="{}T".format(td.days) if td.days else "",
84
hours=td.seconds // 3600,
85
minutes=(td.seconds % 3600) // 60,
86
seconds=td.seconds % 60))
84
def main():
85
parser = argparse.ArgumentParser()
86
add_command_line_options(parser)
87
88
options = parser.parse_args()
89
check_option_syntax(parser, options)
90
91
clientnames = options.client
92
93
if options.debug:
94
log.setLevel(logging.DEBUG)
95
96
bus = dbus.SystemBus()
97
98
mandos_dbus_object = get_mandos_dbus_object(bus)
99
100
mandos_serv = dbus.Interface(
101
mandos_dbus_object, dbus_interface=server_dbus_interface)
102
mandos_serv_object_manager = dbus.Interface(
103
mandos_dbus_object, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
104
105
managed_objects = get_managed_objects(mandos_serv_object_manager)
106
107
all_clients = {}
108
for path, ifs_and_props in managed_objects.items():
109
try:
110
all_clients[path] = ifs_and_props[client_dbus_interface]
111
except KeyError:
112
pass
113
114
# Compile dict of (clientpath: properties) to process
115
if not clientnames:
116
clients = all_clients
117
else:
118
clients = {}
119
for name in clientnames:
120
for objpath, properties in all_clients.items():
121
if properties["Name"] == name:
122
clients[objpath] = properties
123
break
124
else:
125
log.critical("Client not found on server: %r", name)
126
sys.exit(1)
127
128
commands = commands_from_options(options)
129
130
for command in commands:
131
command.run(clients, bus, mandos_serv)
132
133
134
def add_command_line_options(parser):
135
parser.add_argument("--version", action="version",
136
version="%(prog)s {}".format(version),
137
help="show version number and exit")
138
parser.add_argument("-a", "--all", action="store_true",
139
help="Select all clients")
140
parser.add_argument("-v", "--verbose", action="store_true",
141
help="Print all fields")
142
parser.add_argument("-j", "--dump-json", action="store_true",
143
help="Dump client data in JSON format")
144
enable_disable = parser.add_mutually_exclusive_group()
145
enable_disable.add_argument("-e", "--enable", action="store_true",
146
help="Enable client")
147
enable_disable.add_argument("-d", "--disable",
148
action="store_true",
149
help="disable client")
150
parser.add_argument("-b", "--bump-timeout", action="store_true",
151
help="Bump timeout for client")
152
start_stop_checker = parser.add_mutually_exclusive_group()
153
start_stop_checker.add_argument("--start-checker",
154
action="store_true",
155
help="Start checker for client")
156
start_stop_checker.add_argument("--stop-checker",
157
action="store_true",
158
help="Stop checker for client")
159
parser.add_argument("-V", "--is-enabled", action="store_true",
160
help="Check if client is enabled")
161
parser.add_argument("-r", "--remove", action="store_true",
162
help="Remove client")
163
parser.add_argument("-c", "--checker",
164
help="Set checker command for client")
165
parser.add_argument("-t", "--timeout", type=string_to_delta,
166
help="Set timeout for client")
167
parser.add_argument("--extended-timeout", type=string_to_delta,
168
help="Set extended timeout for client")
169
parser.add_argument("-i", "--interval", type=string_to_delta,
170
help="Set checker interval for client")
171
approve_deny_default = parser.add_mutually_exclusive_group()
172
approve_deny_default.add_argument(
173
"--approve-by-default", action="store_true",
174
default=None, dest="approved_by_default",
175
help="Set client to be approved by default")
176
approve_deny_default.add_argument(
177
"--deny-by-default", action="store_false",
178
dest="approved_by_default",
179
help="Set client to be denied by default")
180
parser.add_argument("--approval-delay", type=string_to_delta,
181
help="Set delay before client approve/deny")
182
parser.add_argument("--approval-duration", type=string_to_delta,
183
help="Set duration of one client approval")
184
parser.add_argument("-H", "--host", help="Set host for client")
185
parser.add_argument("-s", "--secret",
186
type=argparse.FileType(mode="rb"),
187
help="Set password blob (file) for client")
188
approve_deny = parser.add_mutually_exclusive_group()
189
approve_deny.add_argument(
190
"-A", "--approve", action="store_true",
191
help="Approve any current client request")
192
approve_deny.add_argument("-D", "--deny", action="store_true",
193
help="Deny any current client request")
194
parser.add_argument("--debug", action="store_true",
195
help="Debug mode (show D-Bus commands)")
196
parser.add_argument("--check", action="store_true",
197
help="Run self-test")
198
parser.add_argument("client", nargs="*", help="Client name")
199
200
201
def string_to_delta(interval):
202
"""Parse a string and return a datetime.timedelta"""
203
204
try:
205
return rfc3339_duration_to_delta(interval)
206
except ValueError as e:
207
log.warning("%s - Parsing as pre-1.6.1 interval instead",
208
' '.join(e.args))
209
return parse_pre_1_6_1_interval(interval)
87
210
88
211
89
212
def rfc3339_duration_to_delta(duration):
109
232
>>> rfc3339_duration_to_delta("")
110
233
Traceback (most recent call last):
111
234
...
112
ValueError: Invalid RFC 3339 duration: u''
235
ValueError: Invalid RFC 3339 duration: ""
113
236
>>> # Must start with "P":
114
237
>>> rfc3339_duration_to_delta("1D")
115
238
Traceback (most recent call last):
116
239
...
117
ValueError: Invalid RFC 3339 duration: u'1D'
240
ValueError: Invalid RFC 3339 duration: "1D"
118
241
>>> # Must use correct order
119
242
>>> rfc3339_duration_to_delta("PT1S2M")
120
243
Traceback (most recent call last):
121
244
...
122
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
245
ValueError: Invalid RFC 3339 duration: "PT1S2M"
123
246
>>> # Time needs time marker
124
247
>>> rfc3339_duration_to_delta("P1H2S")
125
248
Traceback (most recent call last):
126
249
...
127
ValueError: Invalid RFC 3339 duration: u'P1H2S'
250
ValueError: Invalid RFC 3339 duration: "P1H2S"
128
251
>>> # Weeks can not be combined with anything else
129
252
>>> rfc3339_duration_to_delta("P1D2W")
130
253
Traceback (most recent call last):
131
254
...
132
ValueError: Invalid RFC 3339 duration: u'P1D2W'
255
ValueError: Invalid RFC 3339 duration: "P1D2W"
133
256
>>> rfc3339_duration_to_delta("P2W2H")
134
257
Traceback (most recent call last):
135
258
...
136
ValueError: Invalid RFC 3339 duration: u'P2W2H'
259
ValueError: Invalid RFC 3339 duration: "P2W2H"
137
260
"""
138
261
139
262
# Parsing an RFC 3339 duration with regular expressions is not
210
333
break
211
334
else:
212
335
# No currently valid tokens were found
213
raise ValueError("Invalid RFC 3339 duration: {!r}"
336
raise ValueError("Invalid RFC 3339 duration: \"{}\""
214
337
.format(duration))
215
338
# End token found
216
339
return value
217
340
218
341
219
def string_to_delta(interval):
220
"""Parse a string and return a datetime.timedelta"""
221
222
try:
223
return rfc3339_duration_to_delta(interval)
224
except ValueError as e:
225
log.warning("%s - Parsing as pre-1.6.1 interval instead",
226
' '.join(e.args))
227
return parse_pre_1_6_1_interval(interval)
228
229
230
342
def parse_pre_1_6_1_interval(interval):
231
343
"""Parse an interval string as documented by Mandos before 1.6.1,
232
344
and return a datetime.timedelta
270
382
return value
271
383
272
384
273
## Classes for commands.
274
275
# Abstract classes first
276
class Command(object):
277
"""Abstract class for commands"""
278
def run(self, mandos, clients):
279
"""Normal commands should implement run_on_one_client(), but
280
commands which want to operate on all clients at the same time
281
can override this run() method instead."""
282
self.mandos = mandos
283
for client, properties in clients.items():
284
self.run_on_one_client(client, properties)
285
286
class PrintCmd(Command):
287
"""Abstract class for commands printing client details"""
288
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
289
"Created", "Interval", "Host", "KeyID",
290
"Fingerprint", "CheckerRunning", "LastEnabled",
291
"ApprovalPending", "ApprovedByDefault",
292
"LastApprovalRequest", "ApprovalDelay",
293
"ApprovalDuration", "Checker", "ExtendedTimeout",
294
"Expires", "LastCheckerStatus")
295
def run(self, mandos, clients):
296
print(self.output(clients))
297
298
class PropertyCmd(Command):
299
"""Abstract class for Actions for setting one client property"""
300
def run_on_one_client(self, client, properties):
301
"""Set the Client's D-Bus property"""
302
client.Set(client_interface, self.property, self.value_to_set,
303
dbus_interface=dbus.PROPERTIES_IFACE)
304
305
class ValueArgumentMixIn(object):
306
"""Mixin class for commands taking a value as argument"""
307
def __init__(self, value):
308
self.value_to_set = value
309
310
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
311
"""Mixin class for commands taking a value argument as
312
milliseconds."""
313
@property
314
def value_to_set(self):
315
return self._vts
316
@value_to_set.setter
317
def value_to_set(self, value):
318
"""When setting, convert value to a datetime.timedelta"""
319
self._vts = int(round(value.total_seconds() * 1000))
320
321
# Actual (non-abstract) command classes
322
323
class PrintTableCmd(PrintCmd):
324
def __init__(self, verbose=False):
325
self.verbose = verbose
326
327
def output(self, clients):
328
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
329
keywords = default_keywords
330
if self.verbose:
331
keywords = self.all_keywords
332
return str(self.TableOfClients(clients.values(), keywords))
333
334
class TableOfClients(object):
335
tableheaders = {
336
"Name": "Name",
337
"Enabled": "Enabled",
338
"Timeout": "Timeout",
339
"LastCheckedOK": "Last Successful Check",
340
"LastApprovalRequest": "Last Approval Request",
341
"Created": "Created",
342
"Interval": "Interval",
343
"Host": "Host",
344
"Fingerprint": "Fingerprint",
345
"KeyID": "Key ID",
346
"CheckerRunning": "Check Is Running",
347
"LastEnabled": "Last Enabled",
348
"ApprovalPending": "Approval Is Pending",
349
"ApprovedByDefault": "Approved By Default",
350
"ApprovalDelay": "Approval Delay",
351
"ApprovalDuration": "Approval Duration",
352
"Checker": "Checker",
353
"ExtendedTimeout": "Extended Timeout",
354
"Expires": "Expires",
355
"LastCheckerStatus": "Last Checker Status",
356
}
357
358
def __init__(self, clients, keywords, tableheaders=None):
359
self.clients = clients
360
self.keywords = keywords
361
if tableheaders is not None:
362
self.tableheaders = tableheaders
363
364
def __str__(self):
365
return "\n".join(self.rows())
366
367
if sys.version_info.major == 2:
368
__unicode__ = __str__
369
def __str__(self):
370
return str(self).encode(locale.getpreferredencoding())
371
372
def rows(self):
373
format_string = self.row_formatting_string()
374
rows = [self.header_line(format_string)]
375
rows.extend(self.client_line(client, format_string)
376
for client in self.clients)
377
return rows
378
379
def row_formatting_string(self):
380
"Format string used to format table rows"
381
return " ".join("{{{key}:{width}}}".format(
382
width=max(len(self.tableheaders[key]),
383
*(len(self.string_from_client(client, key))
384
for client in self.clients)),
385
key=key)
386
for key in self.keywords)
387
388
def string_from_client(self, client, key):
389
return self.valuetostring(client[key], key)
390
391
@staticmethod
392
def valuetostring(value, keyword):
393
if isinstance(value, dbus.Boolean):
394
return "Yes" if value else "No"
395
if keyword in ("Timeout", "Interval", "ApprovalDelay",
396
"ApprovalDuration", "ExtendedTimeout"):
397
return milliseconds_to_string(value)
398
return str(value)
399
400
def header_line(self, format_string):
401
return format_string.format(**self.tableheaders)
402
403
def client_line(self, client, format_string):
404
return format_string.format(
405
**{key: self.string_from_client(client, key)
406
for key in self.keywords})
407
408
409
410
class DumpJSONCmd(PrintCmd):
411
def output(self, clients):
412
data = {client["Name"]:
413
{key: self.dbus_boolean_to_bool(client[key])
414
for key in self.all_keywords}
415
for client in clients.values()}
416
return json.dumps(data, indent=4, separators=(',', ': '))
417
@staticmethod
418
def dbus_boolean_to_bool(value):
419
if isinstance(value, dbus.Boolean):
420
value = bool(value)
421
return value
422
423
class IsEnabledCmd(Command):
424
def run_on_one_client(self, client, properties):
425
if self.is_enabled(client, properties):
426
sys.exit(0)
427
sys.exit(1)
428
def is_enabled(self, client, properties):
429
return bool(properties["Enabled"])
430
431
class RemoveCmd(Command):
432
def run_on_one_client(self, client, properties):
433
self.mandos.RemoveClient(client.__dbus_object_path__)
434
435
class ApproveCmd(Command):
436
def run_on_one_client(self, client, properties):
437
client.Approve(dbus.Boolean(True),
438
dbus_interface=client_interface)
439
440
class DenyCmd(Command):
441
def run_on_one_client(self, client, properties):
442
client.Approve(dbus.Boolean(False),
443
dbus_interface=client_interface)
444
445
class EnableCmd(PropertyCmd):
446
property = "Enabled"
447
value_to_set = dbus.Boolean(True)
448
449
class DisableCmd(PropertyCmd):
450
property = "Enabled"
451
value_to_set = dbus.Boolean(False)
452
453
class BumpTimeoutCmd(PropertyCmd):
454
property = "LastCheckedOK"
455
value_to_set = ""
456
457
class StartCheckerCmd(PropertyCmd):
458
property = "CheckerRunning"
459
value_to_set = dbus.Boolean(True)
460
461
class StopCheckerCmd(PropertyCmd):
462
property = "CheckerRunning"
463
value_to_set = dbus.Boolean(False)
464
465
class ApproveByDefaultCmd(PropertyCmd):
466
property = "ApprovedByDefault"
467
value_to_set = dbus.Boolean(True)
468
469
class DenyByDefaultCmd(PropertyCmd):
470
property = "ApprovedByDefault"
471
value_to_set = dbus.Boolean(False)
472
473
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
474
property = "Checker"
475
476
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
477
property = "Host"
478
479
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
480
@property
481
def value_to_set(self):
482
return self._vts
483
@value_to_set.setter
484
def value_to_set(self, value):
485
"""When setting, read data from supplied file object"""
486
self._vts = value.read()
487
value.close()
488
property = "Secret"
489
490
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
491
property = "Timeout"
492
493
class SetExtendedTimeoutCmd(PropertyCmd,
494
MillisecondsValueArgumentMixIn):
495
property = "ExtendedTimeout"
496
497
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
498
property = "Interval"
499
500
class SetApprovalDelayCmd(PropertyCmd,
501
MillisecondsValueArgumentMixIn):
502
property = "ApprovalDelay"
503
504
class SetApprovalDurationCmd(PropertyCmd,
505
MillisecondsValueArgumentMixIn):
506
property = "ApprovalDuration"
507
508
def add_command_line_options(parser):
509
parser.add_argument("--version", action="version",
510
version="%(prog)s {}".format(version),
511
help="show version number and exit")
512
parser.add_argument("-a", "--all", action="store_true",
513
help="Select all clients")
514
parser.add_argument("-v", "--verbose", action="store_true",
515
help="Print all fields")
516
parser.add_argument("-j", "--dump-json", action="store_true",
517
help="Dump client data in JSON format")
518
enable_disable = parser.add_mutually_exclusive_group()
519
enable_disable.add_argument("-e", "--enable", action="store_true",
520
help="Enable client")
521
enable_disable.add_argument("-d", "--disable",
522
action="store_true",
523
help="disable client")
524
parser.add_argument("-b", "--bump-timeout", action="store_true",
525
help="Bump timeout for client")
526
start_stop_checker = parser.add_mutually_exclusive_group()
527
start_stop_checker.add_argument("--start-checker",
528
action="store_true",
529
help="Start checker for client")
530
start_stop_checker.add_argument("--stop-checker",
531
action="store_true",
532
help="Stop checker for client")
533
parser.add_argument("-V", "--is-enabled", action="store_true",
534
help="Check if client is enabled")
535
parser.add_argument("-r", "--remove", action="store_true",
536
help="Remove client")
537
parser.add_argument("-c", "--checker",
538
help="Set checker command for client")
539
parser.add_argument("-t", "--timeout", type=string_to_delta,
540
help="Set timeout for client")
541
parser.add_argument("--extended-timeout", type=string_to_delta,
542
help="Set extended timeout for client")
543
parser.add_argument("-i", "--interval", type=string_to_delta,
544
help="Set checker interval for client")
545
approve_deny_default = parser.add_mutually_exclusive_group()
546
approve_deny_default.add_argument(
547
"--approve-by-default", action="store_true",
548
default=None, dest="approved_by_default",
549
help="Set client to be approved by default")
550
approve_deny_default.add_argument(
551
"--deny-by-default", action="store_false",
552
dest="approved_by_default",
553
help="Set client to be denied by default")
554
parser.add_argument("--approval-delay", type=string_to_delta,
555
help="Set delay before client approve/deny")
556
parser.add_argument("--approval-duration", type=string_to_delta,
557
help="Set duration of one client approval")
558
parser.add_argument("-H", "--host", help="Set host for client")
559
parser.add_argument("-s", "--secret",
560
type=argparse.FileType(mode="rb"),
561
help="Set password blob (file) for client")
562
approve_deny = parser.add_mutually_exclusive_group()
563
approve_deny.add_argument(
564
"-A", "--approve", action="store_true",
565
help="Approve any current client request")
566
approve_deny.add_argument("-D", "--deny", action="store_true",
567
help="Deny any current client request")
568
parser.add_argument("--check", action="store_true",
569
help="Run self-test")
570
parser.add_argument("client", nargs="*", help="Client name")
571
572
573
def commands_from_options(options):
574
575
commands = []
576
577
if options.dump_json:
578
commands.append(DumpJSONCmd())
579
580
if options.enable:
581
commands.append(EnableCmd())
582
583
if options.disable:
584
commands.append(DisableCmd())
585
586
if options.bump_timeout:
587
commands.append(BumpTimeoutCmd())
588
589
if options.start_checker:
590
commands.append(StartCheckerCmd())
591
592
if options.stop_checker:
593
commands.append(StopCheckerCmd())
594
595
if options.is_enabled:
596
commands.append(IsEnabledCmd())
597
598
if options.remove:
599
commands.append(RemoveCmd())
600
601
if options.checker is not None:
602
commands.append(SetCheckerCmd(options.checker))
603
604
if options.timeout is not None:
605
commands.append(SetTimeoutCmd(options.timeout))
606
607
if options.extended_timeout:
608
commands.append(
609
SetExtendedTimeoutCmd(options.extended_timeout))
610
611
if options.interval is not None:
612
commands.append(SetIntervalCmd(options.interval))
613
614
if options.approved_by_default is not None:
615
if options.approved_by_default:
616
commands.append(ApproveByDefaultCmd())
617
else:
618
commands.append(DenyByDefaultCmd())
619
620
if options.approval_delay is not None:
621
commands.append(SetApprovalDelayCmd(options.approval_delay))
622
623
if options.approval_duration is not None:
624
commands.append(
625
SetApprovalDurationCmd(options.approval_duration))
626
627
if options.host is not None:
628
commands.append(SetHostCmd(options.host))
629
630
if options.secret is not None:
631
commands.append(SetSecretCmd(options.secret))
632
633
if options.approve:
634
commands.append(ApproveCmd())
635
636
if options.deny:
637
commands.append(DenyCmd())
638
639
# If no command option has been given, show table of clients,
640
# optionally verbosely
641
if not commands:
642
commands.append(PrintTableCmd(verbose=options.verbose))
643
644
return commands
645
646
647
def main():
648
parser = argparse.ArgumentParser()
649
650
add_command_line_options(parser)
651
652
options = parser.parse_args()
385
def check_option_syntax(parser, options):
386
"""Apply additional restrictions on options, not expressible in
387
argparse"""
653
388
654
389
def has_actions(options):
655
390
return any((options.enable,
682
417
parser.error("--all requires an action.")
683
418
if options.is_enabled and len(options.client) > 1:
684
419
parser.error("--is-enabled requires exactly one client")
685
686
clientnames = options.client
687
420
if options.remove:
421
options.remove = False
422
if has_actions(options) and not options.deny:
423
parser.error("--remove can only be combined with --deny")
424
options.remove = True
425
426
427
def get_mandos_dbus_object(bus):
428
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
429
dbus_busname, server_dbus_path)
430
with if_dbus_exception_log_with_exception_and_exit(
431
"Could not connect to Mandos server: %s"):
432
mandos_dbus_object = bus.get_object(dbus_busname,
433
server_dbus_path)
434
return mandos_dbus_object
435
436
437
@contextlib.contextmanager
438
def if_dbus_exception_log_with_exception_and_exit(*args, **kwargs):
688
439
try:
689
bus = dbus.SystemBus()
690
mandos_dbus_objc = bus.get_object(busname, server_path)
691
except dbus.exceptions.DBusException:
692
log.critical("Could not connect to Mandos server")
440
yield
441
except dbus.exceptions.DBusException as e:
442
log.critical(*(args + (e,)), **kwargs)
693
443
sys.exit(1)
694
444
695
mandos_serv = dbus.Interface(mandos_dbus_objc,
696
dbus_interface=server_interface)
697
mandos_serv_object_manager = dbus.Interface(
698
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
699
700
# Filter out log message from dbus module
701
dbus_logger = logging.getLogger("dbus.proxies")
445
446
def get_managed_objects(object_manager):
447
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
448
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
449
with if_dbus_exception_log_with_exception_and_exit(
450
"Failed to access Mandos server through D-Bus:\n%s"):
451
with SilenceLogger("dbus.proxies"):
452
managed_objects = object_manager.GetManagedObjects()
453
return managed_objects
454
455
456
class SilenceLogger(object):
457
"Simple context manager to silence a particular logger"
458
def __init__(self, loggername):
459
self.logger = logging.getLogger(loggername)
460
461
def __enter__(self):
462
self.logger.addFilter(self.nullfilter)
463
702
464
class NullFilter(logging.Filter):
703
465
def filter(self, record):
704
466
return False
705
dbus_filter = NullFilter()
706
try:
707
dbus_logger.addFilter(dbus_filter)
708
mandos_clients = {path: ifs_and_props[client_interface]
709
for path, ifs_and_props in
710
mandos_serv_object_manager
711
.GetManagedObjects().items()
712
if client_interface in ifs_and_props}
713
except dbus.exceptions.DBusException as e:
714
log.critical("Failed to access Mandos server through D-Bus:"
715
"\n%s", e)
716
sys.exit(1)
717
finally:
718
# restore dbus logger
719
dbus_logger.removeFilter(dbus_filter)
720
721
# Compile dict of (clients: properties) to process
722
clients = {}
723
724
if not clientnames:
725
clients = {bus.get_object(busname, path): properties
726
for path, properties in mandos_clients.items()}
727
else:
728
for name in clientnames:
729
for path, client in mandos_clients.items():
730
if client["Name"] == name:
731
client_objc = bus.get_object(busname, path)
732
clients[client_objc] = client
733
break
734
else:
735
log.critical("Client not found on server: %r", name)
736
sys.exit(1)
737
738
# Run all commands on clients
739
commands = commands_from_options(options)
740
for command in commands:
741
command.run(mandos_serv, clients)
467
468
nullfilter = NullFilter()
469
470
def __exit__(self, exc_type, exc_val, exc_tb):
471
self.logger.removeFilter(self.nullfilter)
472
473
474
def commands_from_options(options):
475
476
commands = []
477
478
if options.is_enabled:
479
commands.append(command.IsEnabled())
480
481
if options.approve:
482
commands.append(command.Approve())
483
484
if options.deny:
485
commands.append(command.Deny())
486
487
if options.remove:
488
commands.append(command.Remove())
489
490
if options.dump_json:
491
commands.append(command.DumpJSON())
492
493
if options.enable:
494
commands.append(command.Enable())
495
496
if options.disable:
497
commands.append(command.Disable())
498
499
if options.bump_timeout:
500
commands.append(command.BumpTimeout())
501
502
if options.start_checker:
503
commands.append(command.StartChecker())
504
505
if options.stop_checker:
506
commands.append(command.StopChecker())
507
508
if options.approved_by_default is not None:
509
if options.approved_by_default:
510
commands.append(command.ApproveByDefault())
511
else:
512
commands.append(command.DenyByDefault())
513
514
if options.checker is not None:
515
commands.append(command.SetChecker(options.checker))
516
517
if options.host is not None:
518
commands.append(command.SetHost(options.host))
519
520
if options.secret is not None:
521
commands.append(command.SetSecret(options.secret))
522
523
if options.timeout is not None:
524
commands.append(command.SetTimeout(options.timeout))
525
526
if options.extended_timeout:
527
commands.append(
528
command.SetExtendedTimeout(options.extended_timeout))
529
530
if options.interval is not None:
531
commands.append(command.SetInterval(options.interval))
532
533
if options.approval_delay is not None:
534
commands.append(
535
command.SetApprovalDelay(options.approval_delay))
536
537
if options.approval_duration is not None:
538
commands.append(
539
command.SetApprovalDuration(options.approval_duration))
540
541
# If no command option has been given, show table of clients,
542
# optionally verbosely
543
if not commands:
544
commands.append(command.PrintTable(verbose=options.verbose))
545
546
return commands
547
548
549
class command(object):
550
"""A namespace for command classes"""
551
552
class Base(object):
553
"""Abstract base class for commands"""
554
def run(self, clients, bus=None, mandos=None):
555
"""Normal commands should implement run_on_one_client(),
556
but commands which want to operate on all clients at the same time can
557
override this run() method instead.
558
"""
559
for clientpath, properties in clients.items():
560
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
561
dbus_busname, str(clientpath))
562
client = bus.get_object(dbus_busname, clientpath)
563
self.run_on_one_client(client, properties)
564
565
566
class IsEnabled(Base):
567
def run(self, clients, bus=None, mandos=None):
568
client, properties = next(iter(clients.items()))
569
if self.is_enabled(client, properties):
570
sys.exit(0)
571
sys.exit(1)
572
def is_enabled(self, client, properties):
573
return properties["Enabled"]
574
575
576
class Approve(Base):
577
def run_on_one_client(self, client, properties):
578
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
579
client.__dbus_object_path__,
580
client_dbus_interface)
581
client.Approve(dbus.Boolean(True),
582
dbus_interface=client_dbus_interface)
583
584
585
class Deny(Base):
586
def run_on_one_client(self, client, properties):
587
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
588
client.__dbus_object_path__,
589
client_dbus_interface)
590
client.Approve(dbus.Boolean(False),
591
dbus_interface=client_dbus_interface)
592
593
594
class Remove(Base):
595
def run(self, clients, bus, mandos):
596
for clientpath in clients.keys():
597
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)",
598
dbus_busname, server_dbus_path,
599
server_dbus_interface, clientpath)
600
mandos.RemoveClient(clientpath)
601
602
603
class Output(Base):
604
"""Abstract class for commands outputting client details"""
605
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
606
"Created", "Interval", "Host", "KeyID",
607
"Fingerprint", "CheckerRunning",
608
"LastEnabled", "ApprovalPending",
609
"ApprovedByDefault", "LastApprovalRequest",
610
"ApprovalDelay", "ApprovalDuration",
611
"Checker", "ExtendedTimeout", "Expires",
612
"LastCheckerStatus")
613
614
615
class DumpJSON(Output):
616
def run(self, clients, bus=None, mandos=None):
617
data = {client["Name"]:
618
{key: self.dbus_boolean_to_bool(client[key])
619
for key in self.all_keywords}
620
for client in clients.values()}
621
print(json.dumps(data, indent=4, separators=(',', ': ')))
622
623
@staticmethod
624
def dbus_boolean_to_bool(value):
625
if isinstance(value, dbus.Boolean):
626
value = bool(value)
627
return value
628
629
630
class PrintTable(Output):
631
def __init__(self, verbose=False):
632
self.verbose = verbose
633
634
def run(self, clients, bus=None, mandos=None):
635
default_keywords = ("Name", "Enabled", "Timeout",
636
"LastCheckedOK")
637
keywords = default_keywords
638
if self.verbose:
639
keywords = self.all_keywords
640
print(self.TableOfClients(clients.values(), keywords))
641
642
class TableOfClients(object):
643
tableheaders = {
644
"Name": "Name",
645
"Enabled": "Enabled",
646
"Timeout": "Timeout",
647
"LastCheckedOK": "Last Successful Check",
648
"LastApprovalRequest": "Last Approval Request",
649
"Created": "Created",
650
"Interval": "Interval",
651
"Host": "Host",
652
"Fingerprint": "Fingerprint",
653
"KeyID": "Key ID",
654
"CheckerRunning": "Check Is Running",
655
"LastEnabled": "Last Enabled",
656
"ApprovalPending": "Approval Is Pending",
657
"ApprovedByDefault": "Approved By Default",
658
"ApprovalDelay": "Approval Delay",
659
"ApprovalDuration": "Approval Duration",
660
"Checker": "Checker",
661
"ExtendedTimeout": "Extended Timeout",
662
"Expires": "Expires",
663
"LastCheckerStatus": "Last Checker Status",
664
}
665
666
def __init__(self, clients, keywords):
667
self.clients = clients
668
self.keywords = keywords
669
670
def __str__(self):
671
return "\n".join(self.rows())
672
673
if sys.version_info.major == 2:
674
__unicode__ = __str__
675
def __str__(self):
676
return str(self).encode(
677
locale.getpreferredencoding())
678
679
def rows(self):
680
format_string = self.row_formatting_string()
681
rows = [self.header_line(format_string)]
682
rows.extend(self.client_line(client, format_string)
683
for client in self.clients)
684
return rows
685
686
def row_formatting_string(self):
687
"Format string used to format table rows"
688
return " ".join("{{{key}:{width}}}".format(
689
width=max(len(self.tableheaders[key]),
690
*(len(self.string_from_client(client,
691
key))
692
for client in self.clients)),
693
key=key)
694
for key in self.keywords)
695
696
def string_from_client(self, client, key):
697
return self.valuetostring(client[key], key)
698
699
@classmethod
700
def valuetostring(cls, value, keyword):
701
if isinstance(value, dbus.Boolean):
702
return "Yes" if value else "No"
703
if keyword in ("Timeout", "Interval", "ApprovalDelay",
704
"ApprovalDuration", "ExtendedTimeout"):
705
return cls.milliseconds_to_string(value)
706
return str(value)
707
708
def header_line(self, format_string):
709
return format_string.format(**self.tableheaders)
710
711
def client_line(self, client, format_string):
712
return format_string.format(
713
**{key: self.string_from_client(client, key)
714
for key in self.keywords})
715
716
@staticmethod
717
def milliseconds_to_string(ms):
718
td = datetime.timedelta(0, 0, 0, ms)
719
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
720
.format(days="{}T".format(td.days)
721
if td.days else "",
722
hours=td.seconds // 3600,
723
minutes=(td.seconds % 3600) // 60,
724
seconds=td.seconds % 60))
725
726
727
class PropertySetter(Base):
728
"Abstract class for Actions for setting one client property"
729
730
def run_on_one_client(self, client, properties):
731
"""Set the Client's D-Bus property"""
732
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
733
client.__dbus_object_path__,
734
dbus.PROPERTIES_IFACE, client_dbus_interface,
735
self.propname, self.value_to_set
736
if not isinstance(self.value_to_set,
737
dbus.Boolean)
738
else bool(self.value_to_set))
739
client.Set(client_dbus_interface, self.propname,
740
self.value_to_set,
741
dbus_interface=dbus.PROPERTIES_IFACE)
742
743
@property
744
def propname(self):
745
raise NotImplementedError()
746
747
748
class Enable(PropertySetter):
749
propname = "Enabled"
750
value_to_set = dbus.Boolean(True)
751
752
753
class Disable(PropertySetter):
754
propname = "Enabled"
755
value_to_set = dbus.Boolean(False)
756
757
758
class BumpTimeout(PropertySetter):
759
propname = "LastCheckedOK"
760
value_to_set = ""
761
762
763
class StartChecker(PropertySetter):
764
propname = "CheckerRunning"
765
value_to_set = dbus.Boolean(True)
766
767
768
class StopChecker(PropertySetter):
769
propname = "CheckerRunning"
770
value_to_set = dbus.Boolean(False)
771
772
773
class ApproveByDefault(PropertySetter):
774
propname = "ApprovedByDefault"
775
value_to_set = dbus.Boolean(True)
776
777
778
class DenyByDefault(PropertySetter):
779
propname = "ApprovedByDefault"
780
value_to_set = dbus.Boolean(False)
781
782
783
class PropertySetterValue(PropertySetter):
784
"""Abstract class for PropertySetter recieving a value as
785
constructor argument instead of a class attribute."""
786
def __init__(self, value):
787
self.value_to_set = value
788
789
790
class SetChecker(PropertySetterValue):
791
propname = "Checker"
792
793
794
class SetHost(PropertySetterValue):
795
propname = "Host"
796
797
798
class SetSecret(PropertySetterValue):
799
propname = "Secret"
800
801
@property
802
def value_to_set(self):
803
return self._vts
804
805
@value_to_set.setter
806
def value_to_set(self, value):
807
"""When setting, read data from supplied file object"""
808
self._vts = value.read()
809
value.close()
810
811
812
class PropertySetterValueMilliseconds(PropertySetterValue):
813
"""Abstract class for PropertySetterValue taking a value
814
argument as a datetime.timedelta() but should store it as
815
milliseconds."""
816
817
@property
818
def value_to_set(self):
819
return self._vts
820
821
@value_to_set.setter
822
def value_to_set(self, value):
823
"When setting, convert value from a datetime.timedelta"
824
self._vts = int(round(value.total_seconds() * 1000))
825
826
827
class SetTimeout(PropertySetterValueMilliseconds):
828
propname = "Timeout"
829
830
831
class SetExtendedTimeout(PropertySetterValueMilliseconds):
832
propname = "ExtendedTimeout"
833
834
835
class SetInterval(PropertySetterValueMilliseconds):
836
propname = "Interval"
837
838
839
class SetApprovalDelay(PropertySetterValueMilliseconds):
840
propname = "ApprovalDelay"
841
842
843
class SetApprovalDuration(PropertySetterValueMilliseconds):
844
propname = "ApprovalDuration"
845
742
846
743
847
744
class Test_milliseconds_to_string(unittest.TestCase):
745
def test_all(self):
746
self.assertEqual(milliseconds_to_string(93785000),
747
"1T02:03:05")
748
def test_no_days(self):
749
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
750
def test_all_zero(self):
751
self.assertEqual(milliseconds_to_string(0), "00:00:00")
752
def test_no_fractional_seconds(self):
753
self.assertEqual(milliseconds_to_string(400), "00:00:00")
754
self.assertEqual(milliseconds_to_string(900), "00:00:00")
755
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
756
757
class Test_string_to_delta(unittest.TestCase):
758
def test_handles_basic_rfc3339(self):
759
self.assertEqual(string_to_delta("PT0S"),
760
datetime.timedelta())
761
self.assertEqual(string_to_delta("P0D"),
762
datetime.timedelta())
763
self.assertEqual(string_to_delta("PT1S"),
764
datetime.timedelta(0, 1))
765
self.assertEqual(string_to_delta("PT2H"),
766
datetime.timedelta(0, 7200))
848
class TestCaseWithAssertLogs(unittest.TestCase):
849
"""unittest.TestCase.assertLogs only exists in Python 3.4"""
850
851
if not hasattr(unittest.TestCase, "assertLogs"):
852
@contextlib.contextmanager
853
def assertLogs(self, logger, level=logging.INFO):
854
capturing_handler = self.CapturingLevelHandler(level)
855
old_level = logger.level
856
old_propagate = logger.propagate
857
logger.addHandler(capturing_handler)
858
logger.setLevel(level)
859
logger.propagate = False
860
try:
861
yield capturing_handler.watcher
862
finally:
863
logger.propagate = old_propagate
864
logger.removeHandler(capturing_handler)
865
logger.setLevel(old_level)
866
self.assertGreater(len(capturing_handler.watcher.records),
867
0)
868
869
class CapturingLevelHandler(logging.Handler):
870
def __init__(self, level, *args, **kwargs):
871
logging.Handler.__init__(self, *args, **kwargs)
872
self.watcher = self.LoggingWatcher([], [])
873
def emit(self, record):
874
self.watcher.records.append(record)
875
self.watcher.output.append(self.format(record))
876
877
LoggingWatcher = collections.namedtuple("LoggingWatcher",
878
("records",
879
"output"))
880
881
882
class Test_string_to_delta(TestCaseWithAssertLogs):
883
# Just test basic RFC 3339 functionality here, the doc string for
884
# rfc3339_duration_to_delta() already has more comprehensive
885
# tests, which is run by doctest.
886
887
def test_rfc3339_zero_seconds(self):
888
self.assertEqual(datetime.timedelta(),
889
string_to_delta("PT0S"))
890
891
def test_rfc3339_zero_days(self):
892
self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))
893
894
def test_rfc3339_one_second(self):
895
self.assertEqual(datetime.timedelta(0, 1),
896
string_to_delta("PT1S"))
897
898
def test_rfc3339_two_hours(self):
899
self.assertEqual(datetime.timedelta(0, 7200),
900
string_to_delta("PT2H"))
901
767
902
def test_falls_back_to_pre_1_6_1_with_warning(self):
768
# assertLogs only exists in Python 3.4
769
if hasattr(self, "assertLogs"):
770
with self.assertLogs(log, logging.WARNING):
771
value = string_to_delta("2h")
772
else:
773
class WarningFilter(logging.Filter):
774
"""Don't show, but record the presence of, warnings"""
775
def filter(self, record):
776
is_warning = record.levelno >= logging.WARNING
777
self.found = is_warning or getattr(self, "found",
778
False)
779
return not is_warning
780
warning_filter = WarningFilter()
781
log.addFilter(warning_filter)
903
with self.assertLogs(log, logging.WARNING):
904
value = string_to_delta("2h")
905
self.assertEqual(datetime.timedelta(0, 7200), value)
906
907
908
class Test_check_option_syntax(unittest.TestCase):
909
def setUp(self):
910
self.parser = argparse.ArgumentParser()
911
add_command_line_options(self.parser)
912
913
def test_actions_requires_client_or_all(self):
914
for action, value in self.actions.items():
915
options = self.parser.parse_args()
916
setattr(options, action, value)
917
with self.assertParseError():
918
self.check_option_syntax(options)
919
920
# This mostly corresponds to the definition from has_actions() in
921
# check_option_syntax()
922
actions = {
923
# The actual values set here are not that important, but we do
924
# at least stick to the correct types, even though they are
925
# never used
926
"enable": True,
927
"disable": True,
928
"bump_timeout": True,
929
"start_checker": True,
930
"stop_checker": True,
931
"is_enabled": True,
932
"remove": True,
933
"checker": "x",
934
"timeout": datetime.timedelta(),
935
"extended_timeout": datetime.timedelta(),
936
"interval": datetime.timedelta(),
937
"approved_by_default": True,
938
"approval_delay": datetime.timedelta(),
939
"approval_duration": datetime.timedelta(),
940
"host": "x",
941
"secret": io.BytesIO(b"x"),
942
"approve": True,
943
"deny": True,
944
}
945
946
@contextlib.contextmanager
947
def assertParseError(self):
948
with self.assertRaises(SystemExit) as e:
949
with self.redirect_stderr_to_devnull():
950
yield
951
# Exit code from argparse is guaranteed to be "2". Reference:
952
# https://docs.python.org/3/library
953
# /argparse.html#exiting-methods
954
self.assertEqual(2, e.exception.code)
955
956
@staticmethod
957
@contextlib.contextmanager
958
def redirect_stderr_to_devnull():
959
old_stderr = sys.stderr
960
with contextlib.closing(open(os.devnull, "w")) as null:
961
sys.stderr = null
782
962
try:
783
value = string_to_delta("2h")
963
yield
784
964
finally:
785
log.removeFilter(warning_filter)
786
self.assertTrue(getattr(warning_filter, "found", False))
787
self.assertEqual(value, datetime.timedelta(0, 7200))
788
789
790
class TestCmd(unittest.TestCase):
965
sys.stderr = old_stderr
966
967
def check_option_syntax(self, options):
968
check_option_syntax(self.parser, options)
969
970
def test_actions_all_conflicts_with_verbose(self):
971
for action, value in self.actions.items():
972
options = self.parser.parse_args()
973
setattr(options, action, value)
974
options.all = True
975
options.verbose = True
976
with self.assertParseError():
977
self.check_option_syntax(options)
978
979
def test_actions_with_client_conflicts_with_verbose(self):
980
for action, value in self.actions.items():
981
options = self.parser.parse_args()
982
setattr(options, action, value)
983
options.verbose = True
984
options.client = ["client"]
985
with self.assertParseError():
986
self.check_option_syntax(options)
987
988
def test_dump_json_conflicts_with_verbose(self):
989
options = self.parser.parse_args()
990
options.dump_json = True
991
options.verbose = True
992
with self.assertParseError():
993
self.check_option_syntax(options)
994
995
def test_dump_json_conflicts_with_action(self):
996
for action, value in self.actions.items():
997
options = self.parser.parse_args()
998
setattr(options, action, value)
999
options.dump_json = True
1000
with self.assertParseError():
1001
self.check_option_syntax(options)
1002
1003
def test_all_can_not_be_alone(self):
1004
options = self.parser.parse_args()
1005
options.all = True
1006
with self.assertParseError():
1007
self.check_option_syntax(options)
1008
1009
def test_all_is_ok_with_any_action(self):
1010
for action, value in self.actions.items():
1011
options = self.parser.parse_args()
1012
setattr(options, action, value)
1013
options.all = True
1014
self.check_option_syntax(options)
1015
1016
def test_any_action_is_ok_with_one_client(self):
1017
for action, value in self.actions.items():
1018
options = self.parser.parse_args()
1019
setattr(options, action, value)
1020
options.client = ["client"]
1021
self.check_option_syntax(options)
1022
1023
def test_one_client_with_all_actions_except_is_enabled(self):
1024
options = self.parser.parse_args()
1025
for action, value in self.actions.items():
1026
if action == "is_enabled":
1027
continue
1028
setattr(options, action, value)
1029
options.client = ["client"]
1030
self.check_option_syntax(options)
1031
1032
def test_two_clients_with_all_actions_except_is_enabled(self):
1033
options = self.parser.parse_args()
1034
for action, value in self.actions.items():
1035
if action == "is_enabled":
1036
continue
1037
setattr(options, action, value)
1038
options.client = ["client1", "client2"]
1039
self.check_option_syntax(options)
1040
1041
def test_two_clients_are_ok_with_actions_except_is_enabled(self):
1042
for action, value in self.actions.items():
1043
if action == "is_enabled":
1044
continue
1045
options = self.parser.parse_args()
1046
setattr(options, action, value)
1047
options.client = ["client1", "client2"]
1048
self.check_option_syntax(options)
1049
1050
def test_is_enabled_fails_without_client(self):
1051
options = self.parser.parse_args()
1052
options.is_enabled = True
1053
with self.assertParseError():
1054
self.check_option_syntax(options)
1055
1056
def test_is_enabled_fails_with_two_clients(self):
1057
options = self.parser.parse_args()
1058
options.is_enabled = True
1059
options.client = ["client1", "client2"]
1060
with self.assertParseError():
1061
self.check_option_syntax(options)
1062
1063
def test_remove_can_only_be_combined_with_action_deny(self):
1064
for action, value in self.actions.items():
1065
if action in {"remove", "deny"}:
1066
continue
1067
options = self.parser.parse_args()
1068
setattr(options, action, value)
1069
options.all = True
1070
options.remove = True
1071
with self.assertParseError():
1072
self.check_option_syntax(options)
1073
1074
1075
class Test_get_mandos_dbus_object(TestCaseWithAssertLogs):
1076
def test_calls_and_returns_get_object_on_bus(self):
1077
class MockBus(object):
1078
called = False
1079
def get_object(mockbus_self, busname, dbus_path):
1080
# Note that "self" is still the testcase instance,
1081
# this MockBus instance is in "mockbus_self".
1082
self.assertEqual(dbus_busname, busname)
1083
self.assertEqual(server_dbus_path, dbus_path)
1084
mockbus_self.called = True
1085
return mockbus_self
1086
1087
mockbus = get_mandos_dbus_object(bus=MockBus())
1088
self.assertIsInstance(mockbus, MockBus)
1089
self.assertTrue(mockbus.called)
1090
1091
def test_logs_and_exits_on_dbus_error(self):
1092
class FailingBusStub(object):
1093
def get_object(self, busname, dbus_path):
1094
raise dbus.exceptions.DBusException("Test")
1095
1096
with self.assertLogs(log, logging.CRITICAL):
1097
with self.assertRaises(SystemExit) as e:
1098
bus = get_mandos_dbus_object(bus=FailingBusStub())
1099
1100
if isinstance(e.exception.code, int):
1101
self.assertNotEqual(0, e.exception.code)
1102
else:
1103
self.assertIsNotNone(e.exception.code)
1104
1105
1106
class Test_get_managed_objects(TestCaseWithAssertLogs):
1107
def test_calls_and_returns_GetManagedObjects(self):
1108
managed_objects = {"/clients/client": { "Name": "client"}}
1109
class ObjectManagerStub(object):
1110
def GetManagedObjects(self):
1111
return managed_objects
1112
retval = get_managed_objects(ObjectManagerStub())
1113
self.assertDictEqual(managed_objects, retval)
1114
1115
def test_logs_and_exits_on_dbus_error(self):
1116
dbus_logger = logging.getLogger("dbus.proxies")
1117
1118
class ObjectManagerFailingStub(object):
1119
def GetManagedObjects(self):
1120
dbus_logger.error("Test")
1121
raise dbus.exceptions.DBusException("Test")
1122
1123
class CountingHandler(logging.Handler):
1124
count = 0
1125
def emit(self, record):
1126
self.count += 1
1127
1128
counting_handler = CountingHandler()
1129
1130
dbus_logger.addHandler(counting_handler)
1131
1132
try:
1133
with self.assertLogs(log, logging.CRITICAL) as watcher:
1134
with self.assertRaises(SystemExit) as e:
1135
get_managed_objects(ObjectManagerFailingStub())
1136
finally:
1137
dbus_logger.removeFilter(counting_handler)
1138
1139
# Make sure the dbus logger was suppressed
1140
self.assertEqual(0, counting_handler.count)
1141
1142
# Test that the dbus_logger still works
1143
with self.assertLogs(dbus_logger, logging.ERROR):
1144
dbus_logger.error("Test")
1145
1146
if isinstance(e.exception.code, int):
1147
self.assertNotEqual(0, e.exception.code)
1148
else:
1149
self.assertIsNotNone(e.exception.code)
1150
1151
1152
class Test_commands_from_options(unittest.TestCase):
1153
def setUp(self):
1154
self.parser = argparse.ArgumentParser()
1155
add_command_line_options(self.parser)
1156
1157
def test_is_enabled(self):
1158
self.assert_command_from_args(["--is-enabled", "client"],
1159
command.IsEnabled)
1160
1161
def assert_command_from_args(self, args, command_cls,
1162
**cmd_attrs):
1163
"""Assert that parsing ARGS should result in an instance of
1164
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1165
options = self.parser.parse_args(args)
1166
check_option_syntax(self.parser, options)
1167
commands = commands_from_options(options)
1168
self.assertEqual(1, len(commands))
1169
command = commands[0]
1170
self.assertIsInstance(command, command_cls)
1171
for key, value in cmd_attrs.items():
1172
self.assertEqual(value, getattr(command, key))
1173
1174
def test_is_enabled_short(self):
1175
self.assert_command_from_args(["-V", "client"],
1176
command.IsEnabled)
1177
1178
def test_approve(self):
1179
self.assert_command_from_args(["--approve", "client"],
1180
command.Approve)
1181
1182
def test_approve_short(self):
1183
self.assert_command_from_args(["-A", "client"],
1184
command.Approve)
1185
1186
def test_deny(self):
1187
self.assert_command_from_args(["--deny", "client"],
1188
command.Deny)
1189
1190
def test_deny_short(self):
1191
self.assert_command_from_args(["-D", "client"], command.Deny)
1192
1193
def test_remove(self):
1194
self.assert_command_from_args(["--remove", "client"],
1195
command.Remove)
1196
1197
def test_deny_before_remove(self):
1198
options = self.parser.parse_args(["--deny", "--remove",
1199
"client"])
1200
check_option_syntax(self.parser, options)
1201
commands = commands_from_options(options)
1202
self.assertEqual(2, len(commands))
1203
self.assertIsInstance(commands[0], command.Deny)
1204
self.assertIsInstance(commands[1], command.Remove)
1205
1206
def test_deny_before_remove_reversed(self):
1207
options = self.parser.parse_args(["--remove", "--deny",
1208
"--all"])
1209
check_option_syntax(self.parser, options)
1210
commands = commands_from_options(options)
1211
self.assertEqual(2, len(commands))
1212
self.assertIsInstance(commands[0], command.Deny)
1213
self.assertIsInstance(commands[1], command.Remove)
1214
1215
def test_remove_short(self):
1216
self.assert_command_from_args(["-r", "client"],
1217
command.Remove)
1218
1219
def test_dump_json(self):
1220
self.assert_command_from_args(["--dump-json"],
1221
command.DumpJSON)
1222
1223
def test_enable(self):
1224
self.assert_command_from_args(["--enable", "client"],
1225
command.Enable)
1226
1227
def test_enable_short(self):
1228
self.assert_command_from_args(["-e", "client"],
1229
command.Enable)
1230
1231
def test_disable(self):
1232
self.assert_command_from_args(["--disable", "client"],
1233
command.Disable)
1234
1235
def test_disable_short(self):
1236
self.assert_command_from_args(["-d", "client"],
1237
command.Disable)
1238
1239
def test_bump_timeout(self):
1240
self.assert_command_from_args(["--bump-timeout", "client"],
1241
command.BumpTimeout)
1242
1243
def test_bump_timeout_short(self):
1244
self.assert_command_from_args(["-b", "client"],
1245
command.BumpTimeout)
1246
1247
def test_start_checker(self):
1248
self.assert_command_from_args(["--start-checker", "client"],
1249
command.StartChecker)
1250
1251
def test_stop_checker(self):
1252
self.assert_command_from_args(["--stop-checker", "client"],
1253
command.StopChecker)
1254
1255
def test_approve_by_default(self):
1256
self.assert_command_from_args(["--approve-by-default",
1257
"client"],
1258
command.ApproveByDefault)
1259
1260
def test_deny_by_default(self):
1261
self.assert_command_from_args(["--deny-by-default", "client"],
1262
command.DenyByDefault)
1263
1264
def test_checker(self):
1265
self.assert_command_from_args(["--checker", ":", "client"],
1266
command.SetChecker,
1267
value_to_set=":")
1268
1269
def test_checker_empty(self):
1270
self.assert_command_from_args(["--checker", "", "client"],
1271
command.SetChecker,
1272
value_to_set="")
1273
1274
def test_checker_short(self):
1275
self.assert_command_from_args(["-c", ":", "client"],
1276
command.SetChecker,
1277
value_to_set=":")
1278
1279
def test_host(self):
1280
self.assert_command_from_args(
1281
["--host", "client.example.org", "client"],
1282
command.SetHost, value_to_set="client.example.org")
1283
1284
def test_host_short(self):
1285
self.assert_command_from_args(
1286
["-H", "client.example.org", "client"], command.SetHost,
1287
value_to_set="client.example.org")
1288
1289
def test_secret_devnull(self):
1290
self.assert_command_from_args(["--secret", os.path.devnull,
1291
"client"], command.SetSecret,
1292
value_to_set=b"")
1293
1294
def test_secret_tempfile(self):
1295
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1296
value = b"secret\0xyzzy\nbar"
1297
f.write(value)
1298
f.seek(0)
1299
self.assert_command_from_args(["--secret", f.name,
1300
"client"],
1301
command.SetSecret,
1302
value_to_set=value)
1303
1304
def test_secret_devnull_short(self):
1305
self.assert_command_from_args(["-s", os.path.devnull,
1306
"client"], command.SetSecret,
1307
value_to_set=b"")
1308
1309
def test_secret_tempfile_short(self):
1310
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1311
value = b"secret\0xyzzy\nbar"
1312
f.write(value)
1313
f.seek(0)
1314
self.assert_command_from_args(["-s", f.name, "client"],
1315
command.SetSecret,
1316
value_to_set=value)
1317
1318
def test_timeout(self):
1319
self.assert_command_from_args(["--timeout", "PT5M", "client"],
1320
command.SetTimeout,
1321
value_to_set=300000)
1322
1323
def test_timeout_short(self):
1324
self.assert_command_from_args(["-t", "PT5M", "client"],
1325
command.SetTimeout,
1326
value_to_set=300000)
1327
1328
def test_extended_timeout(self):
1329
self.assert_command_from_args(["--extended-timeout", "PT15M",
1330
"client"],
1331
command.SetExtendedTimeout,
1332
value_to_set=900000)
1333
1334
def test_interval(self):
1335
self.assert_command_from_args(["--interval", "PT2M",
1336
"client"], command.SetInterval,
1337
value_to_set=120000)
1338
1339
def test_interval_short(self):
1340
self.assert_command_from_args(["-i", "PT2M", "client"],
1341
command.SetInterval,
1342
value_to_set=120000)
1343
1344
def test_approval_delay(self):
1345
self.assert_command_from_args(["--approval-delay", "PT30S",
1346
"client"],
1347
command.SetApprovalDelay,
1348
value_to_set=30000)
1349
1350
def test_approval_duration(self):
1351
self.assert_command_from_args(["--approval-duration", "PT1S",
1352
"client"],
1353
command.SetApprovalDuration,
1354
value_to_set=1000)
1355
1356
def test_print_table(self):
1357
self.assert_command_from_args([], command.PrintTable,
1358
verbose=False)
1359
1360
def test_print_table_verbose(self):
1361
self.assert_command_from_args(["--verbose"],
1362
command.PrintTable,
1363
verbose=True)
1364
1365
def test_print_table_verbose_short(self):
1366
self.assert_command_from_args(["-v"], command.PrintTable,
1367
verbose=True)
1368
1369
1370
class TestCommand(unittest.TestCase):
791
1371
"""Abstract class for tests of command classes"""
1372
792
1373
def setUp(self):
793
1374
testcase = self
794
1375
class MockClient(object):
795
1376
def __init__(self, name, **attributes):
796
self.__dbus_object_path__ = "objpath_{}".format(name)
1377
self.__dbus_object_path__ = "/clients/{}".format(name)
797
1378
self.attributes = attributes
798
1379
self.attributes["Name"] = name
799
1380
self.calls = []
800
def Set(self, interface, property, value, dbus_interface):
801
testcase.assertEqual(interface, client_interface)
802
testcase.assertEqual(dbus_interface,
803
dbus.PROPERTIES_IFACE)
804
self.attributes[property] = value
805
def Get(self, interface, property, dbus_interface):
806
testcase.assertEqual(interface, client_interface)
807
testcase.assertEqual(dbus_interface,
808
dbus.PROPERTIES_IFACE)
809
return self.attributes[property]
1381
def Set(self, interface, propname, value, dbus_interface):
1382
testcase.assertEqual(client_dbus_interface, interface)
1383
testcase.assertEqual(dbus.PROPERTIES_IFACE,
1384
dbus_interface)
1385
self.attributes[propname] = value
810
1386
def Approve(self, approve, dbus_interface):
811
testcase.assertEqual(dbus_interface, client_interface)
1387
testcase.assertEqual(client_dbus_interface,
1388
dbus_interface)
812
1389
self.calls.append(("Approve", (approve,
813
1390
dbus_interface)))
814
1391
self.client = MockClient(
854
1431
ApprovedByDefault=dbus.Boolean(False),
855
1432
LastApprovalRequest="2019-01-03T00:00:00",
856
1433
ApprovalDelay=30000,
857
ApprovalDuration=1000,
1434
ApprovalDuration=93785000,
858
1435
Checker=":",
859
1436
ExtendedTimeout=900000,
860
1437
Expires="2019-02-05T00:00:00",
861
1438
LastCheckerStatus=-2)
862
1439
self.clients = collections.OrderedDict(
863
1440
[
864
(self.client, self.client.attributes),
865
(self.other_client, self.other_client.attributes),
1441
(self.client.__dbus_object_path__,
1442
self.client.attributes),
1443
(self.other_client.__dbus_object_path__,
1444
self.other_client.attributes),
866
1445
])
867
self.one_client = {self.client: self.client.attributes}
868
869
class TestPrintTableCmd(TestCmd):
870
def test_normal(self):
871
output = PrintTableCmd().output(self.clients)
872
expected_output = """
873
Name Enabled Timeout Last Successful Check
874
foo Yes 00:05:00 2019-02-03T00:00:00
875
barbar Yes 00:05:00 2019-02-04T00:00:00
876
"""[1:-1]
877
self.assertEqual(output, expected_output)
878
def test_verbose(self):
879
output = PrintTableCmd(verbose=True).output(self.clients)
880
expected_output = """
881
Name Enabled Timeout Last Successful Check Created Interval Host Key ID Fingerprint Check Is Running Last Enabled Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker Extended Timeout Expires Last Checker Status
882
foo Yes 00:05:00 2019-02-03T00:00:00 2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No 2019-01-03T00:00:00 No Yes 00:00:00 00:00:01 fping -q -- %(host)s 00:15:00 2019-02-04T00:00:00 0
883
barbar Yes 00:05:00 2019-02-04T00:00:00 2019-01-03T00:00:00 00:02:00 192.0.2.3 0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e46c2b020f441c 3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 Yes 2019-01-04T00:00:00 No No 2019-01-03T00:00:00 00:00:30 00:00:01 : 00:15:00 2019-02-05T00:00:00 -2
884
"""[1:-1]
885
self.assertEqual(output, expected_output)
886
def test_one_client(self):
887
output = PrintTableCmd().output(self.one_client)
888
expected_output = """
889
Name Enabled Timeout Last Successful Check
890
foo Yes 00:05:00 2019-02-03T00:00:00
891
"""[1:-1]
892
self.assertEqual(output, expected_output)
893
894
class TestDumpJSONCmd(TestCmd):
895
def setUp(self):
896
self.expected_json = {
897
"foo": {
898
"Name": "foo",
899
"KeyID": ("92ed150794387c03ce684574b1139a65"
900
"94a34f895daaaf09fd8ea90a27cddb12"),
901
"Host": "foo.example.org",
902
"Enabled": True,
903
"Timeout": 300000,
904
"LastCheckedOK": "2019-02-03T00:00:00",
905
"Created": "2019-01-02T00:00:00",
906
"Interval": 120000,
907
"Fingerprint": ("778827225BA7DE539C5A"
908
"7CFA59CFF7CDBD9A5920"),
909
"CheckerRunning": False,
910
"LastEnabled": "2019-01-03T00:00:00",
911
"ApprovalPending": False,
912
"ApprovedByDefault": True,
913
"LastApprovalRequest": "",
914
"ApprovalDelay": 0,
915
"ApprovalDuration": 1000,
916
"Checker": "fping -q -- %(host)s",
917
"ExtendedTimeout": 900000,
918
"Expires": "2019-02-04T00:00:00",
919
"LastCheckerStatus": 0,
920
},
921
"barbar": {
922
"Name": "barbar",
923
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
924
"6ab612cff5ad227247e46c2b020f441c"),
925
"Host": "192.0.2.3",
926
"Enabled": True,
927
"Timeout": 300000,
928
"LastCheckedOK": "2019-02-04T00:00:00",
929
"Created": "2019-01-03T00:00:00",
930
"Interval": 120000,
931
"Fingerprint": ("3E393AEAEFB84C7E89E2"
932
"F547B3A107558FCA3A27"),
933
"CheckerRunning": True,
934
"LastEnabled": "2019-01-04T00:00:00",
935
"ApprovalPending": False,
936
"ApprovedByDefault": False,
937
"LastApprovalRequest": "2019-01-03T00:00:00",
938
"ApprovalDelay": 30000,
939
"ApprovalDuration": 1000,
940
"Checker": ":",
941
"ExtendedTimeout": 900000,
942
"Expires": "2019-02-05T00:00:00",
943
"LastCheckerStatus": -2,
944
},
945
}
946
return super(TestDumpJSONCmd, self).setUp()
947
def test_normal(self):
948
json_data = json.loads(DumpJSONCmd().output(self.clients))
949
self.assertDictEqual(json_data, self.expected_json)
950
def test_one_client(self):
951
clients = self.one_client
952
json_data = json.loads(DumpJSONCmd().output(clients))
953
expected_json = {"foo": self.expected_json["foo"]}
954
self.assertDictEqual(json_data, expected_json)
955
956
class TestIsEnabledCmd(TestCmd):
957
def test_is_enabled(self):
958
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
959
for client, properties in self.clients.items()))
960
def test_is_enabled_run_exits_successfully(self):
1446
self.one_client = {self.client.__dbus_object_path__:
1447
self.client.attributes}
1448
1449
@property
1450
def bus(self):
1451
class MockBus(object):
1452
@staticmethod
1453
def get_object(client_bus_name, path):
1454
self.assertEqual(dbus_busname, client_bus_name)
1455
# Note: "self" here is the TestCmd instance, not the
1456
# MockBus instance, since this is a static method!
1457
if path == self.client.__dbus_object_path__:
1458
return self.client
1459
elif path == self.other_client.__dbus_object_path__:
1460
return self.other_client
1461
return MockBus()
1462
1463
1464
class TestBaseCommands(TestCommand):
1465
1466
def test_IsEnabled_exits_successfully(self):
961
1467
with self.assertRaises(SystemExit) as e:
962
IsEnabledCmd().run(None, self.one_client)
1468
command.IsEnabled().run(self.one_client)
963
1469
if e.exception.code is not None:
964
self.assertEqual(e.exception.code, 0)
1470
self.assertEqual(0, e.exception.code)
965
1471
else:
966
1472
self.assertIsNone(e.exception.code)
967
def test_is_enabled_run_exits_with_failure(self):
1473
1474
def test_IsEnabled_exits_with_failure(self):
968
1475
self.client.attributes["Enabled"] = dbus.Boolean(False)
969
1476
with self.assertRaises(SystemExit) as e:
970
IsEnabledCmd().run(None, self.one_client)
1477
command.IsEnabled().run(self.one_client)
971
1478
if isinstance(e.exception.code, int):
972
self.assertNotEqual(e.exception.code, 0)
1479
self.assertNotEqual(0, e.exception.code)
973
1480
else:
974
1481
self.assertIsNotNone(e.exception.code)
975
1482
976
class TestRemoveCmd(TestCmd):
977
def test_remove(self):
978
class MockMandos(object):
1483
def test_Approve(self):
1484
command.Approve().run(self.clients, self.bus)
1485
for clientpath in self.clients:
1486
client = self.bus.get_object(dbus_busname, clientpath)
1487
self.assertIn(("Approve", (True, client_dbus_interface)),
1488
client.calls)
1489
1490
def test_Deny(self):
1491
command.Deny().run(self.clients, self.bus)
1492
for clientpath in self.clients:
1493
client = self.bus.get_object(dbus_busname, clientpath)
1494
self.assertIn(("Approve", (False, client_dbus_interface)),
1495
client.calls)
1496
1497
def test_Remove(self):
1498
class MandosSpy(object):
979
1499
def __init__(self):
980
1500
self.calls = []
981
1501
def RemoveClient(self, dbus_path):
982
1502
self.calls.append(("RemoveClient", (dbus_path,)))
983
mandos = MockMandos()
984
super(TestRemoveCmd, self).setUp()
985
RemoveCmd().run(mandos, self.clients)
986
self.assertEqual(len(mandos.calls), 2)
987
for client in self.clients:
988
self.assertIn(("RemoveClient",
989
(client.__dbus_object_path__,)),
1503
mandos = MandosSpy()
1504
command.Remove().run(self.clients, self.bus, mandos)
1505
for clientpath in self.clients:
1506
self.assertIn(("RemoveClient", (clientpath,)),
990
1507
mandos.calls)
991
1508
992
class TestApproveCmd(TestCmd):
993
def test_approve(self):
994
ApproveCmd().run(None, self.clients)
995
for client in self.clients:
996
self.assertIn(("Approve", (True, client_interface)),
997
client.calls)
998
999
class TestDenyCmd(TestCmd):
1000
def test_deny(self):
1001
DenyCmd().run(None, self.clients)
1002
for client in self.clients:
1003
self.assertIn(("Approve", (False, client_interface)),
1004
client.calls)
1005
1006
class TestEnableCmd(TestCmd):
1007
def test_enable(self):
1008
for client in self.clients:
1009
client.attributes["Enabled"] = False
1010
1011
EnableCmd().run(None, self.clients)
1012
1013
for client in self.clients:
1014
self.assertTrue(client.attributes["Enabled"])
1015
1016
class TestDisableCmd(TestCmd):
1017
def test_disable(self):
1018
DisableCmd().run(None, self.clients)
1019
1020
for client in self.clients:
1021
self.assertFalse(client.attributes["Enabled"])
1022
1023
class Unique(object):
1024
"""Class for objects which exist only to be unique objects, since
1025
unittest.mock.sentinel only exists in Python 3.3"""
1026
1027
class TestPropertyCmd(TestCmd):
1028
"""Abstract class for tests of PropertyCmd classes"""
1509
expected_json = {
1510
"foo": {
1511
"Name": "foo",
1512
"KeyID": ("92ed150794387c03ce684574b1139a65"
1513
"94a34f895daaaf09fd8ea90a27cddb12"),
1514
"Host": "foo.example.org",
1515
"Enabled": True,
1516
"Timeout": 300000,
1517
"LastCheckedOK": "2019-02-03T00:00:00",
1518
"Created": "2019-01-02T00:00:00",
1519
"Interval": 120000,
1520
"Fingerprint": ("778827225BA7DE539C5A"
1521
"7CFA59CFF7CDBD9A5920"),
1522
"CheckerRunning": False,
1523
"LastEnabled": "2019-01-03T00:00:00",
1524
"ApprovalPending": False,
1525
"ApprovedByDefault": True,
1526
"LastApprovalRequest": "",
1527
"ApprovalDelay": 0,
1528
"ApprovalDuration": 1000,
1529
"Checker": "fping -q -- %(host)s",
1530
"ExtendedTimeout": 900000,
1531
"Expires": "2019-02-04T00:00:00",
1532
"LastCheckerStatus": 0,
1533
},
1534
"barbar": {
1535
"Name": "barbar",
1536
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
1537
"6ab612cff5ad227247e46c2b020f441c"),
1538
"Host": "192.0.2.3",
1539
"Enabled": True,
1540
"Timeout": 300000,
1541
"LastCheckedOK": "2019-02-04T00:00:00",
1542
"Created": "2019-01-03T00:00:00",
1543
"Interval": 120000,
1544
"Fingerprint": ("3E393AEAEFB84C7E89E2"
1545
"F547B3A107558FCA3A27"),
1546
"CheckerRunning": True,
1547
"LastEnabled": "2019-01-04T00:00:00",
1548
"ApprovalPending": False,
1549
"ApprovedByDefault": False,
1550
"LastApprovalRequest": "2019-01-03T00:00:00",
1551
"ApprovalDelay": 30000,
1552
"ApprovalDuration": 93785000,
1553
"Checker": ":",
1554
"ExtendedTimeout": 900000,
1555
"Expires": "2019-02-05T00:00:00",
1556
"LastCheckerStatus": -2,
1557
},
1558
}
1559
1560
def test_DumpJSON_normal(self):
1561
with self.capture_stdout_to_buffer() as buffer:
1562
command.DumpJSON().run(self.clients)
1563
json_data = json.loads(buffer.getvalue())
1564
self.assertDictEqual(self.expected_json, json_data)
1565
1566
@staticmethod
1567
@contextlib.contextmanager
1568
def capture_stdout_to_buffer():
1569
capture_buffer = io.StringIO()
1570
old_stdout = sys.stdout
1571
sys.stdout = capture_buffer
1572
try:
1573
yield capture_buffer
1574
finally:
1575
sys.stdout = old_stdout
1576
1577
def test_DumpJSON_one_client(self):
1578
with self.capture_stdout_to_buffer() as buffer:
1579
command.DumpJSON().run(self.one_client)
1580
json_data = json.loads(buffer.getvalue())
1581
expected_json = {"foo": self.expected_json["foo"]}
1582
self.assertDictEqual(expected_json, json_data)
1583
1584
def test_PrintTable_normal(self):
1585
with self.capture_stdout_to_buffer() as buffer:
1586
command.PrintTable().run(self.clients)
1587
expected_output = "\n".join((
1588
"Name Enabled Timeout Last Successful Check",
1589
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1590
"barbar Yes 00:05:00 2019-02-04T00:00:00 ",
1591
)) + "\n"
1592
self.assertEqual(expected_output, buffer.getvalue())
1593
1594
def test_PrintTable_verbose(self):
1595
with self.capture_stdout_to_buffer() as buffer:
1596
command.PrintTable(verbose=True).run(self.clients)
1597
columns = (
1598
(
1599
"Name ",
1600
"foo ",
1601
"barbar ",
1602
),(
1603
"Enabled ",
1604
"Yes ",
1605
"Yes ",
1606
),(
1607
"Timeout ",
1608
"00:05:00 ",
1609
"00:05:00 ",
1610
),(
1611
"Last Successful Check ",
1612
"2019-02-03T00:00:00 ",
1613
"2019-02-04T00:00:00 ",
1614
),(
1615
"Created ",
1616
"2019-01-02T00:00:00 ",
1617
"2019-01-03T00:00:00 ",
1618
),(
1619
"Interval ",
1620
"00:02:00 ",
1621
"00:02:00 ",
1622
),(
1623
"Host ",
1624
"foo.example.org ",
1625
"192.0.2.3 ",
1626
),(
1627
("Key ID "
1628
" "),
1629
("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
1630
"ea90a27cddb12 "),
1631
("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
1632
"46c2b020f441c "),
1633
),(
1634
"Fingerprint ",
1635
"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
1636
"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
1637
),(
1638
"Check Is Running ",
1639
"No ",
1640
"Yes ",
1641
),(
1642
"Last Enabled ",
1643
"2019-01-03T00:00:00 ",
1644
"2019-01-04T00:00:00 ",
1645
),(
1646
"Approval Is Pending ",
1647
"No ",
1648
"No ",
1649
),(
1650
"Approved By Default ",
1651
"Yes ",
1652
"No ",
1653
),(
1654
"Last Approval Request ",
1655
" ",
1656
"2019-01-03T00:00:00 ",
1657
),(
1658
"Approval Delay ",
1659
"00:00:00 ",
1660
"00:00:30 ",
1661
),(
1662
"Approval Duration ",
1663
"00:00:01 ",
1664
"1T02:03:05 ",
1665
),(
1666
"Checker ",
1667
"fping -q -- %(host)s ",
1668
": ",
1669
),(
1670
"Extended Timeout ",
1671
"00:15:00 ",
1672
"00:15:00 ",
1673
),(
1674
"Expires ",
1675
"2019-02-04T00:00:00 ",
1676
"2019-02-05T00:00:00 ",
1677
),(
1678
"Last Checker Status",
1679
"0 ",
1680
"-2 ",
1681
)
1682
)
1683
num_lines = max(len(rows) for rows in columns)
1684
expected_output = ("\n".join("".join(rows[line]
1685
for rows in columns)
1686
for line in range(num_lines))
1687
+ "\n")
1688
self.assertEqual(expected_output, buffer.getvalue())
1689
1690
def test_PrintTable_one_client(self):
1691
with self.capture_stdout_to_buffer() as buffer:
1692
command.PrintTable().run(self.one_client)
1693
expected_output = "\n".join((
1694
"Name Enabled Timeout Last Successful Check",
1695
"foo Yes 00:05:00 2019-02-03T00:00:00 ",
1696
)) + "\n"
1697
self.assertEqual(expected_output, buffer.getvalue())
1698
1699
1700
class TestPropertySetterCmd(TestCommand):
1701
"""Abstract class for tests of command.PropertySetter classes"""
1029
1702
def runTest(self):
1030
1703
if not hasattr(self, "command"):
1031
1704
return
1033
1706
self.values_to_set)
1034
1707
for value_to_set, value_to_get in zip(self.values_to_set,
1035
1708
values_to_get):
1036
for client in self.clients:
1037
old_value = client.attributes[self.property]
1038
self.assertNotIsInstance(old_value, Unique)
1039
client.attributes[self.property] = Unique()
1709
for clientpath in self.clients:
1710
client = self.bus.get_object(dbus_busname, clientpath)
1711
old_value = client.attributes[self.propname]
1712
client.attributes[self.propname] = self.Unique()
1040
1713
self.run_command(value_to_set, self.clients)
1041
for client in self.clients:
1042
value = client.attributes[self.property]
1043
self.assertNotIsInstance(value, Unique)
1044
self.assertEqual(value, value_to_get)
1714
for clientpath in self.clients:
1715
client = self.bus.get_object(dbus_busname, clientpath)
1716
value = client.attributes[self.propname]
1717
self.assertNotIsInstance(value, self.Unique)
1718
self.assertEqual(value_to_get, value)
1719
1720
class Unique(object):
1721
"""Class for objects which exist only to be unique objects,
1722
since unittest.mock.sentinel only exists in Python 3.3"""
1723
1045
1724
def run_command(self, value, clients):
1046
self.command().run(None, clients)
1047
1048
class TestBumpTimeoutCmd(TestPropertyCmd):
1049
command = BumpTimeoutCmd
1050
property = "LastCheckedOK"
1725
self.command().run(clients, self.bus)
1726
1727
1728
class TestEnableCmd(TestPropertySetterCmd):
1729
command = command.Enable
1730
propname = "Enabled"
1731
values_to_set = [dbus.Boolean(True)]
1732
1733
1734
class TestDisableCmd(TestPropertySetterCmd):
1735
command = command.Disable
1736
propname = "Enabled"
1737
values_to_set = [dbus.Boolean(False)]
1738
1739
1740
class TestBumpTimeoutCmd(TestPropertySetterCmd):
1741
command = command.BumpTimeout
1742
propname = "LastCheckedOK"
1051
1743
values_to_set = [""]
1052
1744
1053
class TestStartCheckerCmd(TestPropertyCmd):
1054
command = StartCheckerCmd
1055
property = "CheckerRunning"
1056
values_to_set = [dbus.Boolean(True)]
1057
1058
class TestStopCheckerCmd(TestPropertyCmd):
1059
command = StopCheckerCmd
1060
property = "CheckerRunning"
1061
values_to_set = [dbus.Boolean(False)]
1062
1063
class TestApproveByDefaultCmd(TestPropertyCmd):
1064
command = ApproveByDefaultCmd
1065
property = "ApprovedByDefault"
1066
values_to_set = [dbus.Boolean(True)]
1067
1068
class TestDenyByDefaultCmd(TestPropertyCmd):
1069
command = DenyByDefaultCmd
1070
property = "ApprovedByDefault"
1071
values_to_set = [dbus.Boolean(False)]
1072
1073
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1074
"""Abstract class for tests of PropertyCmd classes using the
1075
ValueArgumentMixIn"""
1745
1746
class TestStartCheckerCmd(TestPropertySetterCmd):
1747
command = command.StartChecker
1748
propname = "CheckerRunning"
1749
values_to_set = [dbus.Boolean(True)]
1750
1751
1752
class TestStopCheckerCmd(TestPropertySetterCmd):
1753
command = command.StopChecker
1754
propname = "CheckerRunning"
1755
values_to_set = [dbus.Boolean(False)]
1756
1757
1758
class TestApproveByDefaultCmd(TestPropertySetterCmd):
1759
command = command.ApproveByDefault
1760
propname = "ApprovedByDefault"
1761
values_to_set = [dbus.Boolean(True)]
1762
1763
1764
class TestDenyByDefaultCmd(TestPropertySetterCmd):
1765
command = command.DenyByDefault
1766
propname = "ApprovedByDefault"
1767
values_to_set = [dbus.Boolean(False)]
1768
1769
1770
class TestPropertySetterValueCmd(TestPropertySetterCmd):
1771
"""Abstract class for tests of PropertySetterValueCmd classes"""
1772
1076
1773
def runTest(self):
1077
if type(self) is TestValueArgumentPropertyCmd:
1774
if type(self) is TestPropertySetterValueCmd:
1078
1775
return
1079
return super(TestValueArgumentPropertyCmd, self).runTest()
1776
return super(TestPropertySetterValueCmd, self).runTest()
1777
1080
1778
def run_command(self, value, clients):
1081
self.command(value).run(None, clients)
1082
1083
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
1084
command = SetCheckerCmd
1085
property = "Checker"
1779
self.command(value).run(clients, self.bus)
1780
1781
1782
class TestSetCheckerCmd(TestPropertySetterValueCmd):
1783
command = command.SetChecker
1784
propname = "Checker"
1086
1785
values_to_set = ["", ":", "fping -q -- %s"]
1087
1786
1088
class TestSetHostCmd(TestValueArgumentPropertyCmd):
1089
command = SetHostCmd
1090
property = "Host"
1091
values_to_set = ["192.0.2.3", "foo.example.org"]
1092
1093
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
1094
command = SetSecretCmd
1095
property = "Secret"
1096
values_to_set = [open("/dev/null", "rb"),
1787
1788
class TestSetHostCmd(TestPropertySetterValueCmd):
1789
command = command.SetHost
1790
propname = "Host"
1791
values_to_set = ["192.0.2.3", "client.example.org"]
1792
1793
1794
class TestSetSecretCmd(TestPropertySetterValueCmd):
1795
command = command.SetSecret
1796
propname = "Secret"
1797
values_to_set = [io.BytesIO(b""),
1097
1798
io.BytesIO(b"secret\0xyzzy\nbar")]
1098
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1099
1100
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1101
command = SetTimeoutCmd
1102
property = "Timeout"
1103
values_to_set = [datetime.timedelta(),
1104
datetime.timedelta(minutes=5),
1105
datetime.timedelta(seconds=1),
1106
datetime.timedelta(weeks=1),
1107
datetime.timedelta(weeks=52)]
1108
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1109
1110
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1111
command = SetExtendedTimeoutCmd
1112
property = "ExtendedTimeout"
1113
values_to_set = [datetime.timedelta(),
1114
datetime.timedelta(minutes=5),
1115
datetime.timedelta(seconds=1),
1116
datetime.timedelta(weeks=1),
1117
datetime.timedelta(weeks=52)]
1118
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1119
1120
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1121
command = SetIntervalCmd
1122
property = "Interval"
1123
values_to_set = [datetime.timedelta(),
1124
datetime.timedelta(minutes=5),
1125
datetime.timedelta(seconds=1),
1126
datetime.timedelta(weeks=1),
1127
datetime.timedelta(weeks=52)]
1128
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1129
1130
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1131
command = SetApprovalDelayCmd
1132
property = "ApprovalDelay"
1133
values_to_set = [datetime.timedelta(),
1134
datetime.timedelta(minutes=5),
1135
datetime.timedelta(seconds=1),
1136
datetime.timedelta(weeks=1),
1137
datetime.timedelta(weeks=52)]
1138
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1139
1140
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1141
command = SetApprovalDurationCmd
1142
property = "ApprovalDuration"
1143
values_to_set = [datetime.timedelta(),
1144
datetime.timedelta(minutes=5),
1145
datetime.timedelta(seconds=1),
1146
datetime.timedelta(weeks=1),
1147
datetime.timedelta(weeks=52)]
1148
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1149
1150
class Test_command_from_options(unittest.TestCase):
1151
def setUp(self):
1152
self.parser = argparse.ArgumentParser()
1153
add_command_line_options(self.parser)
1154
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1155
"""Assert that parsing ARGS should result in an instance of
1156
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1157
options = self.parser.parse_args(args)
1158
commands = commands_from_options(options)
1159
self.assertEqual(len(commands), 1)
1160
command = commands[0]
1161
self.assertIsInstance(command, command_cls)
1162
for key, value in cmd_attrs.items():
1163
self.assertEqual(getattr(command, key), value)
1164
def test_print_table(self):
1165
self.assert_command_from_args([], PrintTableCmd,
1166
verbose=False)
1167
1168
def test_print_table_verbose(self):
1169
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1170
verbose=True)
1171
1172
def test_print_table_verbose_short(self):
1173
self.assert_command_from_args(["-v"], PrintTableCmd,
1174
verbose=True)
1175
1176
def test_enable(self):
1177
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1178
1179
def test_enable_short(self):
1180
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1181
1182
def test_disable(self):
1183
self.assert_command_from_args(["--disable", "foo"],
1184
DisableCmd)
1185
1186
def test_disable_short(self):
1187
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1188
1189
def test_bump_timeout(self):
1190
self.assert_command_from_args(["--bump-timeout", "foo"],
1191
BumpTimeoutCmd)
1192
1193
def test_bump_timeout_short(self):
1194
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1195
1196
def test_start_checker(self):
1197
self.assert_command_from_args(["--start-checker", "foo"],
1198
StartCheckerCmd)
1199
1200
def test_stop_checker(self):
1201
self.assert_command_from_args(["--stop-checker", "foo"],
1202
StopCheckerCmd)
1203
1204
def test_remove(self):
1205
self.assert_command_from_args(["--remove", "foo"],
1206
RemoveCmd)
1207
1208
def test_remove_short(self):
1209
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1210
1211
def test_checker(self):
1212
self.assert_command_from_args(["--checker", ":", "foo"],
1213
SetCheckerCmd, value_to_set=":")
1214
1215
def test_checker_empty(self):
1216
self.assert_command_from_args(["--checker", "", "foo"],
1217
SetCheckerCmd, value_to_set="")
1218
1219
def test_checker_short(self):
1220
self.assert_command_from_args(["-c", ":", "foo"],
1221
SetCheckerCmd, value_to_set=":")
1222
1223
def test_timeout(self):
1224
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1225
SetTimeoutCmd,
1226
value_to_set=300000)
1227
1228
def test_timeout_short(self):
1229
self.assert_command_from_args(["-t", "PT5M", "foo"],
1230
SetTimeoutCmd,
1231
value_to_set=300000)
1232
1233
def test_extended_timeout(self):
1234
self.assert_command_from_args(["--extended-timeout", "PT15M",
1235
"foo"],
1236
SetExtendedTimeoutCmd,
1237
value_to_set=900000)
1238
1239
def test_interval(self):
1240
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1241
SetIntervalCmd,
1242
value_to_set=120000)
1243
1244
def test_interval_short(self):
1245
self.assert_command_from_args(["-i", "PT2M", "foo"],
1246
SetIntervalCmd,
1247
value_to_set=120000)
1248
1249
def test_approve_by_default(self):
1250
self.assert_command_from_args(["--approve-by-default", "foo"],
1251
ApproveByDefaultCmd)
1252
1253
def test_deny_by_default(self):
1254
self.assert_command_from_args(["--deny-by-default", "foo"],
1255
DenyByDefaultCmd)
1256
1257
def test_approval_delay(self):
1258
self.assert_command_from_args(["--approval-delay", "PT30S",
1259
"foo"], SetApprovalDelayCmd,
1260
value_to_set=30000)
1261
1262
def test_approval_duration(self):
1263
self.assert_command_from_args(["--approval-duration", "PT1S",
1264
"foo"], SetApprovalDurationCmd,
1265
value_to_set=1000)
1266
1267
def test_host(self):
1268
self.assert_command_from_args(["--host", "foo.example.org",
1269
"foo"], SetHostCmd,
1270
value_to_set="foo.example.org")
1271
1272
def test_host_short(self):
1273
self.assert_command_from_args(["-H", "foo.example.org",
1274
"foo"], SetHostCmd,
1275
value_to_set="foo.example.org")
1276
1277
def test_secret_devnull(self):
1278
self.assert_command_from_args(["--secret", os.path.devnull,
1279
"foo"], SetSecretCmd,
1280
value_to_set=b"")
1281
1282
def test_secret_tempfile(self):
1283
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1284
value = b"secret\0xyzzy\nbar"
1285
f.write(value)
1286
f.seek(0)
1287
self.assert_command_from_args(["--secret", f.name,
1288
"foo"], SetSecretCmd,
1289
value_to_set=value)
1290
1291
def test_secret_devnull_short(self):
1292
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1293
SetSecretCmd, value_to_set=b"")
1294
1295
def test_secret_tempfile_short(self):
1296
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1297
value = b"secret\0xyzzy\nbar"
1298
f.write(value)
1299
f.seek(0)
1300
self.assert_command_from_args(["-s", f.name, "foo"],
1301
SetSecretCmd,
1302
value_to_set=value)
1303
1304
def test_approve(self):
1305
self.assert_command_from_args(["--approve", "foo"],
1306
ApproveCmd)
1307
1308
def test_approve_short(self):
1309
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1310
1311
def test_deny(self):
1312
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1313
1314
def test_deny_short(self):
1315
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1316
1317
def test_dump_json(self):
1318
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1319
1320
def test_is_enabled(self):
1321
self.assert_command_from_args(["--is-enabled", "foo"],
1322
IsEnabledCmd)
1323
1324
def test_is_enabled_short(self):
1325
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1799
values_to_get = [f.getvalue() for f in values_to_set]
1800
1801
1802
class TestSetTimeoutCmd(TestPropertySetterValueCmd):
1803
command = command.SetTimeout
1804
propname = "Timeout"
1805
values_to_set = [datetime.timedelta(),
1806
datetime.timedelta(minutes=5),
1807
datetime.timedelta(seconds=1),
1808
datetime.timedelta(weeks=1),
1809
datetime.timedelta(weeks=52)]
1810
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1811
1812
1813
class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):
1814
command = command.SetExtendedTimeout
1815
propname = "ExtendedTimeout"
1816
values_to_set = [datetime.timedelta(),
1817
datetime.timedelta(minutes=5),
1818
datetime.timedelta(seconds=1),
1819
datetime.timedelta(weeks=1),
1820
datetime.timedelta(weeks=52)]
1821
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1822
1823
1824
class TestSetIntervalCmd(TestPropertySetterValueCmd):
1825
command = command.SetInterval
1826
propname = "Interval"
1827
values_to_set = [datetime.timedelta(),
1828
datetime.timedelta(minutes=5),
1829
datetime.timedelta(seconds=1),
1830
datetime.timedelta(weeks=1),
1831
datetime.timedelta(weeks=52)]
1832
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1833
1834
1835
class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):
1836
command = command.SetApprovalDelay
1837
propname = "ApprovalDelay"
1838
values_to_set = [datetime.timedelta(),
1839
datetime.timedelta(minutes=5),
1840
datetime.timedelta(seconds=1),
1841
datetime.timedelta(weeks=1),
1842
datetime.timedelta(weeks=52)]
1843
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1844
1845
1846
class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):
1847
command = command.SetApprovalDuration
1848
propname = "ApprovalDuration"
1849
values_to_set = [datetime.timedelta(),
1850
datetime.timedelta(minutes=5),
1851
datetime.timedelta(seconds=1),
1852
datetime.timedelta(weeks=1),
1853
datetime.timedelta(weeks=52)]
1854
values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]
1326
1855
1327
1856
1328
1857
1343
1872
return tests
1344
1873
1345
1874
if __name__ == "__main__":
1346
if should_only_run_tests():
1347
# Call using ./tdd-python-script --check [--verbose]
1348
unittest.main()
1349
else:
1350
main()
1875
try:
1876
if should_only_run_tests():
1877
# Call using ./tdd-python-script --check [--verbose]
1878
unittest.main()
1879
else:
1880
main()
1881
finally:
1882
logging.shutdown()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0