Kubernetes client-go DeltaFIFO 源码分析

2021-09-30 15:35:43 阅读：149 来源： 互联网

标签：DeltaFIFO obj Kubernetes err nil 34 源码 go &#

<!DOCTYPE html>
<html lang="en">
<head>

<script async src="https://www.googletagmanager.com/gtag/js?id=G-994J9VCT2Q"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());

gtag('config', 'G-994J9VCT2Q');
</script>

<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<title>Kubernetes client-go DeltaFIFO 源码分析 - Daniel Hu's Blog | 胡涛的博客</title>
<meta name="renderer" content="webkit" />
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"/>

</head>
<body>
<div id="mobile-navbar" class="mobile-navbar">
<div class="mobile-header-logo">
<a href="/" class="logo">Daniel Hu's Blog</a>
</div>
<div class="mobile-navbar-icon">



</div>
</div>
<nav id="mobile-menu" class="mobile-menu slideout-menu">
<ul class="mobile-menu-list">
<a href="/post/">
<li class="mobile-menu-item">Archives(目录)</li>
</a><a href="/tags/">
<li class="mobile-menu-item">Tags</li>
</a><a href="/about/">
<li class="mobile-menu-item">About</li>
</a><a href="/k8s-source-code-analysis/">
<li class="mobile-menu-item">E-book</li>
</a>
</ul>

</nav>

<div class="container" id="mobile-panel">
<header id="header" class="header">
<div class="logo-wrapper">
<a href="/" class="logo">Daniel Hu's Blog</a>
</div>

<nav class="site-navbar">
<ul id="menu" class="menu">
<li class="menu-item">
<a class="menu-item-link" href="/post/">Archives(目录)</a>
</li><li class="menu-item">
<a class="menu-item-link" href="/tags/">Tags</a>
</li><li class="menu-item">
<a class="menu-item-link" href="/about/">About</a>
</li><li class="menu-item">
<a class="menu-item-link" href="/k8s-source-code-analysis/">E-book</a>
</li>
</ul>
</nav>

</header>

<main id="main" class="main">
<div class="content-wrapper">
<div id="content" class="content">
<article class="post">

<header class="post-header">
<h1 class="post-title">Kubernetes client-go DeltaFIFO 源码分析</h1>

<div class="post-meta">
 2021-09-28 

 2942 words 
 6 mins read 

</div>
</header>

<div class="post-toc" id="post-toc">
<h2 class="post-toc-title">Contents</h2>
<div class="post-toc-content">
<nav id="TableOfContents">
<ul>
<li>
<ul>
<li><a href="#概述">概述</a></li>
<li><a href="#queue-接口">Queue 接口</a></li>
<li><a href="#deltafifo">DeltaFIFO</a></li>
<li><a href="#添加元素---queueactionlocked">添加元素 - queueActionLocked()</a></li>
<li><a href="#pop">Pop()</a></li>
<li><a href="#replace">Replace()</a></li>
</ul>
</li>
</ul>
</nav>
</div>
</div>
<div class="post-content">
<h2 id="概述">概述</h2>
<blockquote>
源码版本信息
<ul>
<li>Project: kubernetes</li>
<li>Branch: master</li>
<li>Last commit id: d25d741c</li>
<li>Date: 2021-09-26</li>
</ul>
</blockquote>
DeltaFIFO 是自定义控制器开发涉及到的一个重要组件，今天我们来详细研究下 client-go 里 DeltaFIFO 相关代码。
<img src="https://gitee.com/daniel-hutao/images/raw/master/delta_fifo.png" alt="">
<h2 id="queue-接口">Queue 接口</h2>
类似 workqueue 里的队列概念，这里也有一个队列，Queue 接口定义在 client-go/tools/cache 包中的 fifo.go 文件里，看下有哪些方法：
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code>1
2
3
4
5
6
7
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">type Queue interface {
Store
Pop(PopProcessFunc) (interface{}, error) // 会阻塞，知道有一个元素可以被 pop 出来，或者队列关闭
 AddIfNotPresent(interface{}) error
