Beispiel #1
0
def parse_create(arg_list):
    groups = group_by_keywords(
        arg_list,
        set(["op", "meta", "clone", "promotable", "bundle"]),
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
        only_found_keywords=True,
    )

    parts = {
        "meta":  prepare_options(groups.get("meta", [])),
        "options":  prepare_options(groups.get("options", [])),
        "op": [
            prepare_options(op)
            for op in build_operations(groups.get("op", []))
        ],
    }

    if "clone" in groups:
        parts["clone"] = prepare_options(groups["clone"])
    if "promotable" in groups:
        parts["promotable"] = prepare_options(groups["promotable"])
    if "bundle" in groups:
        parts["bundle"] = groups["bundle"]

    return parts
Beispiel #2
0
 def test_raises_on_group_repeated_keywords_inconsistency(self):
     self.assertRaises(AssertionError, lambda: group_by_keywords(
         [],
         set(["first", "second"]),
         group_repeated_keywords=["first", "third"],
         implicit_first_group_key="third"
     ))
Beispiel #3
0
def parse_create(arg_list):
    groups = group_by_keywords(
        arg_list,
        set(["op", "meta", "clone", "master", "bundle"]),
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
        only_found_keywords=True,
    )

    parts = {
        "meta":  prepare_options(groups.get("meta", [])),
        "options":  prepare_options(groups.get("options", [])),
        "op": [
            prepare_options(op)
            for op in build_operations(groups.get("op", []))
        ],
    }

    if "clone" in groups:
        parts["clone"] = prepare_options(groups["clone"])

    if "master" in groups:
        parts["master"] = prepare_options(groups["master"])

    if "bundle" in groups:
        parts["bundle"] = groups["bundle"]

    return parts
Beispiel #4
0
def stonith_update_scsi_devices(lib, argv, modifiers):
    """
    Options:
      * --request-timeout - timeout for HTTP requests
      * --skip-offline - skip unreachable nodes
    """
    modifiers.ensure_only_supported("--request-timeout", "--skip-offline")
    if len(argv) < 2:
        raise CmdLineInputError()
    stonith_id = argv[0]
    parsed_args = parse_args.group_by_keywords(
        argv[1:],
        ["set"],
        keyword_repeat_allowed=False,
        only_found_keywords=True,
    )
    set_args = parsed_args["set"] if "set" in parsed_args else []
    if not set_args:
        raise CmdLineInputError(
            show_both_usage_and_message=True,
            hint="You must specify set devices to be updated",
        )
    force_flags = []
    if modifiers.get("--skip-offline"):
        force_flags.append(reports.codes.SKIP_OFFLINE_NODES)
    lib.stonith.update_scsi_devices(stonith_id,
                                    set_args,
                                    force_flags=force_flags)
Beispiel #5
0
def _parse_bundle_groups(arg_list):
    """
    Commandline options: no options
    """
    repeatable_keyword_list = ["port-map", "storage-map"]
    keyword_list = ["meta", "container", "network"] + repeatable_keyword_list
    groups = group_by_keywords(
        arg_list,
        set(keyword_list),
        group_repeated_keywords=repeatable_keyword_list,
        only_found_keywords=True,
    )
    for keyword in keyword_list:
        if keyword not in groups:
            continue
        if keyword in repeatable_keyword_list:
            for repeated_section in groups[keyword]:
                if not repeated_section:
                    raise CmdLineInputError(
                        "No {0} options specified".format(keyword))
        else:
            if not groups[keyword]:
                raise CmdLineInputError(
                    "No {0} options specified".format(keyword))
    return groups
Beispiel #6
0
def parse_clone(arg_list, promotable=False):
    parts = {
        "clone_id": None,
        "meta": {},
    }
    allowed_keywords = set(["op", "meta"])
    if (arg_list and arg_list[0] not in allowed_keywords
            and "=" not in arg_list[0]):
        parts["clone_id"] = arg_list.pop(0)
    groups = group_by_keywords(
        arg_list,
        allowed_keywords,
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
        only_found_keywords=True,
    )
    if "op" in groups:
        raise CmdLineInputError(
            "op settings must be changed on base resource, not the clone", )
    parts["meta"] = prepare_options(
        groups.get("options", []) + groups.get("meta", []), )
    if promotable:
        if "promotable" in parts["meta"]:
            raise CmdLineInputError(
                "you cannot specify both promotable option and promotable "
                "keyword")
        parts["meta"]["promotable"] = "true"
    return parts
