/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos-ctl

  • Committer: Teddy Hogeborn
  • Date: 2019-03-12 20:13:34 UTC
  • mto: This revision was merged to the branch mainline in revision 382.
  • 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:
79
79
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
80
80
 
81
81
 
82
 
def milliseconds_to_string(ms):
83
 
    td = datetime.timedelta(0, 0, 0, ms)
84
 
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
85
 
            .format(days="{}T".format(td.days) if td.days else "",
86
 
                    hours=td.seconds // 3600,
87
 
                    minutes=(td.seconds % 3600) // 60,
88
 
                    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)
89
232
 
90
233
 
91
234
def rfc3339_duration_to_delta(duration):
218
361
    return value
219
362
 
220
363
 
221
 
def string_to_delta(interval):
222
 
    """Parse a string and return a datetime.timedelta"""
223
 
 
224
 
    try:
225
 
        return rfc3339_duration_to_delta(interval)
226
 
    except ValueError as e:
227
 
        log.warning("%s - Parsing as pre-1.6.1 interval instead",
228
 
                    ' '.join(e.args))
229
 
    return parse_pre_1_6_1_interval(interval)
230
 
 
231
 
 
232
364
def parse_pre_1_6_1_interval(interval):
233
365
    """Parse an interval string as documented by Mandos before 1.6.1,
234
366
    and return a datetime.timedelta
272
404
    return value
273
405
 
274
406
 
275
 
## Classes for commands.
276
 
 
277
 
# 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
 
278
523
class Command(object):
279
524
    """Abstract class for commands"""
280
525
    def run(self, clients, bus=None, mandos=None):
288
533
            client = bus.get_object(dbus_busname, clientpath)
289
534
            self.run_on_one_client(client, properties)
290
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
 
291
571
class PrintCmd(Command):
292
572
    """Abstract class for commands printing client details"""
293
573
    all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
302
582
    def output(self, clients):
303
583
        raise NotImplementedError()
304
584
 
305
 
class PropertyCmd(Command):
306
 
    """Abstract class for Actions for setting one client property"""
307
 
    def run_on_one_client(self, client, properties):
308
 
        """Set the Client's D-Bus property"""
309
 
        log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
310
 
                  client.__dbus_object_path__,
311
 
                  dbus.PROPERTIES_IFACE, client_dbus_interface,
312
 
                  self.propname, self.value_to_set
313
 
                  if not isinstance(self.value_to_set, dbus.Boolean)
314
 
                  else bool(self.value_to_set))
315
 
        client.Set(client_dbus_interface, self.propname,
316
 
                   self.value_to_set,
317
 
                   dbus_interface=dbus.PROPERTIES_IFACE)
318
 
    @property
319
 
    def propname(self):
320
 
        raise NotImplementedError()
321
 
 
322
 
class PropertyValueCmd(PropertyCmd):
323
 
    """Abstract class for PropertyCmd recieving a value as argument"""
324
 
    def __init__(self, value):
325
 
        self.value_to_set = value
326
 
 
327
 
class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):
328
 
    """Abstract class for PropertyValueCmd taking a value argument as
329
 
a datetime.timedelta() but should store it as milliseconds."""
330
 
    @property
331
 
    def value_to_set(self):
332
 
        return self._vts
333
 
    @value_to_set.setter
334
 
    def value_to_set(self, value):
335
 
        """When setting, convert value from a datetime.timedelta"""
336
 
        self._vts = int(round(value.total_seconds() * 1000))
337
 
 
338
 
# Actual (non-abstract) command classes
 
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
 
339
599
 
340
600
class PrintTableCmd(PrintCmd):
341
601
    def __init__(self, verbose=False):
424
684
                   for key in self.keywords})
425
685
 
426
686
 
427
 
 
428
 
class DumpJSONCmd(PrintCmd):
429
 
    def output(self, clients):
430
 
        data = {client["Name"]:
431
 
                {key: self.dbus_boolean_to_bool(client[key])
432
 
                 for key in self.all_keywords}
433
 
                for client in clients.values()}
434
 
        return json.dumps(data, indent=4, separators=(',', ': '))
435
 
    @staticmethod
436
 
    def dbus_boolean_to_bool(value):
437
 
        if isinstance(value, dbus.Boolean):
438
 
            value = bool(value)
439
 
        return value
440
 
 
441
 
class IsEnabledCmd(Command):
442
 
    def run(self, clients, bus=None, mandos=None):
443
 
        client, properties = next(iter(clients.items()))
444
 
        if self.is_enabled(client, properties):
445
 
            sys.exit(0)
446
 
        sys.exit(1)
447
 
    def is_enabled(self, client, properties):
448
 
        return properties["Enabled"]
449
 
 
450
 
class RemoveCmd(Command):
451
 
    def run_on_one_client(self, client, properties):
452
 
        log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,
453
 
                  server_dbus_path, server_dbus_interface,
454
 
                  str(client.__dbus_object_path__))
455
 
        self.mandos.RemoveClient(client.__dbus_object_path__)
456
 
 
457
 
class ApproveCmd(Command):
458
 
    def run_on_one_client(self, client, properties):
459
 
        log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
460
 
                  client.__dbus_object_path__, client_dbus_interface)
461
 
        client.Approve(dbus.Boolean(True),
462
 
                       dbus_interface=client_dbus_interface)
463
 
 
464
 
class DenyCmd(Command):
465
 
    def run_on_one_client(self, client, properties):
466
 
        log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
467
 
                  client.__dbus_object_path__, client_dbus_interface)
