/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: 2019-03-12 20:13:34 UTC
  • Revision ID: teddy@recompile.se-20190312201334-my3htrprewjosuw5
mandos-ctl: Refactor

* mandos-ctl: Reorder everything into logical order; put main() first,
              and put every subsequent definition as soon as possible
              after its first use, except superclasses which need to
              be placed before the classes inheriting from them.
              Reorder all tests to match.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
63
64
 
64
65
locale.setlocale(locale.LC_ALL, "")
65
66
 
66
 
domain = "se.recompile"
67
 
busname = domain + ".Mandos"
68
 
server_path = "/"
69
 
server_interface = domain + ".Mandos"
70
 
client_interface = domain + ".Mandos.Client"
 
67
dbus_busname_domain = "se.recompile"
 
68
dbus_busname = dbus_busname_domain + ".Mandos"
 
69
server_dbus_path = "/"
 
70
server_dbus_interface = dbus_busname_domain + ".Mandos"
 
71
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
 
72
del dbus_busname_domain
71
73
version = "1.8.3"
72
74
 
73
75
 
77
79
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
78
80
 
79
81
 
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))
 
82
def main():
 
83
    parser = argparse.ArgumentParser()
 
84
 
 
85
    add_command_line_options(parser)
 
86
 
 
87
    options = parser.parse_args()
 
88
 
 
89
    check_option_syntax(parser, options)
 
90
 
 
91
    clientnames = options.client
 
92
 
 
93
    if options.debug:
 
94
        log.setLevel(logging.DEBUG)
 
95
 
 
96
    try:
 
97
        bus = dbus.SystemBus()
 
98
        log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
 
99
                  dbus_busname, server_dbus_path)
 
100
        mandos_dbus_objc = bus.get_object(dbus_busname,
 
101
                                          server_dbus_path)
 
102
    except dbus.exceptions.DBusException:
 
103
        log.critical("Could not connect to Mandos server")
 
104
        sys.exit(1)
 
105
 
 
106
    mandos_serv = dbus.Interface(mandos_dbus_objc,
 
107
                                 dbus_interface=server_dbus_interface)
 
