def _append_global_identity_args(self, parser, argv):
# Register the CLI arguments that have moved to the session object.
loading.register_session_argparse_arguments(parser)
# Peek into argv to see if os-auth-token or os-token were given,
# in which case, the token auth plugin is what the user wants
# else, we'll default to password
default_auth_plugin = 'password'
if 'os-token' in argv:
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(parser,
argv,
default=default_auth_plugin)
parser.set_defaults(insecure=strutils.bool_from_string(
utils.env('NOVACLIENT_INSECURE', default=False)))
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL', 'NOVA_URL'))
parser.set_defaults(
os_username=utils.env('OS_USERNAME', 'NOVA_USERNAME'))
parser.set_defaults(
os_password=utils.env('OS_PASSWORD', 'NOVA_PASSWORD'))
parser.set_defaults(os_project_name=utils.env(
'OS_PROJECT_NAME', 'OS_TENANT_NAME', 'NOVA_PROJECT_ID'))
parser.set_defaults(
os_project_id=utils.env('OS_PROJECT_ID', 'OS_TENANT_ID'))
def _append_global_identity_args(self, parser, argv):
# Register the CLI arguments that have moved to the session object.
loading.register_session_argparse_arguments(parser)
# Peek into argv to see if os-token was given,
# in which case, the token auth plugin is what the user wants
# else, we'll default to password
default_auth_plugin = 'password'
if "--os-token" in argv:
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_plugin)
parser.set_defaults(insecure=strutils.bool_from_string(
utils.env('NOVACLIENT_INSECURE', default=False)))
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL', 'NOVA_URL'))
parser.set_defaults(os_username=utils.env('OS_USERNAME',
'NOVA_USERNAME'))
parser.set_defaults(os_password=utils.env('OS_PASSWORD',
'NOVA_PASSWORD'))
parser.set_defaults(os_project_name=utils.env(
'OS_PROJECT_NAME', 'OS_TENANT_NAME', 'NOVA_PROJECT_ID'))
parser.set_defaults(os_project_id=utils.env(
'OS_PROJECT_ID', 'OS_TENANT_ID'))
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_user_domain_id=utils.env('OS_USER_DOMAIN_ID'))
parser.set_defaults(
os_user_domain_name=utils.env('OS_USER_DOMAIN_NAME'))
def _append_global_identity_args(self, parser, argv):
if not keystone_client_avail:
return
loading.register_session_argparse_arguments(parser)
default_auth_plugin = 'password'
if 'os-token' in argv:
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_plugin)
def _append_global_identity_args(self, parser, argv):
# register common identity args
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL'))
parser.set_defaults(os_project_name=utils.env(
'OS_PROJECT_NAME', 'OS_TENANT_NAME'))
parser.set_defaults(os_project_id=utils.env(
'OS_PROJECT_ID', 'OS_TENANT_ID'))
parser.add_argument('--os_tenant_id',
help=argparse.SUPPRESS)
parser.add_argument('--os_tenant_name',
help=argparse.SUPPRESS)
parser.add_argument('--os-region-name',
default=utils.env('OS_REGION_NAME'),
help='Defaults to env[OS_REGION_NAME].')
parser.add_argument('--os_region_name',
help=argparse.SUPPRESS)
parser.add_argument('--os-auth-token',
default=utils.env('OS_AUTH_TOKEN'),
help='Defaults to env[OS_AUTH_TOKEN].')
parser.add_argument('--os_auth_token',
help=argparse.SUPPRESS)
parser.add_argument('--os-service-type',
default=utils.env('OS_SERVICE_TYPE'),
help='Defaults to env[OS_SERVICE_TYPE].')
parser.add_argument('--os_service_type',
help=argparse.SUPPRESS)
parser.add_argument('--os-endpoint-type',
default=utils.env('OS_ENDPOINT_TYPE'),
help='Defaults to env[OS_ENDPOINT_TYPE].')
parser.add_argument('--os_endpoint_type',
help=argparse.SUPPRESS)
loading.register_session_argparse_arguments(parser)
# Peek into argv to see if os-auth-token (or the deprecated
# os_auth_token) or the new os-token or the environment variable
# OS_AUTH_TOKEN were given. In which case, the token auth plugin is
# what the user wants. Else, we'll default to password.
default_auth_plugin = 'password'
token_opts = ['os-token', 'os-auth-token', 'os_auth-token']
if argv and any(i in token_opts for i in argv):
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_plugin)
def _append_global_identity_args(self, parser, argv):
if not keystone_client_avail:
return
loading.register_session_argparse_arguments(parser)
default_auth_plugin = 'password'
if 'os-token' in argv:
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_plugin)
def _append_global_identity_args(self, parser, argv):
loading.register_session_argparse_arguments(parser)
# Peek into argv to see if os-auth-token (or the deprecated
# os_auth_token) or the new os-token or the environment variable
# OS_AUTH_TOKEN were given. In which case, the token auth plugin is
# what the user wants. Else, we'll default to password.
default_auth_plugin = 'password'
token_opts = ['os-token', 'os-auth-token', 'os_auth-token']
if argv and any(i in token_opts for i in argv):
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_plugin)
def test_with_default_string_value(self, m):
name = uuid.uuid4().hex
klass = loading.register_auth_argparse_arguments(self.p,
[],
default=name)
self.assertIsInstance(klass, utils.MockLoader)
m.assert_called_once_with(name)
def test_with_default_type_value(self, m):
default = utils.MockLoader()
klass = loading.register_auth_argparse_arguments(self.p,
[],
default=default)
self.assertIsInstance(klass, utils.MockLoader)
self.assertEqual(0, m.call_count)
def append_global_identity_args(parser, argv):
loading.register_auth_argparse_arguments(parser, argv, default='password')
parser.set_defaults(os_auth_url=os.getenv('OS_AUTH_URL', None))
parser.set_defaults(os_username=os.getenv('OS_USERNAME', None))
parser.set_defaults(os_password=os.getenv('OS_PASSWORD', None))
parser.set_defaults(os_project_name=os.getenv('OS_PROJECT_NAME', None))
parser.set_defaults(os_project_id=os.getenv('OS_PROJECT_ID', None))
parser.set_defaults(
os_project_domain_id=os.getenv('OS_PROJECT_DOMAIN_ID', 'default'))
parser.set_defaults(
os_project_domain_name=os.getenv('OS_PROJECT_DOMAIN_NAME', 'default'))
parser.set_defaults(
os_user_domain_id=os.getenv('OS_USER_DOMAIN_ID', 'default'))
parser.set_defaults(
os_user_domain_name=os.getenv('OS_USER_DOMAIN_NAME', 'default'))
parser.set_defaults(os_region_name=os.getenv('OS_REGION_NAME', None))
def test_overrides_default_string_value(self, m):
name = uuid.uuid4().hex
default = uuid.uuid4().hex
argv = ['--os-auth-type', name]
klass = loading.register_auth_argparse_arguments(self.p,
argv,
default=default)
self.assertIsInstance(klass, utils.MockLoader)
m.assert_called_once_with(name)
def test_overrides_default_string_value(self, m):
name = uuid.uuid4().hex
default = uuid.uuid4().hex
argv = ['--os-auth-type', name]
klass = loading.register_auth_argparse_arguments(self.p,
argv,
default=default)
self.assertIsInstance(klass, utils.MockLoader)
m.assert_called_once_with(name)
def test_basic_params_added(self, m):
name = uuid.uuid4().hex
argv = ['--os-auth-plugin', name]
ret = loading.register_auth_argparse_arguments(self.p, argv)
self.assertIsInstance(ret, utils.MockLoader)
for n in ('--os-a-int', '--os-a-bool', '--os-a-float'):
self.assertIn(n, self.p.format_usage())
m.assert_called_once_with(name)
def test_basic_params_added(self, m):
name = uuid.uuid4().hex
argv = ['--os-auth-plugin', name]
ret = loading.register_auth_argparse_arguments(self.p, argv)
self.assertIsInstance(ret, utils.MockLoader)
for n in ('--os-a-int', '--os-a-bool', '--os-a-float'):
self.assertIn(n, self.p.format_usage())
m.assert_called_once_with(name)
def test_overrides_default_type_value(self, m):
# using this test plugin would fail if called because there
# is no get_options() function
class TestLoader(object):
pass
name = uuid.uuid4().hex
argv = ['--os-auth-type', name]
klass = loading.register_auth_argparse_arguments(self.p,
argv,
default=TestLoader)
self.assertIsInstance(klass, utils.MockLoader)
m.assert_called_once_with(name)
def register_keyauth_argparse_arguments(parser):
parser.add_argument(
'--os-region-name',
metavar='<auth-region-name>',
dest='region_name',
default=os.environ.get('OS_REGION_NAME'),
help='Authentication region name (Env: OS_REGION_NAME)')
parser.add_argument(
'--os-interface',
metavar='<interface>',
dest='interface',
choices=['admin', 'public', 'internal'],
default=os.environ.get('OS_INTERFACE'),
help='Select an interface type.'
' Valid interface types: [admin, public, internal].'
' (Env: OS_INTERFACE)')
loading.register_session_argparse_arguments(parser=parser)
loading.register_auth_argparse_arguments(parser=parser, argv=sys.argv,
default='password')
def test_env_overrides_default_opt(self, m):
name = uuid.uuid4().hex
val = uuid.uuid4().hex
self.env('OS_A_STR', val)
klass = loading.register_auth_argparse_arguments(self.p, [],
default=name)
self.assertIsInstance(klass, utils.MockLoader)
opts = self.p.parse_args([])
a = loading.load_auth_from_argparse_arguments(opts)
self.assertEqual(val, a['a_str'])
def test_env_overrides_default_opt(self, m):
name = uuid.uuid4().hex
val = uuid.uuid4().hex
self.env('OS_A_STR', val)
klass = loading.register_auth_argparse_arguments(self.p,
[],
default=name)
self.assertIsInstance(klass, utils.MockLoader)
opts = self.p.parse_args([])
a = loading.load_auth_from_argparse_arguments(opts)
self.assertEqual(val, a['a_str'])
def test_overrides_default_type_value(self, m):
# using this test plugin would fail if called because there
# is no get_options() function
class TestLoader(object):
pass
name = uuid.uuid4().hex
argv = ['--os-auth-type', name]
klass = loading.register_auth_argparse_arguments(self.p,
argv,
default=TestLoader)
self.assertIsInstance(klass, utils.MockLoader)
m.assert_called_once_with(name)
def register_keyauth_argparse_arguments(parser):
parser.add_argument(
'--os-region-name',
metavar='<auth-region-name>',
dest='region_name',
default=os.environ.get('OS_REGION_NAME'),
help='Authentication region name (Env: OS_REGION_NAME)')
parser.add_argument(
'--os-interface',
metavar='<interface>',
dest='interface',
choices=['admin', 'public', 'internal'],
default=os.environ.get('OS_INTERFACE'),
help='Select an interface type.'
' Valid interface types: [admin, public, internal].'
' (Env: OS_INTERFACE)')
loading.register_session_argparse_arguments(parser=parser)
loading.register_auth_argparse_arguments(parser=parser,
argv=sys.argv,
default='password')
def _append_global_identity_args(self, parser, argv):
# Register CLI identity related arguments
# Use keystoneauth to register common CLI arguments
loading.register_session_argparse_arguments(parser)
default_auth_plugin = 'password'
if 'os-token' in argv:
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(parser, argv,
default=default_auth_plugin)
parser.set_defaults(insecure=utils.env('TROVECLIENT_INSECURE',
default=False))
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL'))
parser.set_defaults(os_project_name=utils.env(
'OS_PROJECT_NAME', 'OS_TENANT_NAME'))
parser.set_defaults(os_project_id=utils.env(
'OS_PROJECT_ID', 'OS_TENANT_ID'))
parser.add_argument('--os_tenant_name',
help=argparse.SUPPRESS)
parser.add_argument('--os_tenant_id',
help=argparse.SUPPRESS)
parser.add_argument('--os-auth-token',
default=utils.env('OS_AUTH_TOKEN'),
help=argparse.SUPPRESS)
parser.add_argument('--os-region-name',
metavar='<region-name>',
default=utils.env('OS_REGION_NAME'),
help='Specify the region to use. '
'Defaults to env[OS_REGION_NAME].')
parser.add_argument('--os_region_name',
help=argparse.SUPPRESS)
def _append_global_identity_args(self, parser, argv):
# Register CLI identity related arguments
# Use keystoneauth to register common CLI arguments
loading.register_session_argparse_arguments(parser)
default_auth_plugin = 'password'
if 'os-token' in argv:
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(parser, argv,
default=default_auth_plugin)
parser.set_defaults(insecure=utils.env('TROVECLIENT_INSECURE',
default=False))
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL'))
parser.set_defaults(os_project_name=utils.env(
'OS_PROJECT_NAME', 'OS_TENANT_NAME'))
parser.set_defaults(os_project_id=utils.env(
'OS_PROJECT_ID', 'OS_TENANT_ID'))
parser.add_argument('--os_tenant_name',
help=argparse.SUPPRESS)
parser.add_argument('--os_tenant_id',
help=argparse.SUPPRESS)
parser.add_argument('--os-auth-token',
default=utils.env('OS_AUTH_TOKEN'),
help=argparse.SUPPRESS)
parser.add_argument('--os-region-name',
metavar='<region-name>',
default=utils.env('OS_REGION_NAME'),
help=_('Specify the region to use. '
'Defaults to env[OS_REGION_NAME].'))
parser.add_argument('--os_region_name',
help=argparse.SUPPRESS)
def test_default_options(self, m):
name = uuid.uuid4().hex
argv = ['--os-auth-type', name, '--os-a-float', str(self.a_float)]
klass = loading.register_auth_argparse_arguments(self.p, argv)
self.assertIsInstance(klass, utils.MockLoader)
opts = self.p.parse_args(argv)
self.assertEqual(name, opts.os_auth_type)
a = loading.load_auth_from_argparse_arguments(opts)
self.assertEqual(self.a_float, a['a_float'])
self.assertEqual(3, a['a_int'])
def test_default_options(self, m):
name = uuid.uuid4().hex
argv = ['--os-auth-type', name,
'--os-a-float', str(self.a_float)]
klass = loading.register_auth_argparse_arguments(self.p, argv)
self.assertIsInstance(klass, utils.MockLoader)
opts = self.p.parse_args(argv)
self.assertEqual(name, opts.os_auth_type)
a = loading.load_auth_from_argparse_arguments(opts)
self.assertEqual(self.a_float, a['a_float'])
self.assertEqual(3, a['a_int'])
def build_option_parser(self, description, version):
"""Return an argparse option parser for this application.
Subclasses may override this method to extend
the parser with more global options.
:param description: full description of the application
:paramtype description: str
:param version: version number for the application
:paramtype version: str
"""
parser = super(AodhShell, self).build_option_parser(description,
version)
# Global arguments, one day this should go to keystoneauth1
parser.add_argument(
'--os-region-name',
metavar='<auth-region-name>',
dest='region_name',
default=os.environ.get('OS_REGION_NAME'),
help='Authentication region name (Env: OS_REGION_NAME)')
parser.add_argument(
'--os-interface',
metavar='<interface>',
dest='interface',
choices=['admin', 'public', 'internal'],
default=os.environ.get('OS_INTERFACE'),
help='Select an interface type.'
' Valid interface types: [admin, public, internal].'
' (Env: OS_INTERFACE)')
parser.add_argument(
'--aodh-api-version',
default=os.environ.get('AODH_API_VERSION', '2'),
help='Defaults to env[AODH_API_VERSION] or 2.')
loading.register_session_argparse_arguments(parser=parser)
plugin = loading.register_auth_argparse_arguments(
parser=parser, argv=sys.argv, default="password")
if not isinstance(plugin, noauth.AodhNoAuthLoader):
parser.add_argument(
'--aodh-endpoint',
metavar='<endpoint>',
dest='endpoint',
default=os.environ.get('AODH_ENDPOINT'),
help='Aodh endpoint (Env: AODH_ENDPOINT)')
return parser
def build_option_parser(self, description, version):
"""Return an argparse option parser for this application.
Subclasses may override this method to extend
the parser with more global options.
:param description: full description of the application
:paramtype description: str
:param version: version number for the application
:paramtype version: str
"""
parser = super(AodhShell,
self).build_option_parser(description, version)
# Global arguments, one day this should go to keystoneauth1
parser.add_argument(
'--os-region-name',
metavar='<auth-region-name>',
dest='region_name',
default=os.environ.get('OS_REGION_NAME'),
help='Authentication region name (Env: OS_REGION_NAME)')
parser.add_argument(
'--os-interface',
metavar='<interface>',
dest='interface',
choices=['admin', 'public', 'internal'],
default=os.environ.get('OS_INTERFACE'),
help='Select an interface type.'
' Valid interface types: [admin, public, internal].'
' (Env: OS_INTERFACE)')
parser.add_argument('--aodh-api-version',
default=os.environ.get('AODH_API_VERSION', '2'),
help='Defaults to env[AODH_API_VERSION] or 2.')
loading.register_session_argparse_arguments(parser=parser)
plugin = loading.register_auth_argparse_arguments(parser=parser,
argv=sys.argv,
default="password")
if not isinstance(plugin, noauth.AodhNoAuthLoader):
parser.add_argument('--aodh-endpoint',
metavar='<endpoint>',
dest='endpoint',
default=os.environ.get('AODH_ENDPOINT'),
help='Aodh endpoint (Env: AODH_ENDPOINT)')
return parser
def build_option_parser(self, description, version):
"""Return an argparse option parser for this application.
Subclasses may override this method to extend
the parser with more global options.
:param description: full description of the application
:paramtype description: str
:param version: version number for the application
:paramtype version: str
"""
parser = super(GnocchiShell, self).build_option_parser(
description, version, argparse_kwargs={'allow_abbrev': False})
parser.add_argument('--gnocchi-api-version',
default=os.environ.get('GNOCCHI_API_VERSION', '1'),
help='Defaults to env[GNOCCHI_API_VERSION] or 1.')
# NOTE(jd) This is a workaroun for people using Keystone auth with the
# CLI. A lot of rc files do not export OS_AUTH_TYPE=password and
# assumes it is the default. It's not in that case, but since we can't
# fix all the rc files of the world, workaround it here.
if ("OS_AUTH_PASSWORD" in os.environ
and "OS_AUTH_TYPE" not in os.environ):
os.environ.set("OS_AUTH_TYPE", "password")
loading.register_session_argparse_arguments(parser=parser)
plugin = loading.register_auth_argparse_arguments(
parser=parser, argv=sys.argv, default="gnocchi-basic")
if not isinstance(plugin,
(auth.GnocchiNoAuthLoader, auth.GnocchiBasicLoader)):
adapter.register_adapter_argparse_arguments(parser=parser,
service_type="metric")
adapter.register_service_adapter_argparse_arguments(
parser=parser, service_type="metric")
parser.add_argument(
'--endpoint',
default=os.environ.get('GNOCCHI_ENDPOINT'),
help='Gnocchi endpoint (Env: GNOCCHI_ENDPOINT). '
'Deprecated, use --os-endpoint-override and '
'OS_ENDPOINT_OVERRIDE instead')
return parser
def test_param_loading(self, m):
name = uuid.uuid4().hex
argv = ['--os-auth-type', name,
'--os-a-int', str(self.a_int),
'--os-a-float', str(self.a_float),
'--os-a-bool', str(self.a_bool)]
klass = loading.register_auth_argparse_arguments(self.p, argv)
self.assertIsInstance(klass, utils.MockLoader)
opts = self.p.parse_args(argv)
self.assertEqual(name, opts.os_auth_type)
a = loading.load_auth_from_argparse_arguments(opts)
self.assertTestVals(a)
self.assertEqual(name, opts.os_auth_type)
self.assertEqual(str(self.a_int), opts.os_a_int)
self.assertEqual(str(self.a_float), opts.os_a_float)
self.assertEqual(str(self.a_bool), opts.os_a_bool)
def build_option_parser(self, description, version):
"""Return an argparse option parser for this application.
Subclasses may override this method to extend
the parser with more global options.
:param description: full description of the application
:paramtype description: str
:param version: version number for the application
:paramtype version: str
"""
parser = super(GnocchiShell, self).build_option_parser(
description,
version,
argparse_kwargs={'allow_abbrev': False})
parser.add_argument(
'--gnocchi-api-version',
default=os.environ.get('GNOCCHI_API_VERSION', '1'),
help='Defaults to env[GNOCCHI_API_VERSION] or 1.')
loading.register_session_argparse_arguments(parser=parser)
plugin = loading.register_auth_argparse_arguments(
parser=parser, argv=sys.argv, default="gnocchi-basic")
if not isinstance(plugin, (auth.GnocchiNoAuthLoader,
auth.GnocchiBasicLoader)):
adapter.register_adapter_argparse_arguments(
parser=parser, service_type="metric")
adapter.register_service_adapter_argparse_arguments(
parser=parser, service_type="metric")
parser.add_argument(
'--endpoint',
default=os.environ.get('GNOCCHI_ENDPOINT'),
help='Gnocchi endpoint (Env: GNOCCHI_ENDPOINT). '
'Deprecated, use --os-endpoint-override and '
'OS_ENDPOINT_OVERRIDE instead')
return parser
def test_param_loading(self, m):
name = uuid.uuid4().hex
argv = [
'--os-auth-type', name, '--os-a-int',
str(self.a_int), '--os-a-float',
str(self.a_float), '--os-a-bool',
str(self.a_bool)
]
klass = loading.register_auth_argparse_arguments(self.p, argv)
self.assertIsInstance(klass, utils.MockLoader)
opts = self.p.parse_args(argv)
self.assertEqual(name, opts.os_auth_type)
a = loading.load_auth_from_argparse_arguments(opts)
self.assertTestVals(a)
self.assertEqual(name, opts.os_auth_type)
self.assertEqual(str(self.a_int), opts.os_a_int)
self.assertEqual(str(self.a_float), opts.os_a_float)
self.assertEqual(str(self.a_bool), opts.os_a_bool)
def build_option_parser(self, description, version):
"""Return an argparse option parser for this application.
Subclasses may override this method to extend
the parser with more global options.
:param description: full description of the application
:paramtype description: str
:param version: version number for the application
:paramtype version: str
"""
parser = super(GnocchiShell, self).build_option_parser(
description,
version,
argparse_kwargs={'allow_abbrev': False})
parser.add_argument(
'--gnocchi-api-version',
default=os.environ.get('GNOCCHI_API_VERSION', '1'),
help='Defaults to env[GNOCCHI_API_VERSION] or 1.')
loading.register_session_argparse_arguments(parser=parser)
plugin = loading.register_auth_argparse_arguments(
parser=parser, argv=sys.argv, default="gnocchi-basic")
if not isinstance(plugin, (auth.GnocchiNoAuthLoader,
auth.GnocchiBasicLoader)):
adapter.register_adapter_argparse_arguments(
parser=parser, service_type="metric")
adapter.register_service_adapter_argparse_arguments(
parser=parser, service_type="metric")
parser.add_argument(
'--endpoint',
default=os.environ.get('GNOCCHI_ENDPOINT'),
help='Gnocchi endpoint (Env: GNOCCHI_ENDPOINT). '
'Deprecated, use --os-endpoint-override and '
'OS_ENDPOINT_OVERRIDE instead')
return parser
def _append_global_identity_args(self, parser, argv):
# register common identity args
parser.set_defaults(os_auth_url=utils.env('OS_AUTH_URL'))
parser.set_defaults(os_project_name=utils.env(
'OS_PROJECT_NAME', 'OS_TENANT_NAME'))
parser.set_defaults(os_project_id=utils.env(
'OS_PROJECT_ID', 'OS_TENANT_ID'))
parser.add_argument('--key-file',
dest='os_key',
help='DEPRECATED! Use --os-key.')
parser.add_argument('--ca-file',
dest='os_cacert',
help='DEPRECATED! Use --os-cacert.')
parser.add_argument('--cert-file',
dest='os_cert',
help='DEPRECATED! Use --os-cert.')
parser.add_argument('--os_tenant_id',
help=argparse.SUPPRESS)
parser.add_argument('--os_tenant_name',
help=argparse.SUPPRESS)
parser.add_argument('--os-region-name',
default=utils.env('OS_REGION_NAME'),
help='Defaults to env[OS_REGION_NAME].')
parser.add_argument('--os_region_name',
help=argparse.SUPPRESS)
parser.add_argument('--os-auth-token',
default=utils.env('OS_AUTH_TOKEN'),
help='Defaults to env[OS_AUTH_TOKEN].')
parser.add_argument('--os_auth_token',
help=argparse.SUPPRESS)
parser.add_argument('--os-service-type',
default=utils.env('OS_SERVICE_TYPE'),
help='Defaults to env[OS_SERVICE_TYPE].')
parser.add_argument('--os_service_type',
help=argparse.SUPPRESS)
parser.add_argument('--os-endpoint-type',
default=utils.env('OS_ENDPOINT_TYPE'),
help='Defaults to env[OS_ENDPOINT_TYPE].')
parser.add_argument('--os_endpoint_type',
help=argparse.SUPPRESS)
loading.register_session_argparse_arguments(parser)
# Peek into argv to see if os-auth-token (or the deprecated
# os_auth_token) or the new os-token or the environment variable
# OS_AUTH_TOKEN were given. In which case, the token auth plugin is
# what the user wants. Else, we'll default to password.
default_auth_plugin = 'password'
token_opts = ['os-token', 'os-auth-token', 'os_auth-token']
if argv and any(i in token_opts for i in argv):
default_auth_plugin = 'token'
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_plugin)
def run(self, argv):
"""Equivalent to the main program for the application.
:param argv: input arguments and options
:paramtype argv: list of str
"""
loading.register_auth_argparse_arguments(self.parser, argv)
loading.session.register_argparse_arguments(self.parser)
loading.adapter.register_argparse_arguments(
self.parser, service_type='reservation')
try:
self.options, remainder = self.parser.parse_known_args(argv)
self.api_version = 'v%s' % self.options.os_reservation_api_version
for k, v in self.commands[self.api_version].items():
self.command_manager.add_command(k, v)
index = 0
command_pos = -1
help_pos = -1
help_command_pos = -1
for arg in argv:
if arg == 'bash-completion':
self._bash_completion()
return 0
if arg in self.commands[self.api_version]:
if command_pos == -1:
command_pos = index
elif arg in ('-h', '--help'):
if help_pos == -1:
help_pos = index
elif arg == 'help':
if help_command_pos == -1:
help_command_pos = index
index += 1
if -1 < command_pos < help_pos:
argv = ['help', argv[command_pos]]
if help_command_pos > -1 and command_pos == -1:
argv[help_command_pos] = '--help'
if self.options.deferred_help:
self.deferred_help_action(self.parser, self.parser, None, None)
self.configure_logging()
self.interactive_mode = not remainder
self.initialize_app(remainder)
except Exception as err:
if self.options.debug:
self.log.exception(str(err))
raise
else:
self.log.error(str(err))
return 1
if self.interactive_mode:
_argv = [sys.argv[0]]
sys.argv = _argv
result = self.interact()
else:
result = self.run_subcommand(remainder)
return result
def test_creating_with_no_args(self):
ret = loading.register_auth_argparse_arguments(self.p, [])
self.assertIsNone(ret)
self.assertIn('--os-auth-type', self.p.format_usage())
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():
setup_logging()
parser = argparse.ArgumentParser(
description='Tool to handle image downloads and uploads')
parser.add_argument(
'--in-file',
default=os.environ.get('IMAGETOOL_IN_FILE'),
metavar='FILE',
help='local file to send')
parser.add_argument(
'--repo',
metavar='URL',
default=os.environ.get('IMAGETOOL_REPO'),
help='url to repo containing checksums and image names')
parser.add_argument(
'--repo-match-pattern',
metavar='REGEXP',
default=os.environ.get('IMAGETOOL_REPO_MATCH_PATTERN'),
help='pattern to filter images with')
parser.add_argument(
'--out-file',
metavar='FILE',
default=os.environ.get('IMAGETOOL_OUT_FILE'),
help='file to save the image')
parser.add_argument(
'--out-file-force',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_OUT_FILE_FORCE')),
help='Download image to file even if the same image already exists')
parser.add_argument(
'--out-glance-name',
metavar='NAME',
default=os.environ.get('IMAGETOOL_OUT_GLANCE_NAME'),
help='Name to use in Glance')
parser.add_argument(
'--out-glance-disk-format',
metavar='NAME',
default=os.environ.get('IMAGETOOL_OUT_DISK_FORMAT', 'qcow2'),
help='Disk format to use in Glance')
parser.add_argument(
'--out-glance-container-format',
metavar='name',
default=os.environ.get('IMAGETOOL_OUT_CONTAINER_FORMAT', 'bare'),
help='Container format to use in glance')
parser.add_argument(
'--out-glance-min-disk',
metavar='GB',
type=int,
default=os.environ.get('IMAGETOOL_OUT_GLANCE_MIN_DISK'),
help='Optional minimum disk size required for the image in gigabytes')
parser.add_argument(
'--out-glance-min-ram',
metavar='MB',
type=int,
default=os.environ.get('IMAGETOOL_OUT_GLANCE_MIN_RAM'),
help='Optional minimum ram size required for the image in megabytes')
parser.add_argument(
'--out-glance-properties',
metavar='KEY=VAL,KEY=VAL,..',
default=os.environ.get('IMAGETOOL_OUT_GLANCE_PROPERTY'),
help='Additional image properties to set')
parser.add_argument(
'--out-glance-force',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_OUT_GLANCE_FORCE')),
help='Upload image to glance even if the same image already exists')
parser.add_argument(
'--out-glance-visibility',
metavar='name',
default=os.environ.get('IMAGETOOL_OUT_GLANCE_VISIBILITY', 'private'),
help='Set uploaded image visibility to this value')
parser.add_argument(
'--glance-image-group',
metavar='NAME',
default=os.environ.get('IMAGETOOL_GLANCE_IMAGE_GROUP'),
help='Group name to use in glance for upload and rotate')
parser.add_argument(
'--glance-rotate',
metavar='NUM',
type=int,
default=(lambda x=os.environ.get('IMAGETOOL_GLANCE_ROTATE'): int(x) if x else None)(),
help='Rotate images in glance by the image group, keep NUM amount of old images '+
'before deleting/deactivating/hiding them')
parser.add_argument(
'--glance-rotate-deactivate',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_GLANCE_ROTATE_DEACTIVATE')),
help='Deactivate old images')
parser.add_argument(
'--glance-rotate-delete',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_GLANCE_ROTATE_DELETE')),
help='Delete old images')
parser.add_argument(
'--glance-rotate-hide',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_GLANCE_ROTATE_HIDE')),
help='Hide old images')
parser.add_argument(
'--glance-rotate-force',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_GLANCE_ROTATE_FORCE')),
help='Rotate images even when we did not upload anything')
parser.add_argument(
'--glance-rotate-latest-suffix',
default=os.environ.get('IMAGETOOL_GLANCE_ROTATE_LATEST_SUFFIX'),
help='Rename latest image. Add this suffix')
parser.add_argument(
'--glance-rotate-old-suffix',
default=os.environ.get('IMAGETOOL_GLANCE_ROTATE_OLD_SUFFIX'),
help='Rename old images. Add this suffix')
parser.add_argument(
'--glance-rotate-visibility',
metavar='name',
default=os.environ.get('IMAGETOOL_GLANCE_ROTATE_VISIBILITY',
'private'),
help='Set latest image visibility to this value')
parser.add_argument(
'--verify',
action='store_true',
default=parse_bool(os.environ.get('IMAGETOOL_VERIFY')),
help='Verify uploaded or downloaded image')
loading.register_auth_argparse_arguments(parser, sys.argv)
loading.session.register_argparse_arguments(parser)
args = parser.parse_args()
try:
# Parse ['key1=val', 'key2=val,key3=val']
if args.out_glance_properties:
props = args.out_glance_properties[:]
args.out_glance_properties = [parse_kvs(item) for item in parse_list(props)]
run_tool(args)
except ImageToolError as e:
print('ERROR: {}'.format(e), file=sys.stderr)
return 1
except KeyboardInterrupt:
print('User interrupt')
return 1
return 0
def test_with_default_type_value(self, m):
default = utils.MockLoader()
klass = loading.register_auth_argparse_arguments(self.p, [],
default=default)
self.assertIsInstance(klass, utils.MockLoader)
self.assertEqual(0, m.call_count)
def test_load_with_nothing(self):
loading.register_auth_argparse_arguments(self.p, [])
opts = self.p.parse_args([])
self.assertIsNone(loading.load_auth_from_argparse_arguments(opts))
def test_load_with_nothing(self):
loading.register_auth_argparse_arguments(self.p, [])
opts = self.p.parse_args([])
self.assertIsNone(loading.load_auth_from_argparse_arguments(opts))
def test_creating_with_no_args(self):
ret = loading.register_auth_argparse_arguments(self.p, [])
self.assertIsNone(ret)
self.assertIn('--os-auth-type', self.p.format_usage())
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))
def register_argparse_arguments(self, parser, argv, service_keys=[]):
"""Register all of the common argparse options needed.
Given an argparse parser, register the keystoneauth Session arguments,
the keystoneauth Auth Plugin Options and os-cloud. Also, peek in the
argv to see if all of the auth plugin options should be registered
or merely the ones already configured.
:param argparse.ArgumentParser: parser to attach argparse options to
:param list argv: the arguments provided to the application
:param string service_keys: Service or list of services this argparse
should be specialized for, if known.
The first item in the list will be used
as the default value for service_type
(optional)
:raises exceptions.OpenStackConfigException if an invalid auth-type
is requested
"""
local_parser = argparse_mod.ArgumentParser(add_help=False)
for p in (parser, local_parser):
p.add_argument(
'--os-cloud',
metavar='<name>',
default=os.environ.get('OS_CLOUD', None),
help='Named cloud to connect to')
# we need to peek to see if timeout was actually passed, since
# the keystoneauth declaration of it has a default, which means
# we have no clue if the value we get is from the ksa default
# for from the user passing it explicitly. We'll stash it for later
local_parser.add_argument('--timeout', metavar='<timeout>')
# Peek into the future and see if we have an auth-type set in
# config AND a cloud set, so that we know which command line
# arguments to register and show to the user (the user may want
# to say something like:
# openstack --os-cloud=foo --os-oidctoken=bar
# although I think that user is the cause of my personal pain
options, _args = local_parser.parse_known_args(argv)
if options.timeout:
self._argv_timeout = True
# validate = False because we're not _actually_ loading here
# we're only peeking, so it's the wrong time to assert that
# the rest of the arguments given are invalid for the plugin
# chosen (for instance, --help may be requested, so that the
# user can see what options he may want to give
cloud = self.get_one_cloud(argparse=options, validate=False)
default_auth_type = cloud.config['auth_type']
try:
loading.register_auth_argparse_arguments(
parser, argv, default=default_auth_type)
except Exception:
# Hidiing the keystoneauth exception because we're not actually
# loading the auth plugin at this point, so the error message
# from it doesn't actually make sense to os-client-config users
options, _args = parser.parse_known_args(argv)
plugin_names = loading.get_available_plugin_names()
raise exceptions.OpenStackConfigException(
"An invalid auth-type was specified: {auth_type}."
" Valid choices are: {plugin_names}.".format(
auth_type=options.os_auth_type,
plugin_names=",".join(plugin_names)))
if service_keys:
primary_service = service_keys[0]
else:
primary_service = None
loading.register_session_argparse_arguments(parser)
adapter.register_adapter_argparse_arguments(
parser, service_type=primary_service)
for service_key in service_keys:
# legacy clients have un-prefixed api-version options
parser.add_argument(
'--{service_key}-api-version'.format(
service_key=service_key.replace('_', '-'),
help=argparse_mod.SUPPRESS))
adapter.register_service_adapter_argparse_arguments(
parser, service_type=service_key)
# Backwards compat options for legacy clients
parser.add_argument('--http-timeout', help=argparse_mod.SUPPRESS)
parser.add_argument('--os-endpoint-type', help=argparse_mod.SUPPRESS)
parser.add_argument('--endpoint-type', help=argparse_mod.SUPPRESS)
def register_argparse_arguments(self, parser, argv, service_keys=None):
"""Register all of the common argparse options needed.
Given an argparse parser, register the keystoneauth Session arguments,
the keystoneauth Auth Plugin Options and os-cloud. Also, peek in the
argv to see if all of the auth plugin options should be registered
or merely the ones already configured.
:param argparse.ArgumentParser: parser to attach argparse options to
:param list argv: the arguments provided to the application
:param string service_keys: Service or list of services this argparse
should be specialized for, if known.
The first item in the list will be used
as the default value for service_type
(optional)
:raises exceptions.OpenStackConfigException if an invalid auth-type
is requested
"""
if service_keys is None:
service_keys = []
# Fix argv in place - mapping any keys with embedded _ in them to -
_fix_argv(argv)
local_parser = argparse_mod.ArgumentParser(add_help=False)
for p in (parser, local_parser):
p.add_argument('--os-cloud',
metavar='<name>',
default=os.environ.get('OS_CLOUD', None),
help='Named cloud to connect to')
# we need to peek to see if timeout was actually passed, since
# the keystoneauth declaration of it has a default, which means
# we have no clue if the value we get is from the ksa default
# for from the user passing it explicitly. We'll stash it for later
local_parser.add_argument('--timeout', metavar='<timeout>')
# We need for get_one_cloud to be able to peek at whether a token
# was passed so that we can swap the default from password to
# token if it was. And we need to also peek for --os-auth-token
# for novaclient backwards compat
local_parser.add_argument('--os-token')
local_parser.add_argument('--os-auth-token')
# Peek into the future and see if we have an auth-type set in
# config AND a cloud set, so that we know which command line
# arguments to register and show to the user (the user may want
# to say something like:
# openstack --os-cloud=foo --os-oidctoken=bar
# although I think that user is the cause of my personal pain
options, _args = local_parser.parse_known_args(argv)
if options.timeout:
self._argv_timeout = True
# validate = False because we're not _actually_ loading here
# we're only peeking, so it's the wrong time to assert that
# the rest of the arguments given are invalid for the plugin
# chosen (for instance, --help may be requested, so that the
# user can see what options he may want to give
cloud = self.get_one_cloud(argparse=options, validate=False)
default_auth_type = cloud.config['auth_type']
try:
loading.register_auth_argparse_arguments(parser,
argv,
default=default_auth_type)
except Exception:
# Hidiing the keystoneauth exception because we're not actually
# loading the auth plugin at this point, so the error message
# from it doesn't actually make sense to os-client-config users
options, _args = parser.parse_known_args(argv)
plugin_names = loading.get_available_plugin_names()
raise exceptions.OpenStackConfigException(
"An invalid auth-type was specified: {auth_type}."
" Valid choices are: {plugin_names}.".format(
auth_type=options.os_auth_type,
plugin_names=",".join(plugin_names)))
if service_keys:
primary_service = service_keys[0]
else:
primary_service = None
loading.register_session_argparse_arguments(parser)
adapter.register_adapter_argparse_arguments(
parser, service_type=primary_service)
for service_key in service_keys:
# legacy clients have un-prefixed api-version options
parser.add_argument('--{service_key}-api-version'.format(
service_key=service_key.replace('_', '-'),
help=argparse_mod.SUPPRESS))
adapter.register_service_adapter_argparse_arguments(
parser, service_type=service_key)
# Backwards compat options for legacy clients
parser.add_argument('--http-timeout', help=argparse_mod.SUPPRESS)
parser.add_argument('--os-endpoint-type', help=argparse_mod.SUPPRESS)
parser.add_argument('--endpoint-type', help=argparse_mod.SUPPRESS)
def main():
setup_logging()
parser = argparse.ArgumentParser(
description='Tool to test Nova server provisioning')
parser.add_argument('--image-id',
metavar='UUID',
default=os.environ.get('TEST_IMAGE_ID'),
help='Image to test with')
parser.add_argument('--flavor',
metavar='NAME_OR_UUID',
default=os.environ.get('TEST_FLAVOR'),
help='Flavor name or uuid to test with')
parser.add_argument('--network',
metavar='NAME_OR_UUID',
default=os.environ.get('TEST_NETWORK'),
help='Network name or uuid to test with')
parser.add_argument(
'--test-script',
metavar='FILE',
default=os.environ.get('TEST_TEST_SCRIPT'),
help='Optional test script to deploy to server(s). Must return exit status 0 for ok. ' + \
'Must be powershell script if using cloudbase-init')
parser.add_argument('--console-logs',
metavar='PATH',
default=os.environ.get('TEST_CONSOLE_LOGS'),
help='Save console logs to this dir')
parser.add_argument('--availability-zone',
metavar='NAME',
default=os.environ.get('TEST_AVAILABILITY_ZONE'),
help='Availability zone to use')
parser.add_argument('--count',
metavar='NUM',
type=int,
default=os.environ.get('TEST_COUNT', 1),
help='How many servers to provision for the test')
parser.add_argument(
'--callhome-timeout',
metavar='secs',
type=int,
default=os.environ.get('TEST_CALLHOME_TIMEOUT', 300),
help='how long to wait for server(s) to report test completed')
parser.add_argument('--build-timeout',
metavar='secs',
type=int,
default=os.environ.get('TEST_BUILD_TIMEOUT', 300),
help='how long to wait for server(s) to start')
parser.add_argument(
'--shim-type',
choices=['bash', 'powershell'],
default=os.environ.get('TEST_SHIM_SCRIPT_TYPE', 'bash'),
help=
'What style of shim script to use. You should use powershell if your os is Windows'
)
parser.add_argument('--cloud-init-type',
choices=['cloud-init', 'cloudbase-init'],
default=os.environ.get('TEST_CLOUD_INIT_TYPE',
'cloud-init'),
help='What style cloud-init to use')
parser.add_argument('--no-cleanup-on-error',
action='store_true',
default=parse_bool(
os.environ.get('TEST_NO_CLEANUP_ON_ERROR')),
help='Do not delete instances on workflow failure')
ksloading.register_auth_argparse_arguments(parser, sys.argv)
ksloading.session.register_argparse_arguments(parser)
args = parser.parse_args()
try:
if args.flavor is None or args.image_id is None:
raise TesterError('flavor and image id are required')
auth = ksloading.cli.load_from_argparse_arguments(args)
SimpleTest(auth,
args.image_id,
args.flavor,
count=args.count,
network=args.network,
az=args.availability_zone,
test_script=args.test_script,
console_logs=args.console_logs,
build_timeout=args.build_timeout,
callhome_timeout=args.callhome_timeout,
shim_type=args.shim_type,
cloud_init_type=args.cloud_init_type,
no_cleanup_on_error=args.no_cleanup_on_error).begin()
except TesterError as e:
print('ERROR: {}'.format(e), file=sys.stderr)
return 1
except KeyboardInterrupt:
print('User interrupt')
return 1
return 0
def test_with_default_string_value(self, m):
name = uuid.uuid4().hex
klass = loading.register_auth_argparse_arguments(self.p, [],
default=name)
self.assertIsInstance(klass, utils.MockLoader)
m.assert_called_once_with(name)
