class Host(fixtures.Fixture):

    """The Host class models a physical host running agents, all reporting with

    the same hostname.

    OpenStack installers or administrators connect compute nodes to the

    physical tenant network by connecting the provider bridges to their

    respective physical NICs. Or, if using tunneling, by configuring an

    IP address on the appropriate physical NIC. The Host class does the same

    with the connect_* methods.

    # 是不是可以贡献代码啊？

    TODO(amuller): Add start/stop/restart methods that will start/stop/restart

    all of the agents on this host. Add a kill method that stops all agents

    and disconnects the host from other hosts.

    """

    def __init__(self, env_desc, host_desc,

                 test_name, neutron_config,

                 central_data_bridge, central_external_bridge):

        self.env_desc = env_desc

        self.host_desc = host_desc

        self.test_name = test_name

        self.neutron_config = neutron_config

        self.central_data_bridge = central_data_bridge    # 每个host 都会连接 图中的顶部和底部的bridge。

        self.central_external_bridge = central_external_bridge

        self.host_namespace = None

        self.agents = {}

        # we need to cache already created "per network" bridges if linuxbridge

        # agent is used on host:

        self.network_bridges = {}

    def _setUp(self):

        self.local_ip = self.allocate_local_ip()  # 

        if self.host_desc.l2_agent_type == constants.AGENT_TYPE_OVS:

            self.setup_host_with_ovs_agent()

        elif self.host_desc.l2_agent_type == constants.AGENT_TYPE_LINUXBRIDGE:

            self.setup_host_with_linuxbridge_agent()

        if self.host_desc.l3_agent:

            self.l3_agent = self.useFixture(

                process.L3AgentFixture(

                    self.env_desc, self.host_desc,

                    self.test_name,

                    self.neutron_config,

                    self.l3_agent_cfg_fixture))

    def setup_host_with_ovs_agent(self):

        # config br-int, ovs的名称，open follow接口 ovs-ofctl， db接口vsctl，agent， security group…

        # 以及与之连接的 bridge是br-eth（'vlan'）还是br-tun('vxlan', ‘gre’的情况下)

        agent_cfg_fixture = config.OVSConfigFixture(

            self.env_desc, self.host_desc, self.neutron_config.temp_dir,

            self.local_ip)

        self.useFixture(agent_cfg_fixture)

        # 怎么链接到 图中顶层的bridge， internal的bridge

        if self.env_desc.tunneling_enabled:

            self.useFixture(

                net_helpers.OVSBridgeFixture(

                    agent_cfg_fixture.get_br_tun_name())).bridge

            self.connect_to_internal_network_via_tunneling() # 通过veth连接, 其中一个 veth的IP为local_ip

        else:

            br_phys = self.useFixture(

                net_helpers.OVSBridgeFixture(

                    agent_cfg_fixture.get_br_phys_name())).bridge

            self.connect_to_internal_network_via_vlans(br_phys) # 通过ovs的patch连接

        self.ovs_agent = self.useFixture( # 启动ovs的agent，按照前面的配置。

            process.OVSAgentFixture(

                self.env_desc, self.host_desc,

                self.test_name, self.neutron_config, agent_cfg_fixture))

        # 怎么链接到 图中底层的bridge， external的bridge

        if self.host_desc.l3_agent:

            self.l3_agent_cfg_fixture = self.useFixture(

                # 主要是 namespace 和 interface_driver（ovs 还是linux bridge）

                config.L3ConfigFixture(

                    self.env_desc, self.host_desc,

                    self.neutron_config.temp_dir,

                    self.ovs_agent.agent_cfg_fixture.get_br_int_name()))

            br_ex = self.useFixture(

                net_helpers.OVSBridgeFixture(

                    self.l3_agent_cfg_fixture.get_external_bridge())).bridge

            self.connect_to_external_network(br_ex)  # 通过ovs的patch连接

    def setup_host_with_linuxbridge_agent(self):

        #First we need to provide connectivity for agent to prepare proper

        #bridge mappings in agent's config:

        self.host_namespace = self.useFixture(

            net_helpers.NamespaceFixture(prefix="host-")

        ).name

        # 怎么链接到 图中底层的bridge， external的bridge, 有两种方式，一种是直接连接 bridge?

        # 直接 bridge 带 可使用 veth，也可以不使用。

        # 一种是有增加了一个linux bridge， qbr

        self.connect_namespace_to_control_network()

        agent_cfg_fixture = config.LinuxBridgeConfigFixture(

            self.env_desc, self.host_desc,

            self.neutron_config.temp_dir,

            self.local_ip,

            physical_device_name=self.host_port.name

        )

        self.useFixture(agent_cfg_fixture)

        self.linuxbridge_agent = self.useFixture(

            process.LinuxBridgeAgentFixture(

                self.env_desc, self.host_desc,

                self.test_name, self.neutron_config, agent_cfg_fixture,

                namespace=self.host_namespace

            )

        )

        if self.host_desc.l3_agent:

            self.l3_agent_cfg_fixture = self.useFixture(

                config.L3ConfigFixture(

                    self.env_desc, self.host_desc,

                    self.neutron_config.temp_dir))

    def _connect_ovs_port(self, cidr_address):

        ovs_device = self.useFixture(

            net_helpers.OVSPortFixture(

                bridge=self.central_data_bridge,

                namespace=self.host_namespace)).port

        # NOTE: This sets an IP address on the host's root namespace

        # which is cleaned up when the device is deleted.

        ovs_device.addr.add(cidr_address)

        return ovs_device

    def connect_namespace_to_control_network(self):

        self.host_port = self._connect_ovs_port(

            common_utils.ip_to_cidr(self.local_ip, 24)

        )

        self.host_port.link.set_up()

    def connect_to_internal_network_via_tunneling(self):

        veth_1, veth_2 = self.useFixture(

            net_helpers.VethFixture()).ports

        # NOTE: This sets an IP address on the host's root namespace

        # which is cleaned up when the device is deleted.

        veth_1.addr.add(common_utils.ip_to_cidr(self.local_ip, 32))

        veth_1.link.set_up()

        veth_2.link.set_up()

    def connect_to_internal_network_via_vlans(self, host_data_bridge):

        # If using VLANs as a segmentation device, it's needed to connect

        # a provider bridge to a centralized, shared bridge.

        net_helpers.create_patch_ports(

            self.central_data_bridge, host_data_bridge)

    def connect_to_external_network(self, host_external_bridge):

        net_helpers.create_patch_ports(

            self.central_external_bridge, host_external_bridge)

    def allocate_local_ip(self):

        if not self.env_desc.network_range:

            return str(self.useFixture(

                ip_address.ExclusiveIPAddress(

                    '240.0.0.1', '240.255.255.254')).address)

        return str(self.useFixture(

            ip_address.ExclusiveIPAddress(

                str(self.env_desc.network_range[2]),

                str(self.env_desc.network_range[-2]))).address)

    def get_bridge(self, network_id):

        if "ovs" in self.agents.keys():

            return self.ovs_agent.br_int

        elif "linuxbridge" in self.agents.keys():

            bridge = self.network_bridges.get(network_id, None)

            if not bridge:

                br_prefix = lb_agent.LinuxBridgeManager.get_bridge_name(

                    network_id)

                bridge = self.useFixture(

                    net_helpers.LinuxBridgeFixture(

                        prefix=br_prefix,

                        namespace=self.host_namespace,

                        prefix_is_full_name=True)).bridge

                self.network_bridges[network_id] = bridge

        return bridge

    @property

    def hostname(self):

        return self.neutron_config.config.DEFAULT.host

    @property

    def l3_agent(self):

        return self.agents['l3']

    @l3_agent.setter

    def l3_agent(self, agent):

        self.agents['l3'] = agent

    @property

    def ovs_agent(self):

        return self.agents['ovs']

    @ovs_agent.setter

    def ovs_agent(self, agent):

        self.agents['ovs'] = agent

    @property

    def linuxbridge_agent(self):

        return self.agents['linuxbridge']

    @linuxbridge_agent.setter

    def linuxbridge_agent(self, agent):

        self.agents['linuxbridge'] = agent

IMPORTANT: configure_for_func_testing.sh relies on DevStack to perform
extensive modification to the underlying host. Execution of the script
requires sudo privileges and it is recommended that the following
commands be invoked only on a clean and disposeable
VM. A VM that has had DevStack previously installed on it is also fine.

git clone https://git.openstack.org/openstack-dev/devstack ../devstack

./tools/configure_for_func_testing.sh ../devstack -i

tox -e dsvm-functional