def create_and_update_policy_rule(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name( prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name( prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name) # Now create a new action and classifier and update action_name1 = rutils.generate_random_name( prefix="rally_action_allow_") self._create_policy_action(name=action_name1) # Create a policy classifier classifier_name1 = rutils.generate_random_name( prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name1, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) self._update_policy_rule(rule_name, action_name1, classifier_name1)
def create_and_update_policy_action(self, action_type="allow"): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name, type=action_type) # Create a new action name and update action_name1 = rutils.generate_random_name( prefix="rally_action_allow_") self._update_policy_action(name=action_name, new_name=action_name1)
def create_and_delete_policy_target_group(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name( prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name( prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name) # Now create a policy rule set ruleset_name = rutils.generate_random_name(prefix="rally_ruleset_web_") self._create_policy_rule_set(ruleset_name, [rule_name]) # Now create a policy target group pt_group_name = rutils.generate_random_name(prefix="rally_group_") self._create_policy_target_group(pt_group_name) self._delete_policy_target_group(pt_group_name) self._delete_policy_rule_set(ruleset_name) self._delete_policy_rule(rule_name) self._delete_policy_classifier(classifier_name) self._delete_policy_action(name=action_name)
def create_and_delete_policy_classifier(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) classifier_name = rutils.generate_random_name(prefix="rally_classifier_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) self._delete_policy_classifier(classifier_name) self._delete_policy_action(name=action_name)
def create_policy_classifier(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) classifier_name = rutils.generate_random_name( prefix="rally_classifier_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction'])
def create_network(self, tenant_id, **kwargs): """Create network. The following keyword arguments are accepted: * add_router: Create an external router and add an interface to each subnet created. Default: False * subnets_num: Number of subnets to create per network. Default: 0 * dns_nameservers: Nameservers for each subnet. Default: 8.8.8.8, 8.8.4.4 * network_create_args: Additional network creation arguments. :param tenant_id: str, tenant ID :param kwargs: Additional options, left open-ended for compatbilitiy. See above for recognized keyword args. :returns: dict, network data """ network_args = {"network": kwargs.get("network_create_args", {})} network_args["network"].update({ "tenant_id": tenant_id, "name": utils.generate_random_name("rally_net_") }) network = self.client.create_network(network_args)["network"] router = None if kwargs.get("add_router", False): router = self.create_router(external=True, tenant_id=tenant_id) subnets = [] subnets_num = kwargs.get("subnets_num", 0) for i in range(subnets_num): subnet_args = { "subnet": { "tenant_id": tenant_id, "network_id": network["id"], "name": utils.generate_random_name("rally_subnet_"), "ip_version": self.SUBNET_IP_VERSION, "cidr": self._generate_cidr(), "enable_dhcp": True, "dns_nameservers": kwargs.get("dns_nameservers", ["8.8.8.8", "8.8.4.4"]) } } subnet = self.client.create_subnet(subnet_args)["subnet"] subnets.append(subnet["id"]) if router: self.client.add_interface_router(router["id"], {"subnet_id": subnet["id"]}) return {"id": network["id"], "name": network["name"], "status": network["status"], "subnets": subnets, "external": network.get("router:external", False), "router_id": router and router["id"] or None, "tenant_id": tenant_id}
def create_network(self, tenant_id, **kwargs): """Create network. :param tenant_id: str, tenant ID :param **kwargs: extra options :returns: dict, network data """ network_args = { "network": { "tenant_id": tenant_id, "name": utils.generate_random_name("rally_net_") } } network = self.client.create_network(network_args)["network"] router = None if kwargs.get("add_router", False): router = self.create_router(external=True, tenant_id=tenant_id) subnets = [] subnets_num = kwargs.get("subnets_num", 0) for i in range(subnets_num): subnet_args = { "subnet": { "tenant_id": tenant_id, "network_id": network["id"], "name": utils.generate_random_name("rally_subnet_"), "ip_version": self.SUBNET_IP_VERSION, "cidr": self._generate_cidr(), "enable_dhcp": True, "dns_nameservers": kwargs.get("dns_nameservers", ["8.8.8.8", "8.8.4.4"]) } } subnet = self.client.create_subnet(subnet_args)["subnet"] subnets.append(subnet["id"]) if router: self.client.add_interface_router(router["id"], {"subnet_id": subnet["id"]}) return { "id": network["id"], "name": network["name"], "status": network["status"], "subnets": subnets, "external": network.get("router:external", False), "router_id": router and router["id"] or None, "tenant_id": tenant_id }
def create_policy_rule(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name(prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name,classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name(prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name)
def create_network(self, tenant_id, **kwargs): """Create network. :param tenant_id: str, tenant ID :param **kwargs: extra options :returns: dict, network data """ network_args = { "network": { "tenant_id": tenant_id, "name": utils.generate_random_name("rally_net_") } } network = self.client.create_network(network_args)["network"] router = None if kwargs.get("add_router", False): router = self.create_router(external=True, tenant_id=tenant_id) subnets = [] subnets_num = kwargs.get("subnets_num", 0) for i in range(subnets_num): subnet_args = { "subnet": { "tenant_id": tenant_id, "network_id": network["id"], "name": utils.generate_random_name("rally_subnet_"), "ip_version": self.SUBNET_IP_VERSION, "cidr": self._generate_cidr(), "enable_dhcp": True, "dns_nameservers": kwargs.get("dns_nameservers", ["8.8.8.8", "8.8.4.4"]) } } subnet = self.client.create_subnet(subnet_args)["subnet"] subnets.append(subnet["id"]) if router: self.client.add_interface_router(router["id"], {"subnet_id": subnet["id"]}) return {"id": network["id"], "name": network["name"], "status": network["status"], "subnets": subnets, "external": network.get("router:external", False), "router_id": router and router["id"] or None, "tenant_id": tenant_id}
def _change_app_fullname(self, app_dir): """Change application full name. To avoid name conflict error during package import (when user tries to import a few packages into the same tenant) need to change the application name. For doing this need to replace following parts in manifest.yaml from ... FullName: app.name ... Classes: app.name: app_class.yaml to: ... FullName: <new_name> ... Classes: <new_name>: app_class.yaml :param app_dir: path to directory with Murano application context """ new_fullname = common_utils.generate_random_name("app.") manifest_file = os.path.join(app_dir, "manifest.yaml") manifest = self._read_from_file(manifest_file) class_file_name = manifest["Classes"][manifest["FullName"]] # update manifest.yaml file del manifest["Classes"][manifest["FullName"]] manifest["FullName"] = new_fullname manifest["Classes"][new_fullname] = class_file_name self._write_to_file(manifest, manifest_file)
def setup(self): utils.init_sahara_context(self) for user, tenant_id in rutils.iterate_per_tenants( self.context["users"]): clients = osclients.Clients(user["endpoint"]) sahara = clients.sahara() if self.config["output_type"] == "swift": swift = swift_utils.SwiftScenario(clients=clients, context=self.context) container_name = rutils.generate_random_name( prefix=self.config["output_url_prefix"]) self.context["tenants"][tenant_id]["sahara"]["container"] = { "name": swift._create_container( container_name=container_name), "output_swift_objects": [] } self.setup_outputs_swift(swift, sahara, tenant_id, container_name, user["endpoint"].username, user["endpoint"].password) else: self.setup_outputs_hdfs(sahara, tenant_id, self.config["output_url_prefix"])
def create_and_update_policy_target_group(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name(prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name(prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name) # Now create a policy rule set ruleset_name = rutils.generate_random_name(prefix="rally_ruleset_web_") self._create_policy_rule_set(ruleset_name, [rule_name]) # Now create a policy target group pt_group_name = rutils.generate_random_name(prefix="rally_group_") self._create_policy_target_group(pt_group_name) self._update_policy_target_group(pt_group_name, provided_policy_rulesets=[ruleset_name])
def _get_server_group(self, clients): if self.config.get("placement_policy", None) is None: return return clients.nova().server_groups.create( name=rutils.generate_random_name(prefix="rally_server_group_"), policies=[self.config["placement_policy"]] ).id
def base_repo(self): """Get directory to clone tempest to old: _ rally/tempest |_base -> clone from source to here |_for-deployment-<UUID1> -> copy from relevant tempest base |_for-deployment-<UUID2> -> copy from relevant tempest base new: _ rally/tempest |_base ||_ tempest_base-<rand suffix specific for source> -> clone || from source to here ||_ tempest_base-<rand suffix 2> |_for-deployment-<UUID1> -> copy from relevant tempest base |_for-deployment-<UUID2> -> copy from relevant tempest base """ if os.path.exists(Tempest.base_repo_dir): if self._is_git_repo(Tempest.base_repo_dir): # this is the old dir structure and needs to be upgraded directory = utils.generate_random_name("tempest_base-") LOG.debug("Upgrading Tempest directory tree: " "Moving Tempest base dir %s into subdirectory %s" % (Tempest.base_repo_dir, directory)) self._move_contents_to_subdir(Tempest.base_repo_dir, directory) if not self._base_repo: # Search existing tempest bases for a matching source repos = [d for d in os.listdir(Tempest.base_repo_dir) if self._is_git_repo(d) and self.tempest_source == self._get_remote_origin(d)] if len(repos) > 1: raise exceptions.MultipleMatchesFound( needle="git directory", haystack=repos) if repos: # Use existing base with relevant source self._base_repo = repos.pop() if not self._base_repo: directory = utils.generate_random_name("tempest_base-") self._base_repo = os.path.join( os.path.abspath(Tempest.base_repo_dir), directory) return self._base_repo
def base_repo(self): """Get directory to clone tempest to old: _ rally/tempest |_base -> clone from source to here |_for-deployment-<UUID1> -> copy from relevant tempest base |_for-deployment-<UUID2> -> copy from relevant tempest base new: _ rally/tempest |_base ||_ tempest_base-<rand suffix specific for source> -> clone || from source to here ||_ tempest_base-<rand suffix 2> |_for-deployment-<UUID1> -> copy from relevant tempest base |_for-deployment-<UUID2> -> copy from relevant tempest base """ if os.path.exists(Tempest.base_repo_dir): if self._is_git_repo(Tempest.base_repo_dir): # this is the old dir structure and needs to be upgraded directory = utils.generate_random_name("tempest_base-") LOG.debug("Upgrading Tempest directory tree: " "Moving Tempest base dir %s into subdirectory %s" % (Tempest.base_repo_dir, directory)) self._move_contents_to_subdir(Tempest.base_repo_dir, directory) if not self._base_repo: # Search existing tempest bases for a matching source repos = [ d for d in os.listdir(Tempest.base_repo_dir) if self._is_git_repo(d) and self.tempest_source == self._get_remote_origin(d) ] if len(repos) > 1: raise exceptions.MultipleMatchesFound( needle="git directory", haystack=repos) if repos: # Use existing base with relevant source self._base_repo = repos.pop() if not self._base_repo: directory = utils.generate_random_name("tempest_base-") self._base_repo = os.path.join( os.path.abspath(Tempest.base_repo_dir), directory) return self._base_repo
def create_and_update_policy_rule_set(self, classifier_args={}): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name(prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name,classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name(prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name) # Now create a policy rule set ruleset_name = rutils.generate_random_name(prefix="rally_ruleset_web_") self._create_policy_rule_set(ruleset_name, [rule_name]) # Now create a new rule and add it in rule_name1 = rutils.generate_random_name(prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name1, classifier_name, action_name) self._update_policy_rule_set(ruleset_name, [rule_name, rule_name1])
def create_port(self, network_id, **kwargs): """Create neutron port. :param network_id: neutron network id :param **kwargs: POST /v2.0/ports request options :returns: neutron port dict """ kwargs["network_id"] = network_id if "name" not in kwargs: kwargs["name"] = utils.generate_random_name("rally_port_") return self.client.create_port({"port": kwargs})["port"]
def create_network(self, tenant_id, **kwargs): """Create network. :param tenant_id: str, tenant ID :param **kwargs: for compatibility, not used here :returns: dict, network data """ cidr = self._generate_cidr() label = utils.generate_random_name("rally_net_") network = self.client.networks.create( project_id=tenant_id, cidr=cidr, label=label) return self._marshal_network_object(network)
def test_generate_random_name(self, mock_random): choice = "foobarspamchoicestring" idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(), string.ascii_lowercase[:16]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(length=10), string.ascii_lowercase[:10]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(choice=choice), choice[:16]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(choice=choice, length=5), choice[:5]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(prefix="foo_", length=10), "foo_" + string.ascii_lowercase[:10]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual( utils.generate_random_name(prefix="foo_", choice=choice, length=10), "foo_" + choice[:10])
def boot_vm(self, image, flavor, classifier_args={}, **kwargs): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name( prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name( prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name) # Now create a policy rule set ruleset_name = rutils.generate_random_name(prefix="rally_ruleset_web_") self._create_policy_rule_set(ruleset_name, [rule_name]) # Now create a policy target group pt_group_name = rutils.generate_random_name(prefix="rally_group_") self._create_policy_target_group(pt_group_name) # Now update the policy target group self._update_policy_target_group( pt_group_name, provided_policy_rulesets=[ruleset_name]) # Now create a policy target inside the group pt_name = rutils.generate_random_name(prefix="rally_target_web1") self._create_policy_target(pt_name, pt_group_name) # Get the port id based on the policy target port_id = self._show_policy_target(pt_name) kwargs["nics"] = [{"port-id": port_id}] instance = self._boot_server(image, flavor, **kwargs)
def test_generate_random_name(self, mock_random): choice = "foobarspamchoicestring" idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(), string.ascii_lowercase[:16]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(length=10), string.ascii_lowercase[:10]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(choice=choice), choice[:16]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual(utils.generate_random_name(choice=choice, length=5), choice[:5]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual( utils.generate_random_name(prefix="foo_", length=10), "foo_" + string.ascii_lowercase[:10]) idx = iter(range(100)) mock_random.choice.side_effect = lambda choice: choice[next(idx)] self.assertEqual( utils.generate_random_name(prefix="foo_", choice=choice, length=10), "foo_" + choice[:10])
def boot_vm(self, image, flavor, classifier_args= {}, **kwargs): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier classifier_name = rutils.generate_random_name(prefix="rally_classifier_web_traffic_") self._create_policy_classifier(classifier_name, classifier_args['protocol'], classifier_args['port_range'], classifier_args['direction']) # Now create a policy rule rule_name = rutils.generate_random_name(prefix="rally_rule_web_policy_") self._create_policy_rule(rule_name, classifier_name, action_name) # Now create a policy rule set ruleset_name = rutils.generate_random_name(prefix="rally_ruleset_web_") self._create_policy_rule_set(ruleset_name, [rule_name]) # Now create a policy target group pt_group_name = rutils.generate_random_name(prefix="rally_group_") self._create_policy_target_group(pt_group_name) # Now update the policy target group self._update_policy_target_group(pt_group_name, provided_policy_rulesets=[ruleset_name]) # Now create a policy target inside the group pt_name = rutils.generate_random_name(prefix="rally_target_web1") self._create_policy_target(pt_name,pt_group_name) # Get the port id based on the policy target port_id = self._show_policy_target(pt_name) kwargs["nics"] = [{"port-id": port_id}] instance = self._boot_server(image, flavor, **kwargs)
def _create_image(self, hadoop_version, image_url, plugin_name, user, user_name): scenario = glance_utils.GlanceScenario({"user": user}) image_name = rutils.generate_random_name(prefix="rally_sahara_image_") image = scenario._create_image(name=image_name, container_format="bare", image_location=image_url, disk_format="qcow2") scenario.clients("sahara").images.update_image( image_id=image.id, user_name=user_name, desc="") scenario.clients("sahara").images.update_tags( image_id=image.id, new_tags=[plugin_name, hadoop_version]) return image.id
def create_network(self, tenant_id, **kwargs): """Create network. :param tenant_id: str, tenant ID :param **kwargs: for compatibility, not used here :returns: dict, network data """ cidr = self._generate_cidr() label = utils.generate_random_name("rally_net_") network = self.client.networks.create(tenant_id=tenant_id, cidr=cidr, label=label) return self._marshal_network_object(network)
def create_router(self, external=False, **kwargs): """Create neutron router. :param external: bool, whether to set setup external_gateway_info :param **kwargs: POST /v2.0/routers request options :returns: neutron router dict """ if "name" not in kwargs: kwargs["name"] = utils.generate_random_name("rally_router_") if external and "external_gateway_info" not in kwargs: for net in self.external_networks: kwargs["external_gateway_info"] = {"network_id": net["id"], "enable_snat": True} return self.client.create_router({"router": kwargs})["router"]
def create_router(self, external=False, **kwargs): """Create neutron router. :param external: bool, whether to set setup external_gateway_info :param **kwargs: POST /v2.0/routers request options :returns: neutron router dict """ if "name" not in kwargs: kwargs["name"] = utils.generate_random_name("rally_router_") if external and "external_gateway_info" not in kwargs: for net in self.external_networks: kwargs["external_gateway_info"] = { "network_id": net["id"], "enable_snat": True} return self.client.create_router({"router": kwargs})["router"]
def create_v1_pool(self, subnet_id, **kwargs): """Create LB Pool (v1). :param subnet_id: str, neutron subnet-id :param **kwargs: extra options :returns: neutron lb-pool dict """ pool_args = { "pool": { "name": utils.generate_random_name("rally_pool_"), "subnet_id": subnet_id, "lb_method": kwargs.get("lb_method", self.LB_METHOD), "protocol": kwargs.get("protocol", self.LB_PROTOCOL) } } return self.client.create_pool(pool_args)
def create_network(self, tenant_id, **kwargs): """Create network. :param tenant_id: str, tenant ID :param **kwargs: for compatibility, not used here :returns: dict, network data """ cidr = self._generate_cidr() label = utils.generate_random_name("rally_net_") network = self.client.networks.create( tenant_id=tenant_id, cidr=cidr, label=label) return {"id": network.id, "cidr": network.cidr, "name": network.label, "status": "ACTIVE", "external": False, "tenant_id": tenant_id}
def create_network(self, tenant_id, **kwargs): """Create network. :param tenant_id: str, tenant ID :param **kwargs: Additional keyword arguments. Only ``network_create_args`` is honored; other arguments are accepted for compatibility, but are not used here. ``network_create_args`` can be used to provide additional arbitrary network creation arguments. :returns: dict, network data """ cidr = self._generate_cidr() label = utils.generate_random_name("rally_net_") network_create_args = kwargs.get("network_create_args", {}) network = self.client.networks.create(project_id=tenant_id, cidr=cidr, label=label, **network_create_args) return self._marshal_network_object(network)
def _create_node(self, **kwargs): """Create node immediately. :param kwargs: optional parameters to create image :returns: node object """ if "name" not in kwargs: # NOTE(rvasilets): can't use _generate_random_name() because # ironic have specific format for node name. # Check that the supplied hostname conforms to: # * http://en.wikipedia.org/wiki/Hostname # * http://tools.ietf.org/html/rfc952 # * http://tools.ietf.org/html/rfc1123 # or the name could be just uuid. kwargs["name"] = utils.generate_random_name( prefix="rally", choice=string.ascii_lowercase + string.digits) return self.admin_clients("ironic").node.create(**kwargs)
def create_volume(self, size, **kwargs): kwargs["name"] = kwargs.get("name", utils.generate_random_name()) volume = self.client.volumes.create(size, **kwargs) return volume
def update_volume(self, volume, **update_args): update_args["name"] = update_args.get("name", utils.generate_random_name()) update_args["description"] = update_args.get("description") self.client.volumes.update(volume, **update_args)
def create_snapshot(self, volume_id, **kwargs): kwargs["name"] = kwargs.get("name", utils.generate_random_name()) snapshot = self.client.volume_snapshots.create(volume_id, **kwargs) return snapshot
def _generate_random_name(cls, prefix=None, length=None): prefix = cls.RESOURCE_NAME_PREFIX if prefix is None else prefix length = length or cls.RESOURCE_NAME_LENGTH return utils.generate_random_name(prefix, length)
def create_network(self, tenant_id, **kwargs): """Create network. The following keyword arguments are accepted: * add_router: Create an external router and add an interface to each subnet created. Default: False * subnets_num: Number of subnets to create per network. Default: 0 * dns_nameservers: Nameservers for each subnet. Default: 8.8.8.8, 8.8.4.4 * network_create_args: Additional network creation arguments. :param tenant_id: str, tenant ID :param kwargs: Additional options, left open-ended for compatbilitiy. See above for recognized keyword args. :returns: dict, network data """ network_args = {"network": kwargs.get("network_create_args", {})} network_args["network"].update({ "tenant_id": tenant_id, "name": utils.generate_random_name("rally_net_") }) network = self.client.create_network(network_args)["network"] router = None if kwargs.get("add_router", False): router = self.create_router(external=True, tenant_id=tenant_id) subnets = [] subnets_num = kwargs.get("subnets_num", 0) for i in range(subnets_num): subnet_args = { "subnet": { "tenant_id": tenant_id, "network_id": network["id"], "name": utils.generate_random_name("rally_subnet_"), "ip_version": self.SUBNET_IP_VERSION, "cidr": self._generate_cidr(), "enable_dhcp": True, "dns_nameservers": kwargs.get("dns_nameservers", ["8.8.8.8", "8.8.4.4"]) } } subnet = self.client.create_subnet(subnet_args)["subnet"] subnets.append(subnet["id"]) if router: self.client.add_interface_router(router["id"], {"subnet_id": subnet["id"]}) return { "id": network["id"], "name": network["name"], "status": network["status"], "subnets": subnets, "external": network.get("router:external", False), "router_id": router and router["id"] or None, "tenant_id": tenant_id }
def ping_and_ssh_group(self, image, flavor, **kwargs): """ Scenario that has 1. A provider group that provides icmp and ssh bidirectional 2. 2 consumer groups that consumes icmp and ssh bidirectional """ action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier name for icmp and ssh classifier_name_icmp = rutils.generate_random_name(prefix="rally_classifier_icmp_") classifier_name_ssh = rutils.generate_random_name(prefix="rally_classifier_ssh_") # Create the policy classifier for ICMP self._create_policy_classifier(classifier_name_icmp, "icmp", None, "bi") # Create the policy classifier for SSH self._create_policy_classifier(classifier_name_ssh, "tcp", "22", "bi") # Now create a policy rule for ICMP rule_name_icmp = rutils.generate_random_name(prefix="rally_rule_icmp_") self._create_policy_rule(rule_name_icmp, classifier_name_icmp, action_name) # Now create a policy rule for SSH rule_name_ssh = rutils.generate_random_name(prefix="rally_rule_ssh_") self._create_policy_rule(rule_name_ssh, classifier_name_ssh, action_name) # Now create a policy rule set for ICMP ruleset_name_icmp = rutils.generate_random_name(prefix="rally_ruleset_icmp_") self._create_policy_rule_set(ruleset_name_icmp, [rule_name_icmp]) # Create another rule set for SSH ruleset_name_ssh = rutils.generate_random_name(prefix="rally_ruleset_ssh_") self._create_policy_rule_set(ruleset_name_ssh, [rule_name_ssh]) # Create a policy target group that provides ICMP and SSH pt_group_name_provider = rutils.generate_random_name(prefix="rally_group_provider_") self._create_policy_target_group(pt_group_name_provider) # Now update the policy target group to provide ICMP and SSH self._update_policy_target_group(pt_group_name_provider, provided_policy_rulesets=[ruleset_name_icmp, ruleset_name_ssh]) # Create another 2 policy target groups that consumes the ICMP and SSH pt_group_name_consumer_1 = rutils.generate_random_name(prefix="rally_group_consumer_1_") self._create_policy_target_group(pt_group_name_consumer_1) self._update_policy_target_group(pt_group_name_consumer_1, consumed_policy_rulesets=[ruleset_name_icmp, ruleset_name_ssh]) pt_group_name_consumer_2 = rutils.generate_random_name(prefix="rally_group_consumer_2_") self._create_policy_target_group(pt_group_name_consumer_2) self._update_policy_target_group(pt_group_name_consumer_2, consumed_policy_rulesets=[ruleset_name_icmp, ruleset_name_ssh]) # Create a policy target in the provider group pt_name_provider = rutils.generate_random_name(prefix="rally_target_provider_") self._create_policy_target(pt_name_provider, pt_group_name_provider) port_id_provider = self._show_policy_target(pt_name_provider) # Create a policy target in the consumer 1 group pt_name_consumer_1 = rutils.generate_random_name(prefix="rally_target_consumer_1_") self._create_policy_target(pt_name_consumer_1, pt_group_name_consumer_1) port_id_consumer_1 = self._show_policy_target(pt_name_consumer_1) # Create a policy target in the consumer 2 group pt_name_consumer_2 = rutils.generate_random_name(prefix="rally_target_consumer_2_") self._create_policy_target(pt_name_consumer_2, pt_group_name_consumer_2) port_id_consumer_2 = self._show_policy_target(pt_name_consumer_2) # Create a VM in provider group kwargs["nics"] = [{"port-id": port_id_provider}] instance_provider = self._boot_server(image, flavor, **kwargs) # Create a VM in the consumer1 group kwargs["nics"] = [{"port-id": port_id_consumer_1}] instance_consumer_1 = self._boot_server(image, flavor, **kwargs) # Create a VM in the consumer 2 group kwargs["nics"] = [{"port-id": port_id_consumer_2}] instance_consumer_2 = self._boot_server(image, flavor, **kwargs)
def create_and_delete_policy_action(self, action_type="allow"): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name, type=action_type) self._delete_policy_action(name=action_name)
def ping_and_ssh_group(self, image, flavor, **kwargs): """ Scenario that has 1. A provider group that provides icmp and ssh bidirectional 2. 2 consumer groups that consumes icmp and ssh bidirectional """ action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name) # Create a policy classifier name for icmp and ssh classifier_name_icmp = rutils.generate_random_name( prefix="rally_classifier_icmp_") classifier_name_ssh = rutils.generate_random_name( prefix="rally_classifier_ssh_") # Create the policy classifier for ICMP self._create_policy_classifier(classifier_name_icmp, "icmp", None, "bi") # Create the policy classifier for SSH self._create_policy_classifier(classifier_name_ssh, "tcp", "22", "bi") # Now create a policy rule for ICMP rule_name_icmp = rutils.generate_random_name(prefix="rally_rule_icmp_") self._create_policy_rule(rule_name_icmp, classifier_name_icmp, action_name) # Now create a policy rule for SSH rule_name_ssh = rutils.generate_random_name(prefix="rally_rule_ssh_") self._create_policy_rule(rule_name_ssh, classifier_name_ssh, action_name) # Now create a policy rule set for ICMP ruleset_name_icmp = rutils.generate_random_name( prefix="rally_ruleset_icmp_") self._create_policy_rule_set(ruleset_name_icmp, [rule_name_icmp]) # Create another rule set for SSH ruleset_name_ssh = rutils.generate_random_name( prefix="rally_ruleset_ssh_") self._create_policy_rule_set(ruleset_name_ssh, [rule_name_ssh]) # Create a policy target group that provides ICMP and SSH pt_group_name_provider = rutils.generate_random_name( prefix="rally_group_provider_") self._create_policy_target_group(pt_group_name_provider) # Now update the policy target group to provide ICMP and SSH self._update_policy_target_group( pt_group_name_provider, provided_policy_rulesets=[ruleset_name_icmp, ruleset_name_ssh]) # Create another 2 policy target groups that consumes the ICMP and SSH pt_group_name_consumer_1 = rutils.generate_random_name( prefix="rally_group_consumer_1_") self._create_policy_target_group(pt_group_name_consumer_1) self._update_policy_target_group( pt_group_name_consumer_1, consumed_policy_rulesets=[ruleset_name_icmp, ruleset_name_ssh]) pt_group_name_consumer_2 = rutils.generate_random_name( prefix="rally_group_consumer_2_") self._create_policy_target_group(pt_group_name_consumer_2) self._update_policy_target_group( pt_group_name_consumer_2, consumed_policy_rulesets=[ruleset_name_icmp, ruleset_name_ssh]) # Create a policy target in the provider group pt_name_provider = rutils.generate_random_name( prefix="rally_target_provider_") self._create_policy_target(pt_name_provider, pt_group_name_provider) port_id_provider = self._show_policy_target(pt_name_provider) # Create a policy target in the consumer 1 group pt_name_consumer_1 = rutils.generate_random_name( prefix="rally_target_consumer_1_") self._create_policy_target(pt_name_consumer_1, pt_group_name_consumer_1) port_id_consumer_1 = self._show_policy_target(pt_name_consumer_1) # Create a policy target in the consumer 2 group pt_name_consumer_2 = rutils.generate_random_name( prefix="rally_target_consumer_2_") self._create_policy_target(pt_name_consumer_2, pt_group_name_consumer_2) port_id_consumer_2 = self._show_policy_target(pt_name_consumer_2) # Create a VM in provider group kwargs["nics"] = [{"port-id": port_id_provider}] instance_provider = self._boot_server(image, flavor, **kwargs) # Create a VM in the consumer1 group kwargs["nics"] = [{"port-id": port_id_consumer_1}] instance_consumer_1 = self._boot_server(image, flavor, **kwargs) # Create a VM in the consumer 2 group kwargs["nics"] = [{"port-id": port_id_consumer_2}] instance_consumer_2 = self._boot_server(image, flavor, **kwargs)
def create_and_update_policy_action(self, action_type="allow"): action_name = rutils.generate_random_name(prefix="rally_action_allow_") self._create_policy_action(name=action_name, type=action_type) # Create a new action name and update action_name1 = rutils.generate_random_name(prefix="rally_action_allow_") self._update_policy_action(name=action_name, new_name=action_name1)