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)