Reflector

Informer启动后会连接API Server并进行全量资源查询，之后会对资源对象进行监听。以上操作主要是由Reflector实现的。源码路径为k8s.io/client-go/tools/cache/reflector.go。

Reflector使用的List/Watch方法主要分为2部分，第一部分用来获取全量的资源列表；第二部分是对资源对象进行监控。

首先看一下Reflector的结构体定义，示例如下所示。

type Reflector struct {
    name string
    expectedTypeName string
    expectedType reflect.Type
    expectedGVK *schema.GroupVersionKind
    store Store
    listerWatcher ListerWatcher
    backoffManager wait.BackoffManager
        initConnBackoffManager wait.BackoffManager
    resyncPeriod time.Duration
        ShouldResync func() bool
    clock clock.Clock
    paginatedResult bool
    lastSyncResourceVersion string
        isLastSyncResourceVersionUnavailable bool
        lastSyncResourceVersionMutex sync.RWMutex
    WatchListPageSize int64
        watchErrorHandler WatchErrorHandler
}

其中，listerWatcher这个字段是一个接口类型，Reflector在run方法中会调用ListAndWatch方法，而ListerAndWatch方法中实际执行的就是ListerWatcher的Lister方法和Watcher方法，分别用来获取全量的资源对象和对后面的事件变更进行监控。ListerWatcher定义如下所示。

type ListerWatcher interface {
    Lister
    Watcher
}

Lister和Watcher也是接口，Lister接口的代码如下所示。

type Lister interface {
    
    List(options metav1.ListOptions) (runtime.Object, error)
}

Watcher接口的代码如下所示。

type Watcher interface {
    Watch(options metav1.ListOptions) (watch.Interface, error)
}

而实际上r.ListerWacher.List真正调用的是Pod、Deployment等资源对象的Informer下的ListFunc函数和WatchFunc函数，源码路径为k8s.io/client-go/informers/core/v1/pods.go。

Pod Informer的ListFunc函数和WatchFunc函数代码如下所示。

func NewFilteredPodInformer(client kubernetes.Interface, namespace string, 
    resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions 
    internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
    return cache.NewSharedIndexInformer(
        &cache.ListWatch{
            ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
                if tweakListOptions != nil {
                    tweakListOptions(&options)
                }
                return client.CoreV1().Pods(namespace).List(context.TODO(), options)
            },
            WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
                if tweakListOptions != nil {
                    tweakListOptions(&options)
                }
                return client.CoreV1().Pods(namespace).Watch(context.TODO(), options)
            },
        },
        &corev1.Pod{},
        resyncPeriod,
        indexers,
    )
}

ListFunc函数和WatchFunc函数是通过Clientset客户端与API Server交互后获得的，这也是为什么8.2.1节的代码示例中，在生成NewSharedInformerFactory之前需要先获得Clientset，示例如下所示。

//创建KController对象
func NewKubeController(kubeConfig *restclient.Config, clientset *kubernetes.
    Clientset, defaultResync time.Duration) *KubeController {
    kc := &KubeController{kubeConfig: kubeConfig, clientset: clientset}
    //需要传入Clientset
    kc.factory = informers.NewSharedInformerFactory(clientset, defaultResync)
    ...
    kc.deploymentInformer = kc.factory.Apps().V1().Deployments()
    kc.deploymentsLister = kc.deploymentInformer.Lister()
    kc.deploymentsSynced = kc.deploymentInformer.Informer().HasSynced
    kc.podInformer = kc.factory.Core().V1().Pods()
    kc.podsLister = kc.podInformer.Lister()
    kc.podsSynced = kc.podInformer.Informer().HasSynced
    ...
    return kc
}

List/Watch的逻辑比较长，下面分为2部分来分析核心的函数调用，第一部分示例如下所示。