108
    mandos_serv_object_manager = dbus.Interface(
 
109
        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
 
110
 
 
111
    # Filter out log message from dbus module
 
112
    dbus_logger = logging.getLogger("dbus.proxies")
 
113
    class NullFilter(logging.Filter):
 
114
        def filter(self, record):
 
115
            return False
 
116
    dbus_filter = NullFilter()
 
117
    try:
 
118
        dbus_logger.addFilter(dbus_filter)
 
119
        log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
 
120
                  server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
 
121
        mandos_clients = {path: ifs_and_props[client_dbus_interface]
 
122
                          for path, ifs_and_props in
 
123
                          mandos_serv_object_manager
 
124
                          .GetManagedObjects().items()
 
125
                          if client_dbus_interface in ifs_and_props}
 
126
    except dbus.exceptions.DBusException as e:
 
127
        log.critical("Failed to access Mandos server through D-Bus:"
 
128
                     "\n%s", e)
 
129
        sys.exit(1)
 
130
    finally:
 
131
        # restore dbus logger
 
132
        dbus_logger.removeFilter(dbus_filter)
 
133
 
 
134
    # Compile dict of (clients: properties) to process
 
135
    clients = {}
 
136
 
 
137
    if not clientnames:
 
138
        clients = {objpath: properties
 
139
                   for objpath, properties in mandos_clients.items()}
 
140
    else:
 
141
        for name in clientnames:
 
142
            for objpath, properties in mandos_clients.items():
 
143
                if properties["Name"] == name:
 
144
                    clients[objpath] = properties
 
145
                    break
 
146
            else:
 
147
                log.critical("Client not found on server: %r", name)
 
148
                sys.exit(1)
 
149
 
 
150
    # Run all commands on clients
 
151
    commands = commands_from_options(options)
 
152
    for command in commands:
 
153
        command.run(clients, bus, mandos_serv)
 
154
 
 
155
 
 
156
def add_command_line_options(parser):
 
157
    parser.add_argument("--version", action="version",
 
158
                        version="%(prog)s {}".format(version),
 
159
                        help="show version number and exit")
 
160
    parser.add_argument("-a", "--all", action="store_true",
 
161
                        help="Select all clients")
 
162
    parser.add_argument("-v", "--verbose", action="store_true",
 
163
                        help="Print all fields")
 
164
    parser.add_argument("-j", "--dump-json", action="store_true",
 
165
                        help="Dump client data in JSON format")
 
166
    enable_disable = parser.add_mutually_exclusive_group()
 
167
    enable_disable.add_argument("-e", "--enable", action="store_true",
 
168
                                help="Enable client")
 
169
    enable_disable.add_argument("-d", "--disable",
 
170
                                action="store_true",
 
171
                                help="disable client")
 
172
    parser.add_argument("-b", "--bump-timeout", action="store_true",
 
173
                        help="Bump timeout for client")
 
174
    start_stop_checker = parser.add_mutually_exclusive_group()
 
175
    start_stop_checker.add_argument("--start-checker",
 
176
                                    action="store_true",
 
177
                                    help="Start checker for client")
 
178
    start_stop_checker.add_argument("--stop-checker",
 
179
                                    action="store_true",
 
180
                                    help="Stop checker for client")
 
181
    parser.add_argument("-V", "--is-enabled", action="store_true",
 
182
                        help="Check if client is enabled")
 
183
    parser.add_argument("-r", "--remove", action="store_true",
 
184
                        help="Remove client")
 
185
    parser.add_argument("-c", "--checker",
 
186
                        help="Set checker command for client")
 
187
    parser.add_argument("-t", "--timeout", type=string_to_delta,
 
188
                        help="Set timeout for client")
 
189
    parser.add_argument("--extended-timeout", type=string_to_delta,
 
190
                        help="Set extended timeout for client")
 
191
    parser.add_argument("-i", "--interval", type=string_to_delta,
 
192
                        help="Set checker interval for client")
 
193
    approve_deny_default = parser.add_mutually_exclusive_group()
 
194
    approve_deny_default.add_argument(
 
195
        "--approve-by-default", action="store_true",
 
196
        default=None, dest="approved_by_default",
 
197
        help="Set client to be approved by default")
 
198
    approve_deny_default.add_argument(
 
199
        "--deny-by-default", action="store_false",
 
200
        dest="approved_by_default",
 
201
        help="Set client to be denied by default")
 
202
    parser.add_argument("--approval-delay", type=string_to_delta,
 
203
                        help="Set delay before client approve/deny")
 
204
    parser.add_argument("--approval-duration", type=string_to_delta,
 
205
                        help="Set duration of one client approval")
 
206
    parser.add_argument("-H", "--host", help="Set host for client")
 
207
    parser.add_argument("-s", "--secret",
 
208
                        type=argparse.FileType(mode="rb"),
 
209
                        help="Set password blob (file) for client")
 
210
    approve_deny = parser.add_mutually_exclusive_group()
 
211
    approve_deny.add_argument(
 
212
        "-A", "--approve", action="store_true",
 
213
        help="Approve any current client request")
 
214
    approve_deny.add_argument("-D", "--deny", action="store_true",
 
215
                              help="Deny any current client request")
 
216
    parser.add_argument("--debug", action="store_true",
 
217
                        help="Debug mode (show D-Bus commands)")
 
218
    parser.add_argument("--check", action="store_true",
 
219
                        help="Run self-test")
 
220
    parser.add_argument("client", nargs="*", help="Client name")
 
221
 
 
222
 
 
223
def string_to_delta(interval):
 
224
    """Parse a string and return a datetime.timedelta"""
 
225
 
 
226
    try:
 
227
        return rfc3339_duration_to_delta(interval)
 
228
    except ValueError as e:
 
229
        log.warning("%s - Parsing as pre-1.6.1 interval instead",
 
230
                    ' '.join(e.args))
 
231
    return parse_pre_1_6_1_interval(interval)
87
232
 
88
233
 
89
234
def rfc3339_duration_to_delta(duration):
216
361
    return value
217
362
 
218
363
 
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
364
def parse_pre_1_6_1_interval(interval):
231
365
    """Parse an interval string as documented by Mandos before 1.6.1,
232
366
    and return a datetime.timedelta
270
404
    return value
271
405
 
272
406
 
273
 
## Classes for commands.
274
 
 
275
 
# Abstract classes first
 
407
def check_option_syntax(parser, options):
 
408
    """Apply additional restrictions on options, not expressible in
 
409
argparse"""
 
410
 
 
411
    def has_actions(options):
 
412
        return any((options.enable,
 
413
                    options.disable,
 
414
                    options.bump_timeout,
 
415
                    options.start_checker,
 
416
                    options.stop_checker,
 
417
                    options.is_enabled,
 
418
                    options.remove,
 
419
                    options.checker is not None,
 
420
                    options.timeout is not None,
 
421
                    options.extended_timeout is not None,
 
422
                    options.interval is not None,
 
423
                    options.approved_by_default is not None,
 
424
                    options.approval_delay is not None,
 
425
                    options.approval_duration is not None,
 
426
                    options.host is not None,
 
427
                    options.secret is not None,
 
428
                    options.approve,
 
429
                    options.deny))
 
430
 
 
431
    if has_actions(options) and not (options.client or options.all):
 
432
        parser.error("Options require clients names or --all.")
 
433
    if options.verbose and has_actions(options):
 
434
        parser.error("--verbose can only be used alone.")
 
435
    if options.dump_json and (options.verbose
 
436
                              or has_actions(options)):
 
437
        parser.error("--dump-json can only be used alone.")
 
438
    if options.all and not has_actions(options):
 
439
        parser.error("--all requires an action.")
 
440
    if options.is_enabled and len(options.client) > 1:
 
441
        parser.error("--is-enabled requires exactly one client")
 
442
    if options.remove:
 
443
        options.remove = False
 
444
        if has_actions(options) and not options.deny:
 
445
            parser.error("--remove can only be combined with --deny")
 
446
        options.remove = True
 
447
 
 
448
 
 
449
def commands_from_options(options):
 
450
 
 
451
    commands = []
 
452
 
 
453
    if options.is_enabled:
 
454
        commands.append(IsEnabledCmd())
 
455
 
 
456
    if options.approve:
 
457
        commands.append(ApproveCmd())
 
458
 
 
459
    if options.deny:
 
460
        commands.append(DenyCmd())
 
461
 
 
462
    if options.remove:
 
463
        commands.append(RemoveCmd())
 
464
 
 
465
    if options.dump_json:
 
466
        commands.append(DumpJSONCmd())
 
467
 
 
468
    if options.enable:
 
469
        commands.append(EnableCmd())
 
470
 
 
471
    if options.disable:
 
472
        commands.append(DisableCmd())
 
473
 
 
474
    if options.bump_timeout:
 
475
        commands.append(BumpTimeoutCmd())
 
476
 
 
477
    if options.start_checker:
 
478
        commands.append(StartCheckerCmd())
 
479
 
 
480
    if options.stop_checker:
 
481
        commands.append(StopCheckerCmd())
 
482
 
 
483
    if options.approved_by_default is not None:
 
484
        if options.approved_by_default:
 
485
            commands.append(ApproveByDefaultCmd())
 
486
        else:
 
487
            commands.append(DenyByDefaultCmd())
 
488
 
 
489
    if options.checker is not None:
 
490
        commands.append(SetCheckerCmd(options.checker))
 
491
 
 
492
    if options.host is not None:
 
493
        commands.append(SetHostCmd(options.host))
 
494
 
 
495
    if options.secret is not None:
 
496
        commands.append(SetSecretCmd(options.secret))
 
497
 
 
498
    if options.timeout is not None:
 
499
        commands.append(SetTimeoutCmd(options.timeout))
 
500
 
 
501
    if options.extended_timeout:
 
502
        commands.append(
 
503
            SetExtendedTimeoutCmd(options.extended_timeout))
 
504
 
 
505
    if options.interval is not None:
 
506
        commands.append(SetIntervalCmd(options.interval))
 
507
 
 
508
    if options.approval_delay is not None:
 
509
        commands.append(SetApprovalDelayCmd(options.approval_delay))
 
510
 
 
511
    if options.approval_duration is not None:
 
512
        commands.append(
 
513
            SetApprovalDurationCmd(options.approval_duration))
 
514
 
 
515
    # If no command option has been given, show table of clients,
 
516
    # optionally verbosely
 
517
    if not commands:
 
518
        commands.append(PrintTableCmd(verbose=options.verbose))
 
519
 
 
520
    return commands
 
521
 
 
522
 
276
523
class Command(object):
277
524
    """Abstract class for commands"""
278
 
    def run(self, mandos, clients):
 
525
    def run(self, clients, bus=None, mandos=None):
279
526
        """Normal commands should implement run_on_one_client(), but
280
527
        commands which want to operate on all clients at the same time
281
528
        can override this run() method instead."""
282
529
        self.mandos = mandos
283
 
        for client, properties in clients.items():
 
530
        for clientpath, properties in clients.items():
 
531
            log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
 
532
                      dbus_busname, str(clientpath))
 
533
            client = bus.get_object(dbus_busname, clientpath)
284
534
            self.run_on_one_client(client, properties)
285
535
 
 
536
 
 
537
class IsEnabledCmd(Command):
 
538
    def run(self, clients, bus=None, mandos=None):
 
539
        client, properties = next(iter(clients.items()))
 
540
        if self.is_enabled(client, properties):
 
541
            sys.exit(0)
 
542
        sys.exit(1)
 
543
    def is_enabled(self, client, properties):
 
544
        return properties["Enabled"]
 
545
 
 
546
 
 
547
class ApproveCmd(Command):
 
548
    def run_on_one_client(self, client, properties):
 
549
        log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
 
550
                  client.__dbus_object_path__, client_dbus_interface)
 
551
        client.Approve(dbus.Boolean(True),
 
552
                       dbus_interface=client_dbus_interface)
 
553
 
 
554
 
 
555
class DenyCmd(Command):
 
556
    def run_on_one_client(self, client, properties):
 
557
        log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
 
558
                  client.__dbus_object_path__, client_dbus_interface)
 
559
        client.Approve(dbus.Boolean(False),
 
560
                       dbus_interface=client_dbus_interface)
 
561
 
 
562
 
 
563
class RemoveCmd(Command):
 
564
    def run_on_one_client(self, client, properties):
 
565
        log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,
 
566
                  server_dbus_path, server_dbus_interface,
 
567
                  str(client.__dbus_object_path__))
 
568
        self.mandos.RemoveClient(client.__dbus_object_path__)
 
569
 
 
570
 
286
571
class PrintCmd(Command):
287
572
    """Abstract class for commands printing client details"""
288
573
    all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
292
577
                    "LastApprovalRequest", "ApprovalDelay",
293
578
                    "ApprovalDuration", "Checker", "ExtendedTimeout",
294
579
                    "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 = string_to_delta(value).total_seconds() * 1000
320
 
 
321
 
# Actual (non-abstract) command classes
 
580
    def run(self, clients, bus=None, mandos=None):
 
581
        print(self.output(clients.values()))
 
582
    def output(self, clients):
 
583
        raise NotImplementedError()
 
584
 
 
585
 
 
586
class DumpJSONCmd(PrintCmd):
 
587
    def output(self, clients):
 
588
        data = {client["Name"]:
 
589
                {key: self.dbus_boolean_to_bool(client[key])
 
590
                 for key in self.all_keywords}
 
591
                for client in clients.values()}
 
592
        return json.dumps(data, indent=4, separators=(',', ': '))
 
593
    @staticmethod
 
594
    def dbus_boolean_to_bool(value):
 
595
        if isinstance(value, dbus.Boolean):
 
596
            value = bool(value)
 
597
        return value
 
598
 
322
599
 
323
600
class PrintTableCmd(PrintCmd):
324
601
    def __init__(self, verbose=False):
325
602
        self.verbose = verbose
326
603
 
327
604
    def output(self, clients):
328
 
        default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
 
605
        default_keywords = ("Name", "Enabled", "Timeout",
 
606
                            "LastCheckedOK")
329
607
        keywords = default_keywords
330
608
        if self.verbose:
331
609
            keywords = self.all_keywords
332
 
        return str(self.TableOfClients(clients.values(), keywords))
 
610
        return str(self.TableOfClients(clients, keywords))
333
611
 
334
612
    class TableOfClients(object):
335
613
        tableheaders = {
406
684
                   for key in self.keywords})
407
685
 
408
686
 
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)
 
687
def milliseconds_to_string(ms):
 
688
    td = datetime.timedelta(0, 0, 0, ms)
 
689
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
 
690
            .format(days="{}T".format(td.days) if td.days else "",
 
691
                    hours=td.seconds // 3600,
 
692
                    minutes=(td.seconds % 3600) // 60,
 
693
                    seconds=td.seconds % 60))
 
694
 
 
695
 
 
696
class PropertyCmd(Command):
 
697
    """Abstract class for Actions for setting one client property"""
 
698
    def run_on_one_client(self, client, properties):
 
699
        """Set the Client's D-Bus property"""
 
700
        log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
 
701
                  client.__dbus_object_path__,
 
702
                  dbus.PROPERTIES_IFACE, client_dbus_interface,
 
703
                  self.propname, self.value_to_set
 
704
                  if not isinstance(self.value_to_set, dbus.Boolean)
 
705
                  else bool(self.value_to_set))
 
