def get_zun_client_from_env():
# We should catch KeyError exception with the purpose of
# source or configure openrc file.
auth_url = os.environ['OS_AUTH_URL']
username = os.environ['OS_USERNAME']
password = os.environ['OS_PASSWORD']
project_name = os.environ['OS_PROJECT_NAME']
# Either project(user)_domain_name or project(user)_domain_id
# would be acceptable.
project_domain_name = os.environ.get("OS_PROJECT_DOMAIN_NAME")
project_domain_id = os.environ.get("OS_PROJECT_DOMAIN_ID")
user_domain_name = os.environ.get("OS_USER_DOMAIN_NAME")
user_domain_id = os.environ.get("OS_USER_DOMAIN_ID")
auth = identity.Password(auth_url=auth_url,
username=username,
password=password,
project_name=project_name,
project_domain_id=project_domain_id,
project_domain_name=project_domain_name,
user_domain_id=user_domain_id,
user_domain_name=user_domain_name)
session = ks.Session(auth=auth)
return client.Client(ZUN_API_VERSION, session=session)
def test_no_version_argument(self, mock_zun_client_v1):
client.Client(auth_url='http://example/identity', username='******')
api_version = api_versions.get_api_version('1')
mock_zun_client_v1.assert_called_with(
api_version=api_version,
auth_url='http://example/identity',
username='******')
def test_no_version_argument(self, mock_zun_client_v1,
mock_discover_version):
client.Client(auth_url='http://example/identity', username='******')
mock_zun_client_v1.assert_called_with(
api_version=api_versions.APIVersion('1.1'),
auth_url='http://example/identity',
username='******')
def __init__(self):
super(Schedule, self).__init__()
auth = identity.Password(**get_credential(admin_openrc=admin_openrc))
sess = session.Session(auth=auth)
# self.glance = glance_client.Client(version='2', session=sess)
self.nova = nova_client.Client(version='2', session=sess)
self.zun = zun_client.Client(version='1', session=sess)
self.neutron = neutron_client.Client(session=sess)
self.hypervisors = self.nova.hypervisors.list()
def _create(self, version=None):
if not version:
version = self.default_version
interface = self._get_client_option(CLIENT_NAME, 'endpoint_type')
args = {
'interface': interface,
'service_type': self.CONTAINER,
'session': self.context.keystone_session,
'region_name': self._get_region_name()
}
client = zun_client.Client(version, **args)
return client
def get_zun_client_from_creds():
auth_plugin, session = _get_cloud_config_auth_data()
return client.Client(ZUN_API_VERSION, session=session, auth=auth_plugin)
def test_valid_version_argument(self, mock_zun_client):
client.Client(version='1', zun_url='http://myurl/')
mock_zun_client.assert_called_with(zun_url='http://myurl/')
def test_no_version_argument(self, mock_zun_client):
client.Client(input_auth_token='mytoken', zun_url='http://myurl/')
mock_zun_client.assert_called_with(input_auth_token='mytoken',
zun_url='http://myurl/')
def main(self, argv):
# NOTE(Christoph Jansen): With Python 3.4 argv somehow becomes a Map.
# This hack fixes it.
argv = list(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 = api_versions.get_api_version(options.zun_api_version)
# NOTE(dtroyer): Hackery to handle --endpoint_type due to argparse
# thinking usage-list --end is ambiguous; but it
# works fine with only --endpoint-type present
# Go figure.
if '--endpoint_type' in argv:
spot = argv.index('--endpoint_type')
argv[spot] = '--endpoint-type'
subcommand_parser = self.get_subcommand_parser(
api_version, do_help=("help" in args))
self.parser = subcommand_parser
if options.help or not argv:
subcommand_parser.print_help()
return 0
args = subcommand_parser.parse_args(argv)
# Short-circuit and deal with help right away.
# NOTE(jamespage): args.func is not guaranteed with python >= 3.4
if not hasattr(args, 'func') or 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_project_name, os_project_id,
os_user_domain_id, os_user_domain_name,
os_project_domain_id, os_project_domain_name,
os_auth_url, os_auth_system, endpoint_type,
service_type, bypass_url, insecure) = (
(args.os_username, args.os_project_name, args.os_project_id,
args.os_user_domain_id, args.os_user_domain_name,
args.os_project_domain_id, args.os_project_domain_name,
args.os_auth_url, args.os_auth_system, args.endpoint_type,
args.service_type, args.bypass_url, args.insecure)
)
if os_auth_system and os_auth_system != "keystone":
auth_plugin = auth.load_plugin(os_auth_system)
else:
auth_plugin = None
# Fetched and set later as needed
os_password = None
if not endpoint_type:
endpoint_type = DEFAULT_ENDPOINT_TYPE
if not service_type:
service_type = DEFAULT_SERVICE_TYPE
# NA - there is only one service this CLI accesses
# service_type = utils.get_service_type(args.func) or service_type
# FIXME(usrleon): Here should be restrict for project id same as
# for os_username or os_password but for compatibility it is not.
if not cliutils.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 username "
"via either --os-username or "
"env[OS_USERNAME]")
if not os_project_name and not os_project_id:
raise exc.CommandError("You must provide a project name "
"or project id via --os-project-name, "
"--os-project-id, env[OS_PROJECT_NAME] "
"or env[OS_PROJECT_ID]")
if not os_auth_url:
if os_auth_system and os_auth_system != 'keystone':
os_auth_url = auth_plugin.get_auth_url()
if not os_auth_url:
raise exc.CommandError("You must provide an auth url "
"via either --os-auth-url or "
"env[OS_AUTH_URL] or specify an "
"auth_system which defines a "
"default url with --os-auth-system "
"or env[OS_AUTH_SYSTEM]")
# NOTE: The Zun client authenticates when you create it. So instead of
# creating here and authenticating later, which is what the
# novaclient does, we just create the client later.
# Now check for the password/token of which pieces of the
# identifying keyring key can come from the underlying client
if not cliutils.isunauthenticated(args.func):
# NA - Client can't be used with SecretsHelper
if (auth_plugin and auth_plugin.opts and
"os_password" not in auth_plugin.opts):
use_pw = False
else:
use_pw = True
if use_pw:
# Auth using token must have failed or not happened
# at all, so now switch to password mode and save
# the token when its gotten... using our keyring
# saver
os_password = args.os_password
if not os_password:
raise exc.CommandError(
'Expecting a password provided via either '
'--os-password, env[OS_PASSWORD], or '
'prompted response')
kwargs = {}
if profiler:
kwargs["profile"] = args.profile
self.cs = client.Client(version=api_version,
username=os_username,
password=os_password,
project_id=os_project_id,
project_name=os_project_name,
user_domain_id=os_user_domain_id,
user_domain_name=os_user_domain_name,
project_domain_id=os_project_domain_id,
project_domain_name=os_project_domain_name,
auth_url=os_auth_url,
service_type=service_type,
region_name=args.os_region_name,
endpoint_override=bypass_url,
interface=endpoint_type,
insecure=insecure,
**kwargs)
args.func(self.cs, args)
if profiler and args.profile:
trace_id = profiler.get().get_base_id()
print("To display trace use the command:\n\n"
" osprofiler trace show --html %s " % trace_id)