468
 
        client.Approve(dbus.Boolean(False),
469
 
                       dbus_interface=client_dbus_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
 
470
713
 
471
714
class EnableCmd(PropertyCmd):
472
715
    propname = "Enabled"
473
716
    value_to_set = dbus.Boolean(True)
474
717
 
 
718
 
475
719
class DisableCmd(PropertyCmd):
476
720
    propname = "Enabled"
477
721
    value_to_set = dbus.Boolean(False)
478
722
 
 
723
 
479
724
class BumpTimeoutCmd(PropertyCmd):
480
725
    propname = "LastCheckedOK"
481
726
    value_to_set = ""
482
727
 
 
728
 
483
729
class StartCheckerCmd(PropertyCmd):
484
730
    propname = "CheckerRunning"
485
731
    value_to_set = dbus.Boolean(True)
486
732
 
 
733
 
487
734
class StopCheckerCmd(PropertyCmd):
488
735
    propname = "CheckerRunning"
489
736
    value_to_set = dbus.Boolean(False)
490
737
 
 
738
 
491
739
class ApproveByDefaultCmd(PropertyCmd):
492
740
    propname = "ApprovedByDefault"
493
741
    value_to_set = dbus.Boolean(True)
494
742
 
 
743
 
495
744
class DenyByDefaultCmd(PropertyCmd):
496
745
    propname = "ApprovedByDefault"
497
746
    value_to_set = dbus.Boolean(False)
498
747
 
 
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
 
499
755
class SetCheckerCmd(PropertyValueCmd):
500
756
    propname = "Checker"
501
757
 
 
758
 
502
759
class SetHostCmd(PropertyValueCmd):
503
760
    propname = "Host"
504
761
 
 
762
 
505
763
class SetSecretCmd(PropertyValueCmd):
506
764
    propname = "Secret"
507
765
    @property
513
771
        self._vts = value.read()
514
772
        value.close()
515
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
 
516
787
class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
517
788
    propname = "Timeout"
518
789
 
 
790
 
519
791
class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
520
792
    propname = "ExtendedTimeout"
521
793
 
 
794
 
522
795
class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):
523
796
    propname = "Interval"
524
797
 
 
798
 
525
799
class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):
526
800
    propname = "ApprovalDelay"
527
801
 
 
802
 
528
803
class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):
529
804
    propname = "ApprovalDuration"
530
805
 
531
 
def add_command_line_options(parser):
532
 
    parser.add_argument("--version", action="version",
533
 
                        version="%(prog)s {}".format(version),
534
 
                        help="show version number and exit")
535
 
    parser.add_argument("-a", "--all", action="store_true",
536
 
                        help="Select all clients")
537
 
    parser.add_argument("-v", "--verbose", action="store_true",
538
 
                        help="Print all fields")
539
 
    parser.add_argument("-j", "--dump-json", action="store_true",
540
 
                        help="Dump client data in JSON format")
541
 
    enable_disable = parser.add_mutually_exclusive_group()
542
 
    enable_disable.add_argument("-e", "--enable", action="store_true",
543
 
                                help="Enable client")
544
 
    enable_disable.add_argument("-d", "--disable",
545
 
                                action="store_true",
546
 
                                help="disable client")
547
 
    parser.add_argument("-b", "--bump-timeout", action="store_true",
548
 
                        help="Bump timeout for client")
549
 
    start_stop_checker = parser.add_mutually_exclusive_group()
550
 
    start_stop_checker.add_argument("--start-checker",
551
 
                                    action="store_true",
552
 
                                    help="Start checker for client")
553
 
    start_stop_checker.add_argument("--stop-checker",
554
 
                                    action="store_true",
555
 
                                    help="Stop checker for client")
556
 
    parser.add_argument("-V", "--is-enabled", action="store_true",
557
 
                        help="Check if client is enabled")
558
 
    parser.add_argument("-r", "--remove", action="store_true",
559
 
                        help="Remove client")
560
 
    parser.add_argument("-c", "--checker",
561
 
                        help="Set checker command for client")
562
 
    parser.add_argument("-t", "--timeout", type=string_to_delta,
563
 
                        help="Set timeout for client")
564
 
    parser.add_argument("--extended-timeout", type=string_to_delta,
565
 
                        help="Set extended timeout for client")
566
 
    parser.add_argument("-i", "--interval", type=string_to_delta,
567
 
                        help="Set checker interval for client")
568
 
    approve_deny_default = parser.add_mutually_exclusive_group()
569
 
    approve_deny_default.add_argument(
570
 
        "--approve-by-default", action="store_true",
571
 
        default=None, dest="approved_by_default",
572
 
        help="Set client to be approved by default")
573
 
    approve_deny_default.add_argument(
574
 
        "--deny-by-default", action="store_false",
575
 
        dest="approved_by_default",
576
 
        help="Set client to be denied by default")
577
 
    parser.add_argument("--approval-delay", type=string_to_delta,
578
 
                        help="Set delay before client approve/deny")
579
 
    parser.add_argument("--approval-duration", type=string_to_delta,
580
 
                        help="Set duration of one client approval")
581
 
    parser.add_argument("-H", "--host", help="Set host for client")
582
 
    parser.add_argument("-s", "--secret",
583
 
                        type=argparse.FileType(mode="rb"),
584
 
                        help="Set password blob (file) for client")
585
 
    approve_deny = parser.add_mutually_exclusive_group()
586
 
    approve_deny.add_argument(
587
 
        "-A", "--approve", action="store_true",
588
 
        help="Approve any current client request")
589
 
    approve_deny.add_argument("-D", "--deny", action="store_true",
590
 
                              help="Deny any current client request")
591
 
    parser.add_argument("--debug", action="store_true",
592
 
                        help="Debug mode (show D-Bus commands)")
593
 
    parser.add_argument("--check", action="store_true",
594
 
                        help="Run self-test")
595
 
    parser.add_argument("client", nargs="*", help="Client name")
596
 
 
597
 
 
598
 
def commands_from_options(options):
599
 
 
600
 
    commands = []
601
 
 
602
 
    if options.dump_json:
603
 
        commands.append(DumpJSONCmd())
604
 
 
605
 
    if options.enable:
606
 
        commands.append(EnableCmd())
607
 
 
608
 
    if options.disable:
609
 
        commands.append(DisableCmd())
610
 
 
611
 
    if options.bump_timeout:
612
 
        commands.append(BumpTimeoutCmd())
613
 
 
614
 
    if options.start_checker:
615
 
        commands.append(StartCheckerCmd())
616
 
 
617
 
    if options.stop_checker:
618
 
        commands.append(StopCheckerCmd())
619
 
 
620
 
    if options.is_enabled:
621
 
        commands.append(IsEnabledCmd())
622
 
 
623
 
    if options.checker is not None:
624
 
        commands.append(SetCheckerCmd(options.checker))
625
 
 
626
 
    if options.timeout is not None:
627
 
        commands.append(SetTimeoutCmd(options.timeout))
628
 
 
629
 
    if options.extended_timeout:
630
 
        commands.append(
631
 
            SetExtendedTimeoutCmd(options.extended_timeout))
632
 
 
633
 
    if options.interval is not None:
634
 
        commands.append(SetIntervalCmd(options.interval))
635
 
 
636
 
    if options.approved_by_default is not None:
637
 
        if options.approved_by_default:
638
 
            commands.append(ApproveByDefaultCmd())
639
 
        else:
640
 
            commands.append(DenyByDefaultCmd())
641
 
 
642
 
    if options.approval_delay is not None:
643
 
        commands.append(SetApprovalDelayCmd(options.approval_delay))
644
 
 
645
 
    if options.approval_duration is not None:
646
 
        commands.append(
647
 
            SetApprovalDurationCmd(options.approval_duration))
648
 
 
649
 
    if options.host is not None:
650
 
        commands.append(SetHostCmd(options.host))
651
 
 
652
 
    if options.secret is not None:
653
 
        commands.append(SetSecretCmd(options.secret))
654
 
 
655
 
    if options.approve:
656
 
        commands.append(ApproveCmd())
657
 
 
658
 
    if options.deny:
659
 
        commands.append(DenyCmd())
660
 
 
661
 
    if options.remove:
662
 
        commands.append(RemoveCmd())
663
 
 
664
 
    # If no command option has been given, show table of clients,
665
 
    # optionally verbosely
666
 
    if not commands:
667
 
        commands.append(PrintTableCmd(verbose=options.verbose))
668
 
 
669
 
    return commands
670
 
 
671
 
 
672
 
def check_option_syntax(parser, options):
673
 
    """Apply additional restrictions on options, not expressible in
674
 
argparse"""
675
 
 
676
 
    def has_actions(options):
677
 
        return any((options.enable,
678
 
                    options.disable,
679
 
                    options.bump_timeout,
680
 
                    options.start_checker,
681
 
                    options.stop_checker,
682
 
                    options.is_enabled,
683
 
                    options.remove,
684
 
                    options.checker is not None,
685
 
                    options.timeout is not None,
686
 
                    options.extended_timeout is not None,
687
 
                    options.interval is not None,
688
 
                    options.approved_by_default is not None,
689
 
                    options.approval_delay is not None,
690
 
                    options.approval_duration is not None,
691
 
                    options.host is not None,
692
 
                    options.secret is not None,
693
 
                    options.approve,
694
 
                    options.deny))
695
 
 
696
 
    if has_actions(options) and not (options.client or options.all):
697
 
        parser.error("Options require clients names or --all.")
698
 
    if options.verbose and has_actions(options):
699
 
        parser.error("--verbose can only be used alone.")
700
 
    if options.dump_json and (options.verbose
701
 
                              or has_actions(options)):
702
 
        parser.error("--dump-json can only be used alone.")
703
 
    if options.all and not has_actions(options):
704
 
        parser.error("--all requires an action.")
705
 
    if options.is_enabled and len(options.client) > 1:
706
 
        parser.error("--is-enabled requires exactly one client")
707
 
    if options.remove:
708
 
        options.remove = False
709
 
        if has_actions(options) and not options.deny:
710
 
            parser.error("--remove can only be combined with --deny")
711
 
        options.remove = True
712
 
 
713
 
 
714
 
def main():
715
 
    parser = argparse.ArgumentParser()
716
 
 
717
 
    add_command_line_options(parser)
718
 
 
719
 
    options = parser.parse_args()
720
 
 
721
 
    check_option_syntax(parser, options)
722
 
 
723
 
    clientnames = options.client
724
 
 
725
 
    if options.debug:
726
 
        log.setLevel(logging.DEBUG)
727
 
 
728
 
    try:
729
 
        bus = dbus.SystemBus()
730
 
        log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
731
 
                  dbus_busname, server_dbus_path)
732
 
        mandos_dbus_objc = bus.get_object(dbus_busname,
733
 
                                          server_dbus_path)
734
 
    except dbus.exceptions.DBusException:
735
 
        log.critical("Could not connect to Mandos server")
736
 
        sys.exit(1)
737
 
 
738
 
    mandos_serv = dbus.Interface(mandos_dbus_objc,
739
 
                                 dbus_interface=server_dbus_interface)
