kubelet源码分析 LIST&WATCH源码

kubelet源码分析 LIST&WATCH源码

做个笔记记录k8s中赫赫有名的LIST&WATCH。
其实之前的文章中都有过watch的身影了。分别是informer篇和configCh篇这两篇其实都共用了client-go包中的LIST&WATCH方法。这篇内容详细讲一下这个功能

一、简介

LIST&WATCH是一种用于监视资源变化的机制
使用 List&Watch 可以有效地监视 Kubernetes 中的各种资源，包括 Pod、Service、Deployment、ConfigMap 等等。通过 List&Watch，开发人员可以及时了解 Kubernetes 中各种资源的状态和变化情况，从而更好地管理和维护 Kubernetes 集群。
本地开发中，用到它的地方很多，也可以通过这个功能开发很多组件

二、LIST

通过 List 方法，开发人员可以获取某个资源的当前状态，并将其缓存在本地。这个列表包含了该资源的所有实例，以及每个实例的详细信息，例如名称、状态、标签等等。主要是一次性获取到api-server的所有数据
多说无益，上代码！！

• 开启run

• 是否开启流数据模式

• 开启list。resync。watch

• 详解list（流程2.2）

• 初始化分页数据（流程2.3）这个分页有大概三种情况，
  第一种就是第一次list，则返回0，代表的是第一次list，去和api-server拿数据，不需要分页。
  第二种情况，返回""代表第一次的list失败了，则使用分页去etcd拿数据
  第三种情况，是返回>0的版本号，代表有历史查询了

• 开启链路追踪器

• 果是过期错误或者是资源版本错误，则设置unavailable(流程2.1有介绍）后重新在访问一次

• 设置同步成功。把返回的数据转型成podList类型。然后设置获得版本号，链路追踪做记录

• 进行replace同步上一篇的informer介绍过，去查看Replace）

• 设置最新版本号

• 这一次list就完事了

2.1.开启主函数
代码位置:k8s.io/client-go/tools/cache/reflector.go

func (r *Reflector) Run(stopCh <-chan struct{}) {
	klog.V(3).Infof("Starting reflector %s (%s) from %s", r.typeDescription, r.resyncPeriod, r.name)
	wait.BackoffUntil(func() {
	    //开启LIST&WATCH
		if err := r.ListAndWatch(stopCh); err != nil {
			r.watchErrorHandler(r, err)
		}
	}, r.backoffManager, true, stopCh)
	klog.V(3).Infof("Stopping reflector %s (%s) from %s", r.typeDescription, r.resyncPeriod, r.name)
}


func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
	klog.V(3).Infof("Listing and watching %v from %s", r.typeDescription, r.name)
	var err error
	var w watch.Interface
	fallbackToList := !r.UseWatchList
	//如果开启了的话就从API服务器上获取数据。流的主要优点是使用较少的服务器资源来获取数据。
	if r.UseWatchList {
		w, err = r.watchList(stopCh)
		if w == nil && err == nil {
			return nil
		}
		if err != nil {
			if !apierrors.IsInvalid(err) {
				return err
			}
			w = nil
		}
	}

	if fallbackToList {
	    //进入list
		err = r.list(stopCh)
		if err != nil {
			return err
		}
	}

	resyncerrc := make(chan error, 1)
	cancelCh := make(chan struct{})
	defer close(cancelCh)
	//开启resync，informer篇介绍过了
	go r.startResync(stopCh, cancelCh, resyncerrc)
	//开始watch，三、WATCH 介绍
	return r.watch(w, stopCh, resyncerrc)
}

2.2详解list

