*: update kube vendor to v1.7.4

Signed-off-by: Antonio Murdaca <runcom@redhat.com>

vendor/github.com/emicklei/go-restful/route_builder.go

@@ -5,10 +5,12 @@ package restful
 // that can be found in the LICENSE file.
 
 import (
+	"fmt"
 	"os"
 	"reflect"
 	"runtime"
 	"strings"
+	"sync/atomic"
 
 	"github.com/emicklei/go-restful/log"
 )
@@ -22,6 +24,9 @@ type RouteBuilder struct {
 	httpMethod  string        // required
 	function    RouteFunction // required
 	filters     []FilterFunction
+
+	typeNameHandleFunc TypeNameHandleFunction // required
+
 	// documentation
 	doc                     string
 	notes                   string
@@ -29,6 +34,7 @@ type RouteBuilder struct {
 	readSample, writeSample interface{}
 	parameters              []*Parameter
 	errorMap                map[int]ResponseError
+	metadata                map[string]interface{}
 }
 
 // Do evaluates each argument with the RouteBuilder itself.
@@ -92,8 +98,13 @@ func (b *RouteBuilder) Notes(notes string) *RouteBuilder {
 // Reads tells what resource type will be read from the request payload. Optional.
 // A parameter of type "body" is added ,required is set to true and the dataType is set to the qualified name of the sample's type.
 func (b *RouteBuilder) Reads(sample interface{}) *RouteBuilder {
+	fn := b.typeNameHandleFunc
+	if fn == nil {
+		fn = reflectTypeName
+	}
+	typeAsName := fn(sample)
+
 	b.readSample = sample
-	typeAsName := reflect.TypeOf(sample).String()
 	bodyParameter := &Parameter{&ParameterData{Name: "body"}}
 	bodyParameter.beBody()
 	bodyParameter.Required(true)
@@ -145,9 +156,10 @@ func (b *RouteBuilder) ReturnsError(code int, message string, model interface{})
 // The model parameter is optional ; either pass a struct instance or use nil if not applicable.
 func (b *RouteBuilder) Returns(code int, message string, model interface{}) *RouteBuilder {
 	err := ResponseError{
-		Code:    code,
-		Message: message,
-		Model:   model,
+		Code:      code,
+		Message:   message,
+		Model:     model,
+		IsDefault: false,
 	}
 	// lazy init because there is no NewRouteBuilder (yet)
 	if b.errorMap == nil {
@@ -157,10 +169,36 @@ func (b *RouteBuilder) Returns(code int, message string, model interface{}) *Rou
 	return b
 }
 
+// DefaultReturns is a special Returns call that sets the default of the response ; the code is zero.
+func (b *RouteBuilder) DefaultReturns(message string, model interface{}) *RouteBuilder {
+	b.Returns(0, message, model)
+	// Modify the ResponseError just added/updated
+	re := b.errorMap[0]
+	// errorMap is initialized
+	b.errorMap[0] = ResponseError{
+		Code:      re.Code,
+		Message:   re.Message,
+		Model:     re.Model,
+		IsDefault: true,
+	}
+	return b
+}
+
+// Metadata adds or updates a key=value pair to the metadata map.
+func (b *RouteBuilder) Metadata(key string, value interface{}) *RouteBuilder {
+	if b.metadata == nil {
+		b.metadata = map[string]interface{}{}
+	}
+	b.metadata[key] = value
+	return b
+}
+
+// ResponseError represents a response; not necessarily an error.
 type ResponseError struct {
-	Code    int
-	Message string
-	Model   interface{}
+	Code      int
+	Message   string
+	Model     interface{}
+	IsDefault bool
 }
 
 func (b *RouteBuilder) servicePath(path string) *RouteBuilder {
@@ -186,6 +224,13 @@ func (b *RouteBuilder) copyDefaults(rootProduces, rootConsumes []string) {
 	}
 }
 
+// typeNameHandler sets the function that will convert types to strings in the parameter
+// and model definitions.
+func (b *RouteBuilder) typeNameHandler(handler TypeNameHandleFunction) *RouteBuilder {
+	b.typeNameHandleFunc = handler
+	return b
+}
+
 // Build creates a new Route using the specification details collected by the RouteBuilder
 func (b *RouteBuilder) Build() Route {
 	pathExpr, err := newPathExpression(b.currentPath)
@@ -217,7 +262,8 @@ func (b *RouteBuilder) Build() Route {
 		ParameterDocs:  b.parameters,
 		ResponseErrors: b.errorMap,
 		ReadSample:     b.readSample,
-		WriteSample:    b.writeSample}
+		WriteSample:    b.writeSample,
+		Metadata:       b.metadata}
 	route.postBuild()
 	return route
 }
@@ -226,6 +272,8 @@ func concatPath(path1, path2 string) string {
 	return strings.TrimRight(path1, "/") + "/" + strings.TrimLeft(path2, "/")
 }
 
+var anonymousFuncCount int32
+
 // nameOfFunction returns the short name of the function f for documentation.
 // It uses a runtime feature for debugging ; its value may change for later Go versions.
 func nameOfFunction(f interface{}) string {
@@ -236,5 +284,10 @@ func nameOfFunction(f interface{}) string {
 	last = strings.TrimSuffix(last, ")-fm") // Go 1.5
 	last = strings.TrimSuffix(last, "·fm")  // < Go 1.5
 	last = strings.TrimSuffix(last, "-fm")  // Go 1.5
+	if last == "func1" {                    // this could mean conflicts in API docs
+		val := atomic.AddInt32(&anonymousFuncCount, 1)
+		last = "func" + fmt.Sprintf("%d", val)
+		atomic.StoreInt32(&anonymousFuncCount, val)
+	}
 	return last
 }