def setup(self):
self.ports = []
net_wrapper = network_wrapper.wrap(osclients.Clients(
self.context["admin"]["credential"]),
self,
config=self.config)
for user, tenant_id in (utils.iterate_per_tenants(
self.context.get("users", []))):
# Generate FAKE SG that would only have some fake ports.
sg_name = 'sg-remote-%s' % tenant_id
self.remote_sg = _prepare_remote_sg(user, sg_name)
if not self.config.get('create_ports'):
break
neutron = osclients.Clients(user['credential']).neutron()
subnet_id = self.context["tenants"][tenant_id]["networks"][0][
'subnets'][0]
subnet = neutron.show_subnet(subnet_id)
for i in range(0, self.config['num_of_ports']):
port = {
'port': {
'binding:host_id':
RemoteScurityGroup.COMPUTE_HOST,
'name':
"remote_sg_port-%i" % i,
'security_groups': [self.remote_sg['id']],
'network_id':
self.context["tenants"][tenant_id]["networks"][0]['id']
}
}
port = neutron.create_port(port)
self.bind_port(port, subnet, neutron)
self.ports.append(port)
def __init__(self, context=None, admin_clients=None, clients=None):
super(OpenStackScenario, self).__init__(context)
if context:
api_info = {}
if "api_versions@openstack" in context.get("config", {}):
api_versions = context["config"]["api_versions@openstack"]
for service in api_versions:
api_info[service] = {
"version": api_versions[service].get("version"),
"service_type":
api_versions[service].get("service_type")
}
if admin_clients is None and "admin" in context:
self._admin_clients = osclients.Clients(
context["admin"]["credential"], api_info)
if clients is None:
if "users" in context and "user" not in context:
self._choose_user(context)
if "user" in context:
self._clients = osclients.Clients(
context["user"]["credential"], api_info)
if admin_clients:
self._admin_clients = admin_clients
if clients:
self._clients = clients
self._init_profiler(context)
def _remove_default_security_group(self):
"""Delete default security group for tenants."""
clients = osclients.Clients(self.credential)
if consts.Service.NEUTRON not in clients.services().values():
return
use_sg, msg = network.wrap(clients,
self).supports_extension("security-group")
if not use_sg:
LOG.debug("Security group context is disabled: %s" % msg)
return
for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]):
with logging.ExceptionLogger(
LOG, "Unable to delete default security group"):
uclients = osclients.Clients(user["credential"])
security_groups = uclients.neutron()\
.list_security_groups(tenant_id=tenant_id)
default = [
sg for sg in security_groups["security_groups"]
if sg["name"] == "default"
]
if default:
clients.neutron().delete_security_group(default[0]["id"])
def check_health(self):
"""Check whatever platform is alive."""
if self.platform_data["admin"]:
try:
osclients.Clients(
self.platform_data["admin"]).verified_keystone()
except Exception:
d = copy.deepcopy(self.platform_data["admin"])
d["password"] = "******"
return {
"available": False,
"message": (
"Bad admin creds: \n%s"
% json.dumps(d, indent=2, sort_keys=True)),
"traceback": traceback.format_exc()
}
for user in self.platform_data["users"]:
try:
osclients.Clients(user).keystone()
except Exception:
d = copy.deepcopy(user)
d["password"] = "******"
return {
"available": False,
"message": (
"Bad user creds: \n%s"
% json.dumps(d, indent=2, sort_keys=True)),
"traceback": traceback.format_exc()
}
return {"available": True}
def setup(self):
image = self.config["image"]
flavor = self.config["flavor"]
clients = osclients.Clients(self.context["users"][0]["credential"])
image_id = types.EC2Image.transform(clients=clients,
resource_config=image)
for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]):
LOG.debug("Booting servers for tenant %s " % user["tenant_id"])
ec2_scenario = ec2_utils.EC2Scenario({
"user":
user,
"task":
self.context["task"],
"owner_id":
self.context["owner_id"]
})
LOG.debug(
"Calling _boot_servers with "
"image_id=%(image_id)s flavor_name=%(flavor_name)s "
"servers_per_tenant=%(servers_per_tenant)s" % {
"image_id": image_id,
"flavor_name": flavor["name"],
"servers_per_tenant": self.config["servers_per_tenant"]
})
servers = ec2_scenario._boot_servers(
image_id, flavor["name"], self.config["servers_per_tenant"])
current_servers = [server.id for server in servers]
self.context["tenants"][tenant_id]["ec2_servers"] = current_servers
def setup(self):
watcher_scenario = watcher_utils.WatcherScenario(
{"admin": self.context["admin"], "task": self.context["task"],
"owner_id": self.context["owner_id"],
"config": {
"api_versions": self.context["config"].get(
"api_versions", [])}
})
clients = osclients.Clients(self.context["admin"]["credential"])
self.context["audit_templates"] = []
for i in six.moves.range(self.config["audit_templates_per_admin"]):
cfg_size = len(self.config["params"])
if self.config["fill_strategy"] == "round_robin":
audit_params = self.config["params"][i % cfg_size]
elif self.config["fill_strategy"] == "random":
audit_params = random.choice(self.config["params"])
goal_id = types.WatcherGoal.transform(
clients=clients,
resource_config=audit_params["goal"])
strategy_id = types.WatcherStrategy.transform(
clients=clients,
resource_config=audit_params["strategy"])
audit_template = watcher_scenario._create_audit_template(
goal_id, strategy_id)
self.context["audit_templates"].append(audit_template.uuid)
def setup(self):
"""Create list of flavors."""
from novaclient import exceptions as nova_exceptions
self.context["flavors"] = {}
clients = osclients.Clients(self.context["admin"]["credential"])
for flavor_config in self.config:
extra_specs = flavor_config.get("extra_specs")
flavor_config = FlavorConfig(**flavor_config)
try:
flavor = clients.nova().flavors.create(**flavor_config)
except nova_exceptions.Conflict:
msg = "Using existing flavor %s" % flavor_config["name"]
if logging.is_debug():
LOG.exception(msg)
else:
LOG.warning(msg)
continue
if extra_specs:
flavor.set_keys(extra_specs)
self.context["flavors"][flavor_config["name"]] = flavor.to_dict()
LOG.debug("Created flavor with id '%s'" % flavor.id)
def __init__(self, *args, **kwargs):
super(EC2APIPlugin, self).__init__(*args, **kwargs)
if 'instance_id' in _resources:
self.instance_id = _resources['instance_id']
else:
client = self.get_ec2_client()
data = client.describe_instances()
instances = (data['Reservations'][0]['Instances']
if data.get('Reservations') else None)
if instances:
index = len(instances) / 3
self.instance_id = instances[index]['InstanceId']
LOG.info("found instance = %s for ec2" % (self.instance_id))
_resources['instance_id'] = self.instance_id
else:
_resources['instance_id'] = None
if 'nova_server_id' in _resources:
self.nova_server_id = _resources['nova_server_id']
else:
client = osclients.Clients(
self.context['user']['credential']).nova()
project_id = self.context["tenant"]["id"]
servers = client.servers.list(
search_opts={'project_id': project_id})
if servers:
index = len(servers) / 3
self.nova_server_id = servers[index].id
LOG.info("found server = %s for nova" % (self.nova_server_id))
_resources['nova_server_id'] = self.nova_server_id
else:
_resources['nova_server_id'] = None
def test_cached(self):
clients = osclients.Clients({
"auth_url": "url",
"username": "******",
"password": "******"
})
@osclients.configure(self.id())
class SomeClient(osclients.OSClient):
pass
fake_client = SomeClient(clients.credential, clients.api_info,
clients.cache)
fake_client.create_client = mock.MagicMock()
self.assertEqual({}, clients.cache)
fake_client()
self.assertEqual({self.id(): fake_client.create_client.return_value},
clients.cache)
fake_client.create_client.assert_called_once_with()
fake_client()
fake_client.create_client.assert_called_once_with()
fake_client("2")
self.assertEqual(
{
self.id(): fake_client.create_client.return_value,
"%s('2',)" % self.id(): fake_client.create_client.return_value
}, clients.cache)
clients.clear()
self.assertEqual({}, clients.cache)
def setup(self):
nc = osclients.Clients(self.context["admin"]["credential"]).neutron()
agents = nc.list_agents()["agents"]
# NOTE(bence romsics): If you ever add input parameters to this context
# beware that here we use the same key in self.context as is used for
# parameter passing, so we'll overwrite it.
self.context["networking_agents"] = agents
def create_one_image(self, user, **kwargs):
"""Create one image for the user."""
clients = osclients.Clients(user["credential"])
image_id = types.GlanceImage.transform(
clients=clients, resource_config=self.config["image"])
flavor_id = types.Flavor.transform(
clients=clients, resource_config=self.config["flavor"])
vm_scenario = vmtasks.BootRuncommandDelete(self.context,
clients=clients)
server, fip = vm_scenario._boot_server_with_fip(
image=image_id,
flavor=flavor_id,
floating_network=self.config.get("floating_network"),
userdata=self.config.get("userdata"),
key_name=user["keypair"]["name"],
security_groups=[user["secgroup"]["name"]],
**kwargs)
try:
LOG.debug("Installing tools on %r %s" % (server, fip["ip"]))
self.customize_image(server, fip, user)
LOG.debug("Stopping server %r" % server)
vm_scenario._stop_server(server)
LOG.debug("Creating snapshot for %r" % server)
custom_image = vm_scenario._create_image(server)
finally:
vm_scenario._delete_server_with_fip(server, fip)
return custom_image
def _prepare_remote_sg(user, secgroup_name):
neutron = osclients.Clients(user['credential']).neutron()
security_groups = neutron.list_security_groups()["security_groups"]
rally_open = [sg for sg in security_groups if sg["name"] == secgroup_name]
if not rally_open:
descr = "remote_sg needed by some tests"
rally_open = neutron.create_security_group({
"security_group": {
"name": secgroup_name,
"tenant_id": user['tenant_id'],
"description": descr
}
})["security_group"]
else:
rally_open = rally_open[0]
rules_to_add = [{
"protocol": "icmp",
"remote_ip_prefix": "0.0.0.0/0",
"direction": "ingress"
}]
def rule_match(criteria, existing_rule):
return all(existing_rule[key] == value
for key, value in criteria.items())
for new_rule in rules_to_add:
if not any(
rule_match(new_rule, existing_rule) for existing_rule in
rally_open.get("security_group_rules", [])):
new_rule["security_group_id"] = rally_open["id"]
neutron.create_security_group_rule(
{"security_group_rule": new_rule})
return rally_open
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"],
profiler_conn_str=self.credential["profiler_conn_str"],
api_info=self.credential["api_info"])
users.append({
"id": user.id,
"credential": user_credential,
"tenant_id": tenant_id
})
def setup(self):
# NOTE(rkiran): Some clients are not thread-safe. Thus during
# multithreading/multiprocessing, it is likely the
# sockets are left open. This problem is eliminated by
# creating a connection in setup and cleanup separately.
net_wrapper = network_wrapper.wrap(osclients.Clients(
self.context["admin"]["credential"]),
self,
config=self.config)
kwargs = {}
if self.config["dns_nameservers"] is not None:
kwargs["dns_nameservers"] = self.config["dns_nameservers"]
for user, tenant_id in (utils.iterate_per_tenants(
self.context.get("users", []))):
self.context["tenants"][tenant_id]["networks"] = []
for i in range(self.config["networks_per_tenant"]):
# NOTE(amaretskiy): router_create_args and subnets_num take
# effect for Neutron only.
network_create_args = self.config["network_create_args"].copy()
network = net_wrapper.create_network(
tenant_id,
dualstack=self.config["dualstack"],
subnets_num=self.config["subnets_per_network"],
network_create_args=network_create_args,
router_create_args=self.config["router"],
**kwargs)
self.context["tenants"][tenant_id]["networks"].append(network)
def use_existing_users(self):
LOG.debug("Using existing users for OpenStack platform.")
api_info = copy.deepcopy(self.env["platforms"]["openstack"].get(
"api_info", {}))
for user_credential in self.existing_users:
user_credential = copy.deepcopy(user_credential)
if "api_info" in user_credential:
api_info.update(user_credential["api_info"])
user_credential["api_info"] = api_info
user_credential = credential.OpenStackCredential(**user_credential)
user_clients = osclients.Clients(user_credential)
user_id = user_clients.keystone.auth_ref.user_id
tenant_id = user_clients.keystone.auth_ref.project_id
if tenant_id not in self.context["tenants"]:
self.context["tenants"][tenant_id] = {
"id": tenant_id,
"name": user_credential.tenant_name
}
self.context["users"].append({
"credential": user_credential,
"id": user_id,
"tenant_id": tenant_id
})
def __init__(self, ctx):
super(PrepareEC2ClientContext, self).__init__(ctx)
self.net_wrapper = network_wrapper.wrap(osclients.Clients(
self.context["admin"]["credential"]),
self,
config=self.config)
self.net_wrapper.start_cidr = '10.0.0.0/16'
def setup(self):
is_config_app_dir = False
pckg_path = os.path.expanduser(self.config["app_package"])
if zipfile.is_zipfile(pckg_path):
zip_name = pckg_path
elif os.path.isdir(pckg_path):
is_config_app_dir = True
zip_name = fileutils.pack_dir(pckg_path)
else:
msg = "There is no zip archive or directory by this path: %s"
raise exceptions.ContextSetupFailure(msg=msg % pckg_path,
ctx_name=self.get_name())
for user, tenant_id in utils.iterate_per_tenants(
self.context["users"]):
clients = osclients.Clients(user["credential"])
self.context["tenants"][tenant_id]["packages"] = []
if is_config_app_dir:
self.context["tenants"][tenant_id]["murano_ctx"] = zip_name
# TODO(astudenov): use self.generate_random_name()
package = clients.murano().packages.create(
{
"categories": ["Web"],
"tags": ["tag"]
}, {"file": open(zip_name)})
self.context["tenants"][tenant_id]["packages"].append(package)
def consume(cache, args):
role_id, user_id, project_id = args
if "client" not in cache:
clients = osclients.Clients(self.credential)
cache["client"] = identity.Identity(clients)
getattr(cache["client"], func_name)(role_id=role_id,
user_id=user_id,
project_id=project_id)
def cleanup(self):
for user, tenant_id in utils.iterate_per_tenants(
self.context["users"]):
with logging.ExceptionLogger(
LOG, "Unable to delete security group: %s." %
user["secgroup"]["name"]):
clients = osclients.Clients(user["credential"])
clients.neutron().delete_security_group(user["secgroup"]["id"])
def fetch_token(self):
"""Authenticate user token."""
cred = self._clients.credential
aname = "keystone_v%s.fetch_token" % self.version
with atomic.ActionTimer(self, aname):
clients = osclients.Clients(credential=cred,
api_info=self._clients.api_info)
return clients.keystone.auth_ref.auth_token
def __init__(self, context=None, cache=None):
if rally_openstack.__rally_version__ >= (0, 12):
super(OpenStackResourceType, self).__init__(context, cache)
else:
super(OpenStackResourceType, self).__init__()
self._context = context or {}
self._global_cache = cache or {}
self._global_cache.setdefault(self.get_name(), {})
self._cache = self._global_cache[self.get_name()]
self._clients = None
if self._context.get("admin"):
self._clients = osclients.Clients(
self._context["admin"]["credential"])
elif self._context.get("users"):
self._clients = osclients.Clients(
self._context["users"][0]["credential"])
def setup(self):
net_wrapper = network_wrapper.wrap(
osclients.Clients(self.context["admin"]["credential"]),
self, config=self.config)
for user, tenant_id in (utils.iterate_per_tenants(
self.context.get("users", []))):
remote_sg_name = 'sg-remote-%s' % tenant_id
_prepare_rules(user, remote_sg_name, self.config['num_of_rules'])
def setup(self):
for user, tenant_id in utils.iterate_per_tenants(
self.context.get("users", [])):
net_wrapper = network_wrapper.wrap(osclients.Clients(
user["credential"]),
self,
config=self.config)
self.context["tenants"][tenant_id]["networks"] = (
net_wrapper.list_networks())
def consume(cache, args):
domain, task_id, i = args
if "client" not in cache:
clients = osclients.Clients(self.credential)
cache["client"] = identity.Identity(
clients, name_generator=self.generate_random_name)
tenant = cache["client"].create_project(domain_name=domain)
tenant_dict = {"id": tenant.id, "name": tenant.name, "users": []}
tenants.append(tenant_dict)
def setUp(self):
super(CinderScenarioTestCase, self).setUp()
wrap = mock.patch("rally_openstack.wrappers.cinder.wrap")
self.mock_wrap = wrap.start()
self.addCleanup(self.mock_wrap.stop)
self.scenario = utils.CinderScenario(
self.context,
clients=osclients.Clients(
fakes.FakeUserContext.user["credential"]))
def cleanup(self):
net_wrapper = network_wrapper.wrap(
osclients.Clients(self.context["admin"]["credential"]),
self, config=self.config)
for tenant_id, tenant_ctx in self.context["tenants"].items():
for network in tenant_ctx.get("networks", []):
with logging.ExceptionLogger(
LOG,
"Failed to delete network for tenant %s" % tenant_id):
net_wrapper.delete_network(network)
def _prepare_open_secgroup(credential, secgroup_name):
"""Generate secgroup allowing all tcp/udp/icmp access.
In order to run tests on instances it is necessary to have SSH access.
This function generates a secgroup which allows all tcp/udp/icmp access.
:param credential: clients credential
:param secgroup_name: security group name
:returns: dict with security group details
"""
neutron = osclients.Clients(credential).neutron()
security_groups = neutron.list_security_groups()["security_groups"]
rally_open = [sg for sg in security_groups if sg["name"] == secgroup_name]
if not rally_open:
descr = "Allow ssh access to VMs created by Rally"
rally_open = neutron.create_security_group(
{"security_group": {
"name": secgroup_name,
"description": descr
}})["security_group"]
else:
rally_open = rally_open[0]
rules_to_add = [{
"protocol": "tcp",
"port_range_max": 65535,
"port_range_min": 1,
"remote_ip_prefix": "0.0.0.0/0",
"direction": "ingress"
}, {
"protocol": "udp",
"port_range_max": 65535,
"port_range_min": 1,
"remote_ip_prefix": "0.0.0.0/0",
"direction": "ingress"
}, {
"protocol": "icmp",
"remote_ip_prefix": "0.0.0.0/0",
"direction": "ingress"
}]
def rule_match(criteria, existing_rule):
return all(existing_rule[key] == value
for key, value in criteria.items())
for new_rule in rules_to_add:
if not any(
rule_match(new_rule, existing_rule) for existing_rule in
rally_open.get("security_group_rules", [])):
new_rule["security_group_id"] = rally_open["id"]
neutron.create_security_group_rule(
{"security_group_rule": new_rule})
return rally_open
def setup(self):
# FIXME(andreykurilin): move all checks to validate method.
# use admin only when `service_name` is presented
admin_clients = osclients.Clients(
self.context.get("admin", {}).get("credential"))
clients = osclients.Clients(
random.choice(self.context["users"])["credential"])
services = clients.keystone.service_catalog.get_endpoints()
services_from_admin = None
for client_name, conf in self.config.items():
if "service_type" in conf and conf["service_type"] not in services:
raise exceptions.ValidationError(
"There is no service with '%s' type in your environment." %
conf["service_type"])
elif "service_name" in conf:
if not self.context.get("admin", {}).get("credential"):
raise exceptions.ContextSetupFailure(
ctx_name=self.get_name(),
msg="Setting 'service_name' is admin only operation.")
if not services_from_admin:
services_from_admin = dict([
(s.name, s.type)
for s in admin_clients.keystone().services.list()
])
if conf["service_name"] not in services_from_admin:
raise exceptions.ValidationError(
"There is no '%s' service in your environment" %
conf["service_name"])
# TODO(boris-42): Use separate key ["openstack"]["versions"]
self.context["config"]["api_versions@openstack"][client_name][
"service_type"] = services_from_admin[conf["service_name"]]
admin_cred = self.context.get("admin", {}).get("credential")
if admin_cred:
admin_cred["api_info"].update(
self.context["config"]["api_versions@openstack"])
for user in self.context["users"]:
user["credential"]["api_info"].update(
self.context["config"]["api_versions@openstack"])
def __init__(self, ctx):
super(Quotas, self).__init__(ctx)
self.clients = osclients.Clients(self.context["admin"]["credential"])
self.manager = {
"nova": nova_quotas.NovaQuotas(self.clients),
"cinder": cinder_quotas.CinderQuotas(self.clients),
"manila": manila_quotas.ManilaQuotas(self.clients),
"designate": designate_quotas.DesignateQuotas(self.clients),
"neutron": neutron_quotas.NeutronQuotas(self.clients)
}
self.original_quotas = []
def __init__(self, context=None, admin_clients=None, clients=None):
super(OpenStackScenario, self).__init__(context)
if context:
if admin_clients is None and "admin" in context:
self._admin_clients = osclients.Clients(
context["admin"]["credential"])
if clients is None:
if "users" in context and "user" not in context:
self._choose_user(context)
if "user" in context:
self._clients = osclients.Clients(
context["user"]["credential"])
if admin_clients:
self._admin_clients = admin_clients
if clients:
self._clients = clients
self._init_profiler(context)
