golint fixes

pkg/controller/node/scheduler/rate_limited_queue.go

@@ -28,11 +28,14 @@ import (
 )
 
 const (
-	// nodeStatusUpdateRetry controls the number of retries of writing NodeStatus update.
+	// NodeStatusUpdateRetry controls the number of retries of writing
+	// NodeStatus update.
 	NodeStatusUpdateRetry = 5
-	// controls how often NodeController will try to evict Pods from non-responsive Nodes.
+	// NodeEvictionPeriod controls how often NodeController will try to
+	// evict Pods from non-responsive Nodes.
 	NodeEvictionPeriod = 100 * time.Millisecond
-	// Burst value for all eviction rate limiters
+	// EvictionRateLimiterBurst is the burst value for all eviction rate
+	// limiters
 	EvictionRateLimiterBurst = 1
 )
 
@@ -46,19 +49,26 @@ type TimedValue struct {
 }
 
 // now is used to test time
-var now func() time.Time = time.Now
+var now = time.Now
 
 // TimedQueue is a priority heap where the lowest ProcessAt is at the front of the queue
 type TimedQueue []*TimedValue
 
-func (h TimedQueue) Len() int           { return len(h) }
-func (h TimedQueue) Less(i, j int) bool { return h[i].ProcessAt.Before(h[j].ProcessAt) }
-func (h TimedQueue) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+// Len is the length of the queue.
+func (h TimedQueue) Len() int { return len(h) }
 
+// Less returns true if queue[i] < queue[j].
+func (h TimedQueue) Less(i, j int) bool { return h[i].ProcessAt.Before(h[j].ProcessAt) }
+
+// Swap swaps index i and j.
+func (h TimedQueue) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
+
+// Push a new TimedValue on to the queue.
 func (h *TimedQueue) Push(x interface{}) {
 	*h = append(*h, x.(*TimedValue))
 }
 