740
 
    mandos_serv_object_manager = dbus.Interface(
741
 
        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
742
 
 
743
 
    # Filter out log message from dbus module
744
 
    dbus_logger = logging.getLogger("dbus.proxies")
745
 
    class NullFilter(logging.Filter):
746
 
        def filter(self, record):
747
 
            return False
748
 
    dbus_filter = NullFilter()
749
 
    try:
750
 
        dbus_logger.addFilter(dbus_filter)
751
 
        log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
752
 
                  server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
753
 
        mandos_clients = {path: ifs_and_props[client_dbus_interface]
754
 
                          for path, ifs_and_props in
755
 
                          mandos_serv_object_manager
756
 
                          .GetManagedObjects().items()
757
 
                          if client_dbus_interface in ifs_and_props}
758
 
    except dbus.exceptions.DBusException as e:
759
 
        log.critical("Failed to access Mandos server through D-Bus:"
760
 
                     "\n%s", e)
761
 
        sys.exit(1)
762
 
    finally:
763
 
        # restore dbus logger
764
 
        dbus_logger.removeFilter(dbus_filter)
765
 
 
766
 
    # Compile dict of (clients: properties) to process
767
 
    clients = {}
768
 
 
769
 
    if not clientnames:
770
 
        clients = {objpath: properties
771
 
                   for objpath, properties in mandos_clients.items()}
772
 
    else:
773
 
        for name in clientnames:
774
 
            for objpath, properties in mandos_clients.items():
775
 
                if properties["Name"] == name:
776
 
                    clients[objpath] = properties
777
 
                    break
778
 
            else:
779
 
                log.critical("Client not found on server: %r", name)
780
 
                sys.exit(1)
781
 
 
782
 
    # Run all commands on clients
783
 
    commands = commands_from_options(options)
784
 
    for command in commands:
785
 
        command.run(clients, bus, mandos_serv)
786
806
 
787
807
 
788
 
class Test_milliseconds_to_string(unittest.TestCase):
789
 
    def test_all(self):
790
 
        self.assertEqual(milliseconds_to_string(93785000),
791
 
                         "1T02:03:05")
792
 
    def test_no_days(self):
793
 
        self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
794
 
    def test_all_zero(self):
795
 
        self.assertEqual(milliseconds_to_string(0), "00:00:00")
796
 
    def test_no_fractional_seconds(self):
797
 
        self.assertEqual(milliseconds_to_string(400), "00:00:00")
798
 
        self.assertEqual(milliseconds_to_string(900), "00:00:00")
799
 
        self.assertEqual(milliseconds_to_string(1900), "00:00:01")
800
 
 
801
808
class Test_string_to_delta(unittest.TestCase):
802
809
    def test_handles_basic_rfc3339(self):
803
810
        self.assertEqual(string_to_delta("PT0S"),
831
838
        self.assertEqual(value, datetime.timedelta(0, 7200))
832
839
 
833
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
 
834
1171
class TestCmd(unittest.TestCase):
835
1172
    """Abstract class for tests of command classes"""
836
1173
    def setUp(self):
922
1259
                }[path]
923
1260
        return Bus()
924
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
 
 
1318
 
 
1319
class TestDumpJSONCmd(TestCmd):
 
1320
    def setUp(self):
 
1321
        self.expected_json = {
 
1322
            "foo": {
 
1323
                "Name": "foo",
 
1324
                "KeyID": ("92ed150794387c03ce684574b1139a65"
 
1325
                          "94a34f895daaaf09fd8ea90a27cddb12"),
 
1326
                "Host": "foo.example.org",
 
1327
                "Enabled": True,
 
1328
                "Timeout": 300000,
 
1329
                "LastCheckedOK": "2019-02-03T00:00:00",
 
1330
                "Created": "2019-01-02T00:00:00",
 
1331
                "Interval": 120000,
 
1332
                "Fingerprint": ("778827225BA7DE539C5A"
 
1333
                                "7CFA59CFF7CDBD9A5920"),
 
1334
                "CheckerRunning": False,
 
1335
                "LastEnabled": "2019-01-03T00:00:00",
 
1336
                "ApprovalPending": False,
 
1337
                "ApprovedByDefault": True,
 
1338
                "LastApprovalRequest": "",
 
1339
                "ApprovalDelay": 0,
 
1340
                "ApprovalDuration": 1000,
 
1341
                "Checker": "fping -q -- %(host)s",
 
1342
                "ExtendedTimeout": 900000,
 
1343
                "Expires": "2019-02-04T00:00:00",
 
1344
                "LastCheckerStatus": 0,
 
1345
            },
 
1346
            "barbar": {
 
1347
                "Name": "barbar",
 
1348
                "KeyID": ("0558568eedd67d622f5c83b35a115f79"
 
1349
                          "6ab612cff5ad227247e46c2b020f441c"),
 
1350
                "Host": "192.0.2.3",
 
1351
                "Enabled": True,
 
1352
                "Timeout": 300000,
 
1353
                "LastCheckedOK": "2019-02-04T00:00:00",
 
1354
                "Created": "2019-01-03T00:00:00",
 
1355
                "Interval": 120000,
 
1356
                "Fingerprint": ("3E393AEAEFB84C7E89E2"
 
1357
                                "F547B3A107558FCA3A27"),
 
1358
                "CheckerRunning": True,
 
1359
                "LastEnabled": "2019-01-04T00:00:00",
 
1360
                "ApprovalPending": False,
 
1361
                "ApprovedByDefault": False,
 
1362
                "LastApprovalRequest": "2019-01-03T00:00:00",
 
1363
                "ApprovalDelay": 30000,
 
1364
                "ApprovalDuration": 1000,
 
1365
                "Checker": ":",
 
1366
                "ExtendedTimeout": 900000,
 
1367
                "Expires": "2019-02-05T00:00:00",
 
1368
                "LastCheckerStatus": -2,
 
1369
            },
 
1370
        }
 
1371
        return super(TestDumpJSONCmd, self).setUp()
 
1372
    def test_normal(self):
 
1373
        json_data = json.loads(DumpJSONCmd().output(self.clients))
 
1374
        self.assertDictEqual(json_data, self.expected_json)
 
1375
    def test_one_client(self):
 
1376
        clients = self.one_client
 
1377
        json_data = json.loads(DumpJSONCmd().output(clients))
 
1378
        expected_json = {"foo": self.expected_json["foo"]}
 
1379
        self.assertDictEqual(json_data, expected_json)
 
1380
 
 
1381
 
925
1382
class TestPrintTableCmd(TestCmd):
926
1383
    def test_normal(self):
927
1384
        output = PrintTableCmd().output(self.clients.values())
1033
1490
"""[1:-1]
1034
1491
        self.assertEqual(output, expected_output)
1035
1492
 
1036
 
class TestDumpJSONCmd(TestCmd):
1037
 
    def setUp(self):
1038
 
        self.expected_json = {
1039
 
            "foo": {
1040
 
                "Name": "foo",
1041
 
                "KeyID": ("92ed150794387c03ce684574b1139a65"
1042
 
                          "94a34f895daaaf09fd8ea90a27cddb12"),
1043
 
                "Host": "foo.example.org",
1044
 
                "Enabled": True,
1045
 
                "Timeout": 300000,
1046
 
                "LastCheckedOK": "2019-02-03T00:00:00",
1047
 
                "Created": "2019-01-02T00:00:00",
1048
 
                "Interval": 120000,
1049
 
                "Fingerprint": ("778827225BA7DE539C5A"
1050
 
                                "7CFA59CFF7CDBD9A5920"),
1051
 
                "CheckerRunning": False,
1052
 
                "LastEnabled": "2019-01-03T00:00:00",
1053
 
                "ApprovalPending": False,
1054
 
                "ApprovedByDefault": True,
1055
 
                "LastApprovalRequest": "",
1056
 
                "ApprovalDelay": 0,
1057
 
                "ApprovalDuration": 1000,
1058
 
                "Checker": "fping -q -- %(host)s",
1059
 
                "ExtendedTimeout": 900000,
1060
 
                "Expires": "2019-02-04T00:00:00",
1061
 
                "LastCheckerStatus": 0,
1062
 
            },
1063
 
            "barbar": {
1064
 
                "Name": "barbar",
1065
 
                "KeyID": ("0558568eedd67d622f5c83b35a115f79"
1066
 
                          "6ab612cff5ad227247e46c2b020f441c"),
1067
 
                "Host": "192.0.2.3",
1068
 
                "Enabled": True,
1069
 
                "Timeout": 300000,
1070
 
                "LastCheckedOK": "2019-02-04T00:00:00",
1071
 
                "Created": "2019-01-03T00:00:00",
1072
 
                "Interval": 120000,
1073
 
                "Fingerprint": ("3E393AEAEFB84C7E89E2"
1074
 
                                "F547B3A107558FCA3A27"),
1075
 
                "CheckerRunning": True,
1076
 
                "LastEnabled": "2019-01-04T00:00:00",
1077
 
                "ApprovalPending": False,
1078
 
                "ApprovedByDefault": False,
1079
 
                "LastApprovalRequest": "2019-01-03T00:00:00",
1080
 
                "ApprovalDelay": 30000,
1081
 
                "ApprovalDuration": 1000,
1082
 
                "Checker": ":",
1083
 
                "ExtendedTimeout": 900000,
1084
 
                "Expires": "2019-02-05T00:00:00",
1085
 
                "LastCheckerStatus": -2,
1086
 
            },
1087
 
        }
1088
 
        return super(TestDumpJSONCmd, self).setUp()
1089
 
    def test_normal(self):
1090
 
        json_data = json.loads(DumpJSONCmd().output(self.clients))
1091
 
        self.assertDictEqual(json_data, self.expected_json)
1092
 
    def test_one_client(self):
1093
 
        clients = self.one_client
1094
 
        json_data = json.loads(DumpJSONCmd().output(clients))
1095
 
        expected_json = {"foo": self.expected_json["foo"]}
1096
 
        self.assertDictEqual(json_data, expected_json)
1097
 
 
1098
 
class TestIsEnabledCmd(TestCmd):
1099
 
    def test_is_enabled(self):
1100
 
        self.assertTrue(all(IsEnabledCmd().is_enabled(client,
1101
 
                                                      properties)
1102
 
                            for client, properties
1103
 
                            in self.clients.items()))
1104
 
    def test_is_enabled_run_exits_successfully(self):
1105
 
        with self.assertRaises(SystemExit) as e:
1106
 
            IsEnabledCmd().run(self.one_client)
1107
 
        if e.exception.code is not None:
1108
 
            self.assertEqual(e.exception.code, 0)
1109
 
        else:
1110
 
            self.assertIsNone(e.exception.code)
1111
 
    def test_is_enabled_run_exits_with_failure(self):
1112
 
        self.client.attributes["Enabled"] = dbus.Boolean(False)
1113
 
        with self.assertRaises(SystemExit) as e:
1114
 
            IsEnabledCmd().run(self.one_client)
1115
 
        if isinstance(e.exception.code, int):
1116
 
            self.assertNotEqual(e.exception.code, 0)
1117
 
        else:
1118
 
            self.assertIsNotNone(e.exception.code)
1119
 
 
1120
 
class TestRemoveCmd(TestCmd):
1121
 
    def test_remove(self):
1122
 
        class MockMandos(object):
1123
 
            def __init__(self):
1124
 
                self.calls = []
1125
 
            def RemoveClient(self, dbus_path):
1126
 
                self.calls.append(("RemoveClient", (dbus_path,)))
1127
 
        mandos = MockMandos()
1128
 
        super(TestRemoveCmd, self).setUp()
1129
 
        RemoveCmd().run(self.clients, self.bus, mandos)
1130
 
        self.assertEqual(len(mandos.calls), 2)
1131
 
        for clientpath in self.clients:
1132
 
            self.assertIn(("RemoveClient", (clientpath,)),
1133
 
                          mandos.calls)
1134
 
 
1135
 
class TestApproveCmd(TestCmd):
1136
 
    def test_approve(self):
1137
 
        ApproveCmd().run(self.clients, self.bus)
1138
 
        for clientpath in self.clients:
1139
 
            client = self.bus.get_object(dbus_busname, clientpath)
1140
 
            self.assertIn(("Approve", (True, client_dbus_interface)),
1141
 
                          client.calls)
1142
 
 
1143
 
class TestDenyCmd(TestCmd):
1144
 
    def test_deny(self):
1145
 
        DenyCmd().run(self.clients, self.bus)
1146
 
        for clientpath in self.clients:
1147
 
            client = self.bus.get_object(dbus_busname, clientpath)
1148
 
            self.assertIn(("Approve", (False, client_dbus_interface)),
1149
 
                          client.calls)
1150
 
 
1151
 
class TestEnableCmd(TestCmd):
1152
 
    def test_enable(self):
1153
 
        for clientpath in self.clients:
1154
 
            client = self.bus.get_object(dbus_busname, clientpath)
1155
 
            client.attributes["Enabled"] = False
1156
 
 
1157
 
        EnableCmd().run(self.clients, self.bus)
1158
 
 
1159
 
        for clientpath in self.clients:
1160
 
            client = self.bus.get_object(dbus_busname, clientpath)
1161
 
            self.assertTrue(client.attributes["Enabled"])
1162
 
 
1163
 
class TestDisableCmd(TestCmd):
1164
 
    def test_disable(self):
1165
 
        DisableCmd().run(self.clients, self.bus)
1166
 
        for clientpath in self.clients:
1167
 
            client = self.bus.get_object(dbus_busname, clientpath)
1168
 
            self.assertFalse(client.attributes["Enabled"])
 
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
 
1169
1507
 
1170
1508
class Unique(object):
1171
1509
    """Class for objects which exist only to be unique objects, since
1172
1510
unittest.mock.sentinel only exists in Python 3.3"""
1173
1511
 
 
1512
 
1174
1513
class TestPropertyCmd(TestCmd):
1175
1514
    """Abstract class for tests of PropertyCmd classes"""
1176
1515
    def runTest(self):
1194
1533
    def run_command(self, value, clients):
1195
1534
        self.command().run(clients, self.bus)
1196
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
 
 
1557
 
1197
1558
class TestBumpTimeoutCmd(TestPropertyCmd):
1198
1559
    command = BumpTimeoutCmd
1199
1560
    propname = "LastCheckedOK"
1200
1561
    values_to_set = [""]
1201
1562
 
 
1563
 
1202
1564
class TestStartCheckerCmd(TestPropertyCmd):
1203
1565
    command = StartCheckerCmd
1204
1566
    propname = "CheckerRunning"
1205
1567
    values_to_set = [dbus.Boolean(True)]
1206
1568
 
 
1569
 
1207
1570
class TestStopCheckerCmd(TestPropertyCmd):
1208
1571
    command = StopCheckerCmd
1209
1572
    propname = "CheckerRunning"
1210
1573
    values_to_set = [dbus.Boolean(False)]
1211
1574
 
 
1575
 
1212
1576
class TestApproveByDefaultCmd(TestPropertyCmd):
1213
1577
    command = ApproveByDefaultCmd
1214
1578
    propname = "ApprovedByDefault"
1215
1579
    values_to_set = [dbus.Boolean(True)]
1216
1580
 
 
1581
 
1217
1582
class TestDenyByDefaultCmd(TestPropertyCmd):
1218
1583
    command = DenyByDefaultCmd
1219
1584
    propname = "ApprovedByDefault"
1220
1585
    values_to_set = [dbus.Boolean(False)]
1221
1586
 
 
1587
 
1222
1588
class TestPropertyValueCmd(TestPropertyCmd):
1223
1589
    """Abstract class for tests of PropertyValueCmd classes"""
1224
1590
    def runTest(self):
1228
1594
    def run_command(self, value, clients):
1229
1595
        self.command(value).run(clients, self.bus)
1230
1596
 
 
1597
 
1231
1598
class TestSetCheckerCmd(TestPropertyValueCmd):
1232
1599
    command = SetCheckerCmd
1233
1600
    propname = "Checker"
1234
1601
    values_to_set = ["", ":", "fping -q -- %s"]
1235
1602
 
 
1603
 
1236
1604
class TestSetHostCmd(TestPropertyValueCmd):
1237
1605
    command = SetHostCmd
1238
1606
    propname = "Host"
1239
1607
    values_to_set = ["192.0.2.3", "foo.example.org"]
1240
1608
 
 
1609
 
1241
1610
class TestSetSecretCmd(TestPropertyValueCmd):
1242
1611
    command = SetSecretCmd
1243
1612
    propname = "Secret"
1245
1614
                     io.BytesIO(b"secret\0xyzzy\nbar")]
1246
1615
    values_to_get = [b"", b"secret\0xyzzy\nbar"]
1247
1616
 
 
1617
 
1248
1618
class TestSetTimeoutCmd(TestPropertyValueCmd):
1249
1619
    command = SetTimeoutCmd
1250
1620
    propname = "Timeout"
1255
1625
                     datetime.timedelta(weeks=52)]
1256
1626
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1257
1627
 
 
1628
 
1258
1629
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
1259
1630
    command = SetExtendedTimeoutCmd
1260
1631
    propname = "ExtendedTimeout"
1265
1636
                     datetime.timedelta(weeks=52)]
1266
1637
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1267
1638
 
 
1639
 
1268
1640
class TestSetIntervalCmd(TestPropertyValueCmd):
1269
1641
    command = SetIntervalCmd
1270
1642
    propname = "Interval"
1275
1647
                     datetime.timedelta(weeks=52)]
1276
1648
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1277
1649
 
 
1650
 
1278
1651
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
1279
1652
    command = SetApprovalDelayCmd
1280
1653
    propname = "ApprovalDelay"
1285
1658
                     datetime.timedelta(weeks=52)]
1286
1659
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1287
1660
 
 
1661
 
1288
1662
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
1289
1663
    command = SetApprovalDurationCmd
1290
1664
    propname = "ApprovalDuration"
1295
1669
                     datetime.timedelta(weeks=52)]
1296
1670
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1297
1671
 
1298
 
class Test_command_from_options(unittest.TestCase):
1299
 
    def setUp(self):
1300
 
        self.parser = argparse.ArgumentParser()
1301
 
        add_command_line_options(self.parser)
1302
 
    def assert_command_from_args(self, args, command_cls,
1303
 
                                 **cmd_attrs):
1304
 
        """Assert that parsing ARGS should result in an instance of
1305
 
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1306
 
        options = self.parser.parse_args(args)
1307
 
        check_option_syntax(self.parser, options)
1308
 
        commands = commands_from_options(options)
1309
 
        self.assertEqual(len(commands), 1)
1310
 
        command = commands[0]
1311
 
        self.assertIsInstance(command, command_cls)
1312
 
        for key, value in cmd_attrs.items():
1313
 
            self.assertEqual(getattr(command, key), value)
1314
 
    def test_print_table(self):
1315
 
        self.assert_command_from_args([], PrintTableCmd,
1316
 
                                      verbose=False)
1317
 
 
1318
 
    def test_print_table_verbose(self):
1319
 
        self.assert_command_from_args(["--verbose"], PrintTableCmd,
1320
 
                                      verbose=True)
1321
 
 
1322
 
    def test_print_table_verbose_short(self):
1323
 
        self.assert_command_from_args(["-v"], PrintTableCmd,
1324
 
                                      verbose=True)
1325
 
 
1326
 
    def test_enable(self):
1327
 
        self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1328
 
 
1329
 
    def test_enable_short(self):
1330
 
        self.assert_command_from_args(["-e", "foo"], EnableCmd)
1331
 
 
1332
 
    def test_disable(self):
1333
 
        self.assert_command_from_args(["--disable", "foo"],
1334
 
                                      DisableCmd)
1335
 
 
1336
 
    def test_disable_short(self):
1337
 
        self.assert_command_from_args(["-d", "foo"], DisableCmd)
1338
 
 
1339
 
    def test_bump_timeout(self):
1340
 
        self.assert_command_from_args(["--bump-timeout", "foo"],
1341
 
                                      BumpTimeoutCmd)
1342
 
 
1343
 
    def test_bump_timeout_short(self):
1344
 
        self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1345
 
 
1346
 
    def test_start_checker(self):
1347
 
        self.assert_command_from_args(["--start-checker", "foo"],
1348
 
                                      StartCheckerCmd)
1349
 
 
1350
 
    def test_stop_checker(self):
1351
 
        self.assert_command_from_args(["--stop-checker", "foo"],
1352
 
                                      StopCheckerCmd)
1353
 
 
1354
 
    def test_remove(self):
1355
 
        self.assert_command_from_args(["--remove", "foo"],
1356
 
                                      RemoveCmd)
1357
 
 
1358
 
    def test_remove_short(self):
1359
 
        self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1360
 
 
1361
 
    def test_checker(self):
1362
 
        self.assert_command_from_args(["--checker", ":", "foo"],
1363
 
                                      SetCheckerCmd, value_to_set=":")
1364
 
 
1365
 
    def test_checker_empty(self):
1366
 
        self.assert_command_from_args(["--checker", "", "foo"],
1367
 
                                      SetCheckerCmd, value_to_set="")
1368
 
 
1369
 
    def test_checker_short(self):
1370
 
        self.assert_command_from_args(["-c", ":", "foo"],
1371
 
                                      SetCheckerCmd, value_to_set=":")
1372
 
 
1373
 
    def test_timeout(self):
1374
 
        self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1375
 
                                      SetTimeoutCmd,
1376
 
                                      value_to_set=300000)
