【Nova】nova-network网络模型之flat网络-代码学习

在上一篇“【Nova】nova-network网络模型之flat网络”中对flat网络的架构有了一定的认识，那么现在学习代码就事半功倍了。

1.nova-network在接受rpc请求之前，会调用网络管理器的init_host方法进行一定的初始化工作，flat模式下这个初始化工作十分的简单:

只需要配置网络的injected为True即可，也就是我们需要注入网络配置到虚拟机内。前面我们有讲过nova-api-metadata服务，那这里为什么不使用元数据服务来告诉虚拟机它的固定ip呢？因为虚拟机在没有配置网络的情况下，它是无法访问元数据服务的。

class NetworkManager(manager.Manager):

    SHOULD_CREATE_BRIDGE = False
    
    DHCP = False

    def init_host(self):
        ctxt = context.get_admin_context()
        # 对和主机有关联的网络进行以下操作, 通常flat模式仅有一个虚拟网络
        for network in network_obj.NetworkList.get_by_host(ctxt, self.host):
            # 对网络进行设置工作
            self._setup_network_on_host(ctxt, network)
            # update_dns_entries默认为False
            if CONF.update_dns_entries:
                dev = self.driver.get_dev(network)
                self.driver.update_dns(ctxt, dev, network)


class FlatManager(NetworkManager):

    def _setup_network_on_host(self, context, network)
        # 设置网络的injected字段为True;
        # flat_injected代表是否需要注入网络配置到虚拟机内;
        # 由于flat模式并没有DHCP服务, 因此是需要进行注入的
        network.injected = CONF.flat_injected
        network.save()

2.然后我们看一下flat模式下为实例分配网络资源的API allocate_for_instance:

class NetworkManager(manager.Manager):
    
    # 为实例获取网络列表
    def _get_networks_for_instance(self, context, instance_id, project_id,
                                   requested_networks=None):
        if requested_networks is not None and len(requested_networks) != 0:
            # 如果requested_networks不为空, 那么就在requested_networks获取网络列表
            network_uuids = [uuid for (uuid, fixed_ip) in requested_networks]
            networks = self._get_networks_by_uuids(context, network_uuids)
        else:
            # 反之requested_networks为空, 那就获取当前project下的所有网络
            try:
                networks = network_obj.NetworkList.get_all(context)
            except exception.NoNetworksFound:
                return []
        
        # 过滤出不是vlan的网络列表并返回
        return [network for network in networks if not network.vlan]
    
    # 从network中提取出需要使用的部分信息, 并返回字典
    def _get_network_dict(self, network):
        network_dict = {'id': network['uuid'],
                        'bridge': network['bridge'],
                        'label': network['label'],
                        'tenant_id': network['project_id']}

        if network.get('injected'):
            network_dict['injected'] = network['injected']

        return network_dict

    # 为实例创建数据库的VirtualInterface记录, VirtualInterface可理解为虚拟网卡
    def _add_virtual_interface(self, context, instance_uuid, network_id,
                              mac=None):
        # 确定重试次数
        attempts = 1 if mac else CONF.create_unique_mac_address_attempts
        for i in range(attempts):
            try:
                vif = vif_obj.VirtualInterface()
                # 如果没有传递mac地址, 那么我就自动生成一个mac地址;
                # OpenStack的虚拟机mac地址有一个特征: 开头3个字节是0xfa, 0x16, 0x3e
                vif.address = mac or utils.generate_mac_address()
                vif.instance_uuid = instance_uuid
                vif.network_id = network_id
                vif.uuid = str(uuid.uuid4())
                # 将VirtualInterface实例存入数据库并返回
                vif.create(context)
                return vif
            except exception.VirtualInterfaceCreateException:
                # Try again up to max number of attempts
                pass

        raise exception.VirtualInterfaceMacAddressException()

    # 为虚拟机实例分配mac地址
    def _allocate_mac_addresses(self, context, instance_uuid, networks, macs):
        if macs is not None:
            available_macs = set(macs)

        for network in networks:
            if macs is None:
                # 为实例创建mac地址并创建数据库的VirtualInterface记录
                self._add_virtual_interface(context, instance_uuid,
                                           network['id'])
            else:
                # 当传递的macs不为空的情况, 我们从中选取一个mac
                try:
                    mac = available_macs.pop()
                except KeyError:
                    raise exception.VirtualInterfaceCreateException()
                # 为实例创建数据库的VirtualInterface记录
                self._add_virtual_interface(context, instance_uuid,
                                           network['id'], mac)

    # 为实例分配固定IP
    def allocate_fixed_ip(self, context, instance_id, network, **kwargs):
        address = None

        instance = instance_obj.Instance.get_by_uuid(context, instance_id)

        # OpenStack的配额管理可以限制租户对资源的使用情况;
        # 下面这段代码就是判断当前租户的固定ip使用情况是否超出配额
        quotas = self.quotas_cls()
        quota_project, quota_user = quotas_obj.ids_from_instance(context,
                                                                 instance)
        try:
            quotas.reserve(context, fixed_ips=1, project_id=quota_project,
                           user_id=quota_user)
        except exception.OverQuota:
            LOG.warn(_("Quota exceeded for %s, tried to allocate "
                       "fixed IP"), context.project_id)
            raise exception.FixedIpLimitExceeded()

        try:
            if network['cidr']:
                address = kwargs.get('address', None)
                if address:
                    # 如果我们指明了要分配的固定ip,那么直接进行绑定即可;
                    # 在use_local为False的情况下, 这里其实是调用nova-conductor的RpcAPI来实现的
                    fip = fixed_ip_obj.FixedIP.associate(context, address,
                                                         instance_id,
                                                         network['id'])
                else:
                    # 如果我们没有指明要分配的固定IP,那么我们从固定IP池中选取一个可用的固定IP与实例进行绑定
                    fip = fixed_ip_obj.FixedIP.associate_pool(
                        context.elevated(), network['id'], instance_id)
                vif = vif_obj.VirtualInterface.get_by_instance_and_network(
                        context, instance_id, network['id'])
                        
                # 标记固定IP为已分配的, 并与实例在该网络下的虚拟网卡进行关联
                fip.allocated = True
                fip.virtual_interface_id = vif.id
                fip.save()
                # 触发安全组成员实例刷新触发器
                self._do_trigger_security_group_members_refresh_for_instance(
                    instance_id)

            name = instance.display_name

            # 验证实例所在的availability_zone是否与DNS的domain一致, 默认情况下验证通过
            if self._validate_instance_zone_for_dns_domain(context, instance):
                # 使用实例DNS管理器为该实例创建记录;
                # 默认配置下的实例DNS管理器的方法都是noop, 也就是什么都不做
                self.instance_dns_manager.create_entry(
                    name, str(fip.address), "A", self.instance_dns_domain)
                self.instance_dns_manager.create_entry(
                    instance_id, str(fip.address), "A",
                    self.instance_dns_domain)
            # 在该主机上设置该网络, flat模式下就是设置网络的injected字段为True
            self._setup_network_on_host(context, network)

            # 更新该租户的配额使用情况
            quotas.commit(context)
            return address

        except Exception:
            with excutils.save_and_reraise_exception():
                quotas.rollback(context)

    # RpcAPI:为实例分配网络资源
    def allocate_for_instance(self, context, **kwargs):
        instance_uuid = kwargs['instance_id']
        if not uuidutils.is_uuid_like(instance_uuid):
            instance_uuid = kwargs.get('instance_uuid')
        host = kwargs['host']
        project_id = kwargs['project_id']
        rxtx_factor = kwargs['rxtx_factor']
        requested_networks = kwargs.get('requested_networks')
        vpn = kwargs['vpn']
        macs = kwargs['macs']
        admin_context = context.elevated()
        LOG.debug(_("network allocations"), instance_uuid=instance_uuid,
                  context=context)
        # 获取当前实例的可用网络列表
        networks = self._get_networks_for_instance(admin_context,
                                        instance_uuid, project_id,
                                        requested_networks=requested_networks)
        # 从networks中提取出需要的部分网络信息, 包括uuid、bridge、label、project_id和injected等
        networks_list = [self._get_network_dict(network)
                                 for network in networks]
        LOG.debug(_('networks retrieved for instance: |%s|'),
                  networks_list, context=context, instance_uuid=instance_uuid)

        try:
            # 为实例分配mac地址并创建数据库的VirtualInterface记录
            self._allocate_mac_addresses(context, instance_uuid, networks,
                                         macs)
        except Exception as e:
            with excutils.save_and_reraise_exception():
                # 发生异常时, 删除实例的已有VirtualInterface记录并向外抛出异常
                vif_obj.VirtualInterface.delete_by_instance_uuid(context,
                        instance_uuid)

        # 为实例分配固定ip
        self._allocate_fixed_ips(admin_context, instance_uuid,
                                 host, networks, vpn=vpn,
                                 requested_networks=requested_networks)

        # 默认不用更新DNS记录
        if CONF.update_dns_entries:
            network_ids = [network['id'] for network in networks]
            self.network_rpcapi.update_dns(context, network_ids)

        # 返回实例的所有网络信息
        return self.get_instance_nw_info(context, instance_uuid, rxtx_factor,
                                         host)

class FlatManager(NetworkManager):

    def _allocate_fixed_ips(self, context, instance_id, host, networks,
                            **kwargs):
        requested_networks = kwargs.get('requested_networks')
        # 针对networks中的每个网络分配一次固定ip
        for network in networks:
            address = None
            if requested_networks is not None:
                # 如果我们希望对特定的网络指定要分配的固定ip, 那么就可以通过requested_networks来传递这个意愿;
                # 我们假设对同一个网络指定了多个要分配的固定ip, 那么只选取第一个来进行分配
                for address in (fixed_ip for (uuid, fixed_ip) in
                                requested_networks if network['uuid'] == uuid):
                    break
            # 调用基类的allocate_fixed_ip来实现真正的分配工作
            self.allocate_fixed_ip(context, instance_id,
                                   network, address=address)

