def _validate_server_version(server_start_version, server_end_version):
"""Validates the server version.
Checks that the 'server_end_version' is greater than the minimum version
supported by the client. Then checks that the 'server_start_version' is
less than the maximum version supported by the client.
:param server_start_version:
:param server_end_version:
:return:
"""
if APIVersion(MIN_VERSION) > server_end_version:
raise exceptions.UnsupportedVersion(
_("Server's version is too old. The client's 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': MIN_VERSION,
'client_max': MAX_VERSION,
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()
})
elif APIVersion(MAX_VERSION) < server_start_version:
raise exceptions.UnsupportedVersion(
_("Server's version is too new. The client's 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': MIN_VERSION,
'client_max': MAX_VERSION,
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()
})
def _validate_requested_version(requested_version,
server_start_version,
server_end_version):
"""Validates the requested version.
Checks 'requested_version' is within the min/max range supported by the
server. If 'requested_version' is not within range then attempts to
downgrade to 'server_end_version'. Otherwise an UnsupportedVersion
exception is thrown.
:param requested_version: requestedversion represented by APIVersion obj
:param server_start_version: APIVersion object representing server min
:param server_end_version: APIVersion object representing server max
"""
valid_version = requested_version
if not requested_version.matches(server_start_version, server_end_version):
if server_end_version <= requested_version:
if (APIVersion(MIN_VERSION) <= server_end_version and
server_end_version <= APIVersion(MAX_VERSION)):
msg = _("Requested version %(requested_version)s is "
"not supported. Downgrading requested version "
"to %(server_end_version)s.")
LOG.debug(msg, {
"requested_version": requested_version,
"server_end_version": server_end_version})
valid_version = server_end_version
else:
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 valid_version
def _validate_requested_version(requested_version,
server_start_version,
server_end_version):
"""Validates the requested version.
Checks 'requested_version' is within the min/max range supported by the
server. If 'requested_version' is not within range then attempts to
downgrade to 'server_end_version'. Otherwise an UnsupportedVersion
exception is thrown.
:param requested_version: requestedversion represented by APIVersion obj
:param server_start_version: APIVersion object representing server min
:param server_end_version: APIVersion object representing server max
"""
valid_version = requested_version
if not requested_version.matches(server_start_version, server_end_version):
if server_end_version <= requested_version:
if (APIVersion(MIN_VERSION) <= server_end_version and
server_end_version <= APIVersion(MAX_VERSION)):
msg = _("Requested version %(requested_version)s is "
"not supported. Downgrading requested version "
"to %(server_end_version)s.")
LOG.debug(msg, {
"requested_version": requested_version,
"server_end_version": server_end_version})
valid_version = server_end_version
else:
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 valid_version
def _validate_server_version(server_start_version, server_end_version):
"""Validates the server version.
Checks that the 'server_end_version' is greater than the minimum version
supported by the client. Then checks that the 'server_start_version' is
less than the maximum version supported by the client.
:param server_start_version:
:param server_end_version:
:return:
"""
if APIVersion(MIN_VERSION) > server_end_version:
raise exceptions.UnsupportedVersion(
_("Server's version is too old. The client's 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': MIN_VERSION,
'client_max': MAX_VERSION,
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif APIVersion(MAX_VERSION) < server_start_version:
raise exceptions.UnsupportedVersion(
_("Server's version is too new. The client's 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': MIN_VERSION,
'client_max': MAX_VERSION,
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
def discover_version(client, requested_version):
"""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('2.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 requested_version == APIVersion('2.0'):
if (server_start_version == APIVersion('2.1') or
(server_start_version.is_null() and
server_end_version.is_null())):
return APIVersion('2.0')
else:
raise exceptions.UnsupportedVersion(
_("The server isn't backward compatible with Cinder V2 REST "
"API"))
if server_start_version.is_null() and server_end_version.is_null():
return APIVersion('2.0')
elif cinderclient.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': cinderclient.API_MIN_VERSION.get_string(),
'client_max': cinderclient.API_MAX_VERSION.get_string(),
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif cinderclient.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': cinderclient.API_MIN_VERSION.get_string(),
'client_max': cinderclient.API_MAX_VERSION.get_string(),
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif cinderclient.API_MAX_VERSION <= server_end_version:
return cinderclient.API_MAX_VERSION
elif server_end_version < cinderclient.API_MAX_VERSION:
return server_end_version
def discover_version(client, requested_version):
"""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)
both_versions_null = not (server_start_version or server_end_version)
if (not requested_version.is_latest() and
requested_version != APIVersion('2.0')):
if both_versions_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 requested_version == APIVersion('2.0'):
if server_start_version == APIVersion('2.1') or both_versions_null:
return APIVersion('2.0')
raise exceptions.UnsupportedVersion(
_("The server isn't backward compatible with Cinder V2 REST "
"API"))
if both_versions_null:
return APIVersion('2.0')
if cinderclient.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': cinderclient.API_MIN_VERSION.get_string(),
'client_max': cinderclient.API_MAX_VERSION.get_string(),
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif cinderclient.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': cinderclient.API_MIN_VERSION.get_string(),
'client_max': cinderclient.API_MAX_VERSION.get_string(),
'server_min': server_start_version.get_string(),
'server_max': server_end_version.get_string()})
elif cinderclient.API_MAX_VERSION <= server_end_version:
return cinderclient.API_MAX_VERSION
elif server_end_version < cinderclient.API_MAX_VERSION:
return server_end_version
def _build_versioned_help_message(self, start_version, end_version):
if start_version and end_version:
msg = (_(" (Supported by API versions %(start)s - %(end)s)")
% {"start": start_version.get_string(),
"end": end_version.get_string()})
elif start_version:
msg = (_(" (Supported by API version %(start)s and later)")
% {"start": start_version.get_string()})
else:
msg = (_(" Supported until API version %(end)s)")
% {"end": end_version.get_string()})
return six.text_type(msg)
def _build_versioned_help_message(self, start_version, end_version):
if start_version and end_version:
msg = (_(" (Supported by API versions %(start)s - %(end)s)")
% {"start": start_version.get_string(),
"end": end_version.get_string()})
elif start_version:
msg = (_(" (Supported by API version %(start)s and later)")
% {"start": start_version.get_string()})
else:
msg = (_(" (Supported until API version %(end)s)")
% {"end": end_version.get_string()})
return six.text_type(msg)
def get_volume_api_version_from_endpoint(self):
try:
version = get_volume_api_from_url(self.management_url)
except exceptions.UnsupportedVersion as e:
if self.management_url == self.os_endpoint:
msg = (_("Invalid url was specified in --os-endpoint %s")
% six.text_type(e))
else:
msg = (_("Service catalog returned invalid url.\n"
"%s") % six.text_type(e))
raise exceptions.UnsupportedVersion(msg)
return version
def get_volume_api_version_from_endpoint(self):
try:
version = get_volume_api_from_url(self.management_url)
except exceptions.UnsupportedVersion as e:
if self.management_url == self.bypass_url:
msg = (_("Invalid url was specified in --bypass-url or "
"environment variable CINDERCLIENT_BYPASS_URL.\n"
"%s") % six.text_type(e.message))
else:
msg = (_("Service catalog returned invalid url.\n"
"%s") % six.text_type(e.message))
raise exceptions.UnsupportedVersion(msg)
return version
def get_volume_api_version_from_endpoint(self):
try:
version = get_volume_api_from_url(self.management_url)
except exceptions.UnsupportedVersion as e:
if self.management_url == self.bypass_url:
msg = (_("Invalid url was specified in --os-endpoint or "
"environment variable CINDERCLIENT_BYPASS_URL.\n"
"%s") % six.text_type(e.message))
else:
msg = (_("Service catalog returned invalid url.\n"
"%s") % six.text_type(e.message))
raise exceptions.UnsupportedVersion(msg)
return version
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("cinderclient.v%s.client.Client" % version.ver_major)
def get_volume_api_version_from_endpoint(self):
try:
version = get_volume_api_from_url(self.get_endpoint())
except exceptions.UnsupportedVersion as e:
msg = _("Service catalog returned invalid url.\n" "%s") % six.text_type(e.message)
raise exceptions.UnsupportedVersion(msg)
return version
def get_volume_api_version_from_endpoint(self):
try:
version = get_volume_api_from_url(self.get_endpoint())
except exceptions.UnsupportedVersion as e:
msg = (_("Service catalog returned invalid url.\n"
"%s") % six.text_type(e.message))
raise exceptions.UnsupportedVersion(msg)
return version
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(
"cinderclient.v%s.client.Client" % version.ver_major)
def get_volume_api_from_url(url):
scheme, netloc, path, query, frag = urlparse.urlsplit(url)
components = path.split("/")
for version in _VALID_VERSIONS:
if version in components:
return version[1:]
msg = (_("Invalid url: '%(url)s'. It must include one of: %(version)s.")
% {'url': url, 'version': ', '.join(_VALID_VERSIONS)})
raise exceptions.UnsupportedVersion(msg)
class BrickInterfaceException(Exception):
"""Base exception for brick-cinderclient."""
message = _("An unknown exception occurred.")
def __init__(self, message=None, **kwargs):
if message:
self.message = message
self.message = self.message % kwargs
def __str__(self):
return self.message
def get_volume_api_from_url(url):
scheme, netloc, path, query, frag = urlparse.urlsplit(url)
components = path.split("/")
for version in _VALID_VERSIONS:
if version in components:
return version[1:]
msg = (_("Invalid url: '%(url)s'. It must include one of: %(version)s.")
% {'url': url, 'version': ', '.join(_VALID_VERSIONS)})
raise exceptions.UnsupportedVersion(msg)
def _get_server_version_range(client):
try:
versions = client.services.server_api_version()
except AttributeError:
# Wrong client was used, translate to something helpful.
raise exceptions.UnsupportedVersion(
_('Invalid client version %s to get server version range. Only '
'the v3 client is supported for this operation.') %
client.version)
if not versions:
return APIVersion(), APIVersion()
for version in versions:
if '3.' in version.version:
return APIVersion(version.min_version), APIVersion(version.version)
def _get_server_version_range(client):
try:
versions = client.services.server_api_version()
except AttributeError:
# Wrong client was used, translate to something helpful.
raise exceptions.UnsupportedVersion(
_('Invalid client version %s to get server version range. Only '
'the v3 client is supported for this operation.') %
client.version)
if not versions:
return APIVersion(), APIVersion()
for version in versions:
if '3.' in version.version:
return APIVersion(version.min_version), APIVersion(version.version)
def __init__(self, version_str=None):
"""Create an API version object."""
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 __init__(self, version_str=None):
"""Create an API version object."""
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 discover_version(client, requested_version):
"""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 server_start_version and not server_end_version:
msg = ("Server does not support microversions. Changing server "
"version to %(min_version)s.")
LOG.debug(msg, {"min_version": DEPRECATED_VERSION})
return APIVersion(DEPRECATED_VERSION)
_validate_server_version(server_start_version, server_end_version)
# get the highest version the server can handle relative to the
# requested version
valid_version = _validate_requested_version(
requested_version,
server_start_version,
server_end_version)
# see if we need to downgrade for the client
client_max = APIVersion(MAX_VERSION)
if client_max < valid_version:
msg = _("Requested version %(requested_version)s is "
"not supported. Downgrading requested version "
"to %(actual_version)s.")
LOG.debug(msg, {
"requested_version": requested_version,
"actual_version": client_max})
valid_version = client_max
return valid_version
def discover_version(client, requested_version):
"""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 server_start_version and not server_end_version:
msg = ("Server does not support microversions. Changing server "
"version to %(min_version)s.")
LOG.debug(msg, {"min_version": DEPRECATED_VERSION})
return APIVersion(DEPRECATED_VERSION)
_validate_server_version(server_start_version, server_end_version)
# get the highest version the server can handle relative to the
# requested version
valid_version = _validate_requested_version(requested_version,
server_start_version,
server_end_version)
# see if we need to downgrade for the client
client_max = APIVersion(MAX_VERSION)
if client_max < valid_version:
msg = _("Requested version %(requested_version)s is "
"not supported. Downgrading requested version "
"to %(actual_version)s.")
LOG.debug(msg, {
"requested_version": requested_version,
"actual_version": client_max
})
valid_version = client_max
return valid_version
class NicNotFound(BrickInterfaceException):
message = _("Could not find network interface %(iface)s.")
class NeedAttachmentUUID(BrickInterfaceException):
message = _("Volume %(volume_id)s has more than one attachment. "
"Please pass in the attachment_uuid you wish to detach.")
def _append_global_identity_args(self, parser):
# FIXME(bklei): these are global identity (Keystone) arguments which
# should be consistent and shared by all service clients. Therefore,
# they should be provided by python-keystoneclient. We will need to
# refactor this code once this functionality is available in
# python-keystoneclient.
parser.add_argument(
'--os-auth-strategy',
metavar='<auth-strategy>',
default=utils.env('OS_AUTH_STRATEGY', default='keystone'),
help=_('Authentication strategy (Env: OS_AUTH_STRATEGY'
', default keystone). For now, any other value will'
' disable the authentication.'))
parser.add_argument('--os_auth_strategy', help=argparse.SUPPRESS)
parser.add_argument('--os-username',
metavar='<auth-user-name>',
default=utils.env('OS_USERNAME',
'CINDER_USERNAME'),
help='OpenStack user name. '
'Default=env[OS_USERNAME].')
parser.add_argument('--os_username', help=argparse.SUPPRESS)
parser.add_argument('--os-password',
metavar='<auth-password>',
default=utils.env('OS_PASSWORD',
'CINDER_PASSWORD'),
help='Password for OpenStack user. '
'Default=env[OS_PASSWORD].')
parser.add_argument('--os_password', help=argparse.SUPPRESS)
parser.add_argument('--os-tenant-name',
metavar='<auth-tenant-name>',
default=utils.env('OS_TENANT_NAME',
'CINDER_PROJECT_ID'),
help='Tenant name. '
'Default=env[OS_TENANT_NAME].')
parser.add_argument('--os_tenant_name', help=argparse.SUPPRESS)
parser.add_argument('--os-tenant-id',
metavar='<auth-tenant-id>',
default=utils.env('OS_TENANT_ID',
'CINDER_TENANT_ID'),
help='ID for the tenant. '
'Default=env[OS_TENANT_ID].')
parser.add_argument('--os_tenant_id', help=argparse.SUPPRESS)
parser.add_argument('--os-auth-url',
metavar='<auth-url>',
default=utils.env('OS_AUTH_URL', 'CINDER_URL'),
help='URL for the authentication service. '
'Default=env[OS_AUTH_URL].')
parser.add_argument('--os_auth_url', help=argparse.SUPPRESS)
parser.add_argument(
'--os-user-id',
metavar='<auth-user-id>',
default=utils.env('OS_USER_ID'),
help=_('Authentication user ID (Env: OS_USER_ID).'))
parser.add_argument('--os_user_id', help=argparse.SUPPRESS)
parser.add_argument('--os-user-domain-id',
metavar='<auth-user-domain-id>',
default=utils.env('OS_USER_DOMAIN_ID'),
help='OpenStack user domain ID. '
'Defaults to env[OS_USER_DOMAIN_ID].')
parser.add_argument('--os_user_domain_id', help=argparse.SUPPRESS)
parser.add_argument('--os-user-domain-name',
metavar='<auth-user-domain-name>',
default=utils.env('OS_USER_DOMAIN_NAME'),
help='OpenStack user domain name. '
'Defaults to env[OS_USER_DOMAIN_NAME].')
parser.add_argument('--os_user_domain_name', help=argparse.SUPPRESS)
parser.add_argument('--os-project-id',
metavar='<auth-project-id>',
default=utils.env('OS_PROJECT_ID'),
help='Another way to specify tenant ID. '
'This option is mutually exclusive with '
' --os-tenant-id. '
'Defaults to env[OS_PROJECT_ID].')
parser.add_argument('--os_project_id', help=argparse.SUPPRESS)
parser.add_argument('--os-project-name',
metavar='<auth-project-name>',
default=utils.env('OS_PROJECT_NAME'),
help='Another way to specify tenant name. '
'This option is mutually exclusive with '
' --os-tenant-name. '
'Defaults to env[OS_PROJECT_NAME].')
parser.add_argument('--os_project_name', help=argparse.SUPPRESS)
parser.add_argument('--os-project-domain-id',
metavar='<auth-project-domain-id>',
default=utils.env('OS_PROJECT_DOMAIN_ID'),
help='Defaults to env[OS_PROJECT_DOMAIN_ID].')
parser.add_argument('--os-project-domain-name',
metavar='<auth-project-domain-name>',
default=utils.env('OS_PROJECT_DOMAIN_NAME'),
help='Defaults to env[OS_PROJECT_DOMAIN_NAME].')
parser.add_argument('--os-region-name',
metavar='<region-name>',
default=utils.env('OS_REGION_NAME',
'CINDER_REGION_NAME'),
help='Region name. '
'Default=env[OS_REGION_NAME].')
parser.add_argument('--os_region_name', help=argparse.SUPPRESS)
parser.add_argument('--os-token',
metavar='<token>',
default=utils.env('OS_TOKEN'),
help=_('Defaults to env[OS_TOKEN].'))
parser.add_argument('--os_token', help=argparse.SUPPRESS)
parser.add_argument('--os-url',
metavar='<url>',
default=utils.env('OS_URL'),
help=_('Defaults to env[OS_URL].'))
parser.add_argument('--os_url', help=argparse.SUPPRESS)
# Register the CLI arguments that have moved to the session object.
session.Session.register_cli_options(parser)
parser.set_defaults(
insecure=utils.env('CINDERCLIENT_INSECURE', default=False))
def main(self, argv):
# Parse args once to find version and debug settings
parser = self.get_base_parser()
(options, args) = parser.parse_known_args(argv)
self.setup_debugging(options.debug)
api_version_input = True
self.options = options
if not options.os_volume_api_version:
api_version = api_versions.get_api_version(
DEFAULT_MAJOR_OS_VOLUME_API_VERSION)
else:
api_version = api_versions.get_api_version(
options.os_volume_api_version)
# build available subcommands based on version
major_version_string = "%s" % api_version.ver_major
self.extensions = client.discover_extensions(major_version_string)
self._run_extension_hooks('__pre_parse_args__')
subcommand_parser = self.get_subcommand_parser(major_version_string)
self.parser = subcommand_parser
if options.help or not argv:
subcommand_parser.print_help()
return 0
argv = self._delimit_metadata_args(argv)
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
(os_username, os_password, os_tenant_name, os_auth_url, os_region_name,
os_tenant_id, endpoint_type, service_type, service_name,
volume_service_name, bypass_url, cacert,
os_auth_system) = (args.os_username, args.os_password,
args.os_tenant_name, args.os_auth_url,
args.os_region_name, args.os_tenant_id,
args.os_endpoint_type, args.service_type,
args.service_name, args.volume_service_name,
args.bypass_url, args.os_cacert,
args.os_auth_system)
if os_auth_system and os_auth_system != "keystone":
auth_plugin = cinderclient.auth_plugin.load_plugin(os_auth_system)
else:
auth_plugin = None
if not service_type:
service_type = client.SERVICE_TYPES[major_version_string]
# FIXME(usrleon): Here should be restrict for project id same as
# for os_username or os_password but for compatibility it is not.
# V3 stuff
project_info_provided = ((self.options.os_tenant_name
or self.options.os_tenant_id)
or (self.options.os_project_name and
(self.options.os_project_domain_name
or self.options.os_project_domain_id))
or self.options.os_project_id)
if not utils.isunauthenticated(args.func):
if auth_plugin:
auth_plugin.parse_opts(args)
if not auth_plugin or not auth_plugin.opts:
if not os_username:
raise exc.CommandError("You must provide a user name "
"through --os-username or "
"env[OS_USERNAME].")
if not os_password:
# No password, If we've got a tty, try prompting for it
if hasattr(sys.stdin, 'isatty') and sys.stdin.isatty():
# Check for Ctl-D
try:
os_password = getpass.getpass('OS Password: '******'t have a tty or the
# user Ctl-D when prompted.
if not os_password:
raise exc.CommandError("You must provide a password "
"through --os-password, "
"env[OS_PASSWORD] "
"or, prompted response.")
if not project_info_provided:
raise exc.CommandError(
_("You must provide a tenant_name, tenant_id, "
"project_id or project_name (with "
"project_domain_name or project_domain_id) via "
" --os-tenant-name (env[OS_TENANT_NAME]),"
" --os-tenant-id (env[OS_TENANT_ID]),"
" --os-project-id (env[OS_PROJECT_ID])"
" --os-project-name (env[OS_PROJECT_NAME]),"
" --os-project-domain-id "
"(env[OS_PROJECT_DOMAIN_ID])"
" --os-project-domain-name "
"(env[OS_PROJECT_DOMAIN_NAME])"))
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 authentication URL "
"through --os-auth-url or env[OS_AUTH_URL].")
if not project_info_provided:
raise exc.CommandError(
_("You must provide a tenant_name, tenant_id, "
"project_id or project_name (with "
"project_domain_name or project_domain_id) via "
" --os-tenant-name (env[OS_TENANT_NAME]),"
" --os-tenant-id (env[OS_TENANT_ID]),"
" --os-project-id (env[OS_PROJECT_ID])"
" --os-project-name (env[OS_PROJECT_NAME]),"
" --os-project-domain-id "
"(env[OS_PROJECT_DOMAIN_ID])"
" --os-project-domain-name "
"(env[OS_PROJECT_DOMAIN_NAME])"))
if not os_auth_url:
raise exc.CommandError(
"You must provide an authentication URL "
"through --os-auth-url or env[OS_AUTH_URL].")
auth_session = None
if not auth_plugin:
auth_session = self._get_keystone_session()
insecure = self.options.insecure
self.cs = client.Client(api_version,
os_username,
os_password,
os_tenant_name,
os_auth_url,
region_name=os_region_name,
tenant_id=os_tenant_id,
endpoint_type=endpoint_type,
extensions=self.extensions,
service_type=service_type,
service_name=service_name,
volume_service_name=volume_service_name,
bypass_url=bypass_url,
retries=options.retries,
http_log_debug=args.debug,
insecure=insecure,
cacert=cacert,
auth_system=os_auth_system,
auth_plugin=auth_plugin,
session=auth_session)
try:
if not utils.isunauthenticated(args.func):
self.cs.authenticate()
except exc.Unauthorized:
raise exc.CommandError("OpenStack credentials are not valid.")
except exc.AuthorizationFailure:
raise exc.CommandError("Unable to authorize user.")
endpoint_api_version = None
# Try to get the API version from the endpoint URL. If that fails fall
# back to trying to use what the user specified via
# --os-volume-api-version or with the OS_VOLUME_API_VERSION environment
# variable. Fail safe is to use the default API setting.
try:
endpoint_api_version = \
self.cs.get_volume_api_version_from_endpoint()
except exc.UnsupportedVersion:
endpoint_api_version = options.os_volume_api_version
if api_version_input:
logger.warning("Cannot determine the API version from "
"the endpoint URL. Falling back to the "
"user-specified version: %s" %
endpoint_api_version)
else:
logger.warning("Cannot determine the API version from the "
"endpoint URL or user input. Falling back "
"to the default API version: %s" %
endpoint_api_version)
profile = osprofiler_profiler and options.profile
if profile:
osprofiler_profiler.init(options.profile)
args.func(self.cs, args)
if profile:
trace_id = osprofiler_profiler.get().get_base_id()
print("Trace ID: %s" % trace_id)
print("To display trace use next command:\n"
"osprofiler trace show --html %s " % trace_id)
def _append_global_identity_args(self, parser):
loading.register_session_argparse_arguments(parser)
# Use "password" auth plugin as default and keep the explicit
# "--os-token" arguments below for backward compatibility.
default_auth_plugin = 'password'
# Passing [] to loading.register_auth_argparse_arguments to avoid
# the auth_type being overridden by the command line.
loading.register_auth_argparse_arguments(parser, [],
default=default_auth_plugin)
parser.add_argument(
'--os-auth-strategy',
metavar='<auth-strategy>',
default=utils.env('OS_AUTH_STRATEGY', default='keystone'),
help=_('Authentication strategy (Env: OS_AUTH_STRATEGY'
', default keystone). For now, any other value will'
' disable the authentication.'))
parser.add_argument('--os_auth_strategy', help=argparse.SUPPRESS)
# Change os_auth_type default value defined by
# register_auth_argparse_arguments to be backward compatible
# with OS_AUTH_SYSTEM.
env_plugin = utils.env('OS_AUTH_TYPE', 'OS_AUTH_PLUGIN',
'OS_AUTH_SYSTEM')
parser.set_defaults(os_auth_type=env_plugin)
parser.add_argument('--os_auth_type', help=argparse.SUPPRESS)
parser.set_defaults(
os_username=utils.env('OS_USERNAME', 'CINDER_USERNAME'))
parser.add_argument('--os_username', help=argparse.SUPPRESS)
parser.set_defaults(
os_password=utils.env('OS_PASSWORD', 'CINDER_PASSWORD'))
parser.add_argument('--os_password', help=argparse.SUPPRESS)
parser.set_defaults(
os_project_name=utils.env('OS_PROJECT_NAME', 'CINDER_PROJECT_ID'))
parser.add_argument('--os_project_name', help=argparse.SUPPRESS)
parser.set_defaults(
os_project_id=utils.env('OS_PROJECT_ID', 'CINDER_PROJECT_ID'))
parser.add_argument('--os_project_id', help=argparse.SUPPRESS)
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL', 'CINDER_URL'))
parser.add_argument('--os_auth_url', help=argparse.SUPPRESS)
parser.set_defaults(os_user_id=utils.env('OS_USER_ID'))
parser.add_argument('--os_user_id', help=argparse.SUPPRESS)
parser.set_defaults(os_user_domain_id=utils.env('OS_USER_DOMAIN_ID'))
parser.add_argument('--os_user_domain_id', help=argparse.SUPPRESS)
parser.set_defaults(
os_user_domain_name=utils.env('OS_USER_DOMAIN_NAME'))
parser.add_argument('--os_user_domain_name', help=argparse.SUPPRESS)
parser.set_defaults(
os_project_domain_id=utils.env('OS_PROJECT_DOMAIN_ID'))
parser.set_defaults(
os_project_domain_name=utils.env('OS_PROJECT_DOMAIN_NAME'))
parser.set_defaults(
os_region_name=utils.env('OS_REGION_NAME', 'CINDER_REGION_NAME'))
parser.add_argument('--os_region_name', help=argparse.SUPPRESS)
parser.add_argument('--os-token',
metavar='<token>',
default=utils.env('OS_TOKEN'),
help=_('Defaults to env[OS_TOKEN].'))
parser.add_argument('--os_token', help=argparse.SUPPRESS)
parser.add_argument('--os-url',
metavar='<url>',
default=utils.env('OS_URL'),
help=_('Defaults to env[OS_URL].'))
parser.add_argument('--os_url', help=argparse.SUPPRESS)
parser.set_defaults(
insecure=utils.env('CINDERCLIENT_INSECURE', default=False))
def main(self, argv):
# Parse args once to find version and debug settings
for filter in FILTER_CHECK:
if filter in argv:
self.check_duplicate_filters(argv, filter)
break
parser = self.get_base_parser()
(options, args) = parser.parse_known_args(argv)
self.setup_debugging(options.debug)
api_version_input = True
self.options = options
do_help = ('help' in argv) or ('--help'
in argv) or ('-h' in argv) or not argv
api_version = self._validate_input_api_version(options)
# build available subcommands based on version
major_version_string = "%s" % api_version.ver_major
self.extensions = client.discover_extensions(major_version_string)
self._run_extension_hooks('__pre_parse_args__')
subcommand_parser = self.get_subcommand_parser(api_version, do_help,
args)
self.parser = subcommand_parser
if argv and len(argv) > 1 and '--help' in argv:
argv = [x for x in argv if x != '--help']
if argv[0] in self.subcommands:
self.subcommands[argv[0]].print_help()
return 0
if options.help or not argv:
subcommand_parser.print_help()
return 0
argv = self._delimit_metadata_args(argv)
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
(os_username, os_password, os_project_name, os_auth_url,
os_region_name, os_project_id, endpoint_type, service_type,
service_name, volume_service_name, os_endpoint, cacert,
os_auth_type) = (args.os_username, args.os_password,
args.os_project_name, args.os_auth_url,
args.os_region_name, args.os_project_id,
args.os_endpoint_type, args.service_type,
args.service_name, args.volume_service_name,
args.os_endpoint, args.os_cacert, args.os_auth_type)
auth_session = None
if os_auth_type and os_auth_type != "keystone":
auth_plugin = loading.load_auth_from_argparse_arguments(
self.options)
auth_session = loading.load_session_from_argparse_arguments(
self.options, auth=auth_plugin)
else:
auth_plugin = None
if not service_type:
service_type = client.SERVICE_TYPES[major_version_string]
# FIXME(usrleon): Here should be restrict for project id same as
# for os_username or os_password but for compatibility it is not.
# V3 stuff
project_info_provided = ((self.options.os_project_name and
(self.options.os_project_domain_name
or self.options.os_project_domain_id))
or self.options.os_project_id
or self.options.os_project_name)
# NOTE(e0ne): if auth_session exists it means auth plugin created
# session and we don't need to check for password and other
# authentification-related things.
if not utils.isunauthenticated(args.func) and not auth_session:
if not os_password:
# No password, If we've got a tty, try prompting for it
if hasattr(sys.stdin, 'isatty') and sys.stdin.isatty():
# Check for Ctl-D
try:
os_password = getpass.getpass('OS Password: '******'t have a tty or the
# user Ctl-D when prompted.
if not os_password:
raise exc.CommandError("You must provide a password "
"through --os-password, "
"env[OS_PASSWORD] "
"or, prompted response.")
if not project_info_provided:
raise exc.CommandError(
_("You must provide a project_id or project_name (with "
"project_domain_name or project_domain_id) via "
" --os-project-id (env[OS_PROJECT_ID])"
" --os-project-name (env[OS_PROJECT_NAME]),"
" --os-project-domain-id "
"(env[OS_PROJECT_DOMAIN_ID])"
" --os-project-domain-name "
"(env[OS_PROJECT_DOMAIN_NAME])"))
if not os_auth_url:
raise exc.CommandError(
"You must provide an authentication URL "
"through --os-auth-url or env[OS_AUTH_URL].")
if not project_info_provided:
raise exc.CommandError(
_("You must provide a project_id or project_name (with "
"project_domain_name or project_domain_id) via "
" --os-project-id (env[OS_PROJECT_ID])"
" --os-project-name (env[OS_PROJECT_NAME]),"
" --os-project-domain-id "
"(env[OS_PROJECT_DOMAIN_ID])"
" --os-project-domain-name "
"(env[OS_PROJECT_DOMAIN_NAME])"))
if not os_auth_url and not auth_plugin:
raise exc.CommandError(
"You must provide an authentication URL "
"through --os-auth-url or env[OS_AUTH_URL].")
if not auth_session:
auth_session = self._get_keystone_session()
insecure = self.options.insecure
client_args = dict(
region_name=os_region_name,
tenant_id=os_project_id,
endpoint_type=endpoint_type,
extensions=self.extensions,
service_type=service_type,
service_name=service_name,
volume_service_name=volume_service_name,
os_endpoint=os_endpoint,
retries=options.retries,
http_log_debug=args.debug,
insecure=insecure,
cacert=cacert,
auth_system=os_auth_type,
auth_plugin=auth_plugin,
session=auth_session,
logger=self.ks_logger if auth_session else self.client_logger)
self.cs = client.Client(api_version, os_username, os_password,
os_project_name, os_auth_url, **client_args)
try:
if not utils.isunauthenticated(args.func):
self.cs.authenticate()
except exc.Unauthorized:
raise exc.CommandError("OpenStack credentials are not valid.")
except exc.AuthorizationFailure:
raise exc.CommandError("Unable to authorize user.")
endpoint_api_version = None
# Try to get the API version from the endpoint URL. If that fails fall
# back to trying to use what the user specified via
# --os-volume-api-version or with the OS_VOLUME_API_VERSION environment
# variable. Fail safe is to use the default API setting.
try:
endpoint_api_version = \
self.cs.get_volume_api_version_from_endpoint()
except exc.UnsupportedVersion:
endpoint_api_version = options.os_volume_api_version
if api_version_input:
logger.warning(
"Cannot determine the API version from "
"the endpoint URL. Falling back to the "
"user-specified version: %s", endpoint_api_version)
else:
logger.warning(
"Cannot determine the API version from the "
"endpoint URL or user input. Falling back "
"to the default API version: %s", endpoint_api_version)
API_MAX_VERSION = api_versions.APIVersion(api_versions.MAX_VERSION)
if endpoint_api_version[0] == '3':
disc_client = client.Client(API_MAX_VERSION, os_username,
os_password, os_project_name,
os_auth_url, **client_args)
self.cs, discovered_version = self._discover_client(
disc_client, api_version, args.os_endpoint_type,
args.service_type, os_username, os_password, os_project_name,
os_auth_url, client_args)
if discovered_version < api_version:
self.downgrade_warning(api_version, discovered_version)
profile = osprofiler_profiler and options.profile
if profile:
osprofiler_profiler.init(options.profile)
try:
args.func(self.cs, args)
finally:
if profile:
trace_id = osprofiler_profiler.get().get_base_id()
print("Trace ID: %s" % trace_id)
print("To display trace use next command:\n"
"osprofiler trace show --html %s " % trace_id)
def get_base_parser(self):
parser = CinderClientArgumentParser(
prog='cinder',
description=__doc__.strip(),
epilog=_('Run "cinder help SUBCOMMAND" for help on a subcommand.'),
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=cinderclient.__version__)
parser.add_argument('-d',
'--debug',
action='store_true',
default=utils.env('CINDERCLIENT_DEBUG',
default=False),
help=_('Shows debugging output.'))
parser.add_argument('--service-type',
metavar='<service-type>',
help=_('Service type. '
'For most actions, default is volume.'))
parser.add_argument('--service_type', help=argparse.SUPPRESS)
parser.add_argument('--service-name',
metavar='<service-name>',
default=utils.env('CINDER_SERVICE_NAME'),
help=_('Service name. '
'Default=env[CINDER_SERVICE_NAME].'))
parser.add_argument('--service_name', help=argparse.SUPPRESS)
parser.add_argument('--volume-service-name',
metavar='<volume-service-name>',
default=utils.env('CINDER_VOLUME_SERVICE_NAME'),
help=_('Volume service name. '
'Default=env[CINDER_VOLUME_SERVICE_NAME].'))
parser.add_argument('--volume_service_name', help=argparse.SUPPRESS)
parser.add_argument('--os-endpoint-type',
metavar='<os-endpoint-type>',
default=utils.env(
'CINDER_ENDPOINT_TYPE',
default=utils.env(
'OS_ENDPOINT_TYPE',
default=DEFAULT_CINDER_ENDPOINT_TYPE)),
help=_('Endpoint type, which is publicURL or '
'internalURL. '
'Default=env[OS_ENDPOINT_TYPE] or '
'nova env[CINDER_ENDPOINT_TYPE] or %s.') %
DEFAULT_CINDER_ENDPOINT_TYPE)
parser.add_argument('--os_endpoint_type', help=argparse.SUPPRESS)
parser.add_argument(
'--os-volume-api-version',
metavar='<volume-api-ver>',
default=utils.env('OS_VOLUME_API_VERSION', default=None),
help=_('Block Storage API version. '
'Accepts X, X.Y (where X is major and Y is minor '
'part).'
'Default=env[OS_VOLUME_API_VERSION].'))
parser.add_argument('--os_volume_api_version', help=argparse.SUPPRESS)
parser.add_argument('--os-endpoint',
metavar='<os-endpoint>',
dest='os_endpoint',
default=utils.env('CINDER_ENDPOINT'),
help=_("Use this API endpoint instead of the "
"Service Catalog. Defaults to "
"env[CINDER_ENDPOINT]."))
parser.add_argument('--os_endpoint', help=argparse.SUPPRESS)
parser.add_argument('--retries',
metavar='<retries>',
type=int,
default=0,
help=_('Number of retries.'))
parser.set_defaults(func=self.do_help)
parser.set_defaults(command='')
if osprofiler_profiler:
parser.add_argument(
'--profile',
metavar='HMAC_KEY',
default=utils.env('OS_PROFILE'),
help=_('HMAC key to use for encrypting '
'context data for performance profiling '
'of operation. This key needs to match the '
'one configured on the cinder api server. '
'Without key the profiling will not be '
'triggered even if osprofiler is enabled '
'on server side. Defaults to '
'env[OS_PROFILE].'))
self._append_global_identity_args(parser)
return parser
def _append_global_identity_args(self, parser):
# FIXME(bklei): these are global identity (Keystone) arguments which
# should be consistent and shared by all service clients. Therefore,
# they should be provided by python-keystoneclient. We will need to
# refactor this code once this functionality is available in
# python-keystoneclient.
parser.add_argument(
'--os-auth-strategy', metavar='<auth-strategy>',
default=utils.env('OS_AUTH_STRATEGY', default='keystone'),
help=_('Authentication strategy (Env: OS_AUTH_STRATEGY'
', default keystone). For now, any other value will'
' disable the authentication.'))
parser.add_argument(
'--os_auth_strategy',
help=argparse.SUPPRESS)
parser.add_argument('--os-username',
metavar='<auth-user-name>',
default=utils.env('OS_USERNAME',
'CINDER_USERNAME'),
help='OpenStack user name. '
'Default=env[OS_USERNAME].')
parser.add_argument('--os_username',
help=argparse.SUPPRESS)
parser.add_argument('--os-password',
metavar='<auth-password>',
default=utils.env('OS_PASSWORD',
'CINDER_PASSWORD'),
help='Password for OpenStack user. '
'Default=env[OS_PASSWORD].')
parser.add_argument('--os_password',
help=argparse.SUPPRESS)
parser.add_argument('--os-tenant-name',
metavar='<auth-tenant-name>',
default=utils.env('OS_TENANT_NAME',
'OS_PROJECT_NAME',
'CINDER_PROJECT_ID'),
help='Tenant name. '
'Default=env[OS_TENANT_NAME].')
parser.add_argument('--os_tenant_name',
help=argparse.SUPPRESS)
parser.add_argument('--os-tenant-id',
metavar='<auth-tenant-id>',
default=utils.env('OS_TENANT_ID',
'OS_PROJECT_ID',
'CINDER_TENANT_ID'),
help='ID for the tenant. '
'Default=env[OS_TENANT_ID].')
parser.add_argument('--os_tenant_id',
help=argparse.SUPPRESS)
parser.add_argument('--os-auth-url',
metavar='<auth-url>',
default=utils.env('OS_AUTH_URL',
'CINDER_URL'),
help='URL for the authentication service. '
'Default=env[OS_AUTH_URL].')
parser.add_argument('--os_auth_url',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-user-id', metavar='<auth-user-id>',
default=utils.env('OS_USER_ID'),
help=_('Authentication user ID (Env: OS_USER_ID).'))
parser.add_argument(
'--os_user_id',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-user-domain-id',
metavar='<auth-user-domain-id>',
default=utils.env('OS_USER_DOMAIN_ID'),
help='OpenStack user domain ID. '
'Defaults to env[OS_USER_DOMAIN_ID].')
parser.add_argument(
'--os_user_domain_id',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-user-domain-name',
metavar='<auth-user-domain-name>',
default=utils.env('OS_USER_DOMAIN_NAME'),
help='OpenStack user domain name. '
'Defaults to env[OS_USER_DOMAIN_NAME].')
parser.add_argument(
'--os_user_domain_name',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-project-id',
metavar='<auth-project-id>',
default=utils.env('OS_PROJECT_ID'),
help='Another way to specify tenant ID. '
'This option is mutually exclusive with '
' --os-tenant-id. '
'Defaults to env[OS_PROJECT_ID].')
parser.add_argument(
'--os_project_id',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-project-name',
metavar='<auth-project-name>',
default=utils.env('OS_PROJECT_NAME'),
help='Another way to specify tenant name. '
'This option is mutually exclusive with '
' --os-tenant-name. '
'Defaults to env[OS_PROJECT_NAME].')
parser.add_argument(
'--os_project_name',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-project-domain-id',
metavar='<auth-project-domain-id>',
default=utils.env('OS_PROJECT_DOMAIN_ID'),
help='Defaults to env[OS_PROJECT_DOMAIN_ID].')
parser.add_argument(
'--os-project-domain-name',
metavar='<auth-project-domain-name>',
default=utils.env('OS_PROJECT_DOMAIN_NAME'),
help='Defaults to env[OS_PROJECT_DOMAIN_NAME].')
parser.add_argument('--os-region-name',
metavar='<region-name>',
default=utils.env('OS_REGION_NAME',
'CINDER_REGION_NAME'),
help='Region name. '
'Default=env[OS_REGION_NAME].')
parser.add_argument('--os_region_name',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-token', metavar='<token>',
default=utils.env('OS_TOKEN'),
help=_('Defaults to env[OS_TOKEN].'))
parser.add_argument(
'--os_token',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-url', metavar='<url>',
default=utils.env('OS_URL'),
help=_('Defaults to env[OS_URL].'))
parser.add_argument(
'--os_url',
help=argparse.SUPPRESS)
# Register the CLI arguments that have moved to the session object.
session.Session.register_cli_options(parser)
parser.set_defaults(insecure=utils.env('CINDERCLIENT_INSECURE',
default=False))
def get_base_parser(self):
parser = CinderClientArgumentParser(
prog='cinder',
description=__doc__.strip(),
epilog=_('Run "cinder help SUBCOMMAND" for help on a subcommand.'),
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=cinderclient.__version__)
parser.add_argument('-d', '--debug',
action='store_true',
default=utils.env('CINDERCLIENT_DEBUG',
default=False),
help=_('Shows debugging output.'))
parser.add_argument('--os-auth-system',
metavar='<auth-system>',
default=utils.env('OS_AUTH_SYSTEM'),
help=_('Defaults to env[OS_AUTH_SYSTEM].'))
parser.add_argument('--os_auth_system',
help=argparse.SUPPRESS)
parser.add_argument('--service-type',
metavar='<service-type>',
help=_('Service type. '
'For most actions, default is volume.'))
parser.add_argument('--service_type',
help=argparse.SUPPRESS)
parser.add_argument('--service-name',
metavar='<service-name>',
default=utils.env('CINDER_SERVICE_NAME'),
help=_('Service name. '
'Default=env[CINDER_SERVICE_NAME].'))
parser.add_argument('--service_name',
help=argparse.SUPPRESS)
parser.add_argument('--volume-service-name',
metavar='<volume-service-name>',
default=utils.env('CINDER_VOLUME_SERVICE_NAME'),
help=_('Volume service name. '
'Default=env[CINDER_VOLUME_SERVICE_NAME].'))
parser.add_argument('--volume_service_name',
help=argparse.SUPPRESS)
parser.add_argument('--os-endpoint-type',
metavar='<os-endpoint-type>',
default=utils.env('CINDER_ENDPOINT_TYPE',
default=utils.env('OS_ENDPOINT_TYPE',
default=DEFAULT_CINDER_ENDPOINT_TYPE)),
help=_('Endpoint type, which is publicURL or '
'internalURL. '
'Default=env[OS_ENDPOINT_TYPE] or '
'nova env[CINDER_ENDPOINT_TYPE] or %s.')
% DEFAULT_CINDER_ENDPOINT_TYPE)
parser.add_argument('--os_endpoint_type',
help=argparse.SUPPRESS)
parser.add_argument('--endpoint-type',
metavar='<endpoint-type>',
dest='os_endpoint_type',
help=_('DEPRECATED! Use --os-endpoint-type.'))
parser.add_argument('--endpoint_type',
dest='os_endpoint_type',
help=argparse.SUPPRESS)
parser.add_argument('--os-volume-api-version',
metavar='<volume-api-ver>',
default=utils.env('OS_VOLUME_API_VERSION',
default=None),
help=_('Block Storage API version. '
'Accepts X, X.Y (where X is major and Y is minor '
'part).'
'Default=env[OS_VOLUME_API_VERSION].'))
parser.add_argument('--os_volume_api_version',
help=argparse.SUPPRESS)
parser.add_argument('--bypass-url',
metavar='<bypass-url>',
dest='bypass_url',
default=utils.env('CINDERCLIENT_BYPASS_URL'),
help=_("Use this API endpoint instead of the "
"Service Catalog. Defaults to "
"env[CINDERCLIENT_BYPASS_URL]."))
parser.add_argument('--bypass_url',
help=argparse.SUPPRESS)
parser.add_argument('--retries',
metavar='<retries>',
type=int,
default=0,
help=_('Number of retries.'))
if osprofiler_profiler:
parser.add_argument('--profile',
metavar='HMAC_KEY',
help=_('HMAC key to use for encrypting '
'context data for performance profiling '
'of operation. This key needs to match the '
'one configured on the cinder api server. '
'Without key the profiling will not be '
'triggered even if osprofiler is enabled '
'on server side.'))
self._append_global_identity_args(parser)
# The auth-system-plugins might require some extra options
cinderclient.auth_plugin.discover_auth_systems()
cinderclient.auth_plugin.load_auth_system_opts(parser)
return parser
class NoAttachmentsFound(BrickInterfaceException):
message = _("There were no attachments found for %(volume_id)s")
class IncorrectNic(BrickInterfaceException):
# TODO(mdovgal): change message after adding ipv6 support
message = _("Network interface %(iface)s has not ipv4 address assigned.")
def main(self, argv):
# Parse args once to find version and debug settings
parser = self.get_base_parser()
(options, args) = parser.parse_known_args(argv)
self.setup_debugging(options.debug)
api_version_input = True
self.options = options
if not options.os_volume_api_version:
api_version = api_versions.get_api_version(
DEFAULT_MAJOR_OS_VOLUME_API_VERSION)
else:
api_version = api_versions.get_api_version(
options.os_volume_api_version)
# build available subcommands based on version
major_version_string = "%s" % api_version.ver_major
self.extensions = client.discover_extensions(major_version_string)
self._run_extension_hooks('__pre_parse_args__')
subcommand_parser = self.get_subcommand_parser(major_version_string)
self.parser = subcommand_parser
if options.help or not argv:
subcommand_parser.print_help()
return 0
argv = self._delimit_metadata_args(argv)
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
(os_username, os_password, os_tenant_name, os_auth_url,
os_region_name, os_tenant_id, endpoint_type,
service_type, service_name, volume_service_name, bypass_url,
cacert, os_auth_system) = (
args.os_username, args.os_password,
args.os_tenant_name, args.os_auth_url,
args.os_region_name, args.os_tenant_id,
args.os_endpoint_type,
args.service_type, args.service_name,
args.volume_service_name,
args.bypass_url, args.os_cacert,
args.os_auth_system)
if os_auth_system and os_auth_system != "keystone":
auth_plugin = cinderclient.auth_plugin.load_plugin(os_auth_system)
else:
auth_plugin = None
if not service_type:
service_type = client.SERVICE_TYPES[major_version_string]
# FIXME(usrleon): Here should be restrict for project id same as
# for os_username or os_password but for compatibility it is not.
# V3 stuff
project_info_provided = ((self.options.os_tenant_name or
self.options.os_tenant_id) or
(self.options.os_project_name and
(self.options.os_project_domain_name or
self.options.os_project_domain_id)) or
self.options.os_project_id)
if not utils.isunauthenticated(args.func):
if auth_plugin:
auth_plugin.parse_opts(args)
if not auth_plugin or not auth_plugin.opts:
if not os_username:
raise exc.CommandError("You must provide a user name "
"through --os-username or "
"env[OS_USERNAME].")
if not os_password:
# No password, If we've got a tty, try prompting for it
if hasattr(sys.stdin, 'isatty') and sys.stdin.isatty():
# Check for Ctl-D
try:
os_password = getpass.getpass('OS Password: '******'t have a tty or the
# user Ctl-D when prompted.
if not os_password:
raise exc.CommandError("You must provide a password "
"through --os-password, "
"env[OS_PASSWORD] "
"or, prompted response.")
if not project_info_provided:
raise exc.CommandError(_(
"You must provide a tenant_name, tenant_id, "
"project_id or project_name (with "
"project_domain_name or project_domain_id) via "
" --os-tenant-name (env[OS_TENANT_NAME]),"
" --os-tenant-id (env[OS_TENANT_ID]),"
" --os-project-id (env[OS_PROJECT_ID])"
" --os-project-name (env[OS_PROJECT_NAME]),"
" --os-project-domain-id "
"(env[OS_PROJECT_DOMAIN_ID])"
" --os-project-domain-name "
"(env[OS_PROJECT_DOMAIN_NAME])"
))
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 authentication URL "
"through --os-auth-url or env[OS_AUTH_URL].")
if not project_info_provided:
raise exc.CommandError(_(
"You must provide a tenant_name, tenant_id, "
"project_id or project_name (with "
"project_domain_name or project_domain_id) via "
" --os-tenant-name (env[OS_TENANT_NAME]),"
" --os-tenant-id (env[OS_TENANT_ID]),"
" --os-project-id (env[OS_PROJECT_ID])"
" --os-project-name (env[OS_PROJECT_NAME]),"
" --os-project-domain-id "
"(env[OS_PROJECT_DOMAIN_ID])"
" --os-project-domain-name "
"(env[OS_PROJECT_DOMAIN_NAME])"
))
if not os_auth_url:
raise exc.CommandError(
"You must provide an authentication URL "
"through --os-auth-url or env[OS_AUTH_URL].")
auth_session = None
if not auth_plugin:
auth_session = self._get_keystone_session()
insecure = self.options.insecure
self.cs = client.Client(
api_version, os_username,
os_password, os_tenant_name, os_auth_url,
region_name=os_region_name,
tenant_id=os_tenant_id,
endpoint_type=endpoint_type,
extensions=self.extensions,
service_type=service_type,
service_name=service_name,
volume_service_name=volume_service_name,
bypass_url=bypass_url,
retries=options.retries,
http_log_debug=args.debug,
insecure=insecure,
cacert=cacert, auth_system=os_auth_system,
auth_plugin=auth_plugin,
session=auth_session,
logger=self.ks_logger if auth_session else self.client_logger)
try:
if not utils.isunauthenticated(args.func):
self.cs.authenticate()
except exc.Unauthorized:
raise exc.CommandError("OpenStack credentials are not valid.")
except exc.AuthorizationFailure:
raise exc.CommandError("Unable to authorize user.")
endpoint_api_version = None
# Try to get the API version from the endpoint URL. If that fails fall
# back to trying to use what the user specified via
# --os-volume-api-version or with the OS_VOLUME_API_VERSION environment
# variable. Fail safe is to use the default API setting.
try:
endpoint_api_version = \
self.cs.get_volume_api_version_from_endpoint()
except exc.UnsupportedVersion:
endpoint_api_version = options.os_volume_api_version
if api_version_input:
logger.warning("Cannot determine the API version from "
"the endpoint URL. Falling back to the "
"user-specified version: %s" %
endpoint_api_version)
else:
logger.warning("Cannot determine the API version from the "
"endpoint URL or user input. Falling back "
"to the default API version: %s" %
endpoint_api_version)
profile = osprofiler_profiler and options.profile
if profile:
osprofiler_profiler.init(options.profile)
args.func(self.cs, args)
if profile:
trace_id = osprofiler_profiler.get().get_base_id()
print("Trace ID: %s" % trace_id)
print("To display trace use next command:\n"
"osprofiler trace show --html %s " % trace_id)
def _append_global_identity_args(self, parser):
loading.register_session_argparse_arguments(parser)
# Use "password" auth plugin as default and keep the explicit
# "--os-token" arguments below for backward compatibility.
default_auth_plugin = 'password'
# Passing [] to loading.register_auth_argparse_arguments to avoid
# the auth_type being overridden by the command line.
loading.register_auth_argparse_arguments(
parser, [], default=default_auth_plugin)
parser.add_argument(
'--os-auth-strategy', metavar='<auth-strategy>',
default=utils.env('OS_AUTH_STRATEGY', default='keystone'),
help=_('Authentication strategy (Env: OS_AUTH_STRATEGY'
', default keystone). For now, any other value will'
' disable the authentication.'))
parser.add_argument(
'--os_auth_strategy',
help=argparse.SUPPRESS)
# Change os_auth_type default value defined by
# register_auth_argparse_arguments to be backward compatible
# with OS_AUTH_SYSTEM.
env_plugin = utils.env('OS_AUTH_TYPE',
'OS_AUTH_PLUGIN',
'OS_AUTH_SYSTEM')
parser.set_defaults(os_auth_type=env_plugin)
parser.add_argument('--os_auth_type',
help=argparse.SUPPRESS)
parser.set_defaults(os_username=utils.env('OS_USERNAME',
'CINDER_USERNAME'))
parser.add_argument('--os_username',
help=argparse.SUPPRESS)
parser.set_defaults(os_password=utils.env('OS_PASSWORD',
'CINDER_PASSWORD'))
parser.add_argument('--os_password',
help=argparse.SUPPRESS)
# tenant_name is deprecated by project_name in keystoneauth
parser.set_defaults(os_project_name=utils.env('OS_PROJECT_NAME',
'OS_TENANT_NAME',
'CINDER_PROJECT_ID'))
parser.add_argument('--os_tenant_name',
dest='os_project_name',
help=argparse.SUPPRESS)
parser.add_argument(
'--os_project_name',
help=argparse.SUPPRESS)
# tenant_id is deprecated by project_id in keystoneauth
parser.set_defaults(os_project_id=utils.env('OS_PROJECT_ID',
'OS_TENANT_ID',
'CINDER_TENANT_ID'))
parser.add_argument('--os_tenant_id',
dest='os_project_id',
help=argparse.SUPPRESS)
parser.add_argument(
'--os_project_id',
help=argparse.SUPPRESS)
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL',
'CINDER_URL'))
parser.add_argument('--os_auth_url',
help=argparse.SUPPRESS)
parser.set_defaults(os_user_id=utils.env('OS_USER_ID'))
parser.add_argument(
'--os_user_id',
help=argparse.SUPPRESS)
parser.set_defaults(
os_user_domain_id=utils.env('OS_USER_DOMAIN_ID'))
parser.add_argument(
'--os_user_domain_id',
help=argparse.SUPPRESS)
parser.set_defaults(
os_user_domain_name=utils.env('OS_USER_DOMAIN_NAME'))
parser.add_argument(
'--os_user_domain_name',
help=argparse.SUPPRESS)
parser.set_defaults(
os_project_domain_id=utils.env('OS_PROJECT_DOMAIN_ID'))
parser.set_defaults(
os_project_domain_name=utils.env('OS_PROJECT_DOMAIN_NAME'))
parser.set_defaults(
os_region_name=utils.env('OS_REGION_NAME',
'CINDER_REGION_NAME'))
parser.add_argument('--os_region_name',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-token', metavar='<token>',
default=utils.env('OS_TOKEN'),
help=_('Defaults to env[OS_TOKEN].'))
parser.add_argument(
'--os_token',
help=argparse.SUPPRESS)
parser.add_argument(
'--os-url', metavar='<url>',
default=utils.env('OS_URL'),
help=_('Defaults to env[OS_URL].'))
parser.add_argument(
'--os_url',
help=argparse.SUPPRESS)
parser.set_defaults(insecure=utils.env('CINDERCLIENT_INSECURE',
default=False))