1377
 
 
1378
 
    def test_timeout_short(self):
1379
 
        self.assert_command_from_args(["-t", "PT5M", "foo"],
1380
 
                                      SetTimeoutCmd,
1381
 
                                      value_to_set=300000)
1382
 
 
1383
 
    def test_extended_timeout(self):
1384
 
        self.assert_command_from_args(["--extended-timeout", "PT15M",
1385
 
                                       "foo"],
1386
 
                                      SetExtendedTimeoutCmd,
1387
 
                                      value_to_set=900000)
1388
 
 
1389
 
    def test_interval(self):
1390
 
        self.assert_command_from_args(["--interval", "PT2M", "foo"],
1391
 
                                      SetIntervalCmd,
1392
 
                                      value_to_set=120000)
1393
 
 
1394
 
    def test_interval_short(self):
1395
 
        self.assert_command_from_args(["-i", "PT2M", "foo"],
1396
 
                                      SetIntervalCmd,
1397
 
                                      value_to_set=120000)
1398
 
 
1399
 
    def test_approve_by_default(self):
1400
 
        self.assert_command_from_args(["--approve-by-default", "foo"],
1401
 
                                      ApproveByDefaultCmd)
1402
 
 
1403
 
    def test_deny_by_default(self):
1404
 
        self.assert_command_from_args(["--deny-by-default", "foo"],
1405
 
                                      DenyByDefaultCmd)