Beispiel #7
0
def _parse_bundle_groups(arg_list):
    """
    Commandline options: no options
    """
    repeatable_keyword_list = ["port-map", "storage-map"]
    keyword_list = ["meta", "container", "network"] + repeatable_keyword_list
    groups = group_by_keywords(
        arg_list,
        set(keyword_list),
        group_repeated_keywords=repeatable_keyword_list,
        only_found_keywords=True,
    )
    for keyword in keyword_list:
        if keyword not in groups:
            continue
        if keyword in repeatable_keyword_list:
            for repeated_section in groups[keyword]:
                if not repeated_section:
                    raise CmdLineInputError(
                        "No {0} options specified".format(keyword)
                    )
        else:
            if not groups[keyword]:
                raise CmdLineInputError(
                    "No {0} options specified".format(keyword)
                )
    return groups
Beispiel #8
0
def config_setup(lib, arg_list, modifiers):
    """
    create booth config

    Options:
      * --force - overwrite existing
      * --booth-conf - booth config file
      * --booth-key - booth authkey file
      * --name - name of a booth instance
    """
    modifiers.ensure_only_supported(
        "--force",
        "--booth-conf",
        "--booth-key",
        "--name",
    )
    peers = group_by_keywords(arg_list,
                              set(["sites", "arbitrators"]),
                              keyword_repeat_allowed=False)
    if "sites" not in peers or not peers["sites"]:
        raise CmdLineInputError()

    booth_config = []
    for site in peers["sites"]:
        booth_config.append({"key": "site", "value": site, "details": []})
    for arbitrator in peers["arbitrators"]:
        booth_config.append({
            "key": "arbitrator",
            "value": arbitrator,
            "details": [],
        })

    lib.booth.config_setup(booth_config,
                           overwrite_existing=modifiers.get("--force"))
Beispiel #9
0
def config_setup(lib, arg_list, modifiers):
    """
    create booth config

    Options:
      * --force - overwrite existing
      * --booth-conf - booth config file
      * --booth-key - booth authkey file
      * --name - name of a booth instance
    """
    modifiers.ensure_only_supported(
        "--force", "--booth-conf", "--booth-key", "--name",
    )
    peers = group_by_keywords(
        arg_list, set(["sites", "arbitrators"]), keyword_repeat_allowed=False
    )
    if "sites" not in peers or not peers["sites"]:
        raise CmdLineInputError()

    lib.booth.config_setup(
        peers["sites"],
        peers["arbitrators"],
        instance_name=modifiers.get("--name"),
        overwrite_existing=modifiers.get("--force"),
    )
Beispiel #10
0
 def test_can_disallow_keywords_repeating(self):
     self.assertRaises(
         CmdLineInputError, lambda: group_by_keywords(
             ["first", 1, 2, "second", 3, "first"],
             set(["first", "second"]),
             keyword_repeat_allowed=False,
         ))
Beispiel #11
0
def _stonith_level_parse_target_and_stonith(argv):
    target_type, target_value, devices = None, None, None
    allowed_keywords = {"target", "stonith"}
    missing_target_value, missing_stonith_value = False, False
    groups = parse_args.group_by_keywords(
        argv,
        allowed_keywords,
        only_found_keywords=True,
    )
    if "target" in groups:
        if len(groups["target"]) > 1:
            raise CmdLineInputError("At most one target can be specified")
        if groups["target"]:
            target_type, target_value = _stonith_level_parse_node(
                groups["target"][0])
        else:
            missing_target_value = True
    if "stonith" in groups:
        if groups["stonith"]:
            devices = groups["stonith"]
        else:
            missing_stonith_value = True

    if missing_target_value and missing_stonith_value:
        raise CmdLineInputError("Missing value after 'target' and 'stonith'")
    if missing_target_value:
        raise CmdLineInputError("Missing value after 'target'")
    if missing_stonith_value:
        raise CmdLineInputError("Missing value after 'stonith'")

    return target_type, target_value, devices
