def __call__(self, parser, namespace, values, option_string):
"""Implement the action.
Emits the deprecation warning message (only once for any given
option string), then calls the real action (if any).
:param parser: The ``argparse.ArgumentParser`` instance.
:param namespace: The ``argparse.Namespace`` object which
should have an attribute set.
:param values: Any arguments provided to the option.
:param option_string: The option string that was used.
"""
action = self._get_action(parser)
# Only emit the deprecation warning once per option
if option_string not in self.emitted:
if self.use:
print(_('WARNING: Option "%(option)s" is deprecated; '
'%(use)s') % {
'option': option_string,
'use': self.use,
}, file=sys.stderr)
else:
print(_('WARNING: Option "%(option)s" is deprecated') %
{'option': option_string}, file=sys.stderr)
self.emitted.add(option_string)
if action:
action(parser, namespace, values, option_string)
def find_resource(manager, name_or_id, wrap_exception=True, **find_args):
"""Helper for the _find_* methods."""
# for str id which is not uuid (for Flavor, Keypair and hypervsior in cells
# environments search currently)
if getattr(manager, 'is_alphanum_id_allowed', False):
try:
return manager.get(name_or_id)
except exceptions.NotFound:
pass
# first try to get entity as uuid
try:
tmp_id = encodeutils.safe_encode(name_or_id)
if six.PY3:
tmp_id = tmp_id.decode()
uuid.UUID(tmp_id)
return manager.get(tmp_id)
except (TypeError, ValueError, exceptions.NotFound):
pass
# then try to get entity as name
try:
try:
resource = getattr(manager, 'resource_class', None)
name_attr = resource.NAME_ATTR if resource else 'name'
kwargs = {name_attr: name_or_id}
kwargs.update(find_args)
return manager.find(**kwargs)
except exceptions.NotFound:
pass
# then try to find entity by human_id
try:
return manager.find(human_id=name_or_id, **find_args)
except exceptions.NotFound:
pass
except exceptions.NoUniqueMatch:
msg = (_("Multiple %(class)s matches found for '%(name)s', use an ID "
"to be more specific.") % {
'class': manager.resource_class.__name__.lower(),
'name': name_or_id
})
if wrap_exception:
raise exceptions.CommandError(msg)
raise exceptions.NoUniqueMatch(msg)
# finally try to get entity as integer id
try:
return manager.get(int(name_or_id))
except (TypeError, ValueError, exceptions.NotFound):
msg = (_("No %(class)s with a name or ID of '%(name)s' exists.") % {
'class': manager.resource_class.__name__.lower(),
'name': name_or_id
})
if wrap_exception:
raise exceptions.CommandError(msg)
raise exceptions.NotFound(404, msg)
def do_project_mapper_delete(cs, args):
"""delete project mapper"""
utils.do_action_on_many(
lambda s: cs.project_mapper.delete(s),
args.project_id,
_("Request to delete project mapper %s has been accepted."),
_("Unable to delete the specified project mapper(s)."))
def do_flavor_mapper_delete(cs, args):
"""delete flavor mapper"""
utils.do_action_on_many(
lambda s: cs.flavor_mapper.delete(s),
args.flavor_id,
_("Request to delete flavor mapper %s has been accepted."),
_("Unable to delete the specified flavor mapper(s)."))
def __init__(self, option_strings, dest, help=None,
real_action=None, use=None, **kwargs):
"""Initialize a ``DeprecatedAction`` instance.
:param option_strings: The recognized option strings.
:param dest: The attribute that will be set.
:param help: Help text. This will be updated to indicate the
deprecation, and if ``use`` is provided, that
text will be included as well.
:param real_action: The actual action to invoke. This is
interpreted the same way as the ``action``
parameter.
:param use: Text explaining which option to use instead.
"""
# Update the help text
if not help:
if use:
help = _('Deprecated; %(use)s') % {'use': use}
else:
help = _('Deprecated')
elif help != argparse.SUPPRESS:
if use:
help = _('%(help)s (Deprecated; %(use)s)') % {
'help': help,
'use': use,
}
else:
help = _('%(help)s (Deprecated)') % {'help': help}
# Initialize ourself appropriately
super(DeprecatedAction, self).__init__(
option_strings, dest, help=help, **kwargs)
# 'emitted' tracks which warnings we've emitted
self.emitted = set()
self.use = use
# Select the appropriate action
if real_action == 'nothing':
# NOTE(Vek): "nothing" is distinct from a real_action=None
# argument. When real_action=None, the argparse default
# action of "store" is used; when real_action='nothing',
# however, we explicitly inhibit doing anything with the
# option
self.real_action_args = False
self.real_action = None
elif real_action is None or isinstance(real_action, six.string_types):
# Specified by string (or None); we have to have a parser
# to look up the actual action, so defer to later
self.real_action_args = (option_strings, dest, help, kwargs)
self.real_action = real_action
else:
self.real_action_args = False
self.real_action = real_action(
option_strings, dest, help=help, **kwargs)
def discover_version(client, requested_version):
"""Discover most recent version supported by API and client.
Checks ``requested_version`` and returns the most recent version
supported by both the API and the client.
:param client: client object
:param requested_version: requested version represented by APIVersion obj
:returns: APIVersion
"""
server_start_version, server_end_version = _get_server_version_range(
client)
if (not requested_version.is_latest() and
requested_version != APIVersion('1.0')):
if server_start_version.is_null() and server_end_version.is_null():
raise exceptions.UnsupportedVersion(
_("Server doesn't support microversions"))
if not requested_version.matches(server_start_version,
server_end_version):
raise exceptions.UnsupportedVersion(
_("The specified version isn't supported by server. The valid "
"version range is '%(min)s' to '%(max)s'") % {
"min": server_start_version.get_string(),
"max": server_end_version.get_string()})
return requested_version
if server_start_version.is_null() and server_end_version.is_null():
return APIVersion('1.0')
elif jacketclient.API_MIN_VERSION > server_end_version:
raise exceptions.UnsupportedVersion(
_("Server version is too old. The client valid version range is "
"'%(client_min)s' to '%(client_max)s'. The server valid version "
"range is '%(server_min)s' to '%(server_max)s'.") % {
'client_min': jacketclient.API_MIN_VERSION.get_string(),
'client_max': jacketclient.API_MAX_VERSION.get_string(),
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif jacketclient.API_MAX_VERSION < server_start_version:
raise exceptions.UnsupportedVersion(
_("Server version is too new. The client valid version range is "
"'%(client_min)s' to '%(client_max)s'. The server valid version "
"range is '%(server_min)s' to '%(server_max)s'.") % {
'client_min': jacketclient.API_MIN_VERSION.get_string(),
'client_max': jacketclient.API_MAX_VERSION.get_string(),
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif jacketclient.API_MAX_VERSION <= server_end_version:
return jacketclient.API_MAX_VERSION
elif server_end_version < jacketclient.API_MAX_VERSION:
return server_end_version
def main():
try:
argv = [encodeutils.safe_decode(a) for a in sys.argv[1:]]
OpenStackComputeShell().main(argv)
except Exception as exc:
logger.debug(exc, exc_info=1)
print(_("ERROR (%(type)s): %(msg)s") % {
'type': exc.__class__.__name__,
'msg': encodeutils.exception_to_unicode(exc)},
file=sys.stderr)
sys.exit(1)
except KeyboardInterrupt:
print(_("... terminating jacket client"), file=sys.stderr)
sys.exit(130)
def _get_action(self, parser):
"""Retrieve the action callable.
This internal method is used to retrieve the callable
implementing the action. If ``real_action`` was specified as
``None`` or one of the standard string names, an internal
method of the ``argparse.ArgumentParser`` instance is used to
resolve it into an actual action class, which is then
instantiated. This is cached, in case the action is called
multiple times.
:param parser: The ``argparse.ArgumentParser`` instance.
:returns: The action callable.
"""
# If a lookup is needed, look up the action in the parser
if self.real_action_args is not False:
option_strings, dest, help, kwargs = self.real_action_args
action_class = parser._registry_get('action', self.real_action)
# Did we find the action class?
if action_class is None:
print(_('WARNING: Programming error: Unknown real action '
'"%s"') % self.real_action, file=sys.stderr)
self.real_action = None
else:
# OK, instantiate the action class
self.real_action = action_class(
option_strings, dest, help=help, **kwargs)
# It's been resolved, no further need to look it up
self.real_action_args = False
return self.real_action
def __init__(self, version_str=None):
"""Create an API version object.
:param version_str: String representation of APIVersionRequest.
Correct format is 'X.Y', where 'X' and 'Y'
are int values. None value should be used
to create Null APIVersionRequest, which is
equal to 0.0
"""
self.ver_major = 0
self.ver_minor = 0
if version_str is not None:
match = re.match(r"^([1-9]\d*)\.([1-9]\d*|0|latest)$", version_str)
if match:
self.ver_major = int(match.group(1))
if match.group(2) == "latest":
# NOTE(andreykurilin): Infinity allows to easily determine
# latest version and doesn't require any additional checks
# in comparison methods.
self.ver_minor = float("inf")
else:
self.ver_minor = int(match.group(2))
else:
msg = _("Invalid format of client version '%s'. "
"Expected format 'X.Y', where X is a major part and Y "
"is a minor part of version.") % version_str
raise exceptions.UnsupportedVersion(msg)
def matches(self, min_version, max_version):
"""Matches the version object.
Returns whether the version object represents a version
greater than or equal to the minimum version and less than
or equal to the maximum version.
:param min_version: Minimum acceptable version.
:param max_version: Maximum acceptable version.
:returns: boolean
If min_version is null then there is no minimum limit.
If max_version is null then there is no maximum limit.
If self is null then raise ValueError
"""
if self.is_null():
raise ValueError(_("Null APIVersion doesn't support 'matches'."))
if max_version.is_null() and min_version.is_null():
return True
elif max_version.is_null():
return min_version <= self
elif min_version.is_null():
return self <= max_version
else:
return min_version <= self <= max_version
def validate_flavor_metadata_keys(keys):
for key in keys:
valid_name = VALID_KEY_REGEX.match(key)
if not valid_name:
msg = _('Invalid key: "%s". Keys may only contain letters, '
'numbers, spaces, underscores, periods, colons and '
'hyphens.')
raise exceptions.CommandError(msg % key)
def _get_client_class_and_version(version):
if not isinstance(version, api_versions.APIVersion):
version = api_versions.get_api_version(version)
else:
api_versions.check_major_version(version)
if version.is_latest():
raise exceptions.UnsupportedVersion(
_("The version should be explicit, not latest."))
return version, importutils.import_class("jacketclient.v%s.client.Client" %
version.ver_major)
def check_major_version(api_version):
"""Checks major part of ``APIVersion`` obj is supported.
:raises jacketclient.exceptions.UnsupportedVersion: if major part is not
supported
"""
available_versions = get_available_major_versions()
if (not api_version.is_null() and
str(api_version.ver_major) not in available_versions):
if len(available_versions) == 1:
msg = _("Invalid client version '%(version)s'. "
"Major part should be '%(major)s'") % {
"version": api_version.get_string(),
"major": available_versions[0]}
else:
msg = _("Invalid client version '%(version)s'. "
"Major part must be one of: '%(major)s'") % {
"version": api_version.get_string(),
"major": ", ".join(available_versions)}
raise exceptions.UnsupportedVersion(msg)
def do_help(self, args):
"""
Display help about this program or one of its subcommands.
"""
if args.command:
if args.command in self.subcommands:
self.subcommands[args.command].print_help()
else:
raise exc.CommandError(_("'%s' is not a valid subcommand") %
args.command)
else:
self.parser.print_help()
def get_string(self):
"""Version string representation.
Converts object to string representation which if used to create
an APIVersion object results in the same version.
"""
if self.is_null():
raise ValueError(
_("Null APIVersion cannot be converted to string."))
elif self.is_latest():
return "%s.%s" % (self.ver_major, "latest")
return "%s.%s" % (self.ver_major, self.ver_minor)
def save(self, auth_token, management_url, tenant_id):
if not HAS_KEYRING or not self.args.os_cache:
return
if (auth_token == self.auth_token and
management_url == self.management_url):
# Nothing changed....
return
if not all([management_url, auth_token, tenant_id]):
raise ValueError(_("Unable to save empty management url/auth "
"token"))
value = "|".join([str(auth_token),
str(management_url),
str(tenant_id)])
keyring.set_password("jacketclient_auth", self._make_key(), value)
def create(self, project_id, dest_project_id, **kwargs):
"""create project mapper
:param project_id:
:param dest_project_id:
:param kwargs:
:return:
"""
if dest_project_id is None:
raise exceptions.CommandError(
_("dest project id must be specified."))
body = self._build_body(project_id, dest_project_id, **kwargs)
return self._create("/project_mapper", body, "project_mapper")
def _extract_service_catalog(self, url, resp, body, extract_token=True):
"""Extract service catalog from input resource body.
See what the auth service told us and process the response.
We may get redirected to another site, fail or actually get
back a service catalog with a token and our endpoints.
"""
# content must always present
if resp.status_code == 200 or resp.status_code == 201:
try:
self.auth_url = url
self.service_catalog = \
service_catalog.ServiceCatalog(body)
if extract_token:
self.auth_token = self.service_catalog.get_token()
self.tenant_id = self.service_catalog.get_tenant_id()
self.management_url = self.get_service_url(self.service_type)
return None
except exceptions.AmbiguousEndpoints:
print(
_("Found more than one valid endpoint. Use a more "
"restrictive filter"))
raise
except KeyError:
raise exceptions.AuthorizationFailure()
except exceptions.EndpointNotFound:
print(
_("Could not find any suitable endpoint. Correct "
"region?"))
raise
elif resp.status_code == 305:
return resp.headers['location']
else:
raise exceptions.from_response(resp, body, url)
def error(self, message):
"""error(message: string)
Prints a usage message incorporating the message to stderr and
exits.
"""
self.print_usage(sys.stderr)
# FIXME(lzyeval): if changes occur in argparse.ArgParser._check_value
choose_from = ' (choose from'
progparts = self.prog.partition(' ')
self.exit(2, _("error: %(errmsg)s\nTry '%(mainp)s help %(subp)s'"
" for more information.\n") %
{'errmsg': message.split(choose_from)[0],
'mainp': progparts[0],
'subp': progparts[2]})
def _build_body(project_id, dest_project_id, **kwargs):
project_mapper = {}
if project_id is None:
raise exceptions.CommandError(_("project id must be specified."))
project_mapper['project_id'] = project_id
if dest_project_id:
project_mapper['dest_project_id'] = dest_project_id
for key, value in kwargs.iteritems():
if value:
project_mapper[key] = value
return {'project_mapper': project_mapper}
def create(self, image_id, dest_image_id, project_id=None, **kwargs):
"""create image mapper
:param image_id:
:param dest_image_id:
:param project_id:
:param kwargs:
:return:
"""
if dest_image_id is None:
raise exceptions.CommandError(_("dest image id must be specified."))
body = self._build_body(image_id, dest_image_id, project_id=project_id,
**kwargs)
return self._create("/image_mapper", body, "image_mapper")
def _build_body(image_id, dest_image_id, project_id=None, **kwargs):
image_mapper = {}
if image_id is None:
raise exceptions.CommandError(_("image id must be specified."))
image_mapper['image_id'] = image_id
if dest_image_id:
image_mapper['provider_image_id'] = dest_image_id
if project_id:
image_mapper['project_id'] = project_id
for key, value in kwargs.iteritems():
if value:
image_mapper[key] = value
return {'image_mapper': image_mapper}
def create(self, flavor_id, dest_flavor_id, project_id=None, **kwargs):
"""create flavor mapper
:param flavor_id:
:param dest_flavor_id:
:param project_id:
:param kwargs:
:return:
"""
if dest_flavor_id is None:
raise exceptions.CommandError(
_("dest flavor id must be specified."))
body = self._build_body(flavor_id,
dest_flavor_id,
project_id=project_id,
**kwargs)
return self._create("/flavor_mapper", body, "flavor_mapper")
def _build_body(flavor_id, dest_flavor_id, project_id=None, **kwargs):
flavor_mapper = {}
if flavor_id is None:
raise exceptions.CommandError(_("flavor id must be specified."))
flavor_mapper['flavor_id'] = flavor_id
if dest_flavor_id:
flavor_mapper['dest_flavor_id'] = dest_flavor_id
if project_id:
flavor_mapper['project_id'] = project_id
for key, value in kwargs.iteritems():
if value:
flavor_mapper[key] = value
return {'flavor_mapper': flavor_mapper}
def get_resource_manager_extra_kwargs(f, args, allow_conflicts=False):
"""Return extra_kwargs by calling resource manager kwargs hooks."""
hooks = getattr(f, "resource_manager_kwargs_hooks", [])
extra_kwargs = {}
for hook in hooks:
hook_kwargs = hook(args)
hook_name = hook.__name__
conflicting_keys = set(hook_kwargs.keys()) & set(extra_kwargs.keys())
if conflicting_keys and not allow_conflicts:
msg = (_("Hook '%(hook_name)s' is attempting to redefine "
"attributes '%(conflicting_keys)s'") % {
'hook_name': hook_name,
'conflicting_keys': conflicting_keys
})
raise exceptions.NoUniqueMatch(msg)
extra_kwargs.update(hook_kwargs)
return extra_kwargs
def get_base_parser(self, argv):
parser = JacketClientArgumentParser(
prog='jacket',
description=__doc__.strip(),
epilog='See "jacket help COMMAND" '
'for help on a specific command.',
add_help=False,
formatter_class=OpenStackHelpFormatter,
)
# Global arguments
parser.add_argument(
'-h', '--help',
action='store_true',
help=argparse.SUPPRESS,
)
parser.add_argument('--version',
action='version',
version=jacketclient.__version__)
parser.add_argument(
'--debug',
default=False,
action='store_true',
help=_("Print debugging output."))
parser.add_argument(
'--os-cache',
default=strutils.bool_from_string(
utils.env('OS_CACHE', default=False), True),
action='store_true',
help=_("Use the auth token cache. Defaults to False if "
"env[OS_CACHE] is not set."))
parser.add_argument(
'--timings',
default=False,
action='store_true',
help=_("Print call timing info."))
parser.add_argument(
'--os-region-name',
metavar='<region-name>',
default=utils.env('OS_REGION_NAME', 'JACKET_REGION_NAME'),
help=_('Defaults to env[OS_REGION_NAME].'))
parser.add_argument(
'--os-auth-system',
metavar='<auth-system>',
default=utils.env('OS_AUTH_SYSTEM'),
help=argparse.SUPPRESS)
parser.add_argument(
'--service-type',
metavar='<service-type>',
help=_('Defaults to jacket for most actions.'))
parser.add_argument(
'--service-name',
metavar='<service-name>',
default=utils.env('JACKET_SERVICE_NAME'),
help=_('Defaults to env[JACKET_SERVICE_NAME].'))
parser.add_argument(
'--volume-service-name',
action=DeprecatedAction,
metavar='<volume-service-name>',
default=utils.env('JACKET_VOLUME_SERVICE_NAME'),
use=_('This option will be removed after Nova 15.0.0 is '
'released.'),
help=argparse.SUPPRESS)
parser.add_argument(
'--os-endpoint-type',
metavar='<endpoint-type>',
dest='endpoint_type',
default=utils.env(
'JACKET_ENDPOINT_TYPE', default=utils.env(
'OS_ENDPOINT_TYPE',
default=DEFAULT_JACKET_ENDPOINT_TYPE)),
help=_('Defaults to env[JACKET_ENDPOINT_TYPE], '
'env[OS_ENDPOINT_TYPE] or ') +
DEFAULT_JACKET_ENDPOINT_TYPE + '.')
parser.add_argument(
'--os-jacket-api-version',
metavar='<jacket-api-ver>',
default=utils.env('OS_COMPUTE_API_VERSION',
default=DEFAULT_OS_JACKET_API_VERSION),
help=_('Accepts X, X.Y (where X is major and Y is minor part) or '
'"X.latest", defaults to env[OS_COMPUTE_API_VERSION].'))
parser.add_argument(
'--bypass-url',
metavar='<bypass-url>',
dest='bypass_url',
default=utils.env('jacketclient_BYPASS_URL'),
help=_("Use this API endpoint instead of the Service Catalog. "
"Defaults to env[jacketclient_BYPASS_URL]."))
# The auth-system-plugins might require some extra options
jacketclient.auth_plugin.load_auth_system_opts(parser)
self._append_global_identity_args(parser, argv)
return parser
def _find_actions(self, subparsers, actions_module, version, do_help):
msg = _(" (Supported by API versions '%(start)s' - '%(end)s')")
for attr in (a for a in dir(actions_module) if a.startswith('do_')):
# I prefer to be hyphen-separated instead of underscores.
command = attr[3:].replace('_', '-')
callback = getattr(actions_module, attr)
desc = callback.__doc__ or ''
if hasattr(callback, "versioned"):
additional_msg = ""
subs = api_versions.get_substitutions(callback)
if do_help:
additional_msg = msg % {
'start': subs[0].start_version.get_string(),
'end': subs[-1].end_version.get_string()}
if version.is_latest():
additional_msg += HINT_HELP_MSG
subs = [versioned_method for versioned_method in subs
if version.matches(versioned_method.start_version,
versioned_method.end_version)]
if subs:
# use the "latest" substitution
callback = subs[-1].func
else:
# there is no proper versioned method
continue
desc = callback.__doc__ or desc
desc += additional_msg
action_help = desc.strip()
arguments = getattr(callback, 'arguments', [])
subparser = subparsers.add_parser(
command,
help=action_help,
description=desc,
add_help=False,
formatter_class=OpenStackHelpFormatter)
subparser.add_argument(
'-h', '--help',
action='help',
help=argparse.SUPPRESS,
)
self.subcommands[command] = subparser
for (args, kwargs) in arguments:
start_version = kwargs.get("start_version", None)
if start_version:
start_version = api_versions.APIVersion(start_version)
end_version = kwargs.get("end_version", None)
if end_version:
end_version = api_versions.APIVersion(end_version)
else:
end_version = api_versions.APIVersion(
"%s.latest" % start_version.ver_major)
if do_help:
kwargs["help"] = kwargs.get("help", "") + (msg % {
"start": start_version.get_string(),
"end": end_version.get_string()})
if not version.matches(start_version, end_version):
continue
kw = kwargs.copy()
kw.pop("start_version", None)
kw.pop("end_version", None)
subparser.add_argument(*args, **kw)
subparser.set_defaults(func=callback)
from jacketclient.i18n import _, _LW
LOG = logging.getLogger(__name__)
if not LOG.handlers:
LOG.addHandler(logging.StreamHandler())
LEGACY_HEADER_NAME = "X-OpenStack-Nova-API-Version"
HEADER_NAME = "OpenStack-API-Version"
SERVICE_TYPE = "jacket"
# key is a deprecated version and value is an alternative version.
DEPRECATED_VERSIONS = {}
_SUBSTITUTIONS = {}
_type_error_msg = _("'%(other)s' should be an instance of '%(cls)s'")
class APIVersion(object):
"""This class represents an API Version Request.
This class provides convenience methods for manipulation
and comparison of version numbers that we need to do to
implement microversions.
"""
def __init__(self, version_str=None):
"""Create an API version object.
:param version_str: String representation of APIVersionRequest.
Correct format is 'X.Y', where 'X' and 'Y'
def authenticate(self):
if not self.auth_url:
msg = _("Authentication requires 'auth_url', which should be "
"specified in '%s'") % self.__class__.__name__
raise exceptions.AuthorizationFailure(msg)
magic_tuple = netutils.urlsplit(self.auth_url)
scheme, netloc, path, query, frag = magic_tuple
port = magic_tuple.port
if port is None:
port = 80
path_parts = path.split('/')
for part in path_parts:
if len(part) > 0 and part[0] == 'v':
self.version = part
break
if self.auth_token and self.management_url:
self._save_keys()
return
# TODO(sandy): Assume admin endpoint is 35357 for now.
# Ideally this is going to have to be provided by the service catalog.
new_netloc = netloc.replace(':%d' % port, ':%d' % (35357, ))
admin_url = parse.urlunsplit((scheme, new_netloc, path, query, frag))
auth_url = self.auth_url
if self.version == "v1.0": # FIXME(chris): This should be better.
while auth_url:
if not self.auth_system or self.auth_system == 'keystone':
auth_url = self._v2_auth(auth_url)
else:
auth_url = self._plugin_auth(auth_url)
# Are we acting on behalf of another user via an
# existing token? If so, our actual endpoints may
# be different than that of the admin token.
if self.proxy_token:
if self.bypass_url:
self.set_management_url(self.bypass_url)
else:
self._fetch_endpoints_from_auth(admin_url)
# Since keystone no longer returns the user token
# with the endpoints any more, we need to replace
# our service account token with the user token.
self.auth_token = self.proxy_token
else:
try:
while auth_url:
auth_url = self._v1_auth(auth_url)
# In some configurations jacket makes redirection to
# v2.0 keystone endpoint. Also, new location does not contain
# real endpoint, only hostname and port.
except exceptions.AuthorizationFailure:
if auth_url.find('v1.0') < 0:
auth_url = auth_url + '/v1.0'
self._v2_auth(auth_url)
if self.bypass_url:
self.set_management_url(self.bypass_url)
elif not self.management_url:
raise exceptions.Unauthorized('Jacket Client')
self._save_keys()
def main(self, argv):
# Parse args once to find version and debug settings
parser = self.get_base_parser(argv)
(args, args_list) = parser.parse_known_args(argv)
self.setup_debugging(args.debug)
self.extensions = []
do_help = ('help' in argv) or (
'--help' in argv) or ('-h' in argv) or not argv
# bash-completion should not require authentication
skip_auth = do_help or (
'bash-completion' in argv)
# Discover available auth plugins
jacketclient.auth_plugin.discover_auth_systems()
if not args.os_jacket_api_version:
api_version = api_versions.get_api_version(
DEFAULT_MAJOR_OS_JACKET_API_VERSION)
else:
api_version = api_versions.get_api_version(
args.os_jacket_api_version)
os_username = args.os_username
os_user_id = args.os_user_id
os_password = None # Fetched and set later as needed
os_project_name = getattr(
args, 'os_project_name', getattr(args, 'os_tenant_name', None))
os_project_id = getattr(
args, 'os_project_id', getattr(args, 'os_tenant_id', None))
os_auth_url = args.os_auth_url
os_region_name = args.os_region_name
os_auth_system = args.os_auth_system
if "v2.0" not in os_auth_url:
# NOTE(andreykurilin): assume that keystone V3 is used and try to
# be more user-friendly, i.e provide default values for domains
if (not args.os_project_domain_id and
not args.os_project_domain_name):
setattr(args, "os_project_domain_id", "default")
if not args.os_user_domain_id and not args.os_user_domain_name:
setattr(args, "os_user_domain_id", "default")
endpoint_type = args.endpoint_type
insecure = args.insecure
service_type = args.service_type
service_name = args.service_name
volume_service_name = args.volume_service_name
bypass_url = args.bypass_url
os_cache = args.os_cache
cacert = args.os_cacert
timeout = args.timeout
keystone_session = None
keystone_auth = None
# We may have either, both or none of these.
# If we have both, we don't need USERNAME, PASSWORD etc.
# Fill in the blanks from the SecretsHelper if possible.
# Finally, authenticate unless we have both.
# Note if we don't auth we probably don't have a tenant ID so we can't
# cache the token.
auth_token = getattr(args, 'os_token', None)
management_url = bypass_url if bypass_url else None
if os_auth_system and os_auth_system != "keystone":
warnings.warn(_(
'jacketclient auth plugins that are not keystone are deprecated.'
' Auth plugins should now be done as plugins to keystoneauth'
' and selected with --os-auth-type or OS_AUTH_TYPE'))
auth_plugin = jacketclient.auth_plugin.load_plugin(os_auth_system)
else:
auth_plugin = None
if not endpoint_type:
endpoint_type = DEFAULT_JACKET_ENDPOINT_TYPE
# This allow users to use endpoint_type as (internal, public or admin)
# just like other openstack clients (glance, cinder etc)
if endpoint_type in ['internal', 'public', 'admin']:
endpoint_type += 'URL'
if not service_type:
# Note(alex_xu): We need discover version first, so if there isn't
# service type specified, we use default jacket service type.
service_type = DEFAULT_JACKET_SERVICE_TYPE
# If we have an auth token but no management_url, we must auth anyway.
# Expired tokens are handled by client.py:_cs_request
must_auth = not (auth_token and management_url)
# Do not use Keystone session for cases with no session support. The
# presence of auth_plugin means os_auth_system is present and is not
# keystone.
use_session = True
if auth_plugin or bypass_url or os_cache or volume_service_name:
use_session = False
# FIXME(usrleon): Here should be restrict for project id same as
# for os_username or os_password but for compatibility it is not.
if must_auth and not skip_auth:
if auth_plugin:
auth_plugin.parse_opts(args)
if not auth_plugin or not auth_plugin.opts:
if not os_username and not os_user_id:
raise exc.CommandError(
_("You must provide a username "
"or user ID via --os-username, --os-user-id, "
"env[OS_USERNAME] or env[OS_USER_ID]"))
if not any([os_project_name, os_project_id]):
raise exc.CommandError(_("You must provide a project name or"
" project ID via --os-project-name,"
" --os-project-id, env[OS_PROJECT_ID]"
" or env[OS_PROJECT_NAME]. You may"
" use os-project and os-tenant"
" interchangeably."))
if not os_auth_url:
if os_auth_system and os_auth_system != 'keystone':
os_auth_url = auth_plugin.get_auth_url()
if not os_auth_url:
raise exc.CommandError(
_("You must provide an auth url "
"via either --os-auth-url or env[OS_AUTH_URL] "
"or specify an auth_system which defines a "
"default url with --os-auth-system "
"or env[OS_AUTH_SYSTEM]"))
if use_session:
# Not using Nova auth plugin, so use keystone
with utils.record_time(self.times, args.timings,
'auth_url', args.os_auth_url):
keystone_session = (
loading.load_session_from_argparse_arguments(args))
keystone_auth = (
loading.load_auth_from_argparse_arguments(args))
else:
# set password for auth plugins
os_password = args.os_password
if (not skip_auth and
not any([os_project_name, os_project_id])):
raise exc.CommandError(_("You must provide a project name or"
" project id via --os-project-name,"
" --os-project-id, env[OS_PROJECT_ID]"
" or env[OS_PROJECT_NAME]. You may"
" use os-project and os-tenant"
" interchangeably."))
if not os_auth_url and not skip_auth:
raise exc.CommandError(
_("You must provide an auth url "
"via either --os-auth-url or env[OS_AUTH_URL]"))
# This client is just used to discover api version. Version API needn't
# microversion, so we just pass version 2 at here.
self.cs = client.Client(
api_versions.APIVersion("1.0"),
os_username, os_password, os_project_name,
tenant_id=os_project_id, user_id=os_user_id,
auth_url=os_auth_url, insecure=insecure,
region_name=os_region_name, endpoint_type=endpoint_type,
extensions=self.extensions, service_type=service_type,
service_name=service_name, auth_system=os_auth_system,
auth_plugin=auth_plugin, auth_token=auth_token,
volume_service_name=volume_service_name,
timings=args.timings, bypass_url=bypass_url,
os_cache=os_cache, http_log_debug=args.debug,
cacert=cacert, timeout=timeout,
session=keystone_session, auth=keystone_auth,
logger=self.client_logger)
if not skip_auth:
if not api_version.is_latest():
if api_version > api_versions.APIVersion("1.0"):
if not api_version.matches(jacketclient.API_MIN_VERSION,
jacketclient.API_MAX_VERSION):
raise exc.CommandError(
_("The specified version isn't supported by "
"client. The valid version range is '%(min)s' "
"to '%(max)s'") % {
"min": jacketclient.API_MIN_VERSION.get_string(),
"max": jacketclient.API_MAX_VERSION.get_string()}
)
api_version = api_versions.discover_version(self.cs, api_version)
# build available subcommands based on version
self.extensions = client.discover_extensions(api_version)
self._run_extension_hooks('__pre_parse_args__')
subcommand_parser = self.get_subcommand_parser(
api_version, do_help=do_help, argv=argv)
self.parser = subcommand_parser
if args.help or not argv:
subcommand_parser.print_help()
return 0
args = subcommand_parser.parse_args(argv)
self._run_extension_hooks('__post_parse_args__', args)
# Short-circuit and deal with help right away.
if args.func == self.do_help:
self.do_help(args)
return 0
elif args.func == self.do_bash_completion:
self.do_bash_completion(args)
return 0
if not args.service_type:
service_type = (utils.get_service_type(args.func) or
DEFAULT_JACKET_SERVICE_TYPE)
if utils.isunauthenticated(args.func):
# NOTE(alex_xu): We need authentication for discover microversion.
# But the subcommands may needn't it. If the subcommand needn't,
# we clear the session arguments.
keystone_session = None
keystone_auth = None
# Recreate client object with discovered version.
self.cs = client.Client(
api_version,
os_username, os_password, os_project_name,
tenant_id=os_project_id, user_id=os_user_id,
auth_url=os_auth_url, insecure=insecure,
region_name=os_region_name, endpoint_type=endpoint_type,
extensions=self.extensions, service_type=service_type,
service_name=service_name, auth_system=os_auth_system,
auth_plugin=auth_plugin, auth_token=auth_token,
volume_service_name=volume_service_name,
timings=args.timings, bypass_url=bypass_url,
os_cache=os_cache, http_log_debug=args.debug,
cacert=cacert, timeout=timeout,
session=keystone_session, auth=keystone_auth)
# Now check for the password/token of which pieces of the
# identifying keyring key can come from the underlying client
if must_auth:
helper = SecretsHelper(args, self.cs.client)
self.cs.client.keyring_saver = helper
if (auth_plugin and auth_plugin.opts and
"os_password" not in auth_plugin.opts):
use_pw = False
else:
use_pw = True
tenant_id = helper.tenant_id
# Allow commandline to override cache
if not auth_token:
auth_token = helper.auth_token
if not management_url:
management_url = helper.management_url
if tenant_id and auth_token and management_url:
self.cs.client.tenant_id = tenant_id
self.cs.client.auth_token = auth_token
self.cs.client.management_url = management_url
self.cs.client.password_func = lambda: helper.password
elif use_pw:
# We're missing something, so auth with user/pass and save
# the result in our helper.
self.cs.client.password = helper.password
try:
# This does a couple of bits which are useful even if we've
# got the token + service URL already. It exits fast in that case.
if not utils.isunauthenticated(args.func):
if not use_session:
# Only call authenticate() if Nova auth plugin is used.
# If keystone is used, authentication is handled as part
# of session.
self.cs.authenticate()
except exc.Unauthorized:
raise exc.CommandError(_("Invalid OpenStack Jacket credentials."))
except exc.AuthorizationFailure:
raise exc.CommandError(_("Unable to authorize user"))
args.func(self.cs, args)
if args.timings:
self._dump_timings(self.times + self.cs.get_timings())