706
        client.Set(client_dbus_interface, self.propname,
 
707
                   self.value_to_set,
 
708
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
709
    @property
 
710
    def propname(self):
 
711
        raise NotImplementedError()
 
712
 
444
713
 
445
714
class EnableCmd(PropertyCmd):
446
 
    property = "Enabled"
 
715
    propname = "Enabled"
447
716
    value_to_set = dbus.Boolean(True)
448
717
 
 
718
 
449
719
class DisableCmd(PropertyCmd):
450
 
    property = "Enabled"
 
720
    propname = "Enabled"
451
721
    value_to_set = dbus.Boolean(False)
452
722
 
 
723
 
453
724
class BumpTimeoutCmd(PropertyCmd):
454
 
    property = "LastCheckedOK"
 
725
    propname = "LastCheckedOK"
455
726
    value_to_set = ""
456
727
 
 
728
 
457
729
class StartCheckerCmd(PropertyCmd):
458
 
    property = "CheckerRunning"
 
730
    propname = "CheckerRunning"
459
731
    value_to_set = dbus.Boolean(True)
460
732
 
 
733
 
461
734
class StopCheckerCmd(PropertyCmd):
462
 
    property = "CheckerRunning"
 
735
    propname = "CheckerRunning"
463
736
    value_to_set = dbus.Boolean(False)
464
737
 
 
738
 
465
739
class ApproveByDefaultCmd(PropertyCmd):
466
 
    property = "ApprovedByDefault"
 
740
    propname = "ApprovedByDefault"
467
741
    value_to_set = dbus.Boolean(True)
468
742
 
 
743
 
469
744
class DenyByDefaultCmd(PropertyCmd):
470
 
    property = "ApprovedByDefault"
 
745
    propname = "ApprovedByDefault"
471
746
    value_to_set = dbus.Boolean(False)
472
747
 
473
 
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
474
 
    property = "Checker"
475
 
 
476
 
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
477
 
    property = "Host"
478
 
 
479
 
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
 
748
 
 
749
class PropertyValueCmd(PropertyCmd):
 
750
    """Abstract class for PropertyCmd recieving a value as argument"""
 
751
    def __init__(self, value):
 
752
        self.value_to_set = value
 
753
 
 
754
 
 
755
class SetCheckerCmd(PropertyValueCmd):
 
756
    propname = "Checker"
 
757
 
 
758
 
 
759
class SetHostCmd(PropertyValueCmd):
 
760
    propname = "Host"
 
761
 
 
762
 
 
763
class SetSecretCmd(PropertyValueCmd):
 
764
    propname = "Secret"
480
765
    @property
481
766
    def value_to_set(self):
482
767
        return self._vts
485
770
        """When setting, read data from supplied file object"""
486
771
        self._vts = value.read()
487
772
        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",
540
 
                        help="Set timeout for client")
541
 
    parser.add_argument("--extended-timeout",
542
 
                        help="Set extended timeout for client")
543
 
    parser.add_argument("-i", "--interval",
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",
555
 
                        help="Set delay before client approve/deny")
556
 
    parser.add_argument("--approval-duration",
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()
653
 
 
654
 
    def has_actions(options):
655
 
        return any((options.enable,
656
 
                    options.disable,
657
 
                    options.bump_timeout,
658
 
                    options.start_checker,
659
 
                    options.stop_checker,
660
 
                    options.is_enabled,
661
 
                    options.remove,
662
 
                    options.checker is not None,
663
 
                    options.timeout is not None,
664
 
                    options.extended_timeout is not None,
665
 
                    options.interval is not None,
666
 
                    options.approved_by_default is not None,
667
 
                    options.approval_delay is not None,
668
 
                    options.approval_duration is not None,
669
 
                    options.host is not None,
670
 
                    options.secret is not None,
671
 
                    options.approve,
672
 
                    options.deny))
673
 
 
674
 
    if has_actions(options) and not (options.client or options.all):
675
 
        parser.error("Options require clients names or --all.")
676
 
    if options.verbose and has_actions(options):
677
 
        parser.error("--verbose can only be used alone.")
678
 
    if options.dump_json and (options.verbose
679
 
                              or has_actions(options)):
680
 
        parser.error("--dump-json can only be used alone.")
681
 
    if options.all and not has_actions(options):
682
 
        parser.error("--all requires an action.")
683
 
    if options.is_enabled and len(options.client) > 1:
684
 
        parser.error("--is-enabled requires exactly one client")
685
 
 
686
 
    clientnames = options.client
687
 
 
688
 
    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")
693
 
        sys.exit(1)
694
 
 
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")
702
 
    class NullFilter(logging.Filter):
703
 
        def filter(self, record):
704
 
            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)
 
773
 
 
774
 
 
775
class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):
 
776
    """Abstract class for PropertyValueCmd taking a value argument as
 
777
a datetime.timedelta() but should store it as milliseconds."""
 
778
    @property
 
779
    def value_to_set(self):
 
780
        return self._vts
 
781
    @value_to_set.setter
 
782
    def value_to_set(self, value):
 
783
        """When setting, convert value from a datetime.timedelta"""
 
784
        self._vts = int(round(value.total_seconds() * 1000))
 
785
 
 
786
 
 
787
class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
 
788
    propname = "Timeout"
 
789
 
 
790
 
 
791
class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
 
792
    propname = "ExtendedTimeout"
 
793
 
 
794
 
 
795
class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):
 
796
    propname = "Interval"
 
797
 
 
798
 
 
799
class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):
 
800
    propname = "ApprovalDelay"
 
801
 
 
802
 
 
803
class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):
 
804
    propname = "ApprovalDuration"
 
805
 
742
806
 
743
807
 
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
808
class Test_string_to_delta(unittest.TestCase):
758
809
    def test_handles_basic_rfc3339(self):