func (r *Reflector) list(stopCh <-chan struct{}) error {
	var resourceVersion string
	//初始化分页数据（流程2.1）
	options := metav1.ListOptions{ResourceVersion: r.relistResourceVersion()}
	//这里初始化一下链路追踪器
	initTrace := trace.New("Reflector ListAndWatch", trace.Field{Key: "name", Value: 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)
	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 {
		//如果用户设置了分页数量，则直接采用分页，访问etcd
		case r.WatchListPageSize != 0:
			pager.PageSize = r.WatchListPageSize
		//如果开启了禁止缓存，则进行分页，这个变量后面会设置，访问etcd
		case r.paginatedResult:
		//如果不是0也不是空，则代表有记录不是第一次list了，则继续不用分页使用api-server的缓存
		case options.ResourceVersion != "" && options.ResourceVersion != "0":
			pager.PageSize = 0
		}
		//进行list的http请求连接
		list, paginatedResult, err = pager.List(context.Background(), options)
		//如果是过期错误或者是资源版本错误，则设置unavailable(流程2.1有介绍）然后重新再次请求，这次请求就会不走api缓存，而是去取etcd了
		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:
	}
	initTrace.Step("Objects listed", trace.Field{Key: "error", Value: err})
	if err != nil {
		klog.Warningf("%s: failed to list %v: %v", r.name, r.typeDescription, err)
		return fmt.Errorf("failed to list %v: %w", r.typeDescription, err)
	}
	//返回的分页结果（paginatedResult）意味着观察缓存被禁用，并且有很多特定类型的对象。在这种情况下，没有必要优先选择从监视缓存中列出。
	if options.ResourceVersion == "0" && paginatedResult {
		r.paginatedResult = true
	}
	//设置同步成功
	r.setIsLastSyncResourceVersionUnavailable(false) // list was successful
	//向下转型，把list结构体转换一下
	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")
	//再次向下转型，转到最终的podList这种类型
	items, err := meta.ExtractList(list)
	if err != nil {
		return fmt.Errorf("unable to understand list result %#v (%v)", list, err)
	}
	initTrace.Step("Objects extracted")
	//这里进行Replace同步了（上一篇的informer介绍过，去查看Replace）
	if err := r.syncWith(items, resourceVersion); err != nil {
		return fmt.Errorf("unable to sync list result: %v", err)
	}
	initTrace.Step("SyncWith done")
	//设置最新的版本号
	r.setLastSyncResourceVersion(resourceVersion)
	initTrace.Step("Resource version updated")
	return nil
}

2.3查看是否为第一次list

func (r *Reflector) relistResourceVersion() string {
	r.lastSyncResourceVersionMutex.RLock()
	defer r.lastSyncResourceVersionMutex.RUnlock()
	//上面介绍过，如果这个地方等于true，则代表第一次的同步失败了
	if r.isLastSyncResourceVersionUnavailable {
	   //如果返回的是”“则代表去etcd直接查询，而不使用api-server的缓存
		return ""
	}
	//这里代表第一次，因为初始化的时候就是”“
	if r.lastSyncResourceVersion == "" {
	    //如果返回的是0，则代表是第一次，去api-server的缓存查询，不需要分页了
		return "0"
	}
	//否则就不是第一次了，返回版本号即可
	return r.lastSyncResourceVersion
}

三、WATCH

通过 Watch 方法，开发人员可以实时监视某个资源的变化。一旦有任何新的变化发生，例如创建、删除、更新等等，Kubernetes API 就会将相应的信息推送给开发人员的客户端。主要是持续监听。如果要本地开发，要注意watch功能实用http1.1的长连接方式，并在请求头中指定 Connection: keep-alive 和 Accept: application/json。并且注意返回的数据要以’\n’数据进行截取
3.1 watch创建

• watch就是一个for循环，不会退出，除非收到stopCh退出信号
• 初始化监听数据（版本号，超时时间）
• 创建watch客户端（就是调用client-go的watch了）
• watch链接成功，开始处理返回数据（流程3.2）
• 如果中途退出或出错，记录最后的时间，然后进行for重连了