1406
 
 
1407
 
    def test_approval_delay(self):
1408
 
        self.assert_command_from_args(["--approval-delay", "PT30S",
1409
 
                                       "foo"], SetApprovalDelayCmd,
1410
 
                                      value_to_set=30000)
1411
 
 
1412
 
    def test_approval_duration(self):
1413
 
        self.assert_command_from_args(["--approval-duration", "PT1S",
1414
 
                                       "foo"], SetApprovalDurationCmd,
1415
 
                                      value_to_set=1000)
1416
 
 
1417
 
    def test_host(self):
1418
 
        self.assert_command_from_args(["--host", "foo.example.org",
1419
 
                                       "foo"], SetHostCmd,
1420
 
                                      value_to_set="foo.example.org")
1421
 
 
1422
 
    def test_host_short(self):
1423
 
        self.assert_command_from_args(["-H", "foo.example.org",
1424
 
                                       "foo"], SetHostCmd,
1425
 
                                      value_to_set="foo.example.org")
1426
 
 
1427
 
    def test_secret_devnull(self):
1428
 
        self.assert_command_from_args(["--secret", os.path.devnull,
1429
 
                                       "foo"], SetSecretCmd,
1430
 
                                      value_to_set=b"")
1431
 
 
1432
 
    def test_secret_tempfile(self):