HasSynced() bool
Close()
}
</code></pre></td></tr></table>
</div>
</div>这里嵌里一个 Store 接口，对应定义如下：
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">type Store interface {
Add(obj interface{}) error
Update(obj interface{}) error
Delete(obj interface{}) error
List() []interface{}
ListKeys() []string
Get(obj interface{}) (item interface{}, exists bool, err error)
GetByKey(key string) (item interface{}, exists bool, err error)
Replace([]interface{}, string) error
Resync() error
}
</code></pre></td></tr></table>
</div>
</div>Store 接口的方法都比较直观，Store 的实现有很多，我们等下看 Queue 里用到的是哪个实现。
Queue 接口的实现是 FIFO 和 DeltaFIFO 两个类型，我们在 Informer 里用到的是 DeltaFIFO，而 DeltaFIFO 也没有依赖 FIFO，所以下面我们直接看 DeltaFIFO 是怎么实现的。
<h2 id="deltafifo">DeltaFIFO</h2>
<ul>
<li>client-go/tools/cache/delta_fifo.go:97</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">type DeltaFIFO struct {
lock sync.RWMutex
cond sync.Cond
items map[string]Deltas
queue []string // 这个 queue 里是没有重复元素的，和上面 items 的 key 保持一致
 populated bool
initialPopulationCount int
keyFunc KeyFunc // 用于构造上面 map 用到的 key
 knownObjects KeyListerGetter // 用来检索所有的 keys
 closed bool
emitDeltaTypeReplaced bool
}
</code></pre></td></tr></table>
</div>
</div>这里有一个 Deltas 类型，看下具体的定义：
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">type Deltas []Delta

type Delta struct {
Type DeltaType
Object interface{}
}

type DeltaType string

const (
Added DeltaType = "Added"
Updated DeltaType = "Updated"
Deleted DeltaType = "Deleted"
Replaced DeltaType = "Replaced"
Sync DeltaType = "Sync"
)

