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

// RateLimitingInterface is an interface that rate limits items being added to the queue.
//RateLimiting interface 結合了 delaying work queue ，透過一些方法計算 物件的延遲速率
// 再交由 delaying work queue 丟入Heap 最後放入 common queue中。
type RateLimitingInterface interface {
	DelayingInterface        // delaying work queue 前一篇有介紹過

	// AddRateLimited adds an item to the workqueue after the rate limiter says it's ok
	AddRateLimited(item interface{})    // 對某個物件加入延遲

	// Forget indicates that an item is finished being retried.  Doesn't matter whether it's for perm failing
	// or for success, we'll stop the rate limiter from tracking it.  This only clears the `rateLimiter`, you
	// still have to call `Done` on the queue.
	Forget(item interface{})    //  表示某個物件已經做了

	// NumRequeues returns back how many times the item was requeued
	NumRequeues(item interface{}) int //計算某個物件調用queueAddRateLimited的次數
}

1
2
3
4
5
6
7

// rateLimitingType wraps an Interface and provides rateLimited re-enquing
type rateLimitingType struct {
	DelayingInterface      // 嵌入 delaying work queue 表示 rateLimitingType 也有 delay work queue的能力
                              //（不一定需要傳入實作的物件，本身就是DelayingInterface的一種）
                             
	rateLimiter RateLimiter     //組合了一個 RateLimiter interface，需要明確傳入實作的物件。
}

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

type RateLimiter interface {
	// When gets an item and gets to decide how long that item should wait
    //當一個物件放入的時候，需要回傳延遲多久（可自定義規則，等等會看到）
	When(item interface{}) time.Duration
    
    
	// Forget indicates that an item is finished being retried.  Doesn't matter whether its for perm failing	    
    // or for success, we'll stop tracking it
    //當一個物件完成的時候可以，要忘記曾經延遲過（重新計算）
    Forget(item interface{})
    
    
	// NumRequeues returns back how many failures the item has had
    // 回傳物件已經放入幾次（重試了幾次，白話一點呼叫whem幾次）
	NumRequeues(item interface{}) int
}

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

// AddRateLimited AddAfter's the item based on the time when the rate limiter says it's ok
// rateLimitingType 本身實作了 RateLimitingInterface 
func (q *rateLimitingType) AddRateLimited(item interface{}) {
    // 由於嵌入了 DelayingInterface 可以直接使用 delay work queue的抽象方法
    // 這裡就是說放入的物件要延遲多久，延遲多久就由組合的 rateLimiter 抽象方法實作。
	q.DelayingInterface.AddAfter(item, q.rateLimiter.When(item))
}

//  rateLimitingType 本身實作了 RateLimitingInterface
func (q *rateLimitingType) NumRequeues(item interface{}) int {
    // 這裡就是說放入的物件已經被重複放入多少次了，放入多少次就由組合的 rateLimiter 抽象方法實作。
	return q.rateLimiter.NumRequeues(item)
}

//  rateLimitingType 本身實作了 RateLimitingInterface
func (q *rateLimitingType) Forget(item interface{}) {
    // 這裡就是說放入的物件已經被做完了，可以重新計算了，從新計算的方法就交給組合的 rateLimiter 抽象方法實作。
	q.rateLimiter.Forget(item)
}

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

// NewRateLimitingQueue constructs a new workqueue with rateLimited queuing ability
// Remember to call Forget!  If you don't, you may end up tracking failures forever.
//使用者在使用RateLimiting的時候可以傳入自己實作的RateLimiter，此時使用預設的delay work queue。
func NewRateLimitingQueue(rateLimiter RateLimiter) RateLimitingInterface {
	return &rateLimitingType{
		DelayingInterface: NewDelayingQueue(),        //前一小節有提到過delating work queue的newfunction
		rateLimiter:       rateLimiter,               //自行實作的rateLimiter
	}
}


//使用者在使用RateLimiting的時候可以傳入自己實作的RateLimiter，此時使用預設的delaying  work queue並且可以設定delaying work queue的metric name。
func NewNamedRateLimitingQueue(rateLimiter RateLimiter, name string) RateLimitingInterface {
	return &rateLimitingType{
		DelayingInterface: NewNamedDelayingQueue(name),    //前一小節有提到delating work queue的newfunction（可以設定metric name）
		rateLimiter:       rateLimiter,                    //自行實作的rateLimiter
	}
}