Update deps to Kube 1.11.3

This updates the dependencies to Kube 1.11.3 to pull in a fix allowing
requestheader auth to be used without normal client auth (which makes
things work on clusters that don't enable client auth normally, like
EKS).

vendor/github.com/go-openapi/swag/.golangci.yml

@@ -0,0 +1,19 @@
+linters-settings:
+  govet:
+    check-shadowing: true
+  golint:
+    min-confidence: 0
+  gocyclo:
+    min-complexity: 25
+  maligned:
+    suggest-new: true
+  dupl:
+    threshold: 100
+  goconst:
+    min-len: 2
+    min-occurrences: 2
+
+linters:
+  enable-all: true
+  disable:
+    - maligned

vendor/github.com/go-openapi/swag/.travis.yml

@@ -1,6 +1,8 @@
 language: go
 go:
 - 1.8
+- 1.9.x
+- 1.10.x
 install:
 - go get -u github.com/stretchr/testify
 - go get -u github.com/mailru/easyjson

vendor/github.com/go-openapi/swag/README.md

@@ -1,6 +1,9 @@
 # Swag [![Build Status](https://travis-ci.org/go-openapi/swag.svg?branch=master)](https://travis-ci.org/go-openapi/swag) [![codecov](https://codecov.io/gh/go-openapi/swag/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/swag) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io)
 