759
810
        self.assertEqual(string_to_delta("PT0S"),
787
838
        self.assertEqual(value, datetime.timedelta(0, 7200))
788
839
 
789
840
 
 
841
class Test_check_option_syntax(unittest.TestCase):
 
842
    # This mostly corresponds to the definition from has_actions() in
 
843
    # check_option_syntax()
 
844
    actions = {
 
845
        # The actual values set here are not that important, but we do
 
846
        # at least stick to the correct types, even though they are
 
847
        # never used
 
848
        "enable": True,
 
849
        "disable": True,
 
850
        "bump_timeout": True,
 
851
        "start_checker": True,
 
852
        "stop_checker": True,
 
853
        "is_enabled": True,
 
854
        "remove": True,
 
855
        "checker": "x",
 
856
        "timeout": datetime.timedelta(),
 
857
        "extended_timeout": datetime.timedelta(),
 
858
        "interval": datetime.timedelta(),
 
859
        "approved_by_default": True,
 
860
        "approval_delay": datetime.timedelta(),
 
861
        "approval_duration": datetime.timedelta(),
 
862
        "host": "x",
 
863
        "secret": io.BytesIO(b"x"),
 
864
        "approve": True,
 
865
        "deny": True,
 
866
    }
 
867
 
 
868
    def setUp(self):
 
869
        self.parser = argparse.ArgumentParser()
 
870
        add_command_line_options(self.parser)
 
871
 
 
872
    @contextlib.contextmanager
 
873
    def assertParseError(self):
 
874
        with self.assertRaises(SystemExit) as e:
 
875
            with self.temporarily_suppress_stderr():
 
876
                yield
 
877
        # Exit code from argparse is guaranteed to be "2".  Reference:
 
878
        # https://docs.python.org/3/library
 
879
        # /argparse.html#exiting-methods
 
880
        self.assertEqual(e.exception.code, 2)
 
881
 
 
882
    @staticmethod
 
883
    @contextlib.contextmanager
 
884
    def temporarily_suppress_stderr():
 
885
        null = os.open(os.path.devnull, os.O_RDWR)
 
886
        stderrcopy = os.dup(sys.stderr.fileno())
 
887
        os.dup2(null, sys.stderr.fileno())
 
888
        os.close(null)
 
889
        try:
 
890
            yield
 
891
        finally:
 
892
            # restore stderr
 
893
            os.dup2(stderrcopy, sys.stderr.fileno())
 
894
            os.close(stderrcopy)
 
895
 
 
896
    def check_option_syntax(self, options):
 
897
        check_option_syntax(self.parser, options)
 
898
 
 
899
    def test_actions_requires_client_or_all(self):
 
900
        for action, value in self.actions.items():
 
901
            options = self.parser.parse_args()
 
902
            setattr(options, action, value)
 
903
            with self.assertParseError():
 
904
                self.check_option_syntax(options)
 
905
 
 
906
    def test_actions_conflicts_with_verbose(self):
 
907
        for action, value in self.actions.items():
 
908
            options = self.parser.parse_args()
 
909
            setattr(options, action, value)
 
910
            options.verbose = True
 
911
            with self.assertParseError():
 
912
                self.check_option_syntax(options)
 
913
 
 
914
    def test_dump_json_conflicts_with_verbose(self):
 
915
        options = self.parser.parse_args()
 
916
        options.dump_json = True
 
917
        options.verbose = True
 
918
        with self.assertParseError():
 
919
            self.check_option_syntax(options)
 
920
 
 
921
    def test_dump_json_conflicts_with_action(self):
 
922
        for action, value in self.actions.items():
 
923
            options = self.parser.parse_args()
 
924
            setattr(options, action, value)
 
925
            options.dump_json = True
 
926
            with self.assertParseError():
 
927
                self.check_option_syntax(options)
 
928
 
 
929
    def test_all_can_not_be_alone(self):
 
930
        options = self.parser.parse_args()
 
931
        options.all = True
 
932
        with self.assertParseError():
 
933
            self.check_option_syntax(options)
 
934
 
 
935
    def test_all_is_ok_with_any_action(self):
 
936
        for action, value in self.actions.items():
 
937
            options = self.parser.parse_args()
 
938
            setattr(options, action, value)
 
939
            options.all = True
 
940
            self.check_option_syntax(options)
 
941
 
 
942
    def test_is_enabled_fails_without_client(self):
 
943
        options = self.parser.parse_args()
 
944
        options.is_enabled = True
 
945
        with self.assertParseError():
 
946
            self.check_option_syntax(options)
 
947
 
 
948
    def test_is_enabled_works_with_one_client(self):
 
949
        options = self.parser.parse_args()
 
950
        options.is_enabled = True
 
951
        options.client = ["foo"]
 
952
        self.check_option_syntax(options)
 
953
 
 
954
    def test_is_enabled_fails_with_two_clients(self):
 
955
        options = self.parser.parse_args()
 
956
        options.is_enabled = True
 
957
        options.client = ["foo", "barbar"]
 
958
        with self.assertParseError():
 
959
            self.check_option_syntax(options)
 
960
 
 
961
    def test_remove_can_only_be_combined_with_action_deny(self):
 
962
        for action, value in self.actions.items():
 
963
            if action in {"remove", "deny"}:
 
964
                continue
 
965
            options = self.parser.parse_args()
 
966
            setattr(options, action, value)
 
967
            options.all = True
 
968
            options.remove = True
 
969
            with self.assertParseError():
 
970
                self.check_option_syntax(options)
 
971
 
 
972
 
 
973
class Test_command_from_options(unittest.TestCase):
 
974
    def setUp(self):
 
975
        self.parser = argparse.ArgumentParser()
 
976
        add_command_line_options(self.parser)
 
977
    def assert_command_from_args(self, args, command_cls,
 
978
                                 **cmd_attrs):
 
979
        """Assert that parsing ARGS should result in an instance of
 
980
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
 
981
        options = self.parser.parse_args(args)
 
982
        check_option_syntax(self.parser, options)
 
983
        commands = commands_from_options(options)
 
984
        self.assertEqual(len(commands), 1)
 
985
        command = commands[0]
 
986
        self.assertIsInstance(command, command_cls)
 
987
        for key, value in cmd_attrs.items():
 
988
            self.assertEqual(getattr(command, key), value)
 
989
    def test_print_table(self):
 
990
        self.assert_command_from_args([], PrintTableCmd,
 
991
                                      verbose=False)
 
992
 
 
993
    def test_print_table_verbose(self):
 
994
        self.assert_command_from_args(["--verbose"], PrintTableCmd,
 
995
                                      verbose=True)
 
996
 
 
997
    def test_print_table_verbose_short(self):
 
998
        self.assert_command_from_args(["-v"], PrintTableCmd,
 
999
                                      verbose=True)
 
1000
 
 
1001
    def test_enable(self):
 
1002
        self.assert_command_from_args(["--enable", "foo"], EnableCmd)
 
1003
 
 
1004
    def test_enable_short(self):
 
1005
        self.assert_command_from_args(["-e", "foo"], EnableCmd)
 
1006
 
 
1007
    def test_disable(self):
 
1008
        self.assert_command_from_args(["--disable", "foo"],
 
1009
                                      DisableCmd)
 
1010
 
 
1011
    def test_disable_short(self):
 
1012
        self.assert_command_from_args(["-d", "foo"], DisableCmd)
 
1013
 
 
1014
    def test_bump_timeout(self):
 
1015
        self.assert_command_from_args(["--bump-timeout", "foo"],
 
1016
                                      BumpTimeoutCmd)
 
1017
 
 
1018
    def test_bump_timeout_short(self):
 
1019
        self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
 
1020
 
 
1021
    def test_start_checker(self):
 
1022
        self.assert_command_from_args(["--start-checker", "foo"],
 
1023
                                      StartCheckerCmd)
 
1024
 
 
1025
    def test_stop_checker(self):
 
1026
        self.assert_command_from_args(["--stop-checker", "foo"],
 
1027
                                      StopCheckerCmd)
 
1028
 
 
1029
    def test_remove(self):
 
1030
        self.assert_command_from_args(["--remove", "foo"],
 
1031
                                      RemoveCmd)
 
1032
 
 
1033
    def test_remove_short(self):
 
1034
        self.assert_command_from_args(["-r", "foo"], RemoveCmd)
 
1035
 
 
1036
    def test_checker(self):
 
1037
        self.assert_command_from_args(["--checker", ":", "foo"],
 
1038
                                      SetCheckerCmd, value_to_set=":")
 
1039
 
 
1040
    def test_checker_empty(self):
 
1041
        self.assert_command_from_args(["--checker", "", "foo"],
 
1042
                                      SetCheckerCmd, value_to_set="")
 
1043
 
 
1044
    def test_checker_short(self):
 
1045
        self.assert_command_from_args(["-c", ":", "foo"],
 
1046
                                      SetCheckerCmd, value_to_set=":")
 
1047
 
 
1048
    def test_timeout(self):
 
1049
        self.assert_command_from_args(["--timeout", "PT5M", "foo"],
 
1050
                                      SetTimeoutCmd,
 
1051
                                      value_to_set=300000)
 
1052
 
 
1053
    def test_timeout_short(self):
 
1054
        self.assert_command_from_args(["-t", "PT5M", "foo"],
 
1055
                                      SetTimeoutCmd,
 
1056
                                      value_to_set=300000)
 
1057
 
 
1058
    def test_extended_timeout(self):
 
1059
        self.assert_command_from_args(["--extended-timeout", "PT15M",
 
1060
                                       "foo"],
 
1061
                                      SetExtendedTimeoutCmd,
 
1062
                                      value_to_set=900000)
 
1063
 
 
1064
    def test_interval(self):
 
1065
        self.assert_command_from_args(["--interval", "PT2M", "foo"],
 
1066
                                      SetIntervalCmd,
 
1067
                                      value_to_set=120000)
 
1068
 
 
1069
    def test_interval_short(self):
 
1070
        self.assert_command_from_args(["-i", "PT2M", "foo"],
 
1071
                                      SetIntervalCmd,
 
1072
                                      value_to_set=120000)
 
1073
 
 
1074
    def test_approve_by_default(self):
 
1075
        self.assert_command_from_args(["--approve-by-default", "foo"],
 
1076
                                      ApproveByDefaultCmd)
 
1077
 
 
1078
    def test_deny_by_default(self):
 
1079
        self.assert_command_from_args(["--deny-by-default", "foo"],
 
1080
                                      DenyByDefaultCmd)
 
1081
 
 
1082
    def test_approval_delay(self):
 
1083
        self.assert_command_from_args(["--approval-delay", "PT30S",
 
1084
                                       "foo"], SetApprovalDelayCmd,
 
1085
                                      value_to_set=30000)
 
1086
 
 
1087
    def test_approval_duration(self):
 
1088
        self.assert_command_from_args(["--approval-duration", "PT1S",
 
1089
                                       "foo"], SetApprovalDurationCmd,
 
1090
                                      value_to_set=1000)
 
1091
 
 
1092
    def test_host(self):
 
1093
        self.assert_command_from_args(["--host", "foo.example.org",
 
1094
                                       "foo"], SetHostCmd,
 
1095
                                      value_to_set="foo.example.org")
 
1096
 
 
1097
    def test_host_short(self):
 
1098
        self.assert_command_from_args(["-H", "foo.example.org",
 
1099
                                       "foo"], SetHostCmd,
 
1100
                                      value_to_set="foo.example.org")
 
1101
 
 
1102
    def test_secret_devnull(self):
 
1103
        self.assert_command_from_args(["--secret", os.path.devnull,
 
1104
                                       "foo"], SetSecretCmd,
 
1105
                                      value_to_set=b"")
 
1106
 
 
1107
    def test_secret_tempfile(self):
 
1108
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
 
1109
            value = b"secret\0xyzzy\nbar"
 
1110
            f.write(value)
 
1111
            f.seek(0)
 
1112
            self.assert_command_from_args(["--secret", f.name,
 
1113
                                           "foo"], SetSecretCmd,
 
1114
                                          value_to_set=value)
 
1115
 
 
1116
    def test_secret_devnull_short(self):
 
1117
        self.assert_command_from_args(["-s", os.path.devnull, "foo"],
 
1118
                                      SetSecretCmd, value_to_set=b"")
 
1119
 
 
1120
    def test_secret_tempfile_short(self):
 
1121
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
 
1122
            value = b"secret\0xyzzy\nbar"
 
1123
            f.write(value)
 
1124
            f.seek(0)
 
1125
            self.assert_command_from_args(["-s", f.name, "foo"],
 
1126
                                          SetSecretCmd,
 
1127
                                          value_to_set=value)
 
1128
 
 
1129
    def test_approve(self):
 
1130
        self.assert_command_from_args(["--approve", "foo"],
 
1131
                                      ApproveCmd)
 
1132
 
 
1133
    def test_approve_short(self):
 
1134
        self.assert_command_from_args(["-A", "foo"], ApproveCmd)
 
1135
 
 
1136
    def test_deny(self):
 
1137
        self.assert_command_from_args(["--deny", "foo"], DenyCmd)
 
1138
 
 
1139
    def test_deny_short(self):
 
1140
        self.assert_command_from_args(["-D", "foo"], DenyCmd)
 
1141
 
 
1142
    def test_dump_json(self):
 
1143
        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
 
1144
 
 
1145
    def test_is_enabled(self):
 
1146
        self.assert_command_from_args(["--is-enabled", "foo"],
 
1147
                                      IsEnabledCmd)
 
1148
 
 
1149
    def test_is_enabled_short(self):
 
1150
        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
 
1151
 
 
1152
    def test_deny_before_remove(self):
 
1153
        options = self.parser.parse_args(["--deny", "--remove",
 
1154
                                          "foo"])
 
1155
        check_option_syntax(self.parser, options)
 
1156
        commands = commands_from_options(options)
 
1157
        self.assertEqual(len(commands), 2)
 
1158
        self.assertIsInstance(commands[0], DenyCmd)
 
1159
        self.assertIsInstance(commands[1], RemoveCmd)
 
1160
 
 
1161
    def test_deny_before_remove_reversed(self):
 
1162
        options = self.parser.parse_args(["--remove", "--deny",
 
1163
                                          "--all"])
 
1164
        check_option_syntax(self.parser, options)
 
1165
        commands = commands_from_options(options)
 
1166
        self.assertEqual(len(commands), 2)
 
1167
        self.assertIsInstance(commands[0], DenyCmd)
 
1168
        self.assertIsInstance(commands[1], RemoveCmd)
 
1169
 
 
1170
 
790
1171
class TestCmd(unittest.TestCase):
791
1172
    """Abstract class for tests of command classes"""
792
1173
    def setUp(self):
793
1174
        testcase = self
794
1175
        class MockClient(object):
795
1176
            def __init__(self, name, **attributes):
796
 
                self.__dbus_object_path__ = "objpath_{}".format(name)
 
1177
                self.__dbus_object_path__ = "/clients/{}".format(name)
797
1178
                self.attributes = attributes
798
1179
                self.attributes["Name"] = name
799
1180
                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]
 
1181
            def Set(self, interface, propname, value, dbus_interface):
 
1182
                testcase.assertEqual(interface, client_dbus_interface)
 
1183
                testcase.assertEqual(dbus_interface,
 
1184
                                     dbus.PROPERTIES_IFACE)
 
1185
                self.attributes[propname] = value
 
1186
            def Get(self, interface, propname, dbus_interface):
 
1187
                testcase.assertEqual(interface, client_dbus_interface)
 
1188
                testcase.assertEqual(dbus_interface,
 
1189
                                     dbus.PROPERTIES_IFACE)
 
1190
                return self.attributes[propname]
810
1191
            def Approve(self, approve, dbus_interface):
811
 
                testcase.assertEqual(dbus_interface, client_interface)
 
1192
                testcase.assertEqual(dbus_interface,
 
1193
                                     client_dbus_interface)
812
1194
                self.calls.append(("Approve", (approve,
813
1195
                                               dbus_interface)))
814
1196
        self.client = MockClient(
861
1243
            LastCheckerStatus=-2)
862
1244
        self.clients =  collections.OrderedDict(
863
1245
            [
864
 
                (self.client, self.client.attributes),
865
 
                (self.other_client, self.other_client.attributes),
 
1246
                ("/clients/foo", self.client.attributes),
 
1247
                ("/clients/barbar", self.other_client.attributes),
866
1248
            ])
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)
 
1249
        self.one_client = {"/clients/foo": self.client.attributes}
 
1250
    @property
 
1251
    def bus(self):
 
1252
        class Bus(object):
 
1253
            @staticmethod
 
1254
            def get_object(client_bus_name, path):
 
1255
                self.assertEqual(client_bus_name, dbus_busname)
 
1256
                return {
 
1257
                    "/clients/foo": self.client,
 
1258
                    "/clients/barbar": self.other_client,
 
1259
                }[path]
 
1260
        return Bus()
 
1261
 
 
1262
 
 
1263
class TestIsEnabledCmd(TestCmd):
 
1264
    def test_is_enabled(self):
 
1265
        self.assertTrue(all(IsEnabledCmd().is_enabled(client,
 
1266
                                                      properties)
 
1267
                            for client, properties
 
1268
                            in self.clients.items()))
 
1269
    def test_is_enabled_run_exits_successfully(self):
 
1270
        with self.assertRaises(SystemExit) as e:
 
1271
            IsEnabledCmd().run(self.one_client)
 
1272
        if e.exception.code is not None:
 
1273
            self.assertEqual(e.exception.code, 0)
 
1274
        else:
 
1275
            self.assertIsNone(e.exception.code)
 
1276
    def test_is_enabled_run_exits_with_failure(self):
 
1277
        self.client.attributes["Enabled"] = dbus.Boolean(False)
 
1278
        with self.assertRaises(SystemExit) as e:
 
1279
            IsEnabledCmd().run(self.one_client)
 
1280
        if isinstance(e.exception.code, int):
 
1281
            self.assertNotEqual(e.exception.code, 0)
 
1282
        else:
 
1283
            self.assertIsNotNone(e.exception.code)
 
1284
 
 
1285
 
 
1286
class TestApproveCmd(TestCmd):
 
1287
    def test_approve(self):
 
1288
        ApproveCmd().run(self.clients, self.bus)
 
1289
        for clientpath in self.clients:
 
1290
            client = self.bus.get_object(dbus_busname, clientpath)
 
1291
            self.assertIn(("Approve", (True, client_dbus_interface)),
 
1292
                          client.calls)
 
1293
 
 
1294
 
 
1295
class TestDenyCmd(TestCmd):
 
1296
    def test_deny(self):
 
1297
        DenyCmd().run(self.clients, self.bus)
 
1298
        for clientpath in self.clients:
 
1299
            client = self.bus.get_object(dbus_busname, clientpath)
 
1300
            self.assertIn(("Approve", (False, client_dbus_interface)),
 
1301
                          client.calls)
 
1302
 
 
1303
class TestRemoveCmd(TestCmd):
 
1304
    def test_remove(self):
 
1305
        class MockMandos(object):
 
1306
            def __init__(self):
 
1307
                self.calls = []
 
1308
            def RemoveClient(self, dbus_path):
 
1309
                self.calls.append(("RemoveClient", (dbus_path,)))
 
1310
        mandos = MockMandos()
 
1311
        super(TestRemoveCmd, self).setUp()
 
1312
        RemoveCmd().run(self.clients, self.bus, mandos)
 
1313
        self.assertEqual(len(mandos.calls), 2)
 
1314
        for clientpath in self.clients:
 
1315
            self.assertIn(("RemoveClient", (clientpath,)),
 
1316
                          mandos.calls)
 
1317
 
893
1318
 
894
1319
class TestDumpJSONCmd(TestCmd):
895
1320
    def setUp(self):
953
1378
        expected_json = {"foo": self.expected_json["foo"]}
954
1379
        self.assertDictEqual(json_data, expected_json)
955
1380
 
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):
961
 
        with self.assertRaises(SystemExit) as e:
962
 
            IsEnabledCmd().run(None, self.one_client)
963
 
        if e.exception.code is not None:
964
 
            self.assertEqual(e.exception.code, 0)
965
 
        else:
966
 
            self.assertIsNone(e.exception.code)
967
 
    def test_is_enabled_run_exits_with_failure(self):
968
 
        self.client.attributes["Enabled"] = dbus.Boolean(False)
969
 
        with self.assertRaises(SystemExit) as e:
970
 
            IsEnabledCmd().run(None, self.one_client)
971
 
        if isinstance(e.exception.code, int):
972
 
            self.assertNotEqual(e.exception.code, 0)
973
 
        else:
974
 
            self.assertIsNotNone(e.exception.code)
975
 
 
976
 
class TestRemoveCmd(TestCmd):
977
 
    def test_remove(self):
978
 
        class MockMandos(object):
979
 
            def __init__(self):
980
 
                self.calls = []
981
 
            def RemoveClient(self, dbus_path):
982
 
                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__,)),
990
 
                          mandos.calls)
991
 
 
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"])
 
1381
 
 
1382
class TestPrintTableCmd(TestCmd):
 
1383
    def test_normal(self):
 
1384
        output = PrintTableCmd().output(self.clients.values())
 
1385
        expected_output = "\n".join((
 
1386
            "Name   Enabled Timeout  Last Successful Check",
 
1387
            "foo    Yes     00:05:00 2019-02-03T00:00:00  ",
 
1388
            "barbar Yes     00:05:00 2019-02-04T00:00:00  ",
 
1389
        ))
 
1390
        self.assertEqual(output, expected_output)
 
1391
    def test_verbose(self):
 
1392
        output = PrintTableCmd(verbose=True).output(
 
1393
            self.clients.values())
 
1394
        columns = (
 
1395
            (
 
1396
                "Name   ",
 
1397
                "foo    ",
 
1398
                "barbar ",
 
1399
            ),(
 
1400
                "Enabled ",
 
1401
                "Yes     ",
 
1402
                "Yes     ",
 
1403
            ),(
 
1404
                "Timeout  ",
 
1405
                "00:05:00 ",
 
1406
                "00:05:00 ",
 
1407
            ),(
 
1408
                "Last Successful Check ",
 
1409
                "2019-02-03T00:00:00   ",
 
1410
                "2019-02-04T00:00:00   ",
 
1411
            ),(
 
1412
                "Created             ",
 
1413
                "2019-01-02T00:00:00 ",
 
1414
                "2019-01-03T00:00:00 ",
 
1415
            ),(
 
1416
                "Interval ",
 
1417
                "00:02:00 ",
 
1418
                "00:02:00 ",
 
1419
            ),(
 
1420
                "Host            ",
 
1421
                "foo.example.org ",
 
1422
                "192.0.2.3       ",
 
1423
            ),(
 
1424
                ("Key ID                                             "
 
1425
                 "              "),
 
1426
                ("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"
 
1427
                 "ea90a27cddb12 "),
 
1428
                ("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"
 
1429
                 "46c2b020f441c "),
 
1430
            ),(
 
1431
                "Fingerprint                              ",
 
1432
                "778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",
 
1433
                "3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",
 
1434
            ),(
 
1435
                "Check Is Running ",
 
1436
                "No               ",
 
1437
                "Yes              ",
 
1438
            ),(
 
1439
                "Last Enabled        ",
 
1440
                "2019-01-03T00:00:00 ",
 
1441
                "2019-01-04T00:00:00 ",
 
1442
            ),(
 
1443
                "Approval Is Pending ",
 
1444
                "No                  ",
 
1445
                "No                  ",
 
1446
            ),(
 
1447
                "Approved By Default ",
 
1448
                "Yes                 ",
 
1449
                "No                  ",
 
1450
            ),(
 
1451
                "Last Approval Request ",
 
1452
                "                      ",
 
1453
                "2019-01-03T00:00:00   ",
 
1454
            ),(
 
1455
                "Approval Delay ",
 
1456
                "00:00:00       ",
 
1457
                "00:00:30       ",
 
1458
            ),(
 
1459
                "Approval Duration ",
 
1460
                "00:00:01          ",
 
1461
                "00:00:01          ",
 
1462
            ),(
 
1463
                "Checker              ",
 
1464
                "fping -q -- %(host)s ",
 
1465
                ":                    ",
 
1466
            ),(
 
1467
                "Extended Timeout ",
 
1468
                "00:15:00         ",
 
1469
                "00:15:00         ",
 
1470
            ),(
 
1471
                "Expires             ",
 
1472
                "2019-02-04T00:00:00 ",
 
1473
                "2019-02-05T00:00:00 ",
 
1474
            ),(
 
1475
                "Last Checker Status",
 
1476
                "0                  ",
 
1477
                "-2                 ",
 
1478
            )
 
1479
        )
 
1480
        num_lines = max(len(rows) for rows in columns)
 
1481
        expected_output = "\n".join("".join(rows[line]
 
1482
                                            for rows in columns)
 
1483
                                    for line in range(num_lines))
 
1484
        self.assertEqual(output, expected_output)
 
1485
    def test_one_client(self):
 
1486
        output = PrintTableCmd().output(self.one_client.values())
 
1487
        expected_output = """
 
1488
Name Enabled Timeout  Last Successful Check
 
1489
foo  Yes     00:05:00 2019-02-03T00:00:00  
 
1490
"""[1:-1]
 
1491
        self.assertEqual(output, expected_output)
 
1492
 
 
1493
 
 
1494
class Test_milliseconds_to_string(unittest.TestCase):
 
1495
    def test_all(self):
 
1496
        self.assertEqual(milliseconds_to_string(93785000),
 
1497
                         "1T02:03:05")
 
1498
    def test_no_days(self):
 
1499
        self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
 
1500
    def test_all_zero(self):
 
1501
        self.assertEqual(milliseconds_to_string(0), "00:00:00")
 
1502
    def test_no_fractional_seconds(self):
 
1503
        self.assertEqual(milliseconds_to_string(400), "00:00:00")
 
1504
        self.assertEqual(milliseconds_to_string(900), "00:00:00")
 
1505
        self.assertEqual(milliseconds_to_string(1900), "00:00:01")
 
1506
 
1022
1507
 
1023
1508
class Unique(object):
1024
1509
    """Class for objects which exist only to be unique objects, since
1025
1510
unittest.mock.sentinel only exists in Python 3.3"""
1026
1511
 
 
1512
 
1027
1513
class TestPropertyCmd(TestCmd):
1028
1514
    """Abstract class for tests of PropertyCmd classes"""
1029
1515
    def runTest(self):
1033
1519
                                self.values_to_set)
1034
1520
        for value_to_set, value_to_get in zip(self.values_to_set,
1035
1521
                                              values_to_get):
1036
 
            for client in self.clients:
1037
 
                old_value = client.attributes[self.property]
 
1522
            for clientpath in self.clients:
 
1523
                client = self.bus.get_object(dbus_busname, clientpath)
 
1524
                old_value = client.attributes[self.propname]
1038
1525
                self.assertNotIsInstance(old_value, Unique)
1039
 
                client.attributes[self.property] = Unique()
 
1526
                client.attributes[self.propname] = Unique()
1040
1527
            self.run_command(value_to_set, self.clients)
1041
 
            for client in self.clients:
1042
 
                value = client.attributes[self.property]
 
1528
            for clientpath in self.clients:
 
1529
                client = self.bus.get_object(dbus_busname, clientpath)
 
1530
                value = client.attributes[self.propname]
1043
1531
                self.assertNotIsInstance(value, Unique)
1044
1532
                self.assertEqual(value, value_to_get)
1045
1533
    def run_command(self, value, clients):
1046
 
        self.command().run(None, clients)
 
1534
        self.command().run(clients, self.bus)
 
1535
 
 
1536
 
 
1537
class TestEnableCmd(TestCmd):
 
1538
    def test_enable(self):
 
1539
        for clientpath in self.clients:
 
1540
            client = self.bus.get_object(dbus_busname, clientpath)
 
1541
            client.attributes["Enabled"] = False
 
1542
 
 
1543
        EnableCmd().run(self.clients, self.bus)
 
1544
 
 
1545
        for clientpath in self.clients:
 
1546
            client = self.bus.get_object(dbus_busname, clientpath)
 
1547
            self.assertTrue(client.attributes["Enabled"])
 
1548
 
 
1549
 
 
1550
class TestDisableCmd(TestCmd):
 
1551
    def test_disable(self):
 
1552
        DisableCmd().run(self.clients, self.bus)
 
1553
        for clientpath in self.clients:
 
1554
            client = self.bus.get_object(dbus_busname, clientpath)
 
1555
            self.assertFalse(client.attributes["Enabled"])
 
1556
 
1047
1557
 
1048
1558
class TestBumpTimeoutCmd(TestPropertyCmd):
1049
1559
    command = BumpTimeoutCmd
1050
 
    property = "LastCheckedOK"
 
1560
    propname = "LastCheckedOK"
1051
1561
    values_to_set = [""]
1052
1562
 
 
1563
 
1053
1564
class TestStartCheckerCmd(TestPropertyCmd):
1054
1565
    command = StartCheckerCmd
1055
 
    property = "CheckerRunning"
 
1566
    propname = "CheckerRunning"
1056
1567
    values_to_set = [dbus.Boolean(True)]
1057
1568
 
 
1569
 
1058
1570
class TestStopCheckerCmd(TestPropertyCmd):
1059
1571
    command = StopCheckerCmd
1060
 
    property = "CheckerRunning"
 
1572
    propname = "CheckerRunning"
1061
1573
    values_to_set = [dbus.Boolean(False)]
1062
1574
 
 
1575
 
1063
1576
class TestApproveByDefaultCmd(TestPropertyCmd):
1064
1577
    command = ApproveByDefaultCmd
1065
 
    property = "ApprovedByDefault"
 
1578
    propname = "ApprovedByDefault"
1066
1579
    values_to_set = [dbus.Boolean(True)]
1067
1580
 
 
1581
 
1068
1582
class TestDenyByDefaultCmd(TestPropertyCmd):
1069
1583
    command = DenyByDefaultCmd
1070
 
    property = "ApprovedByDefault"
 
1584
    propname = "ApprovedByDefault"
1071
1585
    values_to_set = [dbus.Boolean(False)]
1072
1586
 
1073
 
class TestValueArgumentPropertyCmd(TestPropertyCmd):
1074
 
    """Abstract class for tests of PropertyCmd classes using the
1075
 
ValueArgumentMixIn"""
 
1587
 
 
1588
class TestPropertyValueCmd(TestPropertyCmd):
 
1589
    """Abstract class for tests of PropertyValueCmd classes"""
1076
1590
    def runTest(self):
1077
 
        if type(self) is TestValueArgumentPropertyCmd:
 
1591
        if type(self) is TestPropertyValueCmd:
1078
1592
            return
1079
 
        return super(TestValueArgumentPropertyCmd, self).runTest()
 
1593
        return super(TestPropertyValueCmd, self).runTest()
1080
1594
    def run_command(self, value, clients):
1081
 
        self.command(value).run(None, clients)
1082
 
 
1083
 
class TestSetCheckerCmd(TestValueArgumentPropertyCmd):
 
1595
        self.command(value).run(clients, self.bus)
 
1596
 
 
1597
 
 
1598
class TestSetCheckerCmd(TestPropertyValueCmd):
1084
1599
    command = SetCheckerCmd
1085
 
    property = "Checker"
 
1600
    propname = "Checker"
1086
1601
    values_to_set = ["", ":", "fping -q -- %s"]
1087
1602
 
1088
 
class TestSetHostCmd(TestValueArgumentPropertyCmd):
 
1603
 
 
1604
class TestSetHostCmd(TestPropertyValueCmd):
1089
1605
    command = SetHostCmd
1090
 
    property = "Host"
 
1606
    propname = "Host"
1091
1607
    values_to_set = ["192.0.2.3", "foo.example.org"]
1092
1608
 
1093
 
class TestSetSecretCmd(TestValueArgumentPropertyCmd):
 
1609
 
 
1610
class TestSetSecretCmd(TestPropertyValueCmd):
1094
1611
    command = SetSecretCmd
1095
 
    property = "Secret"
1096
 
    values_to_set = [open("/dev/null", "rb"),
 
1612
    propname = "Secret"
 
1613
    values_to_set = [io.BytesIO(b""),
1097
1614
                     io.BytesIO(b"secret\0xyzzy\nbar")]
1098
1615
    values_to_get = [b"", b"secret\0xyzzy\nbar"]
1099
1616
 
1100
 
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
 
1617
 
 
1618
class TestSetTimeoutCmd(TestPropertyValueCmd):
1101
1619
    command = SetTimeoutCmd
1102
 
    property = "Timeout"
1103
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1104
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1105
 
 
1106
 
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
 
1620
    propname = "Timeout"
 
1621
    values_to_set = [datetime.timedelta(),
 
1622
                     datetime.timedelta(minutes=5),
 
1623
                     datetime.timedelta(seconds=1),
 
1624
                     datetime.timedelta(weeks=1),
 
1625
                     datetime.timedelta(weeks=52)]
 
1626
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1627
 
 
1628
 
 
1629
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
1107
1630
    command = SetExtendedTimeoutCmd
1108
 
    property = "ExtendedTimeout"
1109
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1110
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1111
 
 
1112
 
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
 
1631
    propname = "ExtendedTimeout"
 
1632
    values_to_set = [datetime.timedelta(),
 
1633
                     datetime.timedelta(minutes=5),
 
1634
                     datetime.timedelta(seconds=1),
 
1635
                     datetime.timedelta(weeks=1),
 
1636
                     datetime.timedelta(weeks=52)]
 
1637
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1638
 
 
1639
 
 
1640
class TestSetIntervalCmd(TestPropertyValueCmd):
1113
1641
    command = SetIntervalCmd
1114
 
    property = "Interval"
1115
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1116
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1117
 
 
1118
 
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
 
1642
    propname = "Interval"
 
1643
    values_to_set = [datetime.timedelta(),
 
1644
                     datetime.timedelta(minutes=5),
 
1645
                     datetime.timedelta(seconds=1),
 
1646
                     datetime.timedelta(weeks=1),
 
1647
                     datetime.timedelta(weeks=52)]
 
1648
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1649
 
 
1650
 
 
1651
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
1119
1652
    command = SetApprovalDelayCmd
1120
 
    property = "ApprovalDelay"
1121
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1122
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1123
 
 
1124
 
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
 
1653
    propname = "ApprovalDelay"
 
1654
    values_to_set = [datetime.timedelta(),
 
1655
                     datetime.timedelta(minutes=5),
 
1656
                     datetime.timedelta(seconds=1),
 
1657
                     datetime.timedelta(weeks=1),
 
1658
                     datetime.timedelta(weeks=52)]
 
1659
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1660
 
 
1661
 
 
1662
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
1125
1663
    command = SetApprovalDurationCmd
1126
 
    property = "ApprovalDuration"
1127
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1128
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1129
 
 
1130
 
class Test_command_from_options(unittest.TestCase):
1131
 
    def setUp(self):
1132
 
        self.parser = argparse.ArgumentParser()
1133
 
        add_command_line_options(self.parser)
1134
 
    def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1135
 
        """Assert that parsing ARGS should result in an instance of
1136
 
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1137
 
        options = self.parser.parse_args(args)
1138
 
        commands = commands_from_options(options)
1139
 
        self.assertEqual(len(commands), 1)
1140
 
        command = commands[0]
1141
 
        self.assertIsInstance(command, command_cls)
1142
 
        for key, value in cmd_attrs.items():
1143
 
            self.assertEqual(getattr(command, key), value)
1144
 
    def test_print_table(self):
1145
 
        self.assert_command_from_args([], PrintTableCmd,
1146
 
                                      verbose=False)
1147
 
 
1148
 
    def test_print_table_verbose(self):
1149
 
        self.assert_command_from_args(["--verbose"], PrintTableCmd,
1150
 
                                      verbose=True)
1151
 
 
1152
 
    def test_enable(self):
1153
 
        self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1154
 
 
1155
 
    def test_disable(self):
1156
 
        self.assert_command_from_args(["--disable", "foo"],
1157
 
                                      DisableCmd)
1158
 
 
1159
 
    def test_bump_timeout(self):
1160
 
        self.assert_command_from_args(["--bump-timeout", "foo"],
1161
 
                                      BumpTimeoutCmd)
1162
 
 
1163
 
    def test_start_checker(self):
1164
 
        self.assert_command_from_args(["--start-checker", "foo"],
1165
 
                                      StartCheckerCmd)
1166
 
 
1167
 
    def test_stop_checker(self):
1168
 
        self.assert_command_from_args(["--stop-checker", "foo"],
1169
 
                                      StopCheckerCmd)
1170
 
 
1171
 
    def test_remove(self):
1172
 
        self.assert_command_from_args(["--remove", "foo"],
1173
 
                                      RemoveCmd)
1174
 
 
1175
 
    def test_checker(self):
1176
 
        self.assert_command_from_args(["--checker", ":", "foo"],
1177
 
                                      SetCheckerCmd, value_to_set=":")
1178
 
 
1179
 
    def test_checker_empty(self):
1180
 
        self.assert_command_from_args(["--checker", "", "foo"],
1181
 
                                      SetCheckerCmd, value_to_set="")
1182
 
 
1183
 
    def test_timeout(self):
1184
 
        self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1185
 
                                      SetTimeoutCmd,
1186
 
                                      value_to_set=300000)