func (r *Reflector) watch(w watch.Interface, stopCh <-chan struct{}, resyncerrc chan error) error {
	var err error
	retry := NewRetryWithDeadline(r.MaxInternalErrorRetryDuration, time.Minute, apierrors.IsInternalError, r.clock)
	for {
		select {
		case <-stopCh:
			return nil
		default:
		}
		//记录开始时间
		start := r.clock.Now()
		//w就是watch的监听结果，如果为空（失败了或者初始化都会为空）则进行创建
		if w == nil {
			timeoutSeconds := int64(minWatchTimeout.Seconds() * (rand.Float64() + 1.0))
			options := metav1.ListOptions{
			    //版本号，如果是本地开发，也最好有这个号，这个版本号的作用是，watch的数据只接受这个版本主会后的
				ResourceVersion: r.LastSyncResourceVersion(),
				//超时时间
				TimeoutSeconds: &timeoutSeconds,
				AllowWatchBookmarks: true,
			}
			//创建watch客户端（就是调用client-go的watch了）
			w, err = r.listerWatcher.Watch(options)
			if err != nil {
				if canRetry := isWatchErrorRetriable(err); canRetry {
					klog.V(4).Infof("%s: watch of %v returned %v - backing off", r.name, r.typeDescription, err)
					select {
					case <-stopCh:
						return nil
					case <-r.initConnBackoffManager.Backoff().C():
						continue
					}
				}
				return err
			}
		}
		//watch链接成功，开始处理返回数据（流程3.2）
		err = watchHandler(start, w, r.store, r.expectedType, r.expectedGVK, r.name, r.typeDescription, r.setLastSyncResourceVersion, nil, r.clock, resyncerrc, stopCh)
		//中途退出或者断开了或者有error了，断开
		w.Stop()
		w = nil
		//记录最后的时间
		retry.After(err)
		if err != nil {
			if err != errorStopRequested {
				switch {
				case isExpiredError(err):
					klog.V(4).Infof("%s: watch of %v closed with: %v", r.name, r.typeDescription, err)
				case apierrors.IsTooManyRequests(err):
					klog.V(2).Infof("%s: watch of %v returned 429 - backing off", r.name, r.typeDescription)
					select {
					case <-stopCh:
						return nil
					case <-r.initConnBackoffManager.Backoff().C():
						continue
					}
				case apierrors.IsInternalError(err) && retry.ShouldRetry():
					klog.V(2).Infof("%s: retrying watch of %v internal error: %v", r.name, r.typeDescription, err)
					continue
				default:
					klog.Warningf("%s: watch of %v ended with: %v", r.name, r.typeDescription, err)
				}
			}
			return nil
		}
	}
}

3.2 watchhanderl处理

• 接收管道传来的数据
• 如果是类型错误，则返回记录（断开的时候就是类型错误）
• 判断一下类型是否正常。断GVK是否正常（group，version，kind)
• 向下转型，转成需要的类型（pod)
• 获得这次的版本号
• 如果是add类型，则更新本地缓存（对应各种类型的本地缓存处理）
• 记录最新版本号
• event数量++（统计这次watch中记录了多少次event）
• 如果断开了，则记录这次watch多长时间
• 如果小于1秒并且接收了0次，则说明是错误了
• watch结束

func watchHandler(start time.Time,
	w watch.Interface,
	store Store,
	expectedType reflect.Type,
	expectedGVK *schema.GroupVersionKind,
	name string,
	expectedTypeName string,
	setLastSyncResourceVersion func(string),
	exitOnInitialEventsEndBookmark *bool,
	clock clock.Clock,
	errc chan error,
	stopCh <-chan struct{},
) error {
	eventCount := 0
	if exitOnInitialEventsEndBookmark != nil {
		*exitOnInitialEventsEndBookmark = false
	}

loop:
	for {
		select {
		case <-stopCh:
			return errorStopRequested
		case err := <-errc:
			return err
	    //这个是watach接收到的数据
		case event, ok := <-w.ResultChan():
			if !ok {
				break loop
			}
			//如果是类型错误，则返回记录（断开的时候就是类型错误）
			if event.Type == watch.Error {
				return apierrors.FromObject(event.Object)
			}
			//判断一下类型是否正常
			if expectedType != nil {
				if e, a := expectedType, reflect.TypeOf(event.Object); e != a {
					utilruntime.HandleError(fmt.Errorf("%s: expected type %v, but watch event object had type %v", name, e, a))
					continue
				}
			}
			//判断GVK是否正常（group，version，kind)
			if expectedGVK != nil {
				if e, a := *expectedGVK, event.Object.GetObjectKind().GroupVersionKind(); e != a {
					utilruntime.HandleError(fmt.Errorf("%s: expected gvk %v, but watch event object had gvk %v", name, e, a))
					continue
				}
			}
			//向下转型，转成需要的类型（pod)
			meta, err := meta.Accessor(event.Object)
			if err != nil {
				utilruntime.HandleError(fmt.Errorf("%s: unable to understand watch event %#v", name, event))
				continue
			}
			//获得这次的版本号
			resourceVersion := meta.GetResourceVersion()
			switch event.Type {
			case watch.Added:
			//如果是add类型，则更新本地缓存
				err := store.Add(event.Object)
				if err != nil {
					utilruntime.HandleError(fmt.Errorf("%s: unable to add watch event object (%#v) to store: %v", name, event.Object, err))
				}
			case watch.Modified:
			//如果是更新类型，则更新本地缓存
				err := store.Update(event.Object)
				if err != nil {
					utilruntime.HandleError(fmt.Errorf("%s: unable to update watch event object (%#v) to store: %v", name, event.Object, err))
				}
			case watch.Deleted:
			//如果是删除类型，则更新本地缓存
				err := store.Delete(event.Object)
				if err != nil {
					utilruntime.HandleError(fmt.Errorf("%s: unable to delete watch event object (%#v) from store: %v", name, event.Object, err))
				}
			case watch.Bookmark:
				if _, ok := meta.GetAnnotations()["k8s.io/initial-events-end"]; ok {
					if exitOnInitialEventsEndBookmark != nil {
						*exitOnInitialEventsEndBookmark = true
					}
				}
			default:
				utilruntime.HandleError(fmt.Errorf("%s: unable to understand watch event %#v", name, event))
			}
			//记录最新版本号
			setLastSyncResourceVersion(resourceVersion)
			if rvu, ok := store.(ResourceVersionUpdater); ok {
				rvu.UpdateResourceVersion(resourceVersion)
			}
			//event数量++（统计这次watch中记录了多少次event）
			eventCount++
			if exitOnInitialEventsEndBookmark != nil && *exitOnInitialEventsEndBookmark {
				watchDuration := clock.Since(start)
				klog.V(4).Infof("exiting %v Watch because received the bookmark that marks the end of initial events stream, total %v items received in %v", name, eventCount, watchDuration)
				return nil
			}
		}
	}
	//记录这次watch多长时间
	watchDuration := clock.Since(start)
	//如果小于1秒并且接收了0次，则说明是错误了
	if watchDuration < 1*time.Second && eventCount == 0 {
		return fmt.Errorf("very short watch: %s: Unexpected watch close - watch lasted less than a second and no items received", name)
	}
	klog.V(4).Infof("%s: Watch close - %v total %v items received", name, expectedTypeName, eventCount)
	return nil
}

四、总结

这里介绍的是client-go封装好的LIST&WATCH，如果想通过HTTP直接访问k8s的API进行LIST&WATCH就需要自己进行封装了，同时需要注意watch的异常断开和超时断开和数据切割等问题~~以后文章有机会再记录。
LIST&WATCH功能还是很强大的，k8s的源码中很多地方使用到了他，比如informer和configCh，同时通过这里的LIST&WATCH进行处理的，可以省去很多资源占用。感兴趣可以通过这个功能开发很多有趣的小组件