def consume(cache, args): username, password, project_dom, user_dom, tenant_id = args if "client" not in cache: clients = osclients.Clients(self.credential) cache["client"] = identity.Identity( clients, name_generator=self.generate_random_name) client = cache["client"] user = client.create_user(username, password=password, project_id=tenant_id, domain_name=user_dom, default_role=default_role) user_credential = credential.OpenStackCredential( auth_url=self.credential.auth_url, username=user.name, password=password, tenant_name=self.context["tenants"][tenant_id]["name"], permission=consts.EndpointPermission.USER, project_domain_name=project_dom, user_domain_name=user_dom, endpoint_type=self.credential.endpoint_type, https_insecure=self.credential.https_insecure, https_cacert=self.credential.https_cacert, region_name=self.credential.region_name, profiler_hmac_key=self.credential.profiler_hmac_key) users.append({ "id": user.id, "credential": user_credential, "tenant_id": tenant_id })
def test_users_contains_default_endpoint_type(self, mock_identity): credential = oscredential.OpenStackCredential("foo_url", "foo", "foo_pass") config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "admin": { "credential": credential }, "task": { "uuid": "task_id", "deployment_uuid": "deployment_id" } } user_generator = users.UserGenerator(config) users_ = user_generator._create_users() for user in users_: self.assertEqual("public", user["credential"].endpoint_type)
def test_keystone_get_session(self, auth_url): credential = oscredential.OpenStackCredential(auth_url, "user", "pass", "tenant") self.set_up_keystone_mocks() keystone = osclients.Keystone(credential, {}, {}) version_data = mock.Mock(return_value=[{"version": (1, 0)}]) self.ksa_auth.discover.Discover.return_value = (mock.Mock( version_data=version_data)) self.assertEqual( (self.ksa_session.Session.return_value, self.ksa_identity_plugin), keystone.get_session()) if auth_url.endswith("v2.0"): self.ksa_password.assert_called_once_with(auth_url=auth_url, password="******", tenant_name="tenant", username="******") else: self.ksa_password.assert_called_once_with(auth_url=auth_url, password="******", tenant_name="tenant", username="******", domain_name=None, project_domain_name=None, user_domain_name=None) self.ksa_session.Session.assert_has_calls([ mock.call(timeout=180.0, verify=True), mock.call(auth=self.ksa_identity_plugin, timeout=180.0, verify=True) ])
def test_users_contains_correct_endpoint_type(self, mock_identity): credential = oscredential.OpenStackCredential( "foo_url", "foo", "foo_pass", endpoint_type=consts.EndpointType.INTERNAL) config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "admin": { "credential": credential }, "task": { "uuid": "task_id" } } user_generator = users.UserGenerator(config) users_ = user_generator._create_users() for user in users_: self.assertEqual("internal", user["credential"].endpoint_type)
def test_users_and_tenants_in_context(self, mock_identity): identity_service = mock_identity.Identity.return_value credential = oscredential.OpenStackCredential("foo_url", "foo", "foo_pass", https_insecure=True, https_cacert="cacert") tmp_context = dict(self.context) tmp_context["config"]["users"] = { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } tmp_context["admin"]["credential"] = credential credential_dict = credential.to_dict() user_list = [ mock.MagicMock(id="id_%d" % i) for i in range(self.users_num) ] identity_service.create_user.side_effect = user_list with users.UserGenerator(tmp_context) as ctx: ctx.generate_random_name = mock.Mock() ctx.setup() create_tenant_calls = [] for i, t in enumerate(ctx.context["tenants"]): create_tenant_calls.append( mock.call(ctx.generate_random_name.return_value, ctx.config["project_domain"])) for user in ctx.context["users"]: self.assertEqual(set(["id", "credential", "tenant_id"]), set(user.keys())) user_credential_dict = user["credential"].to_dict() excluded_keys = [ "auth_url", "username", "password", "tenant_name", "region_name", "project_domain_name", "user_domain_name" ] for key in (set(credential_dict.keys()) - set(excluded_keys)): self.assertEqual(credential_dict[key], user_credential_dict[key]) tenants_ids = [] for t in ctx.context["tenants"].keys(): tenants_ids.append(t) for (user, tenant_id, orig_user) in zip(ctx.context["users"], tenants_ids, user_list): self.assertEqual(user["id"], orig_user.id) self.assertEqual(user["tenant_id"], tenant_id)
def get_all_credentials(self): all_credentials = {} for platform, credentials in self._all_credentials.items(): if platform == "openstack": from rally.plugins.openstack import credential admin = credentials[0]["admin"] if admin: admin = credential.OpenStackCredential( permission=consts.EndpointPermission.ADMIN, **admin) all_credentials[platform] = [{ "admin": admin, "users": [ credential.OpenStackCredential(**user) for user in credentials[0]["users"] ] }] else: all_credentials[platform] = credentials return all_credentials
def create_from_env(cls): creds = envutils.get_creds_from_env_vars() from rally.plugins.openstack import credential oscred = credential.OpenStackCredential( auth_url=creds["auth_url"], username=creds["admin"]["username"], password=creds["admin"]["password"], tenant_name=creds["admin"]["tenant_name"], endpoint_type=creds["endpoint_type"], user_domain_name=creds["admin"].get("user_domain_name"), project_domain_name=creds["admin"].get("project_domain_name"), endpoint=creds["endpoint"], region_name=creds["region_name"], https_cacert=creds["https_cacert"], https_insecure=creds["https_insecure"]) return cls(oscred)
def setUp(self): super(OSClientsTestCase, self).setUp() self.credential = oscredential.OpenStackCredential( "http://auth_url/v2.0", "user", "pass", "tenant") self.clients = osclients.Clients(self.credential, {}) self.fake_keystone = fakes.FakeKeystoneClient() keystone_patcher = mock.patch("rally.osclients.Keystone.create_client", return_value=self.fake_keystone) self.mock_create_keystone_client = keystone_patcher.start() self.auth_ref_patcher = mock.patch("rally.osclients.Keystone.auth_ref") self.auth_ref = self.auth_ref_patcher.start() self.service_catalog = self.auth_ref.service_catalog self.service_catalog.url_for = mock.MagicMock()
def __init__(self, deployment, config): super(OpenStackProvider, self).__init__(deployment, config) user_credential = credential.OpenStackCredential( auth_url=config["auth_url"], username=config["user"], password=config["password"], tenant_name=config["tenant"], region_name=config.get("region")) clients = user_credential.clients() self.nova = clients.nova() self.sg = None try: self.glance = clients.glance() except KeyError: self.glance = None LOG.warning( _("Glance endpoint not available in service catalog" ", only existing images can be used"))
def test__get_endpoint(self, mock_keystone_service_catalog, endpoint_type, service_type, region_name): credential = oscredential.OpenStackCredential( "http://auth_url/v2.0", "user", "pass", endpoint_type=endpoint_type, region_name=region_name) mock_choose_service_type = mock.MagicMock() osclient = osclients.OSClient(credential, {}, mock.MagicMock()) osclient.choose_service_type = mock_choose_service_type mock_url_for = mock_keystone_service_catalog.url_for self.assertEqual(mock_url_for.return_value, osclient._get_endpoint(service_type)) call_args = { "service_type": mock_choose_service_type.return_value, "region_name": region_name} if endpoint_type: call_args["interface"] = endpoint_type mock_url_for.assert_called_once_with(**call_args) mock_choose_service_type.assert_called_once_with(service_type)
def setUp(self): super(SaharaOutputDataSourcesTestCase, self).setUp() fake_dict = oscredential.OpenStackCredential( "http://fake.example.org:5000/v2.0/", "user", "passwd") self.tenants_num = 2 self.users_per_tenant = 2 self.users = self.tenants_num * self.users_per_tenant self.task = mock.MagicMock() self.tenants = {} self.users_key = [] for i in range(self.tenants_num): self.tenants[str(i)] = {"id": str(i), "name": str(i), "sahara": {"image": "42"}} for j in range(self.users_per_tenant): self.users_key.append({"id": "%s_%s" % (str(i), str(j)), "tenant_id": str(i), "credential": fake_dict}) self.user_key = [{"id": i, "tenant_id": j, "credential": "credential"} for j in range(self.tenants_num) for i in range(self.users_per_tenant)] self.context.update({ "config": { "users": { "tenants": self.tenants_num, "users_per_tenant": self.users_per_tenant, }, "sahara_output_data_sources": { "output_type": "hdfs", "output_url_prefix": "hdfs://test_host/", }, }, "admin": {"credential": mock.MagicMock()}, "task": mock.MagicMock(), "users": self.users_key, "tenants": self.tenants })
def main(): parser = argparse.ArgumentParser(description="Launch rally-verify job.") parser.add_argument("--mode", type=str, default="light", help="Mode of job. The 'full' mode corresponds to the " "full set of verifier tests. The 'light' mode " "corresponds to the smoke set of verifier tests.", choices=MODES.keys()) parser.add_argument("--compare", action="store_true", help="Start the second verification to generate a " "trends report for two verifications.") # TODO(ylobankov): Remove hard-coded Tempest related things and make it # configurable. parser.add_argument("--ctx-create-resources", action="store_true", help="Make Tempest context create needed resources " "for the tests.") args = parser.parse_args() if not os.path.exists("%s/extra" % BASE_DIR): os.makedirs("%s/extra" % BASE_DIR) # Choose and check the deployment call_rally("deployment use --deployment %s" % DEPLOYMENT_NAME) call_rally("deployment check") config = json.loads( subprocess.check_output(["rally", "deployment", "config"])) config = config["creds"]["openstack"] config.update(config.pop("admin")) clients = credential.OpenStackCredential(**config).clients() if args.ctx_create_resources: # If the 'ctx-create-resources' arg is provided, delete images and # flavors, and also create a shared network to make Tempest context # create needed resources. LOG.info("The 'ctx-create-resources' arg is provided. Deleting " "images and flavors, and also creating a shared network " "to make Tempest context create needed resources.") LOG.info("Deleting images.") for image in clients.glance().images.list(): clients.glance().images.delete(image.id) LOG.info("Deleting flavors.") for flavor in clients.nova().flavors.list(): clients.nova().flavors.delete(flavor.id) LOG.info("Creating a shared network.") net_body = { "network": { "name": "shared-net-%s" % str(uuid.uuid4()), "tenant_id": clients.keystone.auth_ref.project_id, "shared": True } } clients.neutron().create_network(net_body) else: # Otherwise, just in case create only flavors with the following # properties: RAM = 64MB and 128MB, VCPUs = 1, disk = 0GB to make # Tempest context discover them. LOG.info("The 'ctx-create-resources' arg is not provided. " "Creating flavors to make Tempest context discover them.") for flv_ram in [64, 128]: params = { "name": "flavor-%s" % str(uuid.uuid4()), "ram": flv_ram, "vcpus": 1, "disk": 0 } LOG.info("Creating flavor '%s' with the following properties: RAM " "= %dMB, VCPUs = 1, disk = 0GB" % (params["name"], flv_ram)) clients.nova().flavors.create(**params) render_vars = dict(verifications=[]) # List plugins for verifiers management render_vars["list_plugins"] = call_rally("verify list-plugins") # Create a verifier render_vars["create_verifier"] = call_rally( "verify create-verifier --type %s --name my-verifier --source %s" % (VERIFIER_TYPE, VERIFIER_SOURCE)) # Show the verifier render_vars["show_verifier"] = call_rally("verify show-verifier") # List verifiers render_vars["list_verifiers"] = call_rally("verify list-verifiers") # Get verifier ID verifier_id = envutils.get_global(envutils.ENV_VERIFIER) # Get the penultimate verifier commit ID repo_dir = os.path.join( os.path.expanduser("~"), ".rally/verification/verifier-%s/repo" % verifier_id) p_commit_id = subprocess.check_output( ["git", "log", "-n", "1", "--pretty=format:%H"], cwd=repo_dir).strip() # Switch the verifier to the penultimate version render_vars["update_verifier"] = call_rally( "verify update-verifier --version %s --update-venv" % p_commit_id) # Generate and show the verifier config file render_vars["configure_verifier"] = call_rally( "verify configure-verifier --show") # Add a verifier extension render_vars["add_verifier_ext"] = call_rally( "verify add-verifier-ext --source %s" % VERIFIER_EXT_REPO) # List verifier extensions render_vars["list_verifier_exts"] = call_rally("verify list-verifier-exts") # List verifier tests render_vars["list_verifier_tests"] = call_rally( "verify list-verifier-tests %s" % MODES[args.mode]) # Start a verification, show results and generate reports skip_list_path = write_file("skip-list.yaml", SKIP_TESTS) xfail_list_path = write_file("xfail-list.yaml", XFAIL_TESTS) run_args = ("%s --skip-list %s --xfail-list %s --tag first-run %s-set " "--detailed" % (MODES[args.mode], skip_list_path, xfail_list_path, args.mode)) render_vars["verifications"].append(start_verification(run_args)) if args.compare: # Start another verification, show results and generate reports with gzip.open(render_vars["list_verifier_tests"]["stdout_file"]) as f: tests = [t for t in f.read().split("\n") if TEST_NAME_RE.match(t)] load_list_path = write_file("load-list.txt", "\n".join(tests)) run_args = "--load-list %s --tag second-run %s-set --detailed" % ( load_list_path, args.mode) render_vars["verifications"].append(start_verification(run_args)) # Generate trends reports for two verifications render_vars["compare"] = generate_trends_reports( render_vars["verifications"][-2]["uuid"], render_vars["verifications"][-1]["uuid"]) # List verifications render_vars["list"] = call_rally("verify list") # Delete the verifier extension render_vars["delete_verifier_ext"] = call_rally( "verify delete-verifier-ext --name %s" % VERIFIER_EXT_NAME) # Delete the verifier and all verifications render_vars["delete_verifier"] = call_rally( "verify delete-verifier --id %s --force" % verifier_id) render_page(**render_vars) return _return_status
def __init__(self, **kwargs): self.clients = credential.OpenStackCredential(**kwargs).clients()
def test__remove_url_version(self, original, cropped): credential = oscredential.OpenStackCredential(original, "user", "pass", "tenant") keystone = osclients.Keystone(credential, {}, {}) self.assertEqual(cropped, keystone._remove_url_version())
def setUp(self): super(TestCreateKeystoneClient, self).setUp() self.credential = oscredential.OpenStackCredential( "http://auth_url/v2.0", "user", "pass", "tenant")
def setUp(self): super(OpenStackCredentialTestCase, self).setUp() self.credential = credential.OpenStackCredential( "foo_url", "foo_user", "foo_password", tenant_name="foo_tenant")