Beispiel #12
0
 def test_raises_on_group_repeated_keywords_inconsistency(self):
     self.assertRaises(
         AssertionError, lambda: group_by_keywords(
             [],
             set(["first", "second"]),
             group_repeated_keywords=["first", "third"],
             implicit_first_group_key="third"))
Beispiel #13
0
 def test_group_repeating_keyword_occurences(self):
     self.assertEqual(
         group_by_keywords(["first", 1, 2, "second", 3, "first", 4],
                           set(["first", "second"]),
                           group_repeated_keywords=["first"]), {
                               "first": [[1, 2], [4]],
                               "second": [3],
                           })
Beispiel #14
0
 def test_raises_when_args_do_not_start_with_keyword_nor_implicit(self):
     self.assertRaises(
         CmdLineInputError,
         lambda: group_by_keywords(
             [0, "first", 1, 2, "second", 3],
             set(["first", "second"]),
         ),
     )
Beispiel #15
0
 def test_returns_dict_with_empty_lists_for_no_args(self):
     self.assertEqual(
         group_by_keywords([], set(["first", "second"])),
         {
             "first": [],
             "second": [],
         },
     )
Beispiel #16
0
 def test_implicit_first_kw_applyed_in_the_middle_when_is_in_kwds(self):
     self.assertEqual(
         group_by_keywords([1, 2, "first", 3, "zero", 4],
                           set(["first", "zero"]),
                           implicit_first_group_key="zero"), {
                               "zero": [1, 2, 4],
                               "first": [3],
                           })
Beispiel #17
0
 def test_split_with_implicit_first_keyword(self):
     self.assertEqual(
         group_by_keywords([0, "first", 1, 2, "second", 3],
                           set(["first", "second"]),
                           implicit_first_keyword="zero"), {
                               "zero": [0],
                               "first": [1, 2],
                               "second": [3],
                           })
Beispiel #18
0
 def test_splict_without_implict_keyword(self):
     self.assertEqual(
         group_by_keywords(
             ["first", 1, 2, "second", 3],
             set(["first", "second"]),
         ), {
             "first": [1, 2],
             "second": [3],
         })
Beispiel #19
0
 def test_allow_keywords_repeating(self):
     self.assertEqual(
         group_by_keywords(
             ["first", 1, 2, "second", 3, "first", 4],
             set(["first", "second"]),
         ), {
             "first": [1, 2, 4],
             "second": [3],
         })
Beispiel #20
0
 def test_returns_dict_with_empty_lists_for_no_opts_and_only_found_kws(
         self):
     self.assertEqual(
         group_by_keywords(
             ["first"],
             set(["first", "second"]),
             only_found_keywords=True,
         ), {
             "first": [],
         })
Beispiel #21
0
 def test_splict_without_implict_keyword(self):
     self.assertEqual(
         group_by_keywords(
             ["first", 1, 2, "second", 3],
             set(["first", "second"]),
         ),
         {
             "first": [1, 2],
             "second": [3],
         }
     )
Beispiel #22
0
 def test_returns_dict_with_empty_lists_for_no_args_implicit_case(self):
     self.assertEqual(
         group_by_keywords(
             [],
             set(["first", "second"]),
             implicit_first_keyword="zero",
         ), {
             "zero": [],
             "first": [],
             "second": [],
         })
Beispiel #23
0
 def test_allow_keywords_repeating(self):
     self.assertEqual(
         group_by_keywords(
             ["first", 1, 2, "second", 3, "first", 4],
             set(["first", "second"]),
         ),
         {
             "first": [1, 2, 4],
             "second": [3],
         }
     )
