def opts_table_cb_md_only(api_inst, opts, opts_new):
# if the user didn't specify linked-md-only we're done
if not opts[LI_MD_ONLY]:
return
# li_md_only implies no li_pkg_updates
if LI_PKG_UPDATES in opts:
opts_new[LI_PKG_UPDATES] = False
#
# if li_md_only is false that means we're not updating any packages
# within the current image so there are a ton of options that no
# longer apply to the current operation, and hence are incompatible
# with li_md_only.
#
arg1 = LI_MD_ONLY
if BE_NAME in opts and opts[BE_NAME]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT, [arg1, BE_NAME])
if DENY_NEW_BE in opts and opts[DENY_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, DENY_NEW_BE])
if REQUIRE_NEW_BE in opts and opts[REQUIRE_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, REQUIRE_NEW_BE])
if LI_PARENT_SYNC in opts and not opts[LI_PARENT_SYNC]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[arg1, LI_PARENT_SYNC])
if REJECT_PATS in opts and opts[REJECT_PATS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, REJECT_PATS])
def __parse_linked_props(args):
""""Parse linked image property options that were specified on the
command line into a dictionary. Make sure duplicate properties were
not specified."""
linked_props = dict()
for pv in args:
try:
p, v = pv.split("=", 1)
except ValueError:
raise InvalidOptionError(
msg=_("linked image "
"property arguments must be of the form "
"'<name>=<value>'."))
if p not in li.prop_values:
raise InvalidOptionError(msg=_("invalid linked "
"image property: '{0}'.").format(p))
if p in linked_props:
raise InvalidOptionError(
msg=_("linked image "
"property specified multiple times: "
"'{0}'.").format(p))
linked_props[p] = v
return linked_props
def opts_table_cb_li_recurse(api_inst, opts, opts_new):
del opts_new[LI_ERECURSE_INCL]
del opts_new[LI_ERECURSE_EXCL]
del opts_new[LI_ERECURSE_ALL]
if opts[LI_ERECURSE_EXCL] and not opts[LI_ERECURSE_ALL]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[LI_ERECURSE_EXCL, LI_ERECURSE_ALL])
if opts[LI_ERECURSE_INCL] and not opts[LI_ERECURSE_ALL]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[LI_ERECURSE_INCL, LI_ERECURSE_ALL])
if opts[LI_ERECURSE_INCL] and opts[LI_ERECURSE_EXCL]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_ERECURSE_INCL, LI_ERECURSE_EXCL])
if not opts[LI_ERECURSE_ALL]:
opts_new[LI_ERECURSE] = None
return
# Go through all children and check if they are in the recurse list.
li_child_targets = []
li_child_list = set(
[lin for lin, rel, path in api_inst.list_linked() if rel == "child"])
def parse_lin(ulin):
lin = None
try:
lin = api_inst.parse_linked_name(ulin, allow_unknown=True)
except LinkedImageException as e:
try:
lin = api_inst.parse_linked_name("zone:{0}".format(ulin),
allow_unknown=True)
except LinkedImageException as e:
pass
if lin is None or lin not in li_child_list:
raise InvalidOptionError(msg=_("invalid linked image or zone name "
"'{0}'.").format(ulin))
return lin
if opts[LI_ERECURSE_INCL]:
# include list specified
for ulin in opts[LI_ERECURSE_INCL]:
li_child_targets.append(parse_lin(ulin))
opts_new[LI_ERECURSE] = li_child_targets
else:
# exclude list specified
for ulin in opts[LI_ERECURSE_EXCL]:
li_child_list.remove(parse_lin(ulin))
opts_new[LI_ERECURSE] = li_child_list
# If we use image recursion we need to make sure uninstall and update
# ignore non-existing packages in the parent image.
if opts_new[LI_ERECURSE] and IGNORE_MISSING in opts:
opts_new[IGNORE_MISSING] = True
def opts_table_cb_pub_search(api_inst, opts, opts_new):
if opts[SEARCH_BEFORE] and opts[SEARCH_AFTER]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[SEARCH_BEFORE, SEARCH_AFTER])
if opts[SEARCH_BEFORE] and opts[SEARCH_FIRST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[SEARCH_BEFORE, SEARCH_FIRST])
if opts[SEARCH_AFTER] and opts[SEARCH_FIRST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[SEARCH_AFTER, SEARCH_FIRST])
def opts_table_cb_parsable(api_inst, opts, opts_new):
if opts[PARSABLE_VERSION] and opts.get(VERBOSE, False):
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[VERBOSE, PARSABLE_VERSION])
if opts[PARSABLE_VERSION]:
try:
opts_new[PARSABLE_VERSION] = int(opts[PARSABLE_VERSION])
except ValueError:
raise InvalidOptionError(options=[PARSABLE_VERSION],
msg=_("integer argument expected"))
global_settings.client_output_parsable_version = \
opts_new[PARSABLE_VERSION]
opts_new[QUIET] = True
global_settings.client_output_quiet = True
def opts_table_cb_li_ignore(api_inst, opts, opts_new):
# synthesize li_ignore_all and li_ignore_list into li_ignore
del opts_new[LI_IGNORE_ALL]
del opts_new[LI_IGNORE_LIST]
opts_new[LI_IGNORE] = None
# check if there's nothing to ignore
if not opts[LI_IGNORE_ALL] and not opts[LI_IGNORE_LIST]:
return
if opts[LI_IGNORE_ALL]:
# can't ignore all and specific images
if opts[LI_IGNORE_LIST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_ALL, LI_IGNORE_LIST])
# can't ignore all and target anything.
if LI_TARGET_ALL in opts and opts[LI_TARGET_ALL]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_ALL, LI_TARGET_ALL])
if LI_TARGET_LIST in opts and opts[LI_TARGET_LIST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_ALL, LI_TARGET_LIST])
if LI_NAME in opts and opts[LI_NAME]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_ALL, LI_NAME])
opts_new[LI_IGNORE] = []
return
assert opts[LI_IGNORE_LIST]
# it doesn't make sense to specify images to ignore if the
# user is already specifying images to operate on.
if LI_TARGET_ALL in opts and opts[LI_TARGET_ALL]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_LIST, LI_TARGET_ALL])
if LI_TARGET_LIST in opts and opts[LI_TARGET_LIST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_LIST, LI_TARGET_LIST])
if LI_NAME in opts and opts[LI_NAME]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_IGNORE_LIST, LI_NAME])
li_ignore = []
for li_name in opts[LI_IGNORE_LIST]:
# check for repeats
if li_name in li_ignore:
raise InvalidOptionError(
InvalidOptionError.ARG_REPEAT, [li_name,
LI_IGNORE_LIST])
# add to ignore list
li_ignore.append(li_name)
opts_new[LI_IGNORE] = api_inst.parse_linked_name_list(li_ignore)
def opts_table_cb_stage(api_inst, opts, opts_new):
if opts[STAGE] == None:
opts_new[STAGE] = pkgdefs.API_STAGE_DEFAULT
return
if opts_new[STAGE] not in pkgdefs.api_stage_values:
raise InvalidOptionError(msg=_("invalid operation stage: "
"'{0}'").format(opts[STAGE]))
def opts_table_cb_li_no_psync(api_inst, opts, opts_new):
# if a target child linked image was specified, the no-parent-sync
# option doesn't make sense since we know that both the parent and
# child image are accessible
if LI_TARGET_ALL not in opts:
# we don't accept linked image target options
assert LI_TARGET_LIST not in opts
return
if opts[LI_TARGET_ALL] and not opts[LI_PARENT_SYNC]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[LI_TARGET_ALL, LI_PARENT_SYNC])
if opts[LI_TARGET_LIST] and not opts[LI_PARENT_SYNC]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[LI_TARGET_LIST, LI_PARENT_SYNC])
def opts_cb_fd(k, api_inst, opts, opts_new):
opts_cb_int(k, api_inst, opts, opts_new, minimum=0)
err = _("value '{0}' invalid").format(opts_new[k])
try:
os.fstat(opts_new[k])
except OSError:
# not a valid file descriptor
raise InvalidOptionError(msg=err, options=[k])
def opts_cb_li_attach(api_inst, opts, opts_new):
if opts[ATTACH_PARENT] and opts[ATTACH_CHILD]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[ATTACH_PARENT, ATTACH_CHILD])
if not opts[ATTACH_PARENT] and not opts[ATTACH_CHILD]:
raise InvalidOptionError(InvalidOptionError.XOR,
[ATTACH_PARENT, ATTACH_CHILD])
if opts[ATTACH_CHILD]:
# if we're attaching a new child then that doesn't affect
# any other children, so ignoring them doesn't make sense.
if opts[LI_IGNORE_ALL]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[ATTACH_CHILD, LI_IGNORE_ALL])
if opts[LI_IGNORE_LIST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[ATTACH_CHILD, LI_IGNORE_LIST])
def __parse_set_props(args):
""""Parse set property options that were specified on the command
line into a dictionary. Make sure duplicate properties were not
specified."""
set_props = dict()
for pv in args:
try:
p, v = pv.split("=", 1)
except ValueError:
raise InvalidOptionError(msg=_("properties to be set "
"must be of the form '<name>=<value>'. This is "
"what was given: {0}").format(pv))
if p in set_props:
raise InvalidOptionError(msg=_("a property may only "
"be set once in a command. {0} was set twice"
).format(p))
set_props[p] = v
return set_props
def opts_cb_list(api_inst, opts, opts_new):
if opts_new[ORIGINS] and opts_new[LIST_UPGRADABLE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[ORIGINS, LIST_UPGRADABLE])
if opts_new[ORIGINS] and not opts_new[LIST_NEWEST]:
# Use of -g implies -a unless -n is provided.
opts_new[LIST_INSTALLED_NEWEST] = True
if opts_new[LIST_ALL] and not opts_new[LIST_INSTALLED_NEWEST]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[LIST_ALL, LIST_INSTALLED_NEWEST])
if opts_new[LIST_INSTALLED_NEWEST] and opts_new[LIST_NEWEST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LIST_INSTALLED_NEWEST, LIST_NEWEST])
if opts_new[LIST_INSTALLED_NEWEST] and opts_new[LIST_UPGRADABLE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LIST_INSTALLED_NEWEST, LIST_UPGRADABLE])
if opts_new[SUMMARY] and opts_new[VERBOSE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[SUMMARY, VERBOSE])
if opts_new[QUIET] and opts_new[VERBOSE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT, [QUIET, VERBOSE])
def opts_table_cb_li_target1(api_inst, opts, opts_new):
# figure out which option the user specified
if opts[LI_NAME]:
arg1 = LI_NAME
else:
return
if BE_ACTIVATE in opts and not opts[BE_ACTIVATE]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[arg1, BE_ACTIVATE])
if BE_NAME in opts and opts[BE_NAME]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, BE_NAME])
if DENY_NEW_BE in opts and opts[DENY_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, DENY_NEW_BE])
if REQUIRE_NEW_BE in opts and opts[REQUIRE_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, REQUIRE_NEW_BE])
if REJECT_PATS in opts and opts[REJECT_PATS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, REJECT_PATS])
if ORIGINS in opts and opts[ORIGINS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, ORIGINS])
def opts_table_cb_info(api_inst, opts, opts_new):
opts_new[ORIGINS] = set()
for e in opts[ORIGINS]:
opts_new[ORIGINS].add(misc.parse_uri(e, cwd=_orig_cwd))
if opts[ORIGINS]:
opts_new[INFO_REMOTE] = True
if opts[QUIET]:
global_settings.client_output_quiet = True
if not opts_new[INFO_LOCAL] and not opts_new[INFO_REMOTE]:
opts_new[INFO_LOCAL] = True
elif opts_new[INFO_LOCAL] and opts_new[INFO_REMOTE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[INFO_LOCAL, INFO_REMOTE])
def opts_table_cb_beopts(api_inst, opts, opts_new):
# synthesize require_new_be and deny_new_be into new_be
del opts_new[REQUIRE_NEW_BE]
del opts_new[DENY_NEW_BE]
opts_new[NEW_BE] = None
if (opts[BE_NAME] or opts[REQUIRE_NEW_BE]) and opts[DENY_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REQUIRE_NEW_BE, DENY_NEW_BE])
# create a new key called BACKUP_BE in the options array
if opts[REQUIRE_NEW_BE] or opts[BE_NAME]:
opts_new[NEW_BE] = True
if opts[DENY_NEW_BE]:
opts_new[NEW_BE] = False
# synthesize require_backup_be and no_backup_be into backup_be
del opts_new[REQUIRE_BACKUP_BE]
del opts_new[NO_BACKUP_BE]
opts_new[BACKUP_BE] = None
if (opts[REQUIRE_BACKUP_BE] or opts[BACKUP_BE_NAME]) and \
opts[NO_BACKUP_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REQUIRE_BACKUP_BE, NO_BACKUP_BE])
if (opts[REQUIRE_BACKUP_BE] or opts[BACKUP_BE_NAME]) and \
(opts[REQUIRE_NEW_BE] or opts[BE_NAME]):
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REQUIRE_BACKUP_BE, REQUIRE_NEW_BE])
# create a new key called BACKUP_BE in the options array
if opts[REQUIRE_BACKUP_BE] or opts[BACKUP_BE_NAME]:
opts_new[BACKUP_BE] = True
if opts[NO_BACKUP_BE]:
opts_new[BACKUP_BE] = False
def opts_cb_int(k, api_inst, opts, opts_new, minimum=None):
if k not in opts or opts[k] == None:
err = _("missing required parameter")
raise InvalidOptionError(msg=err, options=[k])
# get the original argument value
v = opts[k]
# make sure it is an integer
try:
v = int(v)
except (ValueError, TypeError):
# not a valid integer
err = _("value '{0}' invalid").format(v)
raise InvalidOptionError(msg=err, options=[k])
# check the minimum bounds
if minimum is not None and v < minimum:
err = _("value must be >= {0:d}").format(minimum)
raise InvalidOptionError(msg=err, options=[k])
# update the new options array to make the value an integer
opts_new[k] = v
def parse_lin(ulin):
lin = None
try:
lin = api_inst.parse_linked_name(ulin, allow_unknown=True)
except LinkedImageException as e:
try:
lin = api_inst.parse_linked_name("zone:{0}".format(ulin),
allow_unknown=True)
except LinkedImageException as e:
pass
if lin is None or lin not in li_child_list:
raise InvalidOptionError(msg=_("invalid linked image or zone name "
"'{0}'.").format(ulin))
return lin
def opts_table_cb_li_target(api_inst, opts, opts_new):
# figure out which option the user specified
if opts[LI_TARGET_ALL] and opts[LI_TARGET_LIST]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[LI_TARGET_ALL, LI_TARGET_LIST])
elif opts[LI_TARGET_ALL]:
arg1 = LI_TARGET_ALL
elif opts[LI_TARGET_LIST]:
arg1 = LI_TARGET_LIST
else:
return
if BE_ACTIVATE in opts and not opts[BE_ACTIVATE]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[arg1, BE_ACTIVATE])
if BE_NAME in opts and opts[BE_NAME]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, BE_NAME])
if DENY_NEW_BE in opts and opts[DENY_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, DENY_NEW_BE])
if REQUIRE_NEW_BE in opts and opts[REQUIRE_NEW_BE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, REQUIRE_NEW_BE])
if REJECT_PATS in opts and opts[REJECT_PATS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, REJECT_PATS])
if ORIGINS in opts and opts[ORIGINS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[arg1, ORIGINS])
# validate linked image name
li_target_list = []
for li_name in opts[LI_TARGET_LIST]:
# check for repeats
if li_name in li_target_list:
raise InvalidOptionError(
InvalidOptionError.ARG_REPEAT, [li_name,
LI_TARGET_LIST])
# add to ignore list
li_target_list.append(li_name)
opts_new[LI_TARGET_LIST] = \
api_inst.parse_linked_name_list(li_target_list)
def __parse_prop_values(args, add=True):
""""Parse add or remove property values options that were specified
on the command line into a dictionary. Make sure duplicate properties
were not specified."""
props_values = dict()
if add:
add_txt = "added"
else:
add_txt = "removed"
for pv in args:
try:
p, v = pv.split("=", 1)
except ValueError:
raise InvalidOptionError(msg=_(
"property values to be "
"{add} must be of the form '<name>=<value>'. "
"This is what was given: {key}").format(add=add_txt, key=pv))
props_values.setdefault(p, [])
props_values[p].append(v)
return props_values
def opts_table_cb_nqv(api_inst, opts, opts_new):
if opts[VERBOSE] and opts[QUIET]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT, [VERBOSE, QUIET])
def opts_assemble(op, api_inst, opts, add_table=None, cwd=None):
"""Assembly of the options for a specific operation. Options are read in
from a dict (see explanation below) and sanity tested.
This is the common interface to supply options to the functions of the
API.
'op' is the operation for which the options need to be assembled and
verified. The currently supported operations are listed in
pkgdefs.pkg_op_values.
'api_inst' is a reference to the API instance, required for some of the
verification steps.
'opts' is the raw options table to be processed. It needs to be a dict
in the format: { option_name: argument, ... }
"""
global _orig_cwd
if cwd is not None:
_orig_cwd = cwd
else:
_orig_cwd = None
popts = get_pkg_opts(op, add_table)
rv = {}
callbacks = []
for o in popts:
if type(o) != tuple:
callbacks.append(o)
continue
valid_args = []
# If no valid argument list specified.
if len(o) == 2:
avail_opt, default = o
elif len(o) == 3:
avail_opt, default, valid_args = o
elif len(o) == 4:
avail_opt, default, valid_args, schema = o
# for options not given we substitue the default value
if avail_opt not in opts:
rv[avail_opt] = default
continue
if type(default) == int:
assert type(opts[avail_opt]) == int, opts[avail_opt]
elif type(default) == list:
assert type(opts[avail_opt]) == list, opts[avail_opt]
elif type(default) == bool:
assert type(opts[avail_opt]) == bool, opts[avail_opt]
if valid_args:
assert type(default) == list or default is None, \
default
raise_error = False
if type(opts[avail_opt]) == list:
if not set(opts[avail_opt]).issubset(set(valid_args)):
raise_error = True
else:
if opts[avail_opt] not in valid_args:
raise_error = True
if raise_error:
raise InvalidOptionError(InvalidOptionError.ARG_INVALID,
[opts[avail_opt], avail_opt],
valid_args=valid_args)
rv[avail_opt] = opts[avail_opt]
rv_updated = rv.copy()
# run the option verification callbacks
for cb in callbacks:
cb(api_inst, rv, rv_updated)
return rv_updated
def opts_table_cb_pub_opts(api_inst, opts, opts_new):
del opts_new[PUB_DISABLE]
del opts_new[PUB_ENABLE]
del opts_new[PUB_STICKY]
del opts_new[PUB_NON_STICKY]
if opts[PUB_DISABLE] and opts[PUB_ENABLE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[PUB_DISABLE, PUB_ENABLE])
if opts[PUB_STICKY] and opts[PUB_NON_STICKY]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[PUB_STICKY, PUB_NON_STICKY])
opts_new[PUB_DISABLE] = None
if opts[PUB_DISABLE]:
opts_new[PUB_DISABLE] = True
if opts[PUB_ENABLE]:
opts_new[PUB_DISABLE] = False
opts_new[PUB_STICKY] = None
if opts[PUB_STICKY]:
opts_new[PUB_STICKY] = True
if opts[PUB_NON_STICKY]:
opts_new[PUB_STICKY] = False
if opts[ORIGIN_URI] and opts[ADD_ORIGINS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[ORIGIN_URI, ADD_ORIGINS])
if opts[ORIGIN_URI] and opts[REMOVE_ORIGINS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[ORIGIN_URI, REMOVE_ORIGINS])
if opts[REPO_URI] and opts[ADD_ORIGINS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, ADD_ORIGINS])
if opts[REPO_URI] and opts[ADD_MIRRORS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, ADD_MIRRORS])
if opts[REPO_URI] and opts[REMOVE_ORIGINS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, REMOVE_ORIGINS])
if opts[REPO_URI] and opts[REMOVE_MIRRORS]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, REMOVE_MIRRORS])
if opts[REPO_URI] and opts[PUB_DISABLE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, PUB_DISABLE])
if opts[REPO_URI] and opts[PUB_ENABLE]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, PUB_ENABLE])
if opts[REPO_URI] and not opts[REFRESH_ALLOWED]:
raise InvalidOptionError(InvalidOptionError.REQUIRED,
[REPO_URI, REFRESH_ALLOWED])
if opts[REPO_URI] and opts[RESET_UUID]:
raise InvalidOptionError(InvalidOptionError.INCOMPAT,
[REPO_URI, RESET_UUID])
if opts[PROXY_URI] and not (opts[ADD_ORIGINS] or opts[ADD_MIRRORS]
or opts[REPO_URI] or opts[REMOVE_ORIGINS]
or opts[REMOVE_MIRRORS]):
raise InvalidOptionError(InvalidOptionError.REQUIRED_ANY, [
PROXY_URI, ADD_ORIGINS, ADD_MIRRORS, REMOVE_ORIGINS,
REMOVE_MIRRORS, REPO_URI
])
opts_new[ADD_ORIGINS] = set()
opts_new[REMOVE_ORIGINS] = set()
opts_new[ADD_MIRRORS] = set()
opts_new[REMOVE_MIRRORS] = set()
for e in opts[ADD_ORIGINS]:
opts_new[ADD_ORIGINS].add(misc.parse_uri(e, cwd=_orig_cwd))
for e in opts[REMOVE_ORIGINS]:
if e == "*":
# Allow wildcard to support an easy, scriptable
# way of removing all existing entries.
opts_new[REMOVE_ORIGINS].add("*")
else:
opts_new[REMOVE_ORIGINS].add(misc.parse_uri(e, cwd=_orig_cwd))
for e in opts[ADD_MIRRORS]:
opts_new[ADD_MIRRORS].add(misc.parse_uri(e, cwd=_orig_cwd))
for e in opts[REMOVE_MIRRORS]:
if e == "*":
# Allow wildcard to support an easy, scriptable
# way of removing all existing entries.
opts_new[REMOVE_MIRRORS].add("*")
else:
opts_new[REMOVE_MIRRORS].add(misc.parse_uri(e, cwd=_orig_cwd))
if opts[REPO_URI]:
opts_new[REPO_URI] = misc.parse_uri(opts[REPO_URI], cwd=_orig_cwd)