</code></pre></td></tr></table>
</div>
</div>可以看到 Delta 结构体保存的是 DeltaType（就是一个字符串）和发生了这种 Delta 的具体对象。
DeltaFIFO 内部主要维护的一个队列和一个 map，直观一点表示如下：
<img src="https://gitee.com/daniel-hutao/images/raw/master/delta_fifo.png" alt="">
DeltaFIFO 的 New 函数是 <code>NewDeltaFIFOWithOptions()</code>
<ul>
<li>client-go/tools/cache/delta_fifo.go:218</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func NewDeltaFIFOWithOptions(opts DeltaFIFOOptions) *DeltaFIFO {
if opts.KeyFunction == nil {
opts.KeyFunction = MetaNamespaceKeyFunc
}

f := &DeltaFIFO{
items: map[string]Deltas{},
queue: []string{},
keyFunc: opts.KeyFunction,
knownObjects: opts.KnownObjects,

emitDeltaTypeReplaced: opts.EmitDeltaTypeReplaced,
}
f.cond.L = &f.lock
return f
}
</code></pre></td></tr></table>
</div>
</div><h2 id="添加元素---queueactionlocked">添加元素 - queueActionLocked()</h2>
可以注意到 DeltaFIFO 的 Add() 等方法等方法体都很简短，大致这样：
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code>1
2
3
4
5
6
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func (f *DeltaFIFO) Add(obj interface{}) error {
f.lock.Lock()
defer f.lock.Unlock()
f.populated = true
return f.queueActionLocked(Added, obj)
}
</code></pre></td></tr></table>
</div>
</div>里面的逻辑就是调用 <code>queueActionLocked()</code> 方法传递对应的 DeltaType 进去，前面提到过 DeltaType 就是 Added、Updated、Deleted 等字符串，所以我们直接先看 <code>queueActionLocked()</code> 方法的实现。
<ul>
<li>client-go/tools/cache/delta_fifo.go:409</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 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
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) error {
id, err := f.KeyOf(obj) // 计算这个对象的 key
 if err != nil {
return KeyError{obj, err}
}
oldDeltas := f.items[id] // 从 items map 里获取当前的 Deltas
 newDeltas := append(oldDeltas, Delta{actionType, obj}) // 构造一个 Delta，添加到 Deltas 中，也就是 []Delta 里
 newDeltas = dedupDeltas(newDeltas) // 如果最近个 Delta 是重复的，则保留后一个；目前版本只处理的 Deleted 重复场景

if len(newDeltas) > 0 { // 理论上 newDeltas 长度一定大于0
 if _, exists := f.items[id]; !exists {
f.queue = append(f.queue, id) // 如果 id 不存在，则在队列里添加
 }
f.items[id] = newDeltas // 如果 id 已经存在，则只更新 items map 里对应这个 key 的 Deltas
 f.cond.Broadcast()
} else { // 理论上这里执行不到
 if oldDeltas == nil {
klog.Errorf("Impossible dedupDeltas for id=%q: oldDeltas=%#+v, obj=%#+v; ignoring", id, oldDeltas, obj)
return nil
}
klog.Errorf("Impossible dedupDeltas for id=%q: oldDeltas=%#+v, obj=%#+v; breaking invariant by storing empty Deltas", id, oldDeltas, obj)
f.items[id] = newDeltas
return fmt.Errorf("Impossible dedupDeltas for id=%q: oldDeltas=%#+v, obj=%#+v; broke DeltaFIFO invariant by storing empty Deltas", id, oldDeltas, obj)
}
return nil
}
</code></pre></td></tr></table>
</div>
</div>到这里再反过来看 Add() Delete() Update() Get() 等函数，就很清晰了，只是将对应变化类型的 obj 添加到队列中。
<h2 id="pop">Pop()</h2>
Pop 按照元素的添加或更新顺序有序返回一个元素(Deltas)，在队列为空时会阻塞。另外 Pop 过程会先从队列中删除一个元素然后返回，所以如果处理失败了需要通过 <code>AddIfNotPresent()</code> 方法将这个元素加回到队列中。
Pop 的参数是 <code>type PopProcessFunc func(interface{}) error</code> 类型的 process，中 <code>Pop()</code> 函数中直接将队列里的第一个元素出队，然后丢给 process 处理，如果处理失败会重新入队，但是这个 Deltas 和对应的错误信息会被返回。
<ul>
<li>client-go/tools/cache/delta_fifo.go:515</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 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
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func (f *DeltaFIFO) Pop(process PopProcessFunc) (interface{}, error) {
f.lock.Lock()
defer f.lock.Unlock()
for { // 这个循环其实没有意义，和下面的 !ok 一起解决了一个不会发生的问题
 for len(f.queue) == 0 { // 如果为空则进入这个循环
 if f.closed { // 队列关闭则直接返回
 return nil, ErrFIFOClosed
}
f.cond.Wait() // 等待
 }
id := f.queue[0] // queue 里放的是 key
 f.queue = f.queue[1:] // queue 中删除这个 key
 depth := len(f.queue)
if f.initialPopulationCount > 0 { // 第一次调用 Replace() 插入到元素数量
 f.initialPopulationCount--
}
item, ok := f.items[id] // 从 items map[string]Deltas 中获取一个 Deltas
 if !ok { // 理论上不可能找不到，为此引入了上面的 for 嵌套，感觉不是很好
 klog.Errorf("Inconceivable! %q was in f.queue but not f.items; ignoring.", id)
continue
}
delete(f.items, id) // items map 中也删除这个元素
 // 当队列长度超过 10 并且处理一个元素时间超过 0.1 s 时打印日志；队列长度理论上不会变长因为处理一个元素时是阻塞的，这时候新的元素加不进来
 if depth > 10 {
trace := utiltrace.New("DeltaFIFO Pop Process",
utiltrace.Field{Key: "ID", Value: id},
utiltrace.Field{Key: "Depth", Value: depth},
utiltrace.Field{Key: "Reason", Value: "slow event handlers blocking the queue"})
defer trace.LogIfLong(100 * time.Millisecond)
}
err := process(item) // 丢给 PopProcessFunc 处理
 if e, ok := err.(ErrRequeue); ok { // 如果需要 requeue 则加回到队列里
 f.addIfNotPresent(id, item)
err = e.Err
}
// 返回这个 Deltas 和错误信息
 return item, err
}
}
</code></pre></td></tr></table>
</div>
</div>我们看一下 Pop() 的实际调用场景：
<ul>
<li>client-go/tools/cache/controller.go:181</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func (c *controller) processLoop() {
for {
obj, err := c.config.Queue.Pop(PopProcessFunc(c.config.Process))
if err != nil {
if err == ErrFIFOClosed {
return
}
if c.config.RetryOnError {
c.config.Queue.AddIfNotPresent(obj) // 其实 Pop 内部已经调用了 AddIfNotPresent，这里也有点多余；也许更加健壮吧
 }
}
}
}
</code></pre></td></tr></table>
</div>
</div>到这还有一个疑问，就是 process 函数是怎么实现的？我们看 sharedIndexInformer 里的 process 函数逻辑：
<ul>
<li>client-go/tools/cache/shared_informer.go:537</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 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
43
44
45
46
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func (s *sharedIndexInformer) HandleDeltas(obj interface{}) error {
s.blockDeltas.Lock()
defer s.blockDeltas.Unlock()

// 这个遍历是从旧到新的过程
 for _, d := range obj.(Deltas) {
switch d.Type {
case Sync, Replaced, Added, Updated: // 下面一个 case 是 Deleted
 s.cacheMutationDetector.AddObject(d.Object)
if old, exists, err := s.indexer.Get(d.Object); err == nil && exists {
// 更新 indexer
 if err := s.indexer.Update(d.Object); err != nil {
return err
}

isSync := false
switch {
case d.Type == Sync:
isSync = true
case d.Type == Replaced:
if accessor, err := meta.Accessor(d.Object); err == nil {
if oldAccessor, err := meta.Accessor(old); err == nil {
isSync = accessor.GetResourceVersion() == oldAccessor.GetResourceVersion()
}
}
}
// 更新通知
 s.processor.distribute(updateNotification{oldObj: old, newObj: d.Object}, isSync)
} else {
// 将 obj 加到 indexer 里
 if err := s.indexer.Add(d.Object); err != nil {
return err
}
// 添加通知
 s.processor.distribute(addNotification{newObj: d.Object}, false)
}
case Deleted: // 如果是删除，则从 indexer 中删除 obj
 if err := s.indexer.Delete(d.Object); err != nil {
return err
}
// 发布一个删除消息
 s.processor.distribute(deleteNotification{oldObj: d.Object}, false)
}
}
return nil
}
</code></pre></td></tr></table>
</div>
</div><h2 id="replace">Replace()</h2>
Replace() 简单地做两件事：
<ol>
<li>给传入的对象列表添加一个 Sync/Replace DeltaType 的 Delta</li>
<li>然后执行一些删除逻辑</li>
</ol>
这里的 Replace() 过程可以简单理解成传递一个新的 []Deltas 过来，如果当前 DeltaFIFO 里已经有这些元素，则追加一个 Sync/Replace 动作，反之 DeltaFIFO 里多出来的 Deltas 则可能是与 apiserver 失联导致实际已经删除，但是删除动作没有 watch 到的那些对象，所以直接追加一个 Deleted 的 Delta；
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code> 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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func (f *DeltaFIFO) Replace(list []interface{}, _ string) error {
f.lock.Lock()
defer f.lock.Unlock()
keys := make(sets.String, len(list)) // 用来保存 list 中每个 item 的 key

// 老代码兼容逻辑
 action := Sync
if f.emitDeltaTypeReplaced {
action = Replaced
}

for _, item := range list { // 在每个 item 后面添加一个 Sync/Replaced 动作
 key, err := f.KeyOf(item)
if err != nil {
return KeyError{item, err}
}
keys.Insert(key)
if err := f.queueActionLocked(action, item); err != nil {
return fmt.Errorf("couldn't enqueue object: %v", err)
}
}

if f.knownObjects == nil {
queuedDeletions := 0
for k, oldItem := range f.items { // 删除 f.items 里的老元素
 if keys.Has(k) {
continue
}

var deletedObj interface{}
if n := oldItem.Newest(); n != nil { // 如果 Deltas 不为空则有返回值
 deletedObj = n.Object
}
queuedDeletions++
// 标记删除；因为和 apiserver 失联引起的删除状态没有及时获取到，所以这里是 DeletedFinalStateUnknown 类型
 if err := f.queueActionLocked(Deleted, DeletedFinalStateUnknown{k, deletedObj}); err != nil {
return err
}
}

if !f.populated {
f.populated = true
f.initialPopulationCount = keys.Len() + queuedDeletions
}

return nil
}

knownKeys := f.knownObjects.ListKeys() // key 就是例如 "default/pod_1" 这种字符串
 queuedDeletions := 0
for _, k := range knownKeys {
if keys.Has(k) {
continue
}
// 新列表里不存在的老元素标记为将要删除
 deletedObj, exists, err := f.knownObjects.GetByKey(k)
if err != nil {
deletedObj = nil
klog.Errorf("Unexpected error %v during lookup of key %v, placing DeleteFinalStateUnknown marker without object", err, k)
} else if !exists {
deletedObj = nil
klog.Infof("Key %v does not exist in known objects store, placing DeleteFinalStateUnknown marker without object", k)
}
queuedDeletions++
// 添加一个删除动作；因为与 apiserver 失联等场景会引起删除事件没有 wathch 到，所以是 DeletedFinalStateUnknown 类型
 if err := f.queueActionLocked(Deleted, DeletedFinalStateUnknown{k, deletedObj}); err != nil {
return err
}
}

return nil
}
</code></pre></td></tr></table>
</div>
</div>这里有一个 knownObjects 属性，要完整理解 Replace() 逻辑还得看下 knownObjects 是什么逻辑。
我们去跟 knownObjects 属性的初始化，可以看到其引用的是 cache 类型实现的 Store，cache 是实现 Indexer 的那个 cache，Indexer 的源码分析可以在我的另外一篇文章<a href="../client-go-indexer/">《Kubernetes client-go Indexer / ThreadSafeStore 源码分析》</a> 中看到。
<ul>
<li>client-go/tools/cache/store.go:258</li>
</ul>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code>1
2
3
4
5
6
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">func NewStore(keyFunc KeyFunc) Store {
return &cache{
cacheStorage: NewThreadSafeStore(Indexers{}, Indices{}),
keyFunc: keyFunc,
}
}
</code></pre></td></tr></table>
</div>
</div>这里是当作一个 Store 来用，而不是 Indexer。中 NewStore() 函数调用时传递的参数是：
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code>1
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">clientState := NewStore(DeletionHandlingMetaNamespaceKeyFunc)
</code></pre></td></tr></table>
</div>
</div><div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code>1
2
3
4
5
6
7
</code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">// 处理了 DeletedFinalStateUnknown 对象获取 key 问题
func DeletionHandlingMetaNamespaceKeyFunc(obj interface{}) (string, error) {
if d, ok := obj.(DeletedFinalStateUnknown); ok {
return d.Key, nil
}
return MetaNamespaceKeyFunc(obj)
}
</code></pre></td></tr></table>
</div>
</div>所以 knownObjects 通过 cache 类型实例，使用了和 Indexer 类似的机制，通过内部 ThreadSafeStore 来实现了检索队列所有元素的 keys 的能力。
DeltaFIFO 和 Indexer 之间还有一个桥梁 Informer，我们这里简单提到了 sharedIndexInformer 的 HandleDeltas() 方法，后面详细分析 Informer 的逻辑，最终再将整个自定义控制器和 client-go 相关组件逻辑串在一起。
（转载请保留本文原始链接）

