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