/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-07 21:38:47 UTC
  • Revision ID: teddy@recompile.se-20190307213847-9ans204sp9s3ki1s
mandos-ctl.xml: Move most normal command to top of synopsis

* mandos-ctl.xml (SYNOPSIS): Move --verbose | --dump-json to top.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
316
316
    @value_to_set.setter
317
317
    def value_to_set(self, value):
318
318
        """When setting, convert value to a datetime.timedelta"""
319
 
        self._vts = string_to_delta(value).total_seconds() * 1000
 
319
        self._vts = int(round(value.total_seconds() * 1000))
320
320
 
321
321
# Actual (non-abstract) command classes
322
322
 
505
505
                             MillisecondsValueArgumentMixIn):
506
506
    property = "ApprovalDuration"
507
507
 
508
 
def has_actions(options):
509
 
    return any((options.enable,
510
 
                options.disable,
511
 
                options.bump_timeout,
512
 
                options.start_checker,
513
 
                options.stop_checker,
514
 
                options.is_enabled,
515
 
                options.remove,
516
 
                options.checker is not None,
517
 
                options.timeout is not None,
518
 
                options.extended_timeout is not None,
519
 
                options.interval is not None,
520
 
                options.approved_by_default is not None,
521
 
                options.approval_delay is not None,
522
 
                options.approval_duration is not None,
523
 
                options.host is not None,
524
 
                options.secret is not None,
525
 
                options.approve,
526
 
                options.deny))
527
 
 
528
508
def add_command_line_options(parser):
529
509
    parser.add_argument("--version", action="version",
530
510
                        version="%(prog)s {}".format(version),
556
536
                        help="Remove client")
557
537
    parser.add_argument("-c", "--checker",
558
538
                        help="Set checker command for client")
