/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-06 22:24:59 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 382.
  • Revision ID: teddy@recompile.se-20190306222459-7q5j7dqwtiiwglg7
mandos-ctl.xml: Fix documentation bug

* mandos-ctl.xml (SYNOPSIS): Remove duplicate "--interval" option.

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 = int(round(value.total_seconds() * 1000))
 
319
        self._vts = string_to_delta(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
 
508
528
def add_command_line_options(parser):
509
529
    parser.add_argument("--version", action="version",
510
530
                        version="%(prog)s {}".format(version),
536
556
                        help="Remove client")
537
557
    parser.add_argument("-c", "--checker",
538
558
                        help="Set checker command for client")
539
 
    parser.add_argument("-t", "--timeout", type=string_to_delta,
 
559
    parser.add_argument("-t", "--timeout",
540
560
                        help="Set timeout for client")
541
 
    parser.add_argument("--extended-timeout", type=string_to_delta,
 
561
    parser.add_argument("--extended-timeout",
542
562
                        help="Set extended timeout for client")
543
 
    parser.add_argument("-i", "--interval", type=string_to_delta,
 
563
    parser.add_argument("-i", "--interval",
544
564
                        help="Set checker interval for client")
545
565
    approve_deny_default = parser.add_mutually_exclusive_group()
546
566
    approve_deny_default.add_argument(
551
571
        "--deny-by-default", action="store_false",
552
572
        dest="approved_by_default",
553
573
        help="Set client to be denied by default")
554
 
    parser.add_argument("--approval-delay", type=string_to_delta,
 
574
    parser.add_argument("--approval-delay",
555
575
                        help="Set delay before client approve/deny")
556
 
    parser.add_argument("--approval-duration", type=string_to_delta,
 
576
    parser.add_argument("--approval-duration",
557
577
                        help="Set duration of one client approval")
558
578
    parser.add_argument("-H", "--host", help="Set host for client")
559
579
    parser.add_argument("-s", "--secret",
651
671
 
652
672
    options = parser.parse_args()
653
673
 
654
 
    def has_actions(options):
655
 
        return any((options.enable,
656
 
                    options.disable,
657
 
                    options.bump_timeout,
658
 
                    options.start_checker,
659
 
                    options.stop_checker,
660
 
                    options.is_enabled,
661
 
                    options.remove,
662
 
                    options.checker is not None,
663
 
                    options.timeout is not None,
664
 
                    options.extended_timeout is not None,
665
 
                    options.interval is not None,
666
 
                    options.approved_by_default is not None,
667
 
                    options.approval_delay is not None,
668
 
                    options.approval_duration is not None,
669
 
                    options.host is not None,
670
 
                    options.secret is not None,
671
 
                    options.approve,
672
 
                    options.deny))
673
 
 
674
674
    if has_actions(options) and not (options.client or options.all):
675
675
        parser.error("Options require clients names or --all.")
676
676
    if options.verbose and has_actions(options):
1100
1100
class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):
1101
1101
    command = SetTimeoutCmd
1102
1102
    property = "Timeout"
1103
 
    values_to_set = [datetime.timedelta(),
1104
 
                     datetime.timedelta(minutes=5),
1105
 
                     datetime.timedelta(seconds=1),
1106
 
                     datetime.timedelta(weeks=1),
1107
 
                     datetime.timedelta(weeks=52)]
1108
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1103
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1104
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1109
1105
 
1110
1106
class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):
1111
1107
    command = SetExtendedTimeoutCmd
1112
1108
    property = "ExtendedTimeout"
1113
 
    values_to_set = [datetime.timedelta(),
1114
 
                     datetime.timedelta(minutes=5),
1115
 
                     datetime.timedelta(seconds=1),
1116
 
                     datetime.timedelta(weeks=1),
1117
 
                     datetime.timedelta(weeks=52)]
1118
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1109
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1110
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1119
1111
 
1120
1112
class TestSetIntervalCmd(TestValueArgumentPropertyCmd):
1121
1113
    command = SetIntervalCmd
1122
1114
    property = "Interval"
1123
 
    values_to_set = [datetime.timedelta(),
1124
 
                     datetime.timedelta(minutes=5),
1125
 
                     datetime.timedelta(seconds=1),
1126
 
                     datetime.timedelta(weeks=1),
1127
 
                     datetime.timedelta(weeks=52)]
1128
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1115
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1116
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1129
1117
 
1130
1118
class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):
1131
1119
    command = SetApprovalDelayCmd
1132
1120
    property = "ApprovalDelay"
1133
 
    values_to_set = [datetime.timedelta(),
1134
 
                     datetime.timedelta(minutes=5),
1135
 
                     datetime.timedelta(seconds=1),
1136
 
                     datetime.timedelta(weeks=1),
1137
 
                     datetime.timedelta(weeks=52)]
1138
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1121
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1122
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1139
1123
 
1140
1124
class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):
1141
1125
    command = SetApprovalDurationCmd
1142
1126
    property = "ApprovalDuration"
1143
 
    values_to_set = [datetime.timedelta(),
1144
 
                     datetime.timedelta(minutes=5),
1145
 
                     datetime.timedelta(seconds=1),
1146
 
                     datetime.timedelta(weeks=1),
1147
 
                     datetime.timedelta(weeks=52)]
1148
 
    values_to_get = [0, 300000, 1000, 604800000, 31449600000]
 
1127
    values_to_set = ["P0D", "PT5M", "PT1S", "PT120S", "P1Y"]
 
1128
    values_to_get = [0, 300000, 1000, 120000, 31449600000]
1149
1129
 
1150
1130
class Test_command_from_options(unittest.TestCase):
1151
1131
    def setUp(self):
1169
1149
        self.assert_command_from_args(["--verbose"], PrintTableCmd,
1170
1150
                                      verbose=True)
1171
1151
 
1172
 
    def test_print_table_verbose_short(self):
1173
 
        self.assert_command_from_args(["-v"], PrintTableCmd,
1174
 
                                      verbose=True)
1175
 
 
1176
1152
    def test_enable(self):
1177
1153
        self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1178
1154
 
1179
 
    def test_enable_short(self):
1180
 
        self.assert_command_from_args(["-e", "foo"], EnableCmd)
1181
 
 
1182
1155
    def test_disable(self):
1183
1156
        self.assert_command_from_args(["--disable", "foo"],
1184
1157
                                      DisableCmd)
1185
1158
 
1186
 
    def test_disable_short(self):
1187
 
        self.assert_command_from_args(["-d", "foo"], DisableCmd)
1188
 
 
1189
1159
    def test_bump_timeout(self):
1190
1160
        self.assert_command_from_args(["--bump-timeout", "foo"],
1191
1161
                                      BumpTimeoutCmd)
1192
1162
 
1193
 
    def test_bump_timeout_short(self):
1194
 
        self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1195
 
 
1196
1163
    def test_start_checker(self):
1197
1164
        self.assert_command_from_args(["--start-checker", "foo"],
1198
1165
                                      StartCheckerCmd)
1205
1172
        self.assert_command_from_args(["--remove", "foo"],
1206
1173
                                      RemoveCmd)
1207
1174
 
1208
 
    def test_remove_short(self):
1209
 
        self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1210
 
 
1211
1175
    def test_checker(self):
1212
1176
        self.assert_command_from_args(["--checker", ":", "foo"],
1213
1177
                                      SetCheckerCmd, value_to_set=":")
1214
1178
 
1215
 
    def test_checker_empty(self):
1216
 
        self.assert_command_from_args(["--checker", "", "foo"],
1217
 
                                      SetCheckerCmd, value_to_set="")
1218
 
 
1219
 
    def test_checker_short(self):
1220
 
        self.assert_command_from_args(["-c", ":", "foo"],
1221
 
                                      SetCheckerCmd, value_to_set=":")
1222
 
 
1223
1179
    def test_timeout(self):
1224
1180
        self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1225
1181
                                      SetTimeoutCmd,
1226
1182
                                      value_to_set=300000)
1227
1183
 
1228
 
    def test_timeout_short(self):
1229
 
        self.assert_command_from_args(["-t", "PT5M", "foo"],
1230
 
                                      SetTimeoutCmd,
1231
 
                                      value_to_set=300000)
1232
 
 
1233
1184
    def test_extended_timeout(self):
1234
1185
        self.assert_command_from_args(["--extended-timeout", "PT15M",
1235
1186
                                       "foo"],
1241
1192
                                      SetIntervalCmd,
1242
1193
                                      value_to_set=120000)
1243
1194
 
1244
 
    def test_interval_short(self):
1245
 
        self.assert_command_from_args(["-i", "PT2M", "foo"],
1246
 
                                      SetIntervalCmd,
1247
 
                                      value_to_set=120000)
1248
 
 
1249
1195
    def test_approve_by_default(self):
1250
1196
        self.assert_command_from_args(["--approve-by-default", "foo"],
1251
1197
                                      ApproveByDefaultCmd)
1269
1215
                                       "foo"], SetHostCmd,
1270
1216
                                      value_to_set="foo.example.org")