</div>

<div class="post-copyright">

Author
Daniel Hu


LastMod

2021-09-29
<a href="/commit/d4a62f6eb6eb8899ca7e1fe814136fc44a1ba64a" title="add client-go-indexer">(d4a62f6)</a>



</div>
<footer class="post-footer">
<div class="post-tags">
<a href="/tags/k8s/">k8s</a>
<a href="/tags/client-go/">client-go</a>
<a href="/tags/deltafifo/">deltafifo</a>
<a href="/tags/%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/">源码分析</a>
</div>
<nav class="post-nav">

<a class="next" href="/post/k8s/client-go-indexer/">
Kubernetes client-go Indexer / ThreadSafeStore 源码分析
Next

</a>
</nav>
</footer>
</article>
</div>

</div>
</main>

<div class="copyright">

Powered by <a class="hexo-link" href="https://gohugo.io">Hugo</a>

|

Theme -
<a class="theme-link" href="https://github.com/olOwOlo/hugo-theme-even">Even</a>

©
2021Daniel Hu

</div>

</footer>

</body>
</html>

标签：DeltaFIFO,obj,Kubernetes,err,nil,34,源码,go,&#
来源： https://www.cnblogs.com/cloudgeek/p/15356962.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Kubernetes client-go DeltaFIFO 源码分析