Beispiel #24
0
 def test_returns_dict_with_empty_lists_for_no_args(self):
     self.assertEqual(
         group_by_keywords(
             [],
             set(["first", "second"])
         ),
         {
             "first": [],
             "second": [],
         }
     )
Beispiel #25
0
 def test_returns_dict_with_empty_lists_for_no_opts_and_only_found_kws(self):
     self.assertEqual(
         group_by_keywords(
             ["first"],
             set(["first", "second"]),
             only_found_keywords=True,
         ),
         {
             "first": [],
         }
     )
Beispiel #26
0
 def test_group_repeating_keyword_occurences(self):
     self.assertEqual(
         group_by_keywords(
             ["first", 1, 2, "second", 3, "first", 4],
             set(["first", "second"]),
             group_repeated_keywords=["first"]
         ),
         {
             "first": [[1, 2], [4]],
             "second": [3],
         }
     )
Beispiel #27
0
 def test_implicit_first_kw_applyed_in_the_middle_when_is_in_kwds(self):
     self.assertEqual(
         group_by_keywords(
             [1, 2, "first", 3, "zero", 4],
             set(["first", "zero"]),
             implicit_first_group_key="zero"
         ),
         {
             "zero": [1, 2, 4],
             "first": [3],
         }
     )
Beispiel #28
0
 def test_empty_repeatable(self):
     self.assertEqual(
         group_by_keywords(
             ["second"],
             set(["first", "second"]),
             group_repeated_keywords=["second"],
             only_found_keywords=True,
         ), {
             "second": [
                 [],
             ],
         })
Beispiel #29
0
 def test_implicit_first_kw_not_applyed_in_the_middle(self):
     self.assertEqual(
         group_by_keywords(
             [1, 2, "first", 3, "zero", 4],
             set(["first"]),
             implicit_first_group_key="zero",
         ),
         {
             "zero": [1, 2],
             "first": [3, "zero", 4],
         },
     )
Beispiel #30
0
 def test_split_with_implicit_first_keyword(self):
     self.assertEqual(
         group_by_keywords(
             [0, "first", 1, 2, "second", 3],
             set(["first", "second"]),
             implicit_first_group_key="zero"
         ),
         {
             "zero": [0],
             "first": [1, 2],
             "second": [3],
         }
     )
Beispiel #31
0
def _parse_quorum_device_groups(arg_list):
    keyword_list = ["model", "heuristics"]
    groups = parse_args.group_by_keywords(arg_list,
                                          set(keyword_list),
                                          implicit_first_group_key="generic",
                                          keyword_repeat_allowed=False,
                                          only_found_keywords=True)
    for keyword in keyword_list:
        if keyword not in groups:
            continue
        if len(groups[keyword]) == 0:
            raise CmdLineInputError("No {0} options specified".format(keyword))
    return groups
Beispiel #32
0
 def test_returns_dict_with_empty_lists_for_no_args_implicit_case(self):
     self.assertEqual(
         group_by_keywords(
             [],
             set(["first", "second"]),
             implicit_first_group_key="zero",
         ),
         {
             "zero": [],
             "first": [],
             "second": [],
         }
     )
Beispiel #33
0
 def test_empty_repeatable(self):
     self.assertEqual(
         group_by_keywords(
             ["second"],
             set(["first", "second"]),
             group_repeated_keywords=["second"],
             only_found_keywords=True,
         ),
         {
             "second": [
                 [],
             ],
         }
     )
