def main():
argv = sys.argv[1:]
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser(
description="Command to generate load on database")
parser.add_argument('-f', '--force', action='store_true', default=False)
parser.add_argument('--resources-file',
required=True,
help='YAML file describing resources to load',
type=argparse.FileType('r'))
parser.add_argument('--cassandra-servers',
help="Cassandra server list' (default: %(default)s)",
nargs='+',
default=['localhost:9160'])
parser.add_argument('--cassandra-username',
help="Cassandra user name (default: %(default)s)",
default=None)
parser.add_argument('--cassandra-password',
help="Cassandra user password (default: %(default)s)",
default=None)
parser.add_argument('--cassandra-use-ssl',
help="Cassandra use SSL flag (default: %(default)s)",
default=None)
parser.add_argument(
'--cassandra-ca-certs',
help="Cassandra CA certs file path (default: %(default)s)",
default=None)
parser.add_argument('--db-prefix',
help="Cassandra keyspace prefix "
"(default: %(default)s)",
default="")
parser.add_argument('--cassandra-batch-size',
type=int,
help="Job queue size for cassandra batch "
"(default: %(default)s)",
default=LoadDataBase.BATCH_QUEUE_SIZE)
parser.add_argument('--dont-populate-zookeeper',
action='store_true',
help="Do not populate zookeeper database which is "
"very slow and may take time "
"(default: %(default)s)",
default=False)
parser.add_argument('--zookeeper-servers',
help="Zookeeper server list (default: %(default)s)",
nargs='+',
default=['localhost:2181'])
parser.add_argument('--rules-per-security-group',
type=int,
help="Rules ramdomly generated per created security "
"group (default: %(default)s)",
default=LoadDataBase.RULES_PER_SG)
ksession.Session.register_cli_options(parser)
kauth.register_argparse_arguments(parser, argv)
params, _ = parser.parse_known_args(argv)
try:
keystone_auth = kauth.load_from_argparse_arguments(params)
keystone_session = ksession.Session.load_from_cli_options(
params, auth=keystone_auth)
keystone_client = kclient.Client(session=keystone_session)
except kexceptions.DiscoveryFailure:
keystone_client = None
param_dict = vars(params)
param_dict['keystone_client'] = keystone_client
for opt in ksession.Session.get_conf_options():
try:
param_dict.pop('os_%s' % opt.dest)
except KeyError:
param_dict.pop('%s' % opt.dest, None)
for opt in\
kauth.base.get_plugin_class(params.os_auth_plugin).get_options():
param_dict.pop('os_%s' % opt.dest)
param_dict = {
k: v
for k, v in param_dict.items() if not k.startswith('os_')
}
database_loader = LoadDataBase(**param_dict)
database_loader.sanitize_resources()
database_loader.summarize_resources_to_create()
database_loader.create_resources()
def _get_keystone(username, password, tenant_name, auth_url):
klient = ksclient.Client(auth_url=auth_url)
klient.authenticate(username=username,
password=password,
tenant_name=tenant_name)
return klient
def get_version(self, base_url=None):
try:
keystone_client = client.Client(auth_url=base_url)
except exceptions.ConnectionRefused:
raise
return keystone_client.version
def get_keystoneclient(session):
return keystone_client.Client("3.1", session=session)
print("PRIVATEIAAS: Initializing v3 API session")
admin_auth = auth_v3.Password(username=username,
password=password,
project_name=project_name,
user_domain_name=user_domain,
project_domain_name=project_domain,
auth_url=auth_url)
admin_session = keystone_session.Session(auth=admin_auth)
try:
print("PRIVATEIAAS: Spawning ADMIN CLIENT")
# admin session
if api_version == 2:
keystoneclient = keystone_client.Client(session=admin_session)
else:
keystoneclient = keystone_client_v3.Client(session=admin_session)
except AuthorizationFailure as user_failed_auth_step:
print(user_failed_auth_step.message)
sys.exit(-1)
except Unauthorized as user_unauthorized:
print(user_unauthorized.message)
sys.exit(-1)
except Exception as e: # Catch superclass, so we can intercept every kind of error.
print("Exception caught while calling client.Client(): \n[%s]" % e)
sys.exit(-1)
# tenant manager reference
if hasattr(keystoneclient, "projects"):
tenant_manager = getattr(keystoneclient, "projects")
def keystone(self):
if not self._keystone:
self._keystone = keyclient.Client(session=self.session)
return self._keystone
def keystone_client(version, session):
return ks_client.Client(version=version,
session=session)
def keystoneclient(self):
if not self._keystoneclient:
client = _keystoneclient.Client(session=self.keystone_session)
self._keystoneclient = client
return self._keystoneclient
def get_keystone_client(other_creds={}):
sess = get_session(other_creds)
return keystoneclient.Client(get_keystone_client_version(),
session=sess,
interface=os.getenv('OS_INTERFACE', 'admin'))
def initialize_client(self, version, **kwargs):
from keystoneclient.v3 import client
auth_plugin = v3.Password(**kwargs)
ses = self.get_session(auth_plugin=auth_plugin)
cli = client.Client(session=ses)
return cli
def keystone_client(other_creds={}):
sess = session(other_creds)
return keystoneclient.Client(keystone_client_version(), session=sess)
# -*- coding: utf-8 -*-
"""
Created on 2018/7/12 16:31
@author: mengph
reach
"""
from keystoneauth1 import loading,session
from keystoneclient import client
from keystoneclient import base
from keystoneclient import exceptions
keystone_url_200="http://172.16.90.2:5000/v2.0"
keystone_url_10_2="http://10.121.137.50:5000/v2.0"
keystone_url_180_3="http://172.15.50.2:5000/v2.0"
keystone_url_108="http://172.16.80.3:5000/v2.0"
keystone_url_tmp="http://10.121.136.132:5000/v2.0"
loader=loading.get_plugin_loader('password')
auth=loader.load_from_options(auth_url=keystone_url_10_2,username="******",password="******",project_name="admin")
sess=session.Session(auth=auth)
keystone=client.Client(version="2.0",session=sess)
print keystone.tokens.authenticate(username="******", tenant_name="admin", password="******").to_dict()["token"]["id"]
def get_keystoneclient(version=DEFAULT_IDENTITY_VERSION):
return ks_client.Client(version, session=get_auth_session())
def get_client(self):
return client.Client(version=self.version,
session=self.session,
auth_url=OS_AUTH_URL)
def kapi(self):
if not self._kapi:
self._kapi = keystone_client.Client(session=self.session)
return self._kapi
def keystone_client(keystone_session):
"""Return a keystone client from the options in hil.cfg"""
return client.Client(session=keystone_session)
def keystone(context):
url = context.session.get_endpoint(service_type='identity')
return keystoneclient.Client(auth_url=url, session=context.session)
def setUp(self):
super(ClientTestBase, self).setUp()
test_timeout = os.environ.get('OS_TEST_TIMEOUT', 0)
try:
test_timeout = int(test_timeout)
except ValueError:
test_timeout = 0
if test_timeout > 0:
self.useFixture(fixtures.Timeout(test_timeout, gentle=True))
if (os.environ.get('OS_STDOUT_CAPTURE') == 'True'
or os.environ.get('OS_STDOUT_CAPTURE') == '1'):
stdout = self.useFixture(fixtures.StringStream('stdout')).stream
self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout))
if (os.environ.get('OS_STDERR_CAPTURE') == 'True'
or os.environ.get('OS_STDERR_CAPTURE') == '1'):
stderr = self.useFixture(fixtures.StringStream('stderr')).stream
self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr))
if (os.environ.get('OS_LOG_CAPTURE') != 'False'
and os.environ.get('OS_LOG_CAPTURE') != '0'):
self.useFixture(
fixtures.LoggerFixture(nuke_handlers=False,
format=self.log_format,
level=None))
# Collecting of credentials:
#
# Grab the cloud config from a user's clouds.yaml file.
# First look for a functional_admin cloud, as this is a cloud
# that the user may have defined for functional testing that has
# admin credentials.
# If that is not found, get the devstack config and override the
# username and project_name to be admin so that admin credentials
# will be used.
#
# Finally, fall back to looking for environment variables to support
# existing users running these the old way. We should deprecate that
# as tox 2.0 blanks out environment.
#
# TODO(sdague): while we collect this information in
# tempest-lib, we do it in a way that's not available for top
# level tests. Long term this probably needs to be in the base
# class.
openstack_config = os_client_config.config.OpenStackConfig()
try:
cloud_config = openstack_config.get_one_cloud('functional_admin')
except os_client_config.exceptions.OpenStackConfigException:
try:
cloud_config = openstack_config.get_one_cloud(
'devstack',
auth=dict(username='******', project_name='admin'))
except os_client_config.exceptions.OpenStackConfigException:
try:
cloud_config = openstack_config.get_one_cloud('envvars')
except os_client_config.exceptions.OpenStackConfigException:
cloud_config = None
if cloud_config is None:
raise NoCloudConfigException(
"Could not find a cloud named functional_admin or a cloud"
" named devstack. Please check your clouds.yaml file and"
" try again.")
auth_info = cloud_config.config['auth']
user = auth_info['username']
passwd = auth_info['password']
self.project_name = auth_info['project_name']
auth_url = auth_info['auth_url']
user_domain_id = auth_info['user_domain_id']
self.project_domain_id = auth_info['project_domain_id']
if 'insecure' in cloud_config.config:
self.insecure = cloud_config.config['insecure']
else:
self.insecure = False
auth = identity.Password(username=user,
password=passwd,
project_name=self.project_name,
auth_url=auth_url,
project_domain_id=self.project_domain_id,
user_domain_id=user_domain_id)
session = ksession.Session(auth=auth, verify=(not self.insecure))
self.client = self._get_novaclient(session)
self.glance = glanceclient.Client('2', session=session)
# pick some reasonable flavor / image combo
if "flavor" not in CACHE:
CACHE["flavor"] = pick_flavor(self.client.flavors.list())
if "image" not in CACHE:
CACHE["image"] = pick_image(self.glance.images.list())
self.flavor = CACHE["flavor"]
self.image = CACHE["image"]
if "network" not in CACHE:
tested_api_version = self.client.api_version
proxy_api_version = novaclient.api_versions.APIVersion('2.35')
if tested_api_version > proxy_api_version:
self.client.api_version = proxy_api_version
try:
# TODO(mriedem): Get the networks from neutron if using neutron
networks = self.client.networks.list()
# Keep track of whether or not there are multiple networks
# available to the given tenant because if so, a specific
# network ID has to be passed in on server create requests
# otherwise the server POST will fail with a 409.
CACHE['multiple_networks'] = len(networks) > 1
CACHE["network"] = pick_network(networks)
finally:
self.client.api_version = tested_api_version
self.network = CACHE["network"]
self.multiple_networks = CACHE['multiple_networks']
# create a CLI client in case we'd like to do CLI
# testing. tempest.lib does this really weird thing where it
# builds a giant factory of all the CLIs that it knows
# about. Eventually that should really be unwound into
# something more sensible.
cli_dir = os.environ.get(
'OS_NOVACLIENT_EXEC_DIR',
os.path.join(os.path.abspath('.'), '.tox/functional/bin'))
self.cli_clients = tempest.lib.cli.base.CLIClient(
username=user,
password=passwd,
tenant_name=self.project_name,
uri=auth_url,
cli_dir=cli_dir,
insecure=self.insecure)
self.keystone = keystoneclient.Client(session=session,
username=user,
password=passwd)
self.cinder = cinderclient.Client(auth=auth, session=session)
if "use_neutron" not in CACHE:
# check to see if we're running with neutron or not
for service in self.keystone.services.list():
if service.type == 'network':
CACHE["use_neutron"] = True
break
else:
CACHE["use_neutron"] = False
def _get_client(**credentials):
return client.Client(session=get_session(**credentials))
def __init__(self, **kwargs):
"""Description
Return Keystone client for defined in 'identity_service' conf.
NOTE: We will use tenant_name until we start using keystone V3
client for all our needs.
:param version: service client version which we will use
:type version: str
:param username: username
:type username: str
:param password: password
:type password: str
:param tenant_name: tenant_name
:type tenant_name: str
:param auth_url: auth_url
:type auth_url: str
:param ctx: blazar context object
:type ctx: dict
:param auth_url: keystone auth url
:type auth_url: string
:param endpoint: keystone management (endpoint) url
:type endpoint: string
:param trust_id: keystone trust ID
:type trust_id: string
:param token: user token to use for authentication
:type token: string
"""
ctx = kwargs.pop('ctx', None)
if ctx is None:
try:
ctx = context.current()
except RuntimeError:
pass
kwargs.setdefault('version', cfg.CONF.keystone_client_version)
if ctx is not None:
kwargs.setdefault('username', ctx.user_name)
kwargs.setdefault('tenant_name', ctx.project_name)
if not kwargs.get('auth_url'):
kwargs['auth_url'] = base.url_for(
ctx.service_catalog,
CONF.identity_service,
os_region_name=CONF.os_region_name)
if not kwargs.get('trust_id'):
try:
kwargs.setdefault(
'endpoint',
base.url_for(ctx.service_catalog,
CONF.identity_service,
endpoint_interface='admin',
os_region_name=CONF.os_region_name))
except AttributeError:
raise manager_exceptions.NoManagementUrl()
if not kwargs.get('password'):
kwargs.setdefault('token', ctx.auth_token)
# NOTE(dbelova): we need this checking to support current
# keystoneclient: token can only be scoped now to either
# a trust or project, not both.
if kwargs.get('trust_id') and kwargs.get('tenant_name'):
kwargs.pop('tenant_name')
try:
# NOTE(n.s.): we shall remove this try: except: clause when
# https://review.openstack.org/#/c/66494/ will be merged
self.keystone = keystone_client.Client(**kwargs)
self.keystone.session.auth = self.keystone
auth_url = self.complement_auth_url(kwargs.get('auth_url', None),
kwargs.get('version', None))
self.keystone.authenticate(auth_url=auth_url)
except AttributeError:
raise manager_exceptions.WrongClientVersion()
self.exceptions = keystone_exception
