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_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_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 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 _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 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 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 _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_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: 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