3.接下来我们看一下flat模式下为实例解绑固定ip的API deallocate_fixed_ip:

class NetworkManager(manager.Manager):

    def deallocate_fixed_ip(self, context, address, host=None, teardown=True,
            instance=None):
        
        # 通过address从数据库中获取到FixedIP对象
        fixed_ip_ref = fixed_ip_obj.FixedIP.get_by_address(
            context, address, expected_attrs=['network'])
        # 获取与固定ip绑定的实例uuid
        instance_uuid = fixed_ip_ref.instance_uuid
        # 获取与固定ip关联的虚拟网卡id
        vif_id = fixed_ip_ref.virtual_interface_id

        if not instance:
            # 如果没有传递instance, 那么通过实例uuid从数据库中获取到Instance对象
            instance = instance_obj.Instance.get_by_uuid(
                context.elevated(read_deleted='yes'), instance_uuid)

        quotas = self.quotas_cls()
        quota_project, quota_user = quotas_obj.ids_from_instance(context,
                                                                 instance)
                                                                 
        # 更新该租户的配额使用情况
        try:
            quotas.reserve(context, fixed_ips=-1, project_id=quota_project,
                           user_id=quota_user)
        except Exception:
            LOG.exception(_("Failed to update usages deallocating "
                            "fixed IP"))
        # 触发安全组成员实例刷新触发器
        self._do_trigger_security_group_members_refresh_for_instance(
            instance_uuid)

        # 默认通过验证
        if self._validate_instance_zone_for_dns_domain(context, instance):
            # 默认什么也不做, noop
            for n in self.instance_dns_manager.get_entries_by_address(address,
                                                     self.instance_dns_domain):
                self.instance_dns_manager.delete_entry(n,
                                                      self.instance_dns_domain)
        # 修改固定ip的已分配情况和关联的虚拟网卡id, 并保存进数据库
        fixed_ip_ref.allocated = False
        fixed_ip_ref.virtual_interface_id = None
        fixed_ip_ref.save()

        if teardown:
            network = fixed_ip_ref.network
            # 如果配置迫使DHCP释放IP
            if CONF.force_dhcp_release:
                # 获取网络的网桥, 即network['bridge']
                dev = self.driver.get_dev(network)
                msg = _("Unable to release %s because vif doesn't exist.")
                if not vif_id:
                    LOG.error(msg % address)
                    return
                # 通过vif_id从数据库中获取VirtualInterface对象
                vif = vif_obj.VirtualInterface.get_by_id(context, vif_id)

                if not vif:
                    LOG.error(msg % address)
                    return

                # 什么也不做
                self._teardown_network_on_host(context, network)
                # 使用dhcp_release命令行工具迫使DHCP释放address;
                # 如果说flat模式没有DHCP服务,那么这里也就是无意义的?
                self.driver.release_dhcp(dev, address, vif.address)

                # 解绑固定ip,这里就是清空FixedIP的instance_uuid字段
                fixed_ip_ref = fixed_ip_obj.FixedIP.get_by_address(
                    context, address)
                if (instance_uuid == fixed_ip_ref.instance_uuid and
                        not fixed_ip_ref.leased):
                    fixed_ip_ref.disassociate()
            else:
                # 什么也不做
                self._teardown_network_on_host(context, network)

        # 提交配额的更新事务
        quotas.commit(context)

class FlatManager(NetworkManager):
    
    # 解绑固定ip使之返回固定ip池
    def deallocate_fixed_ip(self, context, address, host=None, teardown=True,
            instance=None):
        # 调用父类的解绑方法
        super(FlatManager, self).deallocate_fixed_ip(context, address, host,
                                                     teardown,
                                                     instance=instance)
        # disassociate_by_address这个接口, 看名字是解绑固定IP;
        # 但是深入进去, 发现本质是获取固定IP, 不太明白;
        # 不过上面deallocate_fixed_ip已经实现了解绑功能, 这里什么也不做也是可以的
        fixed_ip_obj.FixedIP.disassociate_by_address(context, address)
        
    def _teardown_network_on_host(self, context, network):
        pass

4.在Icehouse版本中，flat模式下nova-network的RpcAPI很少，连浮动IP有关的API都没有，难以在生产环境中的使用

5.不过曾经遇到一些特殊需求, 譬如反nat网络的软件。那么可以考虑使用flat网络来解决，创建网桥br100让虚拟机实例与计算节点共享物理网络，如果物理网络有DHCP,那么可以直接使用，也省去了配置虚拟机实例网络的问题，但是也有新的问题: 分配给虚拟机的固定ip和我们在虚拟机的来宾系统中看到的ip是不一样的，也就是分配给虚拟机的固定ip基本上起不到作用了，这种情况下nova-network形同虚设。