CNI实现：flanneld hostgw backend 相关实现

import (
	// 每个 backend 都是在 init 函数中注册自己的
	_ "github.com/flannel-io/flannel/backend/hostgw"
	// ...
)
func main() {
	// 初始化一个 subnetManager，这个 subnetManager 会启动一个 node 的 informer，监听所有的 node 事件
	sm, _ := newSubnetManager(ctx)

	// 获取 flanneld 网络配置，就两个：集群网段、backend 类型
	config, _ := getConfig(ctx, sm)

	// 初始化一个 backendManager
	bm := backend.NewManager(ctx, sm, extIface)
	// 获取特定的 backend
	be, _ := bm.GetBackend(config.BackendType)
	// 调用特定 backend 的 RegisterNetwork 方法
	bn, _ := be.RegisterNetwork(ctx, &wg, config)

	// 配置 ip forword rule
	if opts.iptablesForwardRules {
		log.Infof("Changing default FORWARD chain policy to ACCEPT")
		go network.SetupAndEnsureIPTables(network.ForwardRules(config.Network.String()), opts.iptablesResyncSeconds)
	}
	// 写配置文件 /var/run/flannel/subnet.env，供 flannel 插件消费
	if err := WriteSubnetFile(opts.subnetFile, config.Network, opts.ipMasq, bn); err != nil {
    	// handle err
	}
	wg.Add(1)
	go func() {
		// 启动 Backend 返回的 Network。
		bn.Run(ctx)
		wg.Done()
	}()
}

func (be *HostgwBackend) RegisterNetwork(ctx context.Context, wg *sync.WaitGroup, config *subnet.Config) (backend.Network, error) {
	// 返回 RouteNetwork
	n := &backend.RouteNetwork{
		SimpleNetwork: backend.SimpleNetwork{
			ExtIface: be.extIface,
		},
		SM:          be.sm,
		BackendType: "host-gw",
		Mtu:         be.extIface.Iface.MTU,
		LinkIndex:   be.extIface.Iface.Index,
	}
	// 根据 lease 生成一条路由
	n.GetRoute = func(lease *subnet.Lease) *netlink.Route {
		return &netlink.Route{
			Dst:       lease.Subnet.ToIPNet(),
			Gw:        lease.Attrs.PublicIP.ToIP(),
			LinkIndex: n.LinkIndex,
		}
	}
	attrs := subnet.LeaseAttrs{
		PublicIP:    ip.FromIP(be.extIface.ExtAddr),
		BackendType: "host-gw",
	}

	// 配置 node annotation
	l, _ := be.sm.AcquireLease(ctx, &attrs)
	return n, nil
}

// RouteNetwork 在其 Run 方法中处理 lease 事件，并添加相应路由策略。
func (n *RouteNetwork) handleSubnetEvents(batch []subnet.Event) {
	for _, evt := range batch {
		switch evt.Type {
		case subnet.EventAdded:
			route := n.GetRoute(&evt.Lease)
			n.addToRouteList(*route)
			if len(routeList) > 0 && routeEqual(routeList[0], *route) {
				// 添加路由策略
			} else if err := netlink.RouteAdd(route); err != nil {
				continue
			}

		case subnet.EventRemoved:
			route := n.GetRoute(&evt.Lease)
			n.removeFromRouteList(*route)

			// 删除路由策略
			if err := netlink.RouteDel(route); err != nil {
				log.Errorf("Error deleting route to %v: %v", evt.Lease.Subnet, err)
				continue
			}
		default:
			log.Error("Internal error: unknown event type: ", int(evt.Type))
		}
	}
}

func init() {
	backend.Register("my-plugin", New)
}

type MyBackend struct {
	sm       subnet.Manager
	extIface *backend.ExternalInterface
}

func New(sm subnet.Manager, extIface *backend.ExternalInterface) (backend.Backend, error) {
	// 实现 New 方法
}

func (be *HostgwBackend) RegisterNetwork(ctx context.Context, wg *sync.WaitGroup, config *subnet.Config) (backend.Network, error) {
	// 实现 RegisterNetwork 方法
}