def test_update_endpoints(self, mock_update):
mock_update.return_value = self.deployment
deploy = objects.Deployment(deployment=self.deployment)
endpoints = {
"admin":
objects.Endpoint("url", "user", "pwd", "tenant",
consts.EndpointPermission.ADMIN),
"users": [
objects.Endpoint("url1", "user1", "pwd1", "tenant1",
consts.EndpointPermission.USER),
objects.Endpoint("url2", "user2", "pwd2", "tenant2",
consts.EndpointPermission.USER),
]
}
expected_users = [
u.to_dict(include_permission=True) for u in endpoints["users"]
]
deploy.update_endpoints(endpoints)
mock_update.assert_called_once_with(
self.deployment["uuid"], {
"admin": endpoints["admin"].to_dict(include_permission=True),
"users": expected_users
})
def check(self, deployment=None):
"""Check keystone authentication and list all available services.
:param deployment: a UUID or name of the deployment
"""
headers = ["services", "type", "status"]
table_rows = []
try:
deployment = db.deployment_get(deployment)
admin = deployment.get("admin")
clients = osclients.Clients(objects.Endpoint(**admin))
client = clients.verified_keystone()
for service in client.services.list():
data = [service.name, service.type, "Available"]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
users = deployment.get("users")
for endpoint_dict in users:
osclients.Clients(objects.Endpoint(**endpoint_dict)).keystone()
print(
_("keystone endpoints are valid and following"
" services are available:"))
except exceptions.InvalidArgumentsException:
data = ["keystone", "identity", "Error"]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
print(_("Authentication Issues: %s.") % sys.exc_info()[1])
return (1)
cliutils.print_list(table_rows, headers)
def test_endpoint(self):
endpoint = objects.Endpoint("url", "user", "pwd", "tenant", "admin")
self.assertEqual(endpoint.to_dict(include_permission=True),
{"auth_url": "url", "username": "******",
"password": "******", "tenant_name": "tenant",
"region_name": None, "permission": "admin",
"use_public_urls": False, 'admin_port': 35357})
def create_from_env(cls):
return cls(
objects.Endpoint(os.environ["OS_AUTH_URL"],
os.environ["OS_USERNAME"],
os.environ["OS_PASSWORD"],
os.environ.get("OS_TENANT_NAME"),
region_name=os.environ.get("OS_REGION_NAME")))
def _prepare_boot(self, mock_osclients, nic=None, assert_nic=False):
fake_server = mock.MagicMock()
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
nova = fakes.FakeNovaClient()
fc.nova = lambda: nova
user_endpoint = objects.Endpoint("url", "user", "password", "tenant")
clients = osclients.Clients(user_endpoint)
scenario = servers.NovaServers(clients=clients)
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
kwargs = {"fakearg": "f"}
expected_kwargs = {"fakearg": "f"}
assert_nic = nic or assert_nic
if nic:
kwargs["nics"] = nic
if assert_nic:
nova.networks.create("net-1")
expected_kwargs["nics"] = nic or [{"net-id": "net-2"}]
print(kwargs)
print(expected_kwargs)
return scenario, kwargs, expected_kwargs
def test_users_contains_correct_endpoint_type(self, mock_keystone):
endpoint = objects.Endpoint("foo_url",
"foo",
"foo_pass",
endpoint_type=consts.EndpointType.INTERNAL)
config = {
"config": {
"users": {
"tenants": 1,
"users_per_tenant": 2,
"resource_management_workers": 1
}
},
"admin": {
"endpoint": endpoint
},
"task": {
"uuid": "task_id"
}
}
user_generator = users.UserGenerator(config)
users_ = user_generator._create_users()
for user in users_:
self.assertEqual("internal", user["endpoint"].endpoint_type)
def test_create_image_and_boot_instances(self, mock_osclients,
mock_create_image,
mock_boot_servers,
mock_random_name):
glance_scenario = images.GlanceImages()
nova_scenario = servers.NovaServers()
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
fake_glance = fakes.FakeGlanceClient()
fc.glance = lambda: fake_glance
fake_nova = fakes.FakeNovaClient()
fc.nova = lambda: fake_nova
user_endpoint = objects.Endpoint("url", "user", "password", "tenant")
nova_scenario._clients = osclients.Clients(user_endpoint)
fake_image = fakes.FakeImage()
fake_servers = [object() for i in range(5)]
mock_create_image.return_value = fake_image
mock_boot_servers.return_value = fake_servers
mock_random_name.return_value = "random_name"
kwargs = {"fakearg": "f"}
with mock.patch("rally.benchmark.scenarios.glance.utils.time.sleep"):
glance_scenario.create_image_and_boot_instances(
"cf", "url", "df", "fid", 5, **kwargs)
mock_create_image.assert_called_once_with("random_name", "cf",
"url", "df")
mock_boot_servers.assert_called_once_with("random_name",
"image-id-0", "fid", 5,
**kwargs)
def flavors(self, deployment=None):
"""Display available flavors.
:param deployment: UUID or name of a deployment
"""
headers = ["ID", "Name", "vCPUs", "RAM (MB)", "Swap (MB)", "Disk (GB)"]
mixed_case_fields = ["ID", "Name", "vCPUs"]
float_cols = ["RAM (MB)", "Swap (MB)", "Disk (GB)"]
formatters = dict(
zip(float_cols,
[cliutils.pretty_float_formatter(col) for col in float_cols]))
for endpoint_dict in self._get_endpoints(deployment):
self._print_header("Flavors", endpoint_dict)
table_rows = []
clients = osclients.Clients(objects.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for flavor in nova_client.flavors.list():
data = [
flavor.id, flavor.name, flavor.vcpus, flavor.ram,
flavor.swap, flavor.disk
]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
formatters=formatters,
mixed_case_fields=mixed_case_fields)
def images(self, deployment=None):
"""Display available images.
:param deployment: UUID or name of a deployment
"""
headers = ["UUID", "Name", "Size (B)"]
mixed_case_fields = ["UUID", "Name"]
float_cols = ["Size (B)"]
table_rows = []
formatters = dict(zip(float_cols,
[cliutils.pretty_float_formatter(col)
for col in float_cols]))
try:
for endpoint_dict in self._get_endpoints(deployment):
clients = osclients.Clients(objects.Endpoint(**endpoint_dict))
glance_client = clients.glance()
for image in glance_client.images.list():
data = [image.id, image.name, image.size]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
formatters=formatters,
mixed_case_fields=mixed_case_fields)
except exceptions.InvalidArgumentsException as e:
print(_("Authentication Issues: %s") % e)
return(1)
def images(self, deployment=None):
"""Display available images.
:param deployment: UUID or name of a deployment
"""
headers = ["UUID", "Name", "Size (B)"]
mixed_case_fields = ["UUID", "Name"]
float_cols = ["Size (B)"]
formatters = dict(
zip(float_cols,
[cliutils.pretty_float_formatter(col) for col in float_cols]))
for endpoint_dict in self._get_endpoints(deployment):
self._print_header("Images", endpoint_dict)
table_rows = []
clients = osclients.Clients(objects.Endpoint(**endpoint_dict))
glance_client = clients.glance()
for image in glance_client.images.list():
data = [image.id, image.name, image.size]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
formatters=formatters,
mixed_case_fields=mixed_case_fields)
def deploy(self):
endpoint_dict = self.deployment['config']['endpoint']
admin_endpoint = objects.Endpoint(endpoint_dict['auth_url'],
endpoint_dict['username'],
endpoint_dict['password'],
endpoint_dict['tenant_name'],
consts.EndpointPermission.ADMIN,
endpoint_dict.get('region_name'))
return [admin_endpoint]
def test_deployment_check_raise(self, mock_deployment_get,
mock_clients_verified_keystone):
deployment_id = "e87e4dca-b515-4477-888d-5f6103f13b42"
sample_endpoint = objects.Endpoint("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
sample_endpoint["not-exist-key"] = "error"
mock_deployment_get.return_value = {"admin": sample_endpoint}
mock_clients_verified_keystone.services.list.return_value = []
self.assertRaises(TypeError, self.deployment.check, deployment_id)
def test_update_endpoints(self, mock_update):
mock_update.return_value = self.deployment
deploy = objects.Deployment(deployment=self.deployment)
endpoints = [
objects.Endpoint("url", "user", "pwd", "tenant",
consts.EndpointPermission.ADMIN)
]
deploy.update_endpoints(endpoints)
mock_update.assert_called_once_with(
self.deployment["uuid"],
{"endpoints": [endpoints[0].to_dict(include_permission=True)]})
def __init__(self,
config,
task,
admin=None,
users=None,
abort_on_sla_failure=False):
"""BenchmarkEngine constructor.
:param config: The configuration with specified benchmark scenarios
:param task: The current task which is being performed
:param admin: Dict with admin credentials
:param users: List of dicts with user credentials
:param abort_on_sla_failure: True if the execution should be stopped
when some SLA check fails
"""
self.config = config
self.task = task
self.admin = admin and objects.Endpoint(**admin) or None
self.users = map(lambda u: objects.Endpoint(**u), users or [])
self.abort_on_sla_failure = abort_on_sla_failure
def __init__(self, deployment, config):
super(OpenStackProvider, self).__init__(deployment, config)
user_endpoint = objects.Endpoint(config["auth_url"], config["user"],
config["password"], config["tenant"])
clients = osclients.Clients(user_endpoint)
self.nova = clients.nova()
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_deployment_check(self, mock_deployment_get, mock_clients_keystone,
mock_clients_verified_keystone):
deployment_id = "e87e4dca-b515-4477-888d-5f6103f13b42"
sample_endpoint = objects.Endpoint("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
mock_deployment_get.return_value = {
"admin": sample_endpoint,
"users": [sample_endpoint]
}
self.deployment.check(deployment_id)
mock_deployment_get.assert_called_once_with(deployment_id)
mock_clients_keystone.assert_called_once_with()
mock_clients_verified_keystone.assert_called_once_with()
class FakeUserContext(FakeContext):
admin = {
"id": "adminuuid",
"endpoint": objects.Endpoint("aurl", "aname", "apwd", "atenant")
}
user = {
"id": "uuid",
"endpoint": objects.Endpoint("url", "name", "pwd", "tenant"),
"tenant_id": "uuid"
}
tenants = {"uuid": {"name": "tenant"}}
def __init__(self, context):
context.setdefault("task", mock.MagicMock())
super(FakeUserContext, self).__init__(context)
context.setdefault("admin", FakeUserContext.admin)
context.setdefault("users", [FakeUserContext.user])
context.setdefault("tenants", FakeUserContext.tenants)
context.setdefault("scenario_name",
"NovaServers.boot_server_from_volume_and_delete")
def _create_endpoint(self, common, user, permission):
return objects.Endpoint(
common["auth_url"],
user["username"],
user["password"],
tenant_name=user.get("project_name", user.get("tenant_name")),
permission=permission,
region_name=common.get("region_name"),
endpoint_type=common.get("endpoint_type",
consts.EndpointType.PUBLIC),
endpoint=common.get("endpoint"),
domain_name=user.get("domain_name"),
user_domain_name=user.get("user_domain_name", "Default"),
project_domain_name=user.get("project_domain_name", "Default"))
def setUp(self):
super(OSClientsTestCase, self).setUp()
self.endpoint = objects.Endpoint("http://auth_url", "use", "pass",
"tenant")
self.clients = osclients.Clients(self.endpoint)
self.fake_keystone = fakes.FakeKeystoneClient()
self.fake_keystone.auth_token = mock.MagicMock()
self.service_catalog = self.fake_keystone.service_catalog
self.service_catalog.url_for = mock.MagicMock()
keystone_patcher = mock.patch("rally.osclients.create_keystone_client")
self.mock_create_keystone_client = keystone_patcher.start()
self.addCleanup(keystone_patcher.stop)
self.mock_create_keystone_client.return_value = self.fake_keystone
def test_endpoint(self):
endpoint = objects.Endpoint("url", "user", "pwd", "tenant", "admin")
self.assertEqual(
endpoint.to_dict(include_permission=True), {
"auth_url": "url",
"username": "******",
"password": "******",
"tenant_name": "tenant",
"region_name": None,
"permission": "admin",
"domain_name": None,
"endpoint_type": consts.EndpointType.PUBLIC,
"project_domain_name": "Default",
"user_domain_name": "Default",
'admin_port': 35357
})
def setup(self):
for user in self.config:
user_endpoint = objects.Endpoint(**user)
user_kclient = osclients.Clients(user_endpoint).keystone()
if user_kclient.tenant_id not in self.context["tenants"]:
self.context["tenants"][user_kclient.tenant_id] = {
"id": user_kclient.tenant_id,
"name": user_kclient.tenant_name
}
self.context["users"].append({
"endpoint": user_endpoint,
"id": user_kclient.user_id,
"tenant_id": user_kclient.tenant_id
})
def secgroups(self, deployment=None):
"""Display security groups."""
headers = ["ID", "Name", "Description"]
mixed_case_fields = ["ID", "Name", "Description"]
for endpoint_dict in self._get_endpoints(deployment):
self._print_header("Security groups", endpoint_dict)
table_rows = []
clients = osclients.Clients(objects.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for secgroup in nova_client.security_groups.list():
data = [secgroup.id, secgroup.name, secgroup.description]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
mixed_case_fields=mixed_case_fields)
def __init__(self, endpoint_=None):
self._nova = None
self._glance = None
self._keystone = None
self._cinder = None
self._neutron = None
self._sahara = None
self._heat = None
self._designate = None
self._ceilometer = None
self._zaqar = None
self._trove = None
self._mistral = None
self._endpoint = endpoint_ or objects.Endpoint(
"http://fake.example.org:5000/v2.0/", "fake_username",
"fake_password", "fake_tenant_name")
def keypairs(self, deployment=None):
"""Display available ssh keypairs."""
headers = ["Name", "Fingerprint"]
mixed_case_fields = ["Name", "Fingerprint"]
for endpoint_dict in self._get_endpoints(deployment):
self._print_header("Keypairs", endpoint_dict)
table_rows = []
clients = osclients.Clients(objects.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for keypair in nova_client.keypairs.list():
data = [keypair.name, keypair.fingerprint]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
mixed_case_fields=mixed_case_fields)
def consume(cache, args):
username, password, project_dom, user_dom, tenant_id = args
if "client" not in cache:
clients = osclients.Clients(self.endpoint)
cache["client"] = keystone.wrap(clients.keystone())
client = cache["client"]
user = client.create_user(username, password,
"*****@*****.**" % username,
tenant_id, user_dom)
user_endpoint = objects.Endpoint(
client.auth_url, user.name, password,
self.context["tenants"][tenant_id]["name"],
consts.EndpointPermission.USER, client.region_name,
project_domain_name=project_dom, user_domain_name=user_dom,
endpoint_type=self.endpoint.endpoint_type)
users.append({"id": user.id,
"endpoint": user_endpoint,
"tenant_id": tenant_id})
def networks(self, deployment=None):
"""Display configured networks."""
headers = ["ID", "Label", "CIDR"]
mixed_case_fields = ["ID", "Label", "CIDR"]
for endpoint_dict in self._get_endpoints(deployment):
self._print_header("Networks", endpoint_dict)
table_rows = []
clients = osclients.Clients(objects.Endpoint(**endpoint_dict))
nova_client = clients.nova()
for network in nova_client.networks.list():
data = [network.id, network.label, network.cidr]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
mixed_case_fields=mixed_case_fields)
def required_cinder_services(config, clients, deployment, service_name):
"""Validator checks that specified Cinder service is available.
It uses Cinder client with admin permissions to call 'cinder service-list'
call
:param service_name: Cinder service name
"""
admin_client = osclients.Clients(
objects.Endpoint(**deployment["admin"])).cinder()
for service in admin_client.services.list():
if (service.binary == six.text_type(service_name)
and service.state == six.text_type("up")):
return ValidationResult(True)
msg = _("%s service is not available") % service_name
return ValidationResult(False, msg)
def test_to_dict(self):
endpoint = objects.Endpoint("foo_url",
"foo_user",
"foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN)
self.assertEqual(
endpoint.to_dict(), {
"auth_url": "foo_url",
"username": "******",
"password": "******",
"tenant_name": "foo_tenant",
"region_name": None,
"domain_name": None,
"endpoint": None,
"endpoint_type": consts.EndpointType.PUBLIC,
"project_domain_name": "Default",
"user_domain_name": "Default"
})
def required_clients(config, clients, deployment, *components, **kwargs):
"""Validator checks if specified OpenStack clients are available.
:param *components: list of client components names
:param **kwargs: optional parameters:
admin - bool, whether to use admin clients
"""
if kwargs.get("admin", False):
clients = osclients.Clients(objects.Endpoint(**deployment["admin"]))
for client_component in components:
try:
getattr(clients, client_component)()
except ImportError:
return ValidationResult(
False,
_("Client for %s is not installed. To install it run "
"`pip install -r"
" optional-requirements.txt`") % client_component)
def deploy(self):
endpoint_dict = self.deployment['config']['endpoint']
project_name = endpoint_dict.get('project_name',
endpoint_dict.get('tenant_name'))
admin_endpoint = objects.Endpoint(
endpoint_dict['auth_url'],
endpoint_dict['username'],
endpoint_dict['password'],
tenant_name=project_name,
permission=consts.EndpointPermission.ADMIN,
region_name=endpoint_dict.get('region_name'),
use_public_urls=endpoint_dict.get('use_public_urls', False),
admin_port=endpoint_dict.get('admin_port', 35357),
domain_name=endpoint_dict.get('domain_name'),
user_domain_name=endpoint_dict.get('user_domain_name', 'Default'),
project_domain_name=endpoint_dict.get('project_domain_name',
'Default'))
return [admin_endpoint]