1187
 
 
1188
 
    def test_extended_timeout(self):
1189
 
        self.assert_command_from_args(["--extended-timeout", "PT15M",
1190
 
                                       "foo"],
1191
 
                                      SetExtendedTimeoutCmd,
1192
 
                                      value_to_set=900000)
1193
 
 
1194
 
    def test_interval(self):
1195
 
        self.assert_command_from_args(["--interval", "PT2M", "foo"],
1196
 
                                      SetIntervalCmd,
1197
 
                                      value_to_set=120000)
1198
 
 
1199
 
    def test_approve_by_default(self):
1200
 
        self.assert_command_from_args(["--approve-by-default", "foo"],
1201
 
                                      ApproveByDefaultCmd)
1202
 
 
1203
 
    def test_deny_by_default(self):
1204
 
        self.assert_command_from_args(["--deny-by-default", "foo"],
1205
 
                                      DenyByDefaultCmd)
1206
 
 
1207
 
    def test_approval_delay(self):
1208
 
        self.assert_command_from_args(["--approval-delay", "PT30S",
1209
 
                                       "foo"], SetApprovalDelayCmd,
1210
 
                                      value_to_set=30000)
1211
 
 
1212
 
    def test_approval_duration(self):
1213
 
        self.assert_command_from_args(["--approval-duration", "PT1S",
1214
 
                                       "foo"], SetApprovalDurationCmd,
1215
 
                                      value_to_set=1000)