Beispiel #34
0
def tag_update(
    lib: Any,
    argv: Sequence[str],
    modifiers: InputModifiers,
) -> None:
    """
    Options:
      * -f - CIB file
      * --after - place a reference id in a tag after the specified reference
        id in the tag
      * --before - place a reference id in a tag before the specified reference
        id in the tag
    """
    modifiers.ensure_only_supported("-f", "--after", "--before")
    if not argv:
        raise CmdLineInputError()
    tag_id = argv[0]
    parsed_args = group_by_keywords(
        argv[1:],
        ["add", "remove"],
        keyword_repeat_allowed=False,
        only_found_keywords=True,
    )
    no_add_remove_arguments = ("add" not in parsed_args
                               and "remove" not in parsed_args)
    no_add_id = "add" in parsed_args and not parsed_args["add"]
    no_remove_id = "remove" in parsed_args and not parsed_args["remove"]
    if no_add_remove_arguments or no_add_id or no_remove_id:
        raise CmdLineInputError(
            show_both_usage_and_message=True,
            hint=("Specify at least one id for 'add' or 'remove' arguments."),
        )
    adjacent_idref = None
    after_adjacent = True
    if modifiers.is_specified("--after") and modifiers.is_specified(
            "--before"):
        raise CmdLineInputError("Cannot specify both --before and --after")
    if modifiers.is_specified("--after"):
        adjacent_idref = modifiers.get("--after")
        after_adjacent = True
    elif modifiers.is_specified("--before"):
        adjacent_idref = modifiers.get("--before")
        after_adjacent = False
    lib.tag.update(
        tag_id,
        parsed_args["add"] if "add" in parsed_args else [],
        parsed_args["remove"] if "remove" in parsed_args else [],
        adjacent_idref=adjacent_idref,
        put_after_adjacent=after_adjacent,
    )
Beispiel #35
0
 def test_returns_empty_lists_no_opts_and_only_found_kws_with_grouping(
         self):
     self.assertEqual(
         group_by_keywords(
             ["second", 1, "second", "second", 2, 3],
             set(["first", "second"]),
             group_repeated_keywords=["second"],
             only_found_keywords=True,
         ), {
             "second": [
                 [1],
                 [],
                 [2, 3],
             ],
         })
Beispiel #36
0
 def test_returns_empty_lists_no_opts_and_only_found_kws_with_grouping(self):
     self.assertEqual(
         group_by_keywords(
             ["second", 1, "second", "second", 2, 3],
             set(["first", "second"]),
             group_repeated_keywords=["second"],
             only_found_keywords=True,
         ),
         {
             "second": [
                 [1],
                 [],
                 [2, 3],
             ],
         }
     )
Beispiel #37
0
def _parse_quorum_device_groups(arg_list):
    keyword_list = ["model", "heuristics"]
    groups = parse_args.group_by_keywords(
        arg_list,
        set(keyword_list),
        implicit_first_group_key="generic",
        keyword_repeat_allowed=False,
        only_found_keywords=True
    )
    for keyword in keyword_list:
        if keyword not in groups:
            continue
        if not groups[keyword]:
            raise CmdLineInputError(
                "No {0} options specified".format(keyword)
            )
    return groups
Beispiel #38
0
def stonith_update_scsi_devices(lib, argv, modifiers):
    """
    Options:
      * --request-timeout - timeout for HTTP requests
      * --skip-offline - skip unreachable nodes
    """
    modifiers.ensure_only_supported("--request-timeout", "--skip-offline")
    force_flags = []
    if modifiers.get("--skip-offline"):
        force_flags.append(reports.codes.SKIP_OFFLINE_NODES)

    if len(argv) < 2:
        raise CmdLineInputError()
    stonith_id = argv[0]
    parsed_args = parse_args.group_by_keywords(
        argv[1:],
        ["set", "add", "remove", "delete"],
        keyword_repeat_allowed=False,
        only_found_keywords=True,
    )
    cmd_exception = CmdLineInputError(
        show_both_usage_and_message=True,
        hint=(
            "You must specify either list of set devices or at least one device"
            " for add or delete/remove devices"),
    )
    if "set" in parsed_args and {"add", "remove", "delete"} & set(
            parsed_args.keys()):
        raise cmd_exception
    if "set" in parsed_args:
        if not parsed_args["set"]:
            raise cmd_exception
        lib.stonith.update_scsi_devices(stonith_id,
                                        parsed_args["set"],
                                        force_flags=force_flags)
    else:
        for key in ("add", "remove", "delete"):
            if key in parsed_args and not parsed_args[key]:
                raise cmd_exception
        lib.stonith.update_scsi_devices_add_remove(
            stonith_id,
            parsed_args.get("add", []),
            parsed_args.get("delete", []) + parsed_args.get("remove", []),
            force_flags=force_flags,
        )