1271
1217
 
1272
 
    def test_host_short(self):
1273
 
        self.assert_command_from_args(["-H", "foo.example.org",
1274
 
                                       "foo"], SetHostCmd,
1275
 
                                      value_to_set="foo.example.org")
1276
 
 
1277
1218
    def test_secret_devnull(self):
1278
1219
        self.assert_command_from_args(["--secret", os.path.devnull,
1279
1220
                                       "foo"], SetSecretCmd,
1288
1229
                                           "foo"], SetSecretCmd,
1289
1230
                                          value_to_set=value)
1290
1231
 
1291
 
    def test_secret_devnull_short(self):
1292
 
        self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1293
 
                                      SetSecretCmd, value_to_set=b"")
1294
 
 
1295
 
    def test_secret_tempfile_short(self):
1296
 
        with tempfile.NamedTemporaryFile(mode="r+b") as f:
1297
 
            value = b"secret\0xyzzy\nbar"
1298
 
            f.write(value)
1299
 
            f.seek(0)
1300
 
            self.assert_command_from_args(["-s", f.name, "foo"],
1301
 
                                          SetSecretCmd,
1302
 
                                          value_to_set=value)
1303
 
 
1304
1232
    def test_approve(self):
1305
1233
        self.assert_command_from_args(["--approve", "foo"],
1306
1234
                                      ApproveCmd)
1307
1235
 
1308
 
    def test_approve_short(self):
1309
 
        self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1310
 
 
1311
1236
    def test_deny(self):
1312
1237
        self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1313
1238
 
1314
 
    def test_deny_short(self):
1315
 
        self.assert_command_from_args(["-D", "foo"], DenyCmd)
1316
 
 
1317
1239
    def test_dump_json(self):
1318
1240
        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1319
1241
 
1321
1243
        self.assert_command_from_args(["--is-enabled", "foo"],
1322
1244
                                      IsEnabledCmd)
1323
1245
 
1324
 
    def test_is_enabled_short(self):
1325
 
        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1326
 
 
1327
1246
 
1328
1247
 
1329
1248
def should_only_run_tests():