1216
 
 
1217
 
    def test_host(self):
1218
 
        self.assert_command_from_args(["--host", "foo.example.org",
1219
 
                                       "foo"], SetHostCmd,
1220
 
                                      value_to_set="foo.example.org")
1221
 
 
1222
 
    def test_secret_devnull(self):
1223
 
        self.assert_command_from_args(["--secret", os.path.devnull,
1224
 
                                       "foo"], SetSecretCmd,
1225
 
                                      value_to_set=b"")
1226
 
 
1227
 
    def test_secret_tempfile(self):
1228
 
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
1229
 
            value = b"secret\0xyzzy\nbar"
1230
 
            f.write(value)
1231
 
            f.seek(0)
1232
 
            self.assert_command_from_args(["--secret", f.name,
1233
 
                                           "foo"], SetSecretCmd,
1234
 
                                          value_to_set=value)
1235
 
 
1236
 
    def test_approve(self):
1237
 
        self.assert_command_from_args(["--approve", "foo"],
1238
 
                                      ApproveCmd)
1239
 
 
1240
 
    def test_deny(self):
1241
 
        self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1242
 
 
1243
 
    def test_dump_json(self):
1244
 
        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1245
 
 
1246
 
    def test_is_enabled(self):
1247
 
        self.assert_command_from_args(["--is-enabled", "foo"],
1248
 
                                      IsEnabledCmd)
 
1664
    propname = "ApprovalDuration"
 
1665
    values_to_set = [datetime.timedelta(),
 
1666
                     datetime.timedelta(minutes=5),
 
1667
                     datetime.timedelta(seconds=1),
 
1668
                     datetime.timedelta(weeks=1),
 
1669
                     datetime.timedelta(weeks=52)]
 
1670
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1249
1671
 
1250
1672
 
1251
1673