Beispiel #39
0
def parse_create(arg_list):
    groups = group_by_keywords(
        arg_list,
        set(["op", "meta", "clone", "promotable", "bundle"]),
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
        only_found_keywords=True,
    )

    try:
        parts = {
            "meta":
            prepare_options(groups.get("meta", [])),
            "options":
            prepare_options(groups.get("options", [])),
            "op": [
                prepare_options(op)
                for op in build_operations(groups.get("op", []))
            ],
        }

        if "clone" in groups:
            if groups["clone"] and "=" not in groups["clone"][0]:
                parts["clone_id"] = groups["clone"].pop(0)
            parts["clone"] = prepare_options(groups["clone"])
        if "promotable" in groups:
            if groups["promotable"] and "=" not in groups["promotable"][0]:
                parts["clone_id"] = groups["promotable"].pop(0)
            parts["promotable"] = prepare_options(groups["promotable"])
        if "bundle" in groups:
            parts["bundle"] = groups["bundle"]
    except CmdLineInputError as e:
        # Print error messages which point users to the changes section in pcs
        # manpage.
        # To be removed in the next significant version.
        if e.message == "missing value of 'master' option":
            raise CmdLineInputError(
                message=e.message,
                hint=("Master/Slave resources have been renamed to promotable "
                      "clones, please use the 'promotable' keyword instead of "
                      "'master'. " + SEE_MAN_CHANGES.format("0.10")),
            ) from e
        raise

    return parts
Beispiel #40
0
def parse_create_simple(arg_list):
    groups = group_by_keywords(
        arg_list,
        set(["op", "meta"]),
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
    )

    parts = {
        "meta":  prepare_options(groups.get("meta", [])),
        "options":  prepare_options(groups.get("options", [])),
        "op": [
            prepare_options(op)
            for op in build_operations(groups.get("op", []))
        ],
    }

    return parts
Beispiel #41
0
def parse_create_simple(arg_list):
    groups = group_by_keywords(
        arg_list,
        set(["op", "meta"]),
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
    )

    parts = {
        "meta":  prepare_options(groups.get("meta", [])),
        "options":  prepare_options(groups.get("options", [])),
        "op": [
            prepare_options(op)
            for op in build_operations(groups.get("op", []))
        ],
    }

    return parts
Beispiel #42
0
def cluster_setup(lib, argv, modifiers):
    DEFAULT_TRANSPORT_TYPE = KNET_KEYWORD
    if len(argv) < 2:
        raise CmdLineInputError()
    cluster_name, *argv = argv
    keywords = [TRANSPORT_KEYWORD, "totem", "quorum"]
    parsed_args = parse_args.group_by_keywords(
        argv,
        keywords,
        implicit_first_group_key="nodes",
        keyword_repeat_allowed=False,
        only_found_keywords=True,
    )
    nodes = [
        _parse_node_options(node, options)
        for node, options in parse_args.split_list_by_any_keywords(
            parsed_args["nodes"],
            "node name",
        ).items()
    ]

    transport_type = DEFAULT_TRANSPORT_TYPE
    transport_options = {}

    if TRANSPORT_KEYWORD in parsed_args:
        transport_type, transport_options = _parse_transport(
            parsed_args[TRANSPORT_KEYWORD])

    lib.cluster.setup(
        cluster_name,
        nodes,
        transport_type=transport_type,
        transport_options=transport_options.get(TRANSPORT_DEFAULT_SECTION, {}),
        link_list=transport_options.get(LINK_KEYWORD, []),
        compression_options=transport_options.get("compression", {}),
        crypto_options=transport_options.get("crypto", {}),
        totem_options=parse_args.prepare_options(parsed_args.get("totem", [])),
        quorum_options=parse_args.prepare_options(parsed_args.get(
            "quorum", [])),
        wait=modifiers["wait"],
        start=modifiers["start"],
        enable=modifiers["enable"],
        force=modifiers["force"],
        force_unresolvable=modifiers["force"])