1433
 
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
1434
 
            value = b"secret\0xyzzy\nbar"
1435
 
            f.write(value)
1436
 
            f.seek(0)
1437
 
            self.assert_command_from_args(["--secret", f.name,
1438
 
                                           "foo"], SetSecretCmd,
1439
 
                                          value_to_set=value)
1440
 
 
1441
 
    def test_secret_devnull_short(self):
1442
 
        self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1443
 
                                      SetSecretCmd, value_to_set=b"")
1444
 
 
1445
 
    def test_secret_tempfile_short(self):
1446
 
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
1447
 
            value = b"secret\0xyzzy\nbar"
1448
 
            f.write(value)
1449
 
            f.seek(0)
1450
 
            self.assert_command_from_args(["-s", f.name, "foo"],
1451
 
                                          SetSecretCmd,
1452
 
                                          value_to_set=value)
1453
 
 
1454
 
    def test_approve(self):
1455
 
        self.assert_command_from_args(["--approve", "foo"],
1456
 
                                      ApproveCmd)
1457
 
 
1458
 
    def test_approve_short(self):
1459
 
        self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1460
 
 
1461
 
    def test_deny(self):
1462
 
        self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1463
 
 
1464
 
    def test_deny_short(self):
1465
 
        self.assert_command_from_args(["-D", "foo"], DenyCmd)
1466
 
 
1467
 
    def test_dump_json(self):
1468
 
        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1469
 
 
1470
 
    def test_is_enabled(self):
1471
 
        self.assert_command_from_args(["--is-enabled", "foo"],
1472
 
                                      IsEnabledCmd)
1473
 
 
1474
 
    def test_is_enabled_short(self):
1475
 
        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1476
 
 
1477
 
    def test_deny_before_remove(self):
1478
 
        options = self.parser.parse_args(["--deny", "--remove",
1479
 
                                          "foo"])
1480
 
        check_option_syntax(self.parser, options)
1481
 
        commands = commands_from_options(options)
1482
 
        self.assertEqual(len(commands), 2)
1483
 
        self.assertIsInstance(commands[0], DenyCmd)
1484
 
        self.assertIsInstance(commands[1], RemoveCmd)
1485
 
 
1486
 
    def test_deny_before_remove_reversed(self):