559
 
    parser.add_argument("-t", "--timeout",
 
539
    parser.add_argument("-t", "--timeout", type=string_to_delta,
560
540
                        help="Set timeout for client")
561
 
    parser.add_argument("--extended-timeout",
 
541
    parser.add_argument("--extended-timeout", type=string_to_delta,
562
542
                        help="Set extended timeout for client")
563
 
    parser.add_argument("-i", "--interval",
 
543
    parser.add_argument("-i", "--interval", type=string_to_delta,
564
544
                        help="Set checker interval for client")
565
545
    approve_deny_default = parser.add_mutually_exclusive_group()
566
546
    approve_deny_default.add_argument(
571
551
        "--deny-by-default", action="store_false",
572
552
        dest="approved_by_default",
573
553
        help="Set client to be denied by default")
574
 
    parser.add_argument("--approval-delay",
 
554
    parser.add_argument("--approval-delay", type=string_to_delta,
575
555
                        help="Set delay before client approve/deny")
576
 
    parser.add_argument("--approval-duration",
 
556
    parser.add_argument("--approval-duration", type=string_to_delta,
577
557
                        help="Set duration of one client approval")
578
558
    parser.add_argument("-H", "--host", help="Set host for client")
579
559
    parser.add_argument("-s", "--secret",
664
644
    return commands
665
645
 
666
646
 
667
 
def main():
668
 
    parser = argparse.ArgumentParser()
669
 
 
670
 
    add_command_line_options(parser)
671
 
 
672
 
    options = parser.parse_args()
 
647
def check_option_syntax(parser, options):
 
648
 
 
649
    def has_actions(options):
 
650
        return any((options.enable,
 
651
                    options.disable,
 
652
                    options.bump_timeout,
 
653
                    options.start_checker,
 
654
                    options.stop_checker,
 
655
                    options.is_enabled,
 
656
                    options.remove,
 
657
                    options.checker is not None,
 
658
                    options.timeout is not None,
 
659
                    options.extended_timeout is not None,
 
660
                    options.interval is not None,
 
661
                    options.approved_by_default is not None,
 
662
                    options.approval_delay is not None,
 
663
                    options.approval_duration is not None,
 
664
                    options.host is not None,
 
665
                    options.secret is not None,
 
666
                    options.approve,
 
667
                    options.deny))
673
668
 
674
669
    if has_actions(options) and not (options.client or options.all):
675
670
        parser.error("Options require clients names or --all.")
683
678
    if options.is_enabled and len(options.client) > 1:
684
679
        parser.error("--is-enabled requires exactly one client")
685
680
 
 
681
 
 
682
def main():
 
683
    parser = argparse.ArgumentParser()
 
684
 
 
685
    add_command_line_options(parser)
 
686
 
 
687
    options = parser.parse_args()
 
688
 
 
689
    check_option_syntax(parser, options)
 
690
 
686
691
    clientnames = options.client
687
692
 
688
693
    try:
1100
1105
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1101
1106
    command = SetTimeoutCmd
1102
1107
    property = "Timeout"
1103
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1104
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1108
    values_to_set = [datetime.timedelta(),
 
1109
                     datetime.timedelta(minutes=5),
 
1110
                     datetime.timedelta(seconds=1),
 
1111
                     datetime.timedelta(weeks=1),
 
1112
                     datetime.timedelta(weeks=52)]
 
1113
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1105
1114
 
1106
1115
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1107
1116
    command = SetExtendedTimeoutCmd
1108
1117
    property = "ExtendedTimeout"
1109
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1110
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1118
    values_to_set = [datetime.timedelta(),
 
1119
                     datetime.timedelta(minutes=5),
 
1120
                     datetime.timedelta(seconds=1),
 
1121
                     datetime.timedelta(weeks=1),
 
1122
                     datetime.timedelta(weeks=52)]
 
1123
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1111
1124
 
1112
1125
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1113
1126
    command = SetIntervalCmd
1114
1127
    property = "Interval"
1115
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1116
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1128
    values_to_set = [datetime.timedelta(),
 
1129
                     datetime.timedelta(minutes=5),
 
1130
                     datetime.timedelta(seconds=1),
 
1131
                     datetime.timedelta(weeks=1),
 
1132
                     datetime.timedelta(weeks=52)]
 
1133
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1117
1134
 
1118
1135
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1119
1136
    command = SetApprovalDelayCmd
1120
1137
    property = "ApprovalDelay"
1121
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1122
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1138
    values_to_set = [datetime.timedelta(),
 
1139
                     datetime.timedelta(minutes=5),
 
1140
                     datetime.timedelta(seconds=1),
 
1141
                     datetime.timedelta(weeks=1),
 
1142
                     datetime.timedelta(weeks=52)]
 
1143
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1123
1144
 
1124
1145
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1125
1146
    command = SetApprovalDurationCmd
1126
1147
    property = "ApprovalDuration"
1127
 
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
1128
 
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
 
1148
    values_to_set = [datetime.timedelta(),
 
1149
                     datetime.timedelta(minutes=5),
 
1150
                     datetime.timedelta(seconds=1),
 
1151
                     datetime.timedelta(weeks=1),
 
1152
                     datetime.timedelta(weeks=52)]
 
1153
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1129
1154
 
1130
1155
class Test_command_from_options(unittest.TestCase):
1131
1156
    def setUp(self):
1135
1160
        """Assert that parsing ARGS should result in an instance of
1136
1161
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1137
1162
        options = self.parser.parse_args(args)
 
1163
        check_option_syntax(self.parser, options)
1138
1164
        commands = commands_from_options(options)
1139
1165
        self.assertEqual(len(commands), 1)
1140
1166
        command = commands[0]
1149
1175
        self.assert_command_from_args(["--verbose"], PrintTableCmd,
1150
1176
                                      verbose=True)
1151
1177
 
 
1178
    def test_print_table_verbose_short(self):
 
1179
        self.assert_command_from_args(["-v"], PrintTableCmd,
 
1180
                                      verbose=True)
 
1181
 
1152
1182
    def test_enable(self):
1153
1183
        self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1154
1184
 
 
1185
    def test_enable_short(self):
 
1186
        self.assert_command_from_args(["-e", "foo"], EnableCmd)
 
1187
 
1155
1188
    def test_disable(self):
1156
1189
        self.assert_command_from_args(["--disable", "foo"],
1157
1190
                                      DisableCmd)
1158
1191
 
 
1192
    def test_disable_short(self):
 
1193
        self.assert_command_from_args(["-d", "foo"], DisableCmd)
 
1194
 
1159
1195
    def test_bump_timeout(self):
1160
1196
        self.assert_command_from_args(["--bump-timeout", "foo"],
1161
1197
                                      BumpTimeoutCmd)
1162
1198
 
 
1199
    def test_bump_timeout_short(self):
 
1200
        self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
 
1201
 
1163
1202
    def test_start_checker(self):
1164
1203
        self.assert_command_from_args(["--start-checker", "foo"],
1165
1204
                                      StartCheckerCmd)
1172
1211
        self.assert_command_from_args(["--remove", "foo"],
1173
1212
                                      RemoveCmd)
1174
1213
 
 
1214
    def test_remove_short(self):
 
1215
        self.assert_command_from_args(["-r", "foo"], RemoveCmd)
 
1216
 
1175
1217
    def test_checker(self):
1176
1218
        self.assert_command_from_args(["--checker", ":", "foo"],
1177
1219
                                      SetCheckerCmd, value_to_set=":")
1178
1220
 
 
1221
    def test_checker_empty(self):
 
1222
        self.assert_command_from_args(["--checker", "", "foo"],
 
1223
                                      SetCheckerCmd, value_to_set="")
 
1224
 
 
1225
    def test_checker_short(self):
 
1226
        self.assert_command_from_args(["-c", ":", "foo"],
 
1227
                                      SetCheckerCmd, value_to_set=":")
 
1228
 
1179
1229
    def test_timeout(self):
1180
1230
        self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1181
1231
                                      SetTimeoutCmd,
1182
1232
                                      value_to_set=300000)
1183
1233
 
 
1234
    def test_timeout_short(self):
 
1235
        self.assert_command_from_args(["-t", "PT5M", "foo"],
 
1236
                                      SetTimeoutCmd,
 
1237
                                      value_to_set=300000)
 
1238
 
1184
1239
    def test_extended_timeout(self):
1185
1240
        self.assert_command_from_args(["--extended-timeout", "PT15M",
1186
1241
                                       "foo"],
1192
1247
                                      SetIntervalCmd,
1193
1248
                                      value_to_set=120000)
1194
1249
 
 
1250
    def test_interval_short(self):
 
1251
        self.assert_command_from_args(["-i", "PT2M", "foo"],
 
1252
                                      SetIntervalCmd,
 
1253
                                      value_to_set=120000)
 
1254
 
1195
1255
    def test_approve_by_default(self):
1196
1256
        self.assert_command_from_args(["--approve-by-default", "foo"],
1197
1257
                                      ApproveByDefaultCmd)
1215
1275
                                       "foo"], SetHostCmd,
1216
1276
                                      value_to_set="foo.example.org")
1217
1277
 
 
1278
    def test_host_short(self):
 
1279
        self.assert_command_from_args(["-H", "foo.example.org",
 
1280
                                       "foo"], SetHostCmd,
 
1281
                                      value_to_set="foo.example.org")
 
1282
 
1218
1283
    def test_secret_devnull(self):
1219
1284
        self.assert_command_from_args(["--secret", os.path.devnull,
1220
1285
                                       "foo"], SetSecretCmd,
1229
1294
                                           "foo"], SetSecretCmd,
1230
1295
                                          value_to_set=value)
1231
1296
 
 
1297
    def test_secret_devnull_short(self):
 
1298
        self.assert_command_from_args(["-s", os.path.devnull, "foo"],
 
1299
                                      SetSecretCmd, value_to_set=b"")
 
1300
 
 
1301
    def test_secret_tempfile_short(self):
 
1302
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
 
1303
            value = b"secret\0xyzzy\nbar"
 
1304
            f.write(value)
 
1305
            f.seek(0)
 
1306
            self.assert_command_from_args(["-s", f.name, "foo"],
 
1307
                                          SetSecretCmd,
 
1308
                                          value_to_set=value)
 
1309
 
1232
1310
    def test_approve(self):
1233
1311
        self.assert_command_from_args(["--approve", "foo"],
1234
1312
                                      ApproveCmd)
1235
1313
 
 
1314
    def test_approve_short(self):
 
1315
        self.assert_command_from_args(["-A", "foo"], ApproveCmd)
 
1316
 
1236
1317
    def test_deny(self):
1237
1318
        self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1238
1319
 
 
1320
    def test_deny_short(self):
 
1321
        self.assert_command_from_args(["-D", "foo"], DenyCmd)
 
1322
 
1239
1323
    def test_dump_json(self):
1240
1324
        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1241
1325
 
1243
1327
        self.assert_command_from_args(["--is-enabled", "foo"],
1244
1328
                                      IsEnabledCmd)
1245
1329
 
 
1330
    def test_is_enabled_short(self):
 
1331
        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
 
1332
 
1246
1333
 
1247
1334
 
1248
1335
def should_only_run_tests():