+// Pop the lowest ProcessAt item.
 func (h *TimedQueue) Pop() interface{} {
 	old := *h
 	n := len(old)
@@ -67,16 +77,17 @@ func (h *TimedQueue) Pop() interface{} {
 	return x
 }
 
-// A FIFO queue which additionally guarantees that any element can be added only once until
-// it is removed.
+// UniqueQueue is a FIFO queue which additionally guarantees that any
+// element can be added only once until it is removed.
 type UniqueQueue struct {
 	lock  sync.Mutex
 	queue TimedQueue
 	set   sets.String
 }
 
-// Adds a new value to the queue if it wasn't added before, or was explicitly removed by the
-// Remove call. Returns true if new value was added.
+// Add a new value to the queue if it wasn't added before, or was
+// explicitly removed by the Remove call. Returns true if new value
+// was added.
 func (q *UniqueQueue) Add(value TimedValue) bool {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -89,8 +100,9 @@ func (q *UniqueQueue) Add(value TimedValue) bool {
 	return true
 }
 
-// Replace replaces an existing value in the queue if it already exists, otherwise it does nothing.
-// Returns true if the item was found.
+// Replace replaces an existing value in the queue if it already
+// exists, otherwise it does nothing. Returns true if the item was
+// found.
 func (q *UniqueQueue) Replace(value TimedValue) bool {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -106,8 +118,9 @@ func (q *UniqueQueue) Replace(value TimedValue) bool {
 	return false
 }
 
-// Removes the value from the queue, but keeps it in the set, so it won't be added second time.
-// Returns true if something was removed.
+// RemoveFromQueue the value from the queue, but keeps it in the set,
+// so it won't be added second time. Returns true if something was
+// removed.
 func (q *UniqueQueue) RemoveFromQueue(value string) bool {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -124,8 +137,9 @@ func (q *UniqueQueue) RemoveFromQueue(value string) bool {
 	return false
 }
 
-// Removes the value from the queue, so Get() call won't return it, and allow subsequent addition
-// of the given value. If the value is not present does nothing and returns false.
+// Remove the value from the queue, so Get() call won't return it, and
+// allow subsequent addition of the given value. If the value is not
+// present does nothing and returns false.
 func (q *UniqueQueue) Remove(value string) bool {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -143,7 +157,7 @@ func (q *UniqueQueue) Remove(value string) bool {
 	return true
 }
 
-// Returns the oldest added value that wasn't returned yet.
+// Get returns the oldest added value that wasn't returned yet.
 func (q *UniqueQueue) Get() (TimedValue, bool) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -155,7 +169,8 @@ func (q *UniqueQueue) Get() (TimedValue, bool) {
 	return *result, true
 }
 
-// Head returns the oldest added value that wasn't returned yet without removing it.
+// Head returns the oldest added value that wasn't returned yet
+// without removing it.
 func (q *UniqueQueue) Head() (TimedValue, bool) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -166,7 +181,8 @@ func (q *UniqueQueue) Head() (TimedValue, bool) {
 	return *result, true
 }
 
-// Clear removes all items from the queue and duplication preventing set.
+// Clear removes all items from the queue and duplication preventing
+// set.
 func (q *UniqueQueue) Clear() {
 	q.lock.Lock()
 	defer q.lock.Unlock()
@@ -178,15 +194,16 @@ func (q *UniqueQueue) Clear() {
 	}
 }
 
-// RateLimitedTimedQueue is a unique item priority queue ordered by the expected next time
-// of execution. It is also rate limited.
+// RateLimitedTimedQueue is a unique item priority queue ordered by
+// the expected next time of execution. It is also rate limited.
 type RateLimitedTimedQueue struct {
 	queue       UniqueQueue
 	limiterLock sync.Mutex
 	limiter     flowcontrol.RateLimiter
 }
 
-// Creates new queue which will use given RateLimiter to oversee execution.
+// NewRateLimitedTimedQueue creates new queue which will use given
+// RateLimiter to oversee execution.
 func NewRateLimitedTimedQueue(limiter flowcontrol.RateLimiter) *RateLimitedTimedQueue {
 	return &RateLimitedTimedQueue{
 		queue: UniqueQueue{
@@ -197,18 +214,21 @@ func NewRateLimitedTimedQueue(limiter flowcontrol.RateLimiter) *RateLimitedTimed
 	}
 }
 
-// ActionFunc takes a timed value and returns false if the item must be retried, with an optional
-// time.Duration if some minimum wait interval should be used.
+// ActionFunc takes a timed value and returns false if the item must
+// be retried, with an optional time.Duration if some minimum wait
+// interval should be used.
 type ActionFunc func(TimedValue) (bool, time.Duration)
 
-// Try processes the queue. Ends prematurely if RateLimiter forbids an action and leak is true.
-// Otherwise, requeues the item to be processed. Each value is processed once if fn returns true,
-// otherwise it is added back to the queue. The returned remaining is used to identify the minimum
-// time to execute the next item in the queue. The same value is processed only once unless
-// Remove is explicitly called on it (it's done by the cancelPodEviction function in NodeController
-// when Node becomes Ready again)
-// TODO: figure out a good way to do garbage collection for all Nodes that were removed from
-// the cluster.
+// Try processes the queue.Ends prematurely if RateLimiter forbids an
+// action and leak is true. Otherwise, requeues the item to be
+// processed. Each value is processed once if fn returns true,
+// otherwise it is added back to the queue. The returned remaining is
+// used to identify the minimum time to execute the next item in the
+// queue. The same value is processed only once unless Remove is
+// explicitly called on it (it's done by the cancelPodEviction
+// function in NodeController when Node becomes Ready again) TODO:
+// figure out a good way to do garbage collection for all Nodes that
+// were removed from the cluster.
 func (q *RateLimitedTimedQueue) Try(fn ActionFunc) {
 	val, ok := q.queue.Head()
 	q.limiterLock.Lock()
@@ -236,8 +256,9 @@ func (q *RateLimitedTimedQueue) Try(fn ActionFunc) {
 	}
 }
 
-// Adds value to the queue to be processed. Won't add the same value(comparsion by value) a second time
-// if it was already added and not removed.
+// Add value to the queue to be processed. Won't add the same
+// value(comparsion by value) a second time if it was already added
+// and not removed.
 func (q *RateLimitedTimedQueue) Add(value string, uid interface{}) bool {
 	now := now()
 	return q.queue.Add(TimedValue{
@@ -248,17 +269,19 @@ func (q *RateLimitedTimedQueue) Add(value string, uid interface{}) bool {
 	})
 }
 
-// Removes Node from the Evictor. The Node won't be processed until added again.
+// Remove Node from the Evictor. The Node won't be processed until
+// added again.
 func (q *RateLimitedTimedQueue) Remove(value string) bool {
 	return q.queue.Remove(value)
 }
 
-// Removes all items from the queue
+// Clear removes all items from the queue
 func (q *RateLimitedTimedQueue) Clear() {
 	q.queue.Clear()
 }
 
-// SwapLimiter safely swaps current limiter for this queue with the passed one if capacities or qps's differ.
+// SwapLimiter safely swaps current limiter for this queue with the
+// passed one if capacities or qps's differ.
 func (q *RateLimitedTimedQueue) SwapLimiter(newQPS float32) {
 	q.limiterLock.Lock()
 	defer q.limiterLock.Unlock()