让 BUG 带你去看代码

def boot_runcommand_delete(self, image, flavor,
                           script, interpreter, username,
                           password=None,
                           volume_args=None,
                           floating_network=None,
                           port=22,
                           use_floating_ip=True,
                           force_delete=False,
                           **kwargs):
    """Boot a server, run a script that outputs JSON, delete the server.

    Example Script in samples/tasks/support/instance_dd_test.sh

    :param image: glance image name to use for the vm
    :param flavor: VM flavor name
    :param script: script to run on server, must output JSON mapping
                   metric names to values (see the sample script below)
    :param interpreter: server's interpreter to run the script
    :param username: ssh username on server, str
    :param password: Password on SSH authentication
    :param volume_args: volume args for booting server from volume
    :param floating_network: external network name, for floating ip
    :param port: ssh port for SSH connection
    :param use_floating_ip: bool, floating or fixed IP for SSH connection
    :param force_delete: whether to use force_delete for servers
    :param **kwargs: extra arguments for booting the server
    :returns: dictionary with keys `data' and `errors':
              data: dict, JSON output from the script
              errors: str, raw data from the script's stderr stream
    """

    if volume_args:
        volume = self._create_volume(volume_args["size"], imageRef=None)
        kwargs["block_device_mapping"] = {"vdrally": "%s:::1" % volume.id}

    server, fip = self._boot_server_with_fip(
        image, flavor, use_floating_ip=use_floating_ip,
        floating_network=floating_network,
        key_name=self.context["user"]["keypair"]["name"],
        **kwargs

... ...

def _boot_server_with_fip(self, image, flavor,
                          use_floating_ip=True, floating_network=None,
                          wait_for_ping=True, **kwargs):
    """Boot server prepared for SSH actions."""
    kwargs["auto_assign_nic"] = True
    server = self._boot_server(image, flavor, **kwargs)

    if not server.networks:
        raise RuntimeError(
            "Server `%(server)s' is not connected to any network. "
            "Use network context for auto-assigning networks "
            "or provide `nics' argument with specific net-id." % {
                "server": server.name})

    if use_floating_ip:
        fip = self._attach_floating_ip(server, floating_network)
    else:
        internal_network = list(server.networks)[0]
        fip = {"ip": server.addresses[internal_network][0]["addr"]}

    if wait_for_ping:
        self._wait_for_ping(fip["ip"])

    return server, {"ip": fip.get("ip"),
                    "id": fip.get("id"),
                    "is_floating": use_floating_ip}

def _boot_server(self, image_id, flavor_id,
                 auto_assign_nic=False, name=None, **kwargs):

    server_name = name or self._generate_random_name()
    secgroup = self.context.get("user", {}).get("secgroup")
    if secgroup:
        if "security_groups" not in kwargs:
            kwargs["security_groups"] = [secgroup["name"]]
        elif secgroup["name"] not in kwargs["security_groups"]:
            kwargs["security_groups"].append(secgroup["name"])

    if auto_assign_nic and not kwargs.get("nics", False):
        nets = [net["id"] for net in
                self.context.get("tenant", {}).get("networks", [])]
        if nets:
            # NOTE(amaretskiy): Balance servers among networks:
            #     divmod(iteration % tenants_num, nets_num)[1]
            net_idx = divmod(
                (self.context["iteration"]
                 % self.context["config"]["users"]["tenants"]),
                len(nets))[1]
            kwargs["nics"] = [{"net-id": nets[net_idx]}]

    server = self.clients("nova").servers.create(
        server_name, image_id, flavor_id, **kwargs)
... ...