Update godeps

vendor/k8s.io/kubernetes/pkg/util/cache/lruexpirecache.go

@@ -25,7 +25,7 @@ import (
 
 type LRUExpireCache struct {
 	cache *lru.Cache
-	lock  sync.RWMutex
+	lock  sync.Mutex
 }
 
 func NewLRUExpireCache(maxSize int) *LRUExpireCache {
@@ -46,8 +46,8 @@ func (c *LRUExpireCache) Add(key lru.Key, value interface{}, ttl time.Duration)
 }
 
 func (c *LRUExpireCache) Get(key lru.Key) (interface{}, bool) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
+	c.lock.Lock()
+	defer c.lock.Unlock()
 	e, ok := c.cache.Get(key)
 	if !ok {
 		return nil, false

vendor/k8s.io/kubernetes/pkg/util/config/feature_gate.go

@@ -39,9 +39,9 @@ const (
 	//   AllAlpha=true,NewFeature=false  will result in newFeature=false
 	allAlphaGate              = "AllAlpha"
 	externalTrafficLocalOnly  = "AllowExtTrafficLocalEndpoints"
+	appArmor                  = "AppArmor"
 	dynamicKubeletConfig      = "DynamicKubeletConfig"
 	dynamicVolumeProvisioning = "DynamicVolumeProvisioning"
-	// TODO: Define gate/accessor for AppArmor
 )
 
 var (
@@ -50,6 +50,7 @@ var (
 	knownFeatures = map[string]featureSpec{
 		allAlphaGate:              {false, alpha},
 		externalTrafficLocalOnly:  {false, alpha},
+		appArmor:                  {true, beta},
 		dynamicKubeletConfig:      {false, alpha},
 		dynamicVolumeProvisioning: {true, alpha},
 	}
@@ -91,6 +92,10 @@ type FeatureGate interface {
 	// // alpha: v1.4
 	// MyFeature() bool
 
+	// owner: @timstclair
+	// beta: v1.4
+	AppArmor() bool
+
 	// owner: @girishkalele
 	// alpha: v1.4
 	ExternalTrafficLocalOnly() bool
@@ -175,6 +180,11 @@ func (f *featureGate) ExternalTrafficLocalOnly() bool {
 	return f.lookup(externalTrafficLocalOnly)
 }
 
+// AppArmor returns the value for the AppArmor feature gate.
+func (f *featureGate) AppArmor() bool {
+	return f.lookup(appArmor)
+}
+
 // DynamicKubeletConfig returns value for dynamicKubeletConfig
 func (f *featureGate) DynamicKubeletConfig() bool {
 	return f.lookup(dynamicKubeletConfig)
@@ -206,6 +216,7 @@ func (f *featureGate) AddFlag(fs *pflag.FlagSet) {
 		}
 		known = append(known, fmt.Sprintf("%s=true|false (%sdefault=%t)", k, pre, v.enabled))
 	}
+	sort.Strings(known)
 	fs.Var(f, flagName, ""+
 		"A set of key=value pairs that describe feature gates for alpha/experimental features. "+
 		"Options are:\n"+strings.Join(known, "\n"))

vendor/k8s.io/kubernetes/pkg/util/errors/errors.go

@@ -31,11 +31,23 @@ type Aggregate interface {
 // NewAggregate converts a slice of errors into an Aggregate interface, which
 // is itself an implementation of the error interface.  If the slice is empty,
 // this returns nil.
+// It will check if any of the element of input error list is nil, to avoid
+// nil pointer panic when call Error().
 func NewAggregate(errlist []error) Aggregate {
 	if len(errlist) == 0 {
 		return nil
 	}
-	return aggregate(errlist)
+	// In case of input error list contains nil
+	var errs []error
+	for _, e := range errlist {
+		if e != nil {
+			errs = append(errs, e)
+		}
+	}
+	if len(errs) == 0 {
+		return nil
+	}
+	return aggregate(errs)
 }
 
 // This helper implements the error and Errors interfaces.  Keeping it private

vendor/k8s.io/kubernetes/pkg/util/workqueue/default_rate_limiters.go

@@ -38,7 +38,7 @@ type RateLimiter interface {
 // both overall and per-item rate limitting.  The overall is a token bucket and the per-item is exponential
 func DefaultControllerRateLimiter() RateLimiter {
 	return NewMaxOfRateLimiter(
-		DefaultItemBasedRateLimiter(),
+		NewItemExponentialFailureRateLimiter(5*time.Millisecond, 1000*time.Second),
 		// 10 qps, 100 bucket size.  This is only for retry speed and its only the overall factor (not per item)
 		&BucketRateLimiter{Bucket: ratelimit.NewBucketWithRate(float64(10), int64(100))},
 	)
@@ -83,16 +83,23 @@ func NewItemExponentialFailureRateLimiter(baseDelay time.Duration, maxDelay time
 }
 
 func DefaultItemBasedRateLimiter() RateLimiter {
-	return NewItemExponentialFailureRateLimiter(1*time.Millisecond, 1000*time.Second)
+	return NewItemExponentialFailureRateLimiter(time.Millisecond, 1000*time.Second)
 }
 
 func (r *ItemExponentialFailureRateLimiter) When(item interface{}) time.Duration {
 	r.failuresLock.Lock()
 	defer r.failuresLock.Unlock()
 
+	exp := r.failures[item]
 	r.failures[item] = r.failures[item] + 1
 
-	calculated := r.baseDelay * time.Duration(math.Pow10(r.failures[item]-1))
+	// The backoff is capped such that 'calculated' value never overflows.
+	backoff := float64(r.baseDelay.Nanoseconds()) * math.Pow(2, float64(exp))
+	if backoff > math.MaxInt64 {
+		return r.maxDelay
+	}
+
+	calculated := time.Duration(backoff)
 	if calculated > r.maxDelay {
 		return r.maxDelay
 	}