-[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/swag/master/LICENSE) [![GoDoc](https://godoc.org/github.com/go-openapi/swag?status.svg)](http://godoc.org/github.com/go-openapi/swag)
+[![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/swag/master/LICENSE)
+[![GoDoc](https://godoc.org/github.com/go-openapi/swag?status.svg)](http://godoc.org/github.com/go-openapi/swag)
+[![GolangCI](https://golangci.com/badges/github.com/go-openapi/swag.svg)](https://golangci.com)
+[![Go Report Card](https://goreportcard.com/badge/github.com/go-openapi/swag)](https://goreportcard.com/report/github.com/go-openapi/swag)
 
 Contains a bunch of helper functions:
 
@@ -9,4 +12,4 @@ Contains a bunch of helper functions:
 * fast json concatenation
 * search in path
 * load from file or http
-* name manglin
+* name mangling

vendor/github.com/go-openapi/swag/convert.go

@@ -22,8 +22,9 @@ import (
 
 // same as ECMA Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER
 const (
-	maxJSONFloat = float64(1<<53 - 1)  // 9007199254740991.0 	 	 2^53 - 1
-	minJSONFloat = -float64(1<<53 - 1) //-9007199254740991.0	-2^53 - 1
+	maxJSONFloat         = float64(1<<53 - 1)  // 9007199254740991.0 	 	 2^53 - 1
+	minJSONFloat         = -float64(1<<53 - 1) //-9007199254740991.0	-2^53 - 1
+	epsilon      float64 = 1e-9
 )
 
 // IsFloat64AJSONInteger allow for integers [-2^53, 2^53-1] inclusive
@@ -31,21 +32,35 @@ func IsFloat64AJSONInteger(f float64) bool {
 	if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
 		return false
 	}
+	fa := math.Abs(f)
+	g := float64(uint64(f))
+	ga := math.Abs(g)
 
-	return f == float64(int64(f)) || f == float64(uint64(f))
+	diff := math.Abs(f - g)
+
+	// more info: https://floating-point-gui.de/errors/comparison/#look-out-for-edge-cases
+	if f == g { // best case
+		return true
+	} else if f == float64(int64(f)) || f == float64(uint64(f)) { // optimistic case
+		return true
+	} else if f == 0 || g == 0 || diff < math.SmallestNonzeroFloat64 { // very close to 0 values
+		return diff < (epsilon * math.SmallestNonzeroFloat64)
+	}
+	// check the relative error
+	return diff/math.Min(fa+ga, math.MaxFloat64) < epsilon
 }
 
 var evaluatesAsTrue = map[string]struct{}{
-	"true":     struct{}{},
-	"1":        struct{}{},
-	"yes":      struct{}{},
-	"ok":       struct{}{},
-	"y":        struct{}{},
-	"on":       struct{}{},
-	"selected": struct{}{},
-	"checked":  struct{}{},
-	"t":        struct{}{},
-	"enabled":  struct{}{},
+	"true":     {},
+	"1":        {},
+	"yes":      {},
+	"ok":       {},
+	"y":        {},
+	"on":       {},
+	"selected": {},
+	"checked":  {},
+	"t":        {},
+	"enabled":  {},
 }
 
 // ConvertBool turn a string into a boolean

vendor/github.com/go-openapi/swag/json.go

@@ -21,6 +21,7 @@ import (
 	"reflect"
 	"strings"
 	"sync"
+	"sync/atomic"
 
 	"github.com/mailru/easyjson/jlexer"
 	"github.com/mailru/easyjson/jwriter"
@@ -34,9 +35,14 @@ var DefaultJSONNameProvider = NewNameProvider()
 
 const comma = byte(',')
 
-var closers = map[byte]byte{
-	'{': '}',
-	'[': ']',
+var atomicClosers atomic.Value
+
+func init() {
+	atomicClosers.Store(
+		map[byte]byte{
+			'{': '}',
+			'[': ']',
+		})
 }
 
 type ejMarshaler interface {
@@ -82,10 +88,7 @@ func DynamicJSONToStruct(data interface{}, target interface{}) error {
 	if err != nil {
 		return err
 	}
-	if err := ReadJSON(b, target); err != nil {
-		return err
-	}
-	return nil
+	return ReadJSON(b, target)
 }
 
 // ConcatJSON concatenates multiple json objects efficiently
@@ -110,6 +113,7 @@ func ConcatJSON(blobs ...[]byte) []byte {
 	var opening, closing byte
 	var idx, a int
 	buf := bytes.NewBuffer(nil)
+	closers := atomicClosers.Load().(map[byte]byte)
 
 	for i, b := range blobs[:last+1] {
 		if b == nil || bytes.Equal(b, nullJSON) {

vendor/github.com/go-openapi/swag/post_go19.go

@@ -0,0 +1,53 @@
+// +build go1.9
+
+package swag
+
+import (
+	"sort"
+	"sync"
+)
+
+// indexOfInitialisms is a thread-safe implementation of the sorted index of initialisms.
+// Since go1.9, this may be implemented with sync.Map.
+type indexOfInitialisms struct {
+	sortMutex *sync.Mutex
+	index     *sync.Map
+}
+
+func newIndexOfInitialisms() *indexOfInitialisms {
+	return &indexOfInitialisms{
+		sortMutex: new(sync.Mutex),
+		index:     new(sync.Map),
+	}
+}
+
+func (m *indexOfInitialisms) load(initial map[string]bool) *indexOfInitialisms {
+	m.sortMutex.Lock()
+	defer m.sortMutex.Unlock()
+	for k, v := range initial {
+		m.index.Store(k, v)
+	}
+	return m
+}
+
+func (m *indexOfInitialisms) isInitialism(key string) bool {
+	_, ok := m.index.Load(key)
+	return ok
+}
+
+func (m *indexOfInitialisms) add(key string) *indexOfInitialisms {
+	m.index.Store(key, true)
+	return m
+}
+
+func (m *indexOfInitialisms) sorted() (result []string) {
+	m.sortMutex.Lock()
+	defer m.sortMutex.Unlock()
+	m.index.Range(func(key, value interface{}) bool {
+		k := key.(string)
+		result = append(result, k)
+		return true
+	})
+	sort.Sort(sort.Reverse(byLength(result)))
+	return
+}

vendor/github.com/go-openapi/swag/pre_go19.go

@@ -0,0 +1,55 @@
+// +build !go1.9
+
+package swag
+
+import (
+	"sort"
+	"sync"
+)
+
+// indexOfInitialisms is a thread-safe implementation of the sorted index of initialisms.
+// Before go1.9, this may be implemented with a mutex on the map.
+type indexOfInitialisms struct {
+	getMutex *sync.Mutex
+	index    map[string]bool
+}
+
+func newIndexOfInitialisms() *indexOfInitialisms {
+	return &indexOfInitialisms{
+		getMutex: new(sync.Mutex),
+		index:    make(map[string]bool, 50),
+	}
+}
+
+func (m *indexOfInitialisms) load(initial map[string]bool) *indexOfInitialisms {
+	m.getMutex.Lock()
+	defer m.getMutex.Unlock()
+	for k, v := range initial {
+		m.index[k] = v
+	}
+	return m
+}
+
+func (m *indexOfInitialisms) isInitialism(key string) bool {
+	m.getMutex.Lock()
+	defer m.getMutex.Unlock()
+	_, ok := m.index[key]
+	return ok
+}
+
+func (m *indexOfInitialisms) add(key string) *indexOfInitialisms {
+	m.getMutex.Lock()
+	defer m.getMutex.Unlock()
+	m.index[key] = true
+	return m
+}
+
+func (m *indexOfInitialisms) sorted() (result []string) {
+	m.getMutex.Lock()
+	defer m.getMutex.Unlock()
+	for k := range m.index {
+		result = append(result, k)
+	}
+	sort.Sort(sort.Reverse(byLength(result)))
+	return
+}

vendor/github.com/go-openapi/swag/util.go

@@ -18,63 +18,74 @@ import (
 	"math"
 	"reflect"
 	"regexp"
-	"sort"
 	"strings"
 	"sync"
 	"unicode"
 )
 
-// Taken from https://github.com/golang/lint/blob/3390df4df2787994aea98de825b964ac7944b817/lint.go#L732-L769
-var commonInitialisms = map[string]bool{
-	"ACL":   true,
-	"API":   true,
-	"ASCII": true,
-	"CPU":   true,
-	"CSS":   true,
-	"DNS":   true,
-	"EOF":   true,
-	"GUID":  true,
-	"HTML":  true,
-	"HTTPS": true,
-	"HTTP":  true,
-	"ID":    true,
-	"IP":    true,
-	"JSON":  true,
-	"LHS":   true,
-	"OAI":   true,
-	"QPS":   true,
-	"RAM":   true,
-	"RHS":   true,
-	"RPC":   true,
-	"SLA":   true,
-	"SMTP":  true,
-	"SQL":   true,
-	"SSH":   true,
-	"TCP":   true,
-	"TLS":   true,
-	"TTL":   true,
-	"UDP":   true,
-	"UI":    true,
-	"UID":   true,
-	"UUID":  true,
-	"URI":   true,
-	"URL":   true,
-	"UTF8":  true,
-	"VM":    true,
-	"XML":   true,
-	"XMPP":  true,
-	"XSRF":  true,
-	"XSS":   true,
-}
+// commonInitialisms are common acronyms that are kept as whole uppercased words.
+var commonInitialisms *indexOfInitialisms
+
+// initialisms is a slice of sorted initialisms
 var initialisms []string
 
 var once sync.Once
 
-func sortInitialisms() {
-	for k := range commonInitialisms {
-		initialisms = append(initialisms, k)
+var isInitialism func(string) bool
+
+func init() {
+	// Taken from https://github.com/golang/lint/blob/3390df4df2787994aea98de825b964ac7944b817/lint.go#L732-L769
+	var configuredInitialisms = map[string]bool{
+		"ACL":   true,
+		"API":   true,
+		"ASCII": true,
+		"CPU":   true,
+		"CSS":   true,
+		"DNS":   true,
+		"EOF":   true,
+		"GUID":  true,
+		"HTML":  true,
+		"HTTPS": true,
+		"HTTP":  true,
+		"ID":    true,
+		"IP":    true,
+		"JSON":  true,
+		"LHS":   true,
+		"OAI":   true,
+		"QPS":   true,
+		"RAM":   true,
+		"RHS":   true,
+		"RPC":   true,
+		"SLA":   true,
+		"SMTP":  true,
+		"SQL":   true,
+		"SSH":   true,
+		"TCP":   true,
+		"TLS":   true,
+		"TTL":   true,
+		"UDP":   true,
+		"UI":    true,
+		"UID":   true,
+		"UUID":  true,
+		"URI":   true,
+		"URL":   true,
+		"UTF8":  true,
+		"VM":    true,
+		"XML":   true,
+		"XMPP":  true,
+		"XSRF":  true,
+		"XSS":   true,
 	}
-	sort.Sort(sort.Reverse(byLength(initialisms)))
+
+	// a thread-safe index of initialisms
+	commonInitialisms = newIndexOfInitialisms().load(configuredInitialisms)
+
+	// a test function
+	isInitialism = commonInitialisms.isInitialism
+}
+
+func ensureSorted() {
+	initialisms = commonInitialisms.sorted()
 }
 
 // JoinByFormat joins a string array by a known format:
@@ -169,7 +180,7 @@ func split(str string) (words []string) {
 	str = rex1.ReplaceAllString(str, " $1")
 
 	// check if consecutive single char things make up an initialism
-	once.Do(sortInitialisms)
+	once.Do(ensureSorted)
 	for _, k := range initialisms {
 		str = strings.Replace(str, rex1.ReplaceAllString(k, " $1"), " "+k, -1)
 	}
@@ -230,7 +241,7 @@ func ToCommandName(name string) string {
 func ToHumanNameLower(name string) string {
 	var out []string
 	for _, w := range split(name) {
-		if !commonInitialisms[upper(w)] {
+		if !isInitialism(upper(w)) {
 			out = append(out, lower(w))
 		} else {
 			out = append(out, w)
@@ -244,7 +255,7 @@ func ToHumanNameTitle(name string) string {
 	var out []string
 	for _, w := range split(name) {
 		uw := upper(w)
-		if !commonInitialisms[uw] {
+		if !isInitialism(uw) {
 			out = append(out, upper(w[:1])+lower(w[1:]))
 		} else {
 			out = append(out, w)
@@ -269,7 +280,7 @@ func ToJSONName(name string) string {
 // ToVarName camelcases a name which can be underscored or pascal cased
 func ToVarName(name string) string {
 	res := ToGoName(name)
-	if _, ok := commonInitialisms[res]; ok {
+	if isInitialism(res) {
 		return lower(res)
 	}
 	if len(res) <= 1 {
@@ -284,7 +295,7 @@ func ToGoName(name string) string {
 	for _, w := range split(name) {
 		uw := upper(w)
 		mod := int(math.Min(float64(len(uw)), 2))
-		if !commonInitialisms[uw] && !commonInitialisms[uw[:len(uw)-mod]] {
+		if !isInitialism(uw) && !isInitialism(uw[:len(uw)-mod]) {
 			uw = upper(w[:1]) + lower(w[1:])
 		}
 		out = append(out, uw)
@@ -350,8 +361,11 @@ func IsZero(data interface{}) bool {
 // AddInitialisms add additional initialisms
 func AddInitialisms(words ...string) {
 	for _, word := range words {
-		commonInitialisms[upper(word)] = true
+		//commonInitialisms[upper(word)] = true
+		commonInitialisms.add(upper(word))
 	}
+	// sort again
+	initialisms = commonInitialisms.sorted()
 }
 
 // CommandLineOptionsGroup represents a group of user-defined command line options

vendor/github.com/go-openapi/swag/yaml.go

@@ -56,14 +56,17 @@ func BytesToYAMLDoc(data []byte) (interface{}, error) {
 	return document, nil
 }
 
+// JSONMapSlice represent a JSON object, with the order of keys maintained
 type JSONMapSlice []JSONMapItem
 
+// MarshalJSON renders a JSONMapSlice as JSON
 func (s JSONMapSlice) MarshalJSON() ([]byte, error) {
 	w := &jwriter.Writer{Flags: jwriter.NilMapAsEmpty | jwriter.NilSliceAsEmpty}
 	s.MarshalEasyJSON(w)
 	return w.BuildBytes()
 }
 
+// MarshalEasyJSON renders a JSONMapSlice as JSON, using easyJSON
 func (s JSONMapSlice) MarshalEasyJSON(w *jwriter.Writer) {
 	w.RawByte('{')
 
@@ -79,11 +82,14 @@ func (s JSONMapSlice) MarshalEasyJSON(w *jwriter.Writer) {
 	w.RawByte('}')
 }
 
+// UnmarshalJSON makes a JSONMapSlice from JSON
 func (s *JSONMapSlice) UnmarshalJSON(data []byte) error {
 	l := jlexer.Lexer{Data: data}
 	s.UnmarshalEasyJSON(&l)
 	return l.Error()
 }
+
+// UnmarshalEasyJSON makes a JSONMapSlice from JSON, using easyJSON
 func (s *JSONMapSlice) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	if in.IsNull() {
 		in.Skip()
@@ -100,23 +106,34 @@ func (s *JSONMapSlice) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	*s = result
 }
 
+// JSONMapItem represents the value of a key in a JSON object held by JSONMapSlice
 type JSONMapItem struct {
 	Key   string
 	Value interface{}
 }
 
+// MarshalJSON renders a JSONMapItem as JSON
 func (s JSONMapItem) MarshalJSON() ([]byte, error) {
 	w := &jwriter.Writer{Flags: jwriter.NilMapAsEmpty | jwriter.NilSliceAsEmpty}
 	s.MarshalEasyJSON(w)
 	return w.BuildBytes()
 }
 
+// MarshalEasyJSON renders a JSONMapItem as JSON, using easyJSON
 func (s JSONMapItem) MarshalEasyJSON(w *jwriter.Writer) {
 	w.String(s.Key)
 	w.RawByte(':')
 	w.Raw(WriteJSON(s.Value))
 }
 
+// UnmarshalJSON makes a JSONMapItem from JSON
+func (s *JSONMapItem) UnmarshalJSON(data []byte) error {
+	l := jlexer.Lexer{Data: data}
+	s.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// UnmarshalEasyJSON makes a JSONMapItem from JSON, using easyJSON
 func (s *JSONMapItem) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	key := in.UnsafeString()
 	in.WantColon()
@@ -125,11 +142,6 @@ func (s *JSONMapItem) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	s.Key = key
 	s.Value = value
 }
-func (s *JSONMapItem) UnmarshalJSON(data []byte) error {
-	l := jlexer.Lexer{Data: data}
-	s.UnmarshalEasyJSON(&l)
-	return l.Error()
-}
 
 func transformData(input interface{}) (out interface{}, err error) {
 	switch in := input.(type) {
@@ -147,9 +159,9 @@ func transformData(input interface{}) (out interface{}, err error) {
 				return nil, fmt.Errorf("types don't match expect map key string or int got: %T", mi.Key)
 			}
 
-			v, err := transformData(mi.Value)
-			if err != nil {
-				return nil, err
+			v, ert := transformData(mi.Value)
+			if ert != nil {
+				return nil, ert
 			}
 			nmi.Value = v
 			o[i] = nmi
@@ -168,9 +180,9 @@ func transformData(input interface{}) (out interface{}, err error) {
 				return nil, fmt.Errorf("types don't match expect map key string or int got: %T", ke)
 			}
 
-			v, err := transformData(va)
-			if err != nil {
-				return nil, err
+			v, ert := transformData(va)
+			if ert != nil {
+				return nil, ert
 			}
 			nmi.Value = v
 			o = append(o, nmi)
@@ -202,7 +214,7 @@ func YAMLDoc(path string) (json.RawMessage, error) {
 		return nil, err
 	}
 
-	return json.RawMessage(data), nil
+	return data, nil
 }
 
 // YAMLData loads a yaml document from either http or a file