func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
    klog.V(3).Infof("Listing and watching %v from %s", r.expectedTypeName, r.name)
    var resourceVersion string
    options := metav1.ListOptions{ResourceVersion: r.relistResourceVersion()}
    if err := func() error {
        initTrace := trace.New("Reflector ListAndWatch", trace.Field{"name", r.name})
        defer initTrace.LogIfLong(10 * time.Second)
        var list runtime.Object
        var paginatedResult bool
        var err error
        listCh := make(chan struct{}, 1)
        panicCh := make(chan interface{}, 1)
        //调用r.listerWatcher.List获取资源数据
        go func() {
            defer func() {
                if r := recover(); r != nil {
                    panicCh <- r
                }
            }()
            pager := pager.New(pager.SimplePageFunc(func(opts metav1.ListOptions) 
                (runtime.Object, error) {
                return r.listerWatcher.List(opts)
            }))
            switch {
            case r.WatchListPageSize != 0:
                pager.PageSize = r.WatchListPageSize
            case r.paginatedResult:
            case options.ResourceVersion != "" && options.ResourceVersion != "0":
                pager.PageSize = 0
            }
            list, paginatedResult, err = pager.List(context.Background(), options)
            if isExpiredError(err) || isTooLargeResourceVersionError(err) {
                r.setIsLastSyncResourceVersionUnavailable(true)
                list, paginatedResult, err = pager.List(context.Background(), metav1.
                    ListOptions{ResourceVersion: r.relistResourceVersion()})
            }
            close(listCh)
        }()
        select {
        case <-stopCh:
            return nil
        case r := <-panicCh:
            panic(r)
        case <-listCh:
        }
        if err != nil {
            return fmt.Errorf("failed to list %v: %v", r.expectedTypeName, err)
        }
        //调用listMetaInterface.GetResourceVersion获取资源的版本号
        if options.ResourceVersion == "0" && paginatedResult {
            r.paginatedResult = true
        }
        r.setIsLastSyncResourceVersionUnavailable(false) 
        initTrace.Step("Objects listed")
        listMetaInterface, err := meta.ListAccessor(list)
        if err != nil {
            return fmt.Errorf("unable to understand list result %#v: %v", list, err)
        }
        resourceVersion = listMetaInterface.GetResourceVersion()
        initTrace.Step("Resource version extracted")
        //调用meta.ExtractList 将资源转换成对象列表
        items, err := meta.ExtractList(list)
        if err != nil {
            return fmt.Errorf("unable to understand list result %#v (%v)", list, err)
        }
        initTrace.Step("Objects extracted")
        //调用r.syncWith 将资源对象列表中的资源对象和对应的版本号存入DeltaFIFO
        if err := r.syncWith(items, resourceVersion); err != nil {
            return fmt.Errorf("unable to sync list result: %v", err)
        }
        initTrace.Step("SyncWith done")

第一部分的主体逻辑和调用函数如下。

·调用r.listerWatcher.List获取资源数据。

·调用listMetaInterface.GetResourceVersion获取资源的版本号。

·调用meta.ExtractList将资源转换成对象列表。

·调用r.syncWith将资源对象列表中的资源对象和对应的版本号存入DeltaFIFO。

第二部分示例如下所示。

//调用r.setLastSyncResourceVersion设置最新的资源版本号
        r.setLastSyncResourceVersion(resourceVersion)
        initTrace.Step("Resource version updated")
        return nil
    }(); err != nil {
        return err
    }
    resyncerrc := make(chan error, 1)
    cancelCh := make(chan struct{})
    defer close(cancelCh)
    go func() {
        resyncCh, cleanup := r.resyncChan()
        defer func() {
            cleanup() 
        }()
        for {
            select {
            case <-resyncCh:
            case <-stopCh:
                return
            case <-cancelCh:
                return
            }
            if r.ShouldResync == nil || r.ShouldResync() {
                klog.V(4).Infof("%s: forcing resync", r.name)
                if err := r.store.Resync(); err != nil {
                    resyncerrc <- err
                    return
                }
            }
            cleanup()
            resyncCh, cleanup = r.resyncChan()
        }
    }()
    for {
        select {
        case <-stopCh:
            return nil
        default:
        }
        timeoutSeconds := int64(minWatchTimeout.Seconds() * (rand.Float64() + 1.0))
        options = metav1.ListOptions{
            ResourceVersion: resourceVersion,
            TimeoutSeconds: &timeoutSeconds,
            AllowWatchBookmarks: true,
        }
        start := r.clock.Now()
        //调用r.listerWatcher.Watch进行资源对象的事件监控
        w, err := r.listerWatcher.Watch(options)
        if err != nil {
            if utilnet.IsConnectionRefused(err) {
                <-r.initConnBackoffManager.Backoff().C()
                continue
            }
            return err
        }
     //触发事件后调用r.watchHandler将资源对象存入DeltaFIFO中并更新版本号
        if err := r.watchHandler(start, w, &resourceVersion, resyncerrc, stopCh); 
            err != nil {
            if err != errorStopRequested {
                switch {
                case isExpiredError(err):
t observed object.
                }
            }
            return nil
        }
    }
}

第二部分的主体逻辑和调用函数如下。

·调用r.setLastSyncResourceVersion设置最新的资源版本号。

·调用r.listerWatcher.Watch进行资源对象的事件监控。

·触发事件后调用r.watchHandler将资源对象存入DeltaFIFO中并更新版本号。

List/Watch方法逻辑中调用的函数较多，感兴趣的读者可以查阅源码。

关于Watch的底层实现，其实是使用HTTP长连接来监听事件的，并且使用了HTTP的分块传输编码（Chunked Transfer Encoding）。根据百度百科上的介绍，分块传输编码是HTTP中的一种数据传输机制，允许HTTP由网页服务器发送给客户端应用（通常是网页浏览器）的数据可以分成多个部分。分块传输编码只在HTTP 1.1版本中提供。

通常，HTTP应答消息中的数据是整个发送的，Content-Length消息头字段表示数据的长度。数据的长度很重要，因为客户端需要知道哪里是应答消息的结束，以及哪里是后续应答消息的开始。然而，使用分块传输编码将数据分解成一系列数据块，并以一个或多个块发送，这样服务器可以发送数据而不需要预先知道发送内容的大小。通常，数据块的大小是固定的，但也不总是这种情况。