1487
 
        options = self.parser.parse_args(["--remove", "--deny",
1488
 
                                          "--all"])
1489
 
        check_option_syntax(self.parser, options)
1490
 
        commands = commands_from_options(options)
1491
 
        self.assertEqual(len(commands), 2)
1492
 
        self.assertIsInstance(commands[0], DenyCmd)
1493
 
        self.assertIsInstance(commands[1], RemoveCmd)
1494
 
 
1495
 
 
1496
 
class Test_check_option_syntax(unittest.TestCase):
1497
 
    # This mostly corresponds to the definition from has_actions() in
1498
 
    # check_option_syntax()
1499
 
    actions = {
1500
 
        # The actual values set here are not that important, but we do
1501
 
        # at least stick to the correct types, even though they are
1502
 
        # never used
1503
 
        "enable": True,
1504
 
        "disable": True,
1505
 
        "bump_timeout": True,
1506
 
        "start_checker": True,
1507
 
        "stop_checker": True,
1508
 
        "is_enabled": True,
1509
 
        "remove": True,
1510
 
        "checker": "x",
1511
 
        "timeout": datetime.timedelta(),
1512
 
        "extended_timeout": datetime.timedelta(),
1513
 
        "interval": datetime.timedelta(),
1514
 
        "approved_by_default": True,
1515
 
        "approval_delay": datetime.timedelta(),
1516
 
        "approval_duration": datetime.timedelta(),
1517
 
        "host": "x",
1518
 
        "secret": io.BytesIO(b"x"),
1519
 
        "approve": True,
1520
 
        "deny": True,
1521
 
    }
1522
 
 
1523
 
    def setUp(self):
1524
 
        self.parser = argparse.ArgumentParser()
1525
 
        add_command_line_options(self.parser)
1526
 
 
1527
 
    @contextlib.contextmanager
1528
 
    def assertParseError(self):
1529
 
        with self.assertRaises(SystemExit) as e:
1530
 
            with self.temporarily_suppress_stderr():
1531
 
                yield
1532
 
        # Exit code from argparse is guaranteed to be "2".  Reference:
1533
 
        # https://docs.python.org/3/library
1534
 
        # /argparse.html#exiting-methods
1535
 
        self.assertEqual(e.exception.code, 2)
1536
 
 
1537
 
    @staticmethod
1538
 
    @contextlib.contextmanager
1539
 
    def temporarily_suppress_stderr():
1540
 
        null = os.open(os.path.devnull, os.O_RDWR)
1541
 
        stderrcopy = os.dup(sys.stderr.fileno())
1542
 
        os.dup2(null, sys.stderr.fileno())
1543
 
        os.close(null)
1544
 
        try:
1545
 
            yield
1546
 
        finally:
1547
 
            # restore stderr
1548
 
            os.dup2(stderrcopy, sys.stderr.fileno())
1549
 
            os.close(stderrcopy)
1550
 
 
1551
 
    def check_option_syntax(self, options):
1552
 
        check_option_syntax(self.parser, options)
1553
 
 
1554
 
    def test_actions_requires_client_or_all(self):
1555
 
        for action, value in self.actions.items():
1556
 
            options = self.parser.parse_args()
1557
 
            setattr(options, action, value)
1558
 
            with self.assertParseError():
1559
 
                self.check_option_syntax(options)
1560
 
 
1561
 
    def test_actions_conflicts_with_verbose(self):
1562
 
        for action, value in self.actions.items():
1563
 
            options = self.parser.parse_args()
1564
 
            setattr(options, action, value)
1565
 
            options.verbose = True
1566
 
            with self.assertParseError():
1567
 
                self.check_option_syntax(options)
1568
 
 
1569
 
    def test_dump_json_conflicts_with_verbose(self):
1570
 
        options = self.parser.parse_args()
1571
 
        options.dump_json = True
1572
 
        options.verbose = True
1573
 
        with self.assertParseError():
1574
 
            self.check_option_syntax(options)
1575
 
 
1576
 
    def test_dump_json_conflicts_with_action(self):
1577
 
        for action, value in self.actions.items():
1578
 
            options = self.parser.parse_args()
1579
 
            setattr(options, action, value)
1580
 
            options.dump_json = True
1581
 
            with self.assertParseError():
1582
 
                self.check_option_syntax(options)
1583
 
 
1584
 
    def test_all_can_not_be_alone(self):
1585
 
        options = self.parser.parse_args()
1586
 
        options.all = True
1587
 
        with self.assertParseError():
1588
 
            self.check_option_syntax(options)
1589
 
 
1590
 
    def test_all_is_ok_with_any_action(self):
1591
 
        for action, value in self.actions.items():
1592
 
            options = self.parser.parse_args()
1593
 
            setattr(options, action, value)
1594
 
            options.all = True
1595
 
            self.check_option_syntax(options)
1596
 
 
1597
 
    def test_is_enabled_fails_without_client(self):
1598
 
        options = self.parser.parse_args()
1599
 
        options.is_enabled = True
1600
 
        with self.assertParseError():
1601
 
            self.check_option_syntax(options)
1602
 
 
1603
 
    def test_is_enabled_works_with_one_client(self):
1604
 
        options = self.parser.parse_args()
1605
 
        options.is_enabled = True
1606
 
        options.client = ["foo"]
1607
 
        self.check_option_syntax(options)
1608
 
 
1609
 
    def test_is_enabled_fails_with_two_clients(self):
1610
 
        options = self.parser.parse_args()
1611
 
        options.is_enabled = True
1612
 
        options.client = ["foo", "barbar"]
1613
 
        with self.assertParseError():
1614
 
            self.check_option_syntax(options)
1615
 
 
1616
 
    def test_remove_can_only_be_combined_with_action_deny(self):
1617
 
        for action, value in self.actions.items():
1618
 
            if action in {"remove", "deny"}:
1619
 
                continue
1620
 
            options = self.parser.parse_args()
1621
 
            setattr(options, action, value)
1622
 
            options.all = True
1623
 
            options.remove = True
1624
 
            with self.assertParseError():
1625
 
                self.check_option_syntax(options)
1626
 
 
1627
1672
 
1628
1673
 
1629
1674
def should_only_run_tests():