Beispiel #43
0
def config_setup(lib, arg_list, modifiers):
    """
    create booth config
    """
    peers = group_by_keywords(arg_list,
                              set(["sites", "arbitrators"]),
                              keyword_repeat_allowed=False)
    if "sites" not in peers or not peers["sites"]:
        raise CmdLineInputError()

    booth_config = []
    for site in peers["sites"]:
        booth_config.append({"key": "site", "value": site, "details": []})
    for arbitrator in peers["arbitrators"]:
        booth_config.append({
            "key": "arbitrator",
            "value": arbitrator,
            "details": [],
        })

    lib.booth.config_setup(booth_config, modifiers["force"])
Beispiel #44
0
def config_setup(lib, arg_list, modifiers):
    """
    create booth config
    """
    peers = group_by_keywords(
        arg_list,
        set(["sites", "arbitrators"]),
        keyword_repeat_allowed=False
    )
    if "sites" not in peers or not peers["sites"]:
        raise CmdLineInputError()

    booth_config = []
    for site in peers["sites"]:
        booth_config.append({"key": "site", "value": site, "details": []})
    for arbitrator in peers["arbitrators"]:
        booth_config.append({
            "key": "arbitrator",
            "value": arbitrator,
            "details": [],
        })

    lib.booth.config_setup(booth_config, modifiers["force"])
Beispiel #45
0
def _parse_transport(transport_args):
    if len(transport_args) < 1:
        raise CmdLineInputError("{} type not defined".format(
            TRANSPORT_KEYWORD.capitalize()))
    transport_type, *transport_options = transport_args

    keywords = {"compression", "crypto", LINK_KEYWORD}
    parsed_options = parse_args.group_by_keywords(
        transport_options,
        keywords,
        implicit_first_group_key=TRANSPORT_DEFAULT_SECTION,
        group_repeated_keywords=[LINK_KEYWORD],
    )
    options = {
        section: parse_args.prepare_options(parsed_options[section])
        for section in keywords | {TRANSPORT_DEFAULT_SECTION}
        if section != LINK_KEYWORD
    }
    options[LINK_KEYWORD] = [
        parse_args.prepare_options(link_options)
        for link_options in parsed_options[LINK_KEYWORD]
    ]

    return transport_type, options
Beispiel #46
0
def parse_create(arg_list):
    groups = group_by_keywords(
        arg_list,
        set(["op", "meta", "clone", "promotable", "bundle"]),
        implicit_first_group_key="options",
        group_repeated_keywords=["op"],
        only_found_keywords=True,
    )

    try:
        parts = {
            "meta":
            prepare_options(groups.get("meta", [])),
            "options":
            prepare_options(groups.get("options", [])),
            "op": [
                prepare_options(op)
                for op in build_operations(groups.get("op", []))
            ],
        }

        if "clone" in groups:
            parts["clone"] = prepare_options(groups["clone"])
        if "promotable" in groups:
            parts["promotable"] = prepare_options(groups["promotable"])
        if "bundle" in groups:
            parts["bundle"] = groups["bundle"]
    except CmdLineInputError as e:
        # Print error messages which point users to the changes section in pcs
        # manpage.
        # To be removed in the next significant version.
        if e.message == "missing value of 'master' option":
            raise CmdLineInputError(message=e.message, hint=HINT_SYNTAX_CHANGE)
        raise e

    return parts
Beispiel #47
0
 def test_raises_when_args_do_not_start_with_keyword_nor_implicit(self):
     self.assertRaises(CmdLineInputError, lambda: group_by_keywords(
         [0, "first", 1, 2, "second", 3],
         set(["first", "second"]),
     ))
Beispiel #48
0
 def test_can_disallow_keywords_repeating(self):
     self.assertRaises(CmdLineInputError, lambda: group_by_keywords(
         ["first", 1, 2, "second", 3, "first"],
         set(["first", "second"]),
         keyword_repeat_allowed=False,
     ))