1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

    // 先不管他底層是如何實作的，這裡就是會監聽kubernetes api server 
    // 監控 pod 的變化，會帶一些條件例如： 要監聽的 namespace ，label等等
	podListWatcher := cache.NewListWatchFromClient(clientset.CoreV1().RESTClient(), "pods", v1.NamespaceDefault, fields.Everything())
    
    // 傳入監控pod的物件、pod的資料結構，resync的時間
    // 處理事件的控制function以及儲存資料的地方(local cache)
        indexer, informer := cache.NewIndexerInformer(podListWatcher, &v1.Pod{}, 0, cache.ResourceEventHandlerFuncs{
		...
        ,
	}, cache.Indexers{})    
    
    
    //建立 infomer 物件
func NewIndexerInformer(
	lw ListerWatcher,
	objType runtime.Object,
	resyncPeriod time.Duration,
	h ResourceEventHandler,
	indexers Indexers,
) (Indexer, Controller) {
	// 建立一個 indexer 作為local cache用
	clientState := NewIndexer(DeletionHandlingMetaNamespaceKeyFunc, indexers)
        //回傳 indexer 以及 實作 controller interface 的物件（之後會講到先不用管他）
	return clientState, newInformer(lw, objType, resyncPeriod, h, clientState)
}

    //基本上就是封裝成實作 controller interface 的物件（之後會講到先不用管他）
func newInformer(
	lw ListerWatcher,
	objType runtime.Object,
	resyncPeriod time.Duration,
	h ResourceEventHandler,
	clientState Store,
) Controller {

    ...
    return New(cfg)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// ListerWatcher 組合了 Lister 跟 Watcher 接下去看 這兩個interface負責什麼
type ListerWatcher interface {
	Lister
	Watcher
}

// Lister is any object that knows how to perform an initial list.
type Lister interface {
	// 根據 ListOptions 來決定要列出哪些物件
	List(options metav1.ListOptions) (runtime.Object, error)
}

// Watcher is any object that knows how to start a watch on a resource.
type Watcher interface {
	// 根據 ListOptions 來決定要跟蹤哪些物件
	Watch(options metav1.ListOptions) (watch.Interface, error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 定義實作 Lister 的 struct
type ListFunc func(options metav1.ListOptions) (runtime.Object, error)

// 定義實作 Watcher 的 struct
type WatchFunc func(options metav1.ListOptions) (watch.Interface, error)


// ListWatch knows how to list and watch a set of apiserver resources.  It satisfies the ListerWatcher interface.
// It is a convenience function for users of NewReflector, etc.
// ListFunc and WatchFunc must not be nil
type ListWatch struct {
	ListFunc  ListFunc
	WatchFunc WatchFunc
	// DisableChunking requests no chunking for this list watcher.
	DisableChunking bool
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// NewListWatchFromClient通過指定的 client ， resource ，namespace
//  和 fieldsSelector 建立一個ListWatch。
func NewListWatchFromClient(c Getter, resource string, namespace string, fieldSelector fields.Selector) *ListWatch {
    //封裝 fieldSelector 為 func(options *metav1.ListOptions)
	optionsModifier := func(options *metav1.ListOptions) {
		options.FieldSelector = fieldSelector.String()
	}
    //建立一個ListWatch
	return NewFilteredListWatchFromClient(c, resource, namespace, optionsModifier)
}

// NewFilteredListWatchFromClient 跟上面那個很類似不過他是接收 optionsModifier 而不是 fieldsSelector
func NewFilteredListWatchFromClient(c Getter, resource string, namespace string, optionsModifier func(options *metav1.ListOptions)) *ListWatch {
    //建立一個實作 lister  的物件
	listFunc := func(options metav1.ListOptions) (runtime.Object, error) {
            //這個手法滿厲害的，就是在其他地方使用listFunc(ListOptions)時候
            //把傳入的 ListOptions 透過 optionsModifier function 處理
		optionsModifier(&options)
               //這裡就是 kubernetes client 請求 kubernetes api server 的方法
		return c.Get().
			Namespace(namespace).
			Resource(resource).
			VersionedParams(&options, metav1.ParameterCodec).
			Do(context.TODO()).
			Get()
	}
    //建立一個實作 Watcher  的物件
	watchFunc := func(options metav1.ListOptions) (watch.Interface, error) {
		options.Watch = true
            //這個手法滿厲害的，就是在其他地方使用watchFunc(ListOptions)時候
            //把傳入的 ListOptions 透過 optionsModifier function 處理
		optionsModifier(&options)
               //這裡就是 kubernetes client 請求 kubernetes api server 的方法
		return c.Get().
			Namespace(namespace).
			Resource(resource).
			VersionedParams(&options, metav1.ParameterCodec).
			Watch(context.TODO())
	}
    //建立實作 ListWatcher 的物件
	return &ListWatch{ListFunc: listFunc, WatchFunc: watchFunc}
}

1
2
3
4
5
6

// 委託給剛剛的 object 列出物件的情況
func (lw *ListWatch) List(options metav1.ListOptions) (runtime.Object, error) {
	// ListWatch is used in Reflector, which already supports pagination.
	// Don't paginate here to avoid duplication.
	return lw.ListFunc(options)
}

1
2
3
4
5

// 委託給剛剛的 object 監控物件的情況
func (lw *ListWatch) Watch(options metav1.ListOptions) (watch.Interface, error) {
	return lw.WatchFunc(options)
}