vendor: Update vendor logic

vendor/github.com/emicklei/go-restful/CHANGES.md

@@ -1,25 +1,56 @@
-Change history of go-restful
-=
+## Change history of go-restful
+
+
+v2.9.5
+- fix panic in Response.WriteError if err == nil
+
+v2.9.4
+
+- fix issue #400 , parsing mime type quality
+- Route Builder added option for contentEncodingEnabled (#398)
+
+v2.9.3
+
+- Avoid return of 415 Unsupported Media Type when request body is empty (#396)
+
+v2.9.2
+
+- Reduce allocations in per-request methods to improve performance (#395)
+
+v2.9.1
+
+- Fix issue with default responses and invalid status code 0. (#393)
+
+v2.9.0
+
+- add per Route content encoding setting (overrides container setting)
+
 v2.8.0
+
 - add Request.QueryParameters()
 - add json-iterator (via build tag)
 - disable vgo module (until log is moved)
 
 v2.7.1
+
 - add vgo module
 
 v2.6.1
+
 - add JSONNewDecoderFunc to allow custom JSON Decoder usage (go 1.10+)
 
 v2.6.0
+
 - Make JSR 311 routing and path param processing consistent
 - Adding description to RouteBuilder.Reads()
 - Update example for Swagger12 and OpenAPI
 
 2017-09-13
+
 - added route condition functions using `.If(func)` in route building.
 
 2017-02-16
+
 - solved issue #304, make operation names unique
 
 2017-01-30

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

@@ -97,7 +97,7 @@ func (c *Container) Add(service *WebService) *Container {
 	// cannot have duplicate root paths
 	for _, each := range c.webServices {
 		if each.RootPath() == service.RootPath() {
-			log.Printf("[restful] WebService with duplicate root path detected:['%v']", each)
+			log.Printf("WebService with duplicate root path detected:['%v']", each)
 			os.Exit(1)
 		}
 	}
@@ -139,7 +139,7 @@ func (c *Container) addHandler(service *WebService, serveMux *http.ServeMux) boo
 
 func (c *Container) Remove(ws *WebService) error {
 	if c.ServeMux == http.DefaultServeMux {
-		errMsg := fmt.Sprintf("[restful] cannot remove a WebService from a Container using the DefaultServeMux: ['%v']", ws)
+		errMsg := fmt.Sprintf("cannot remove a WebService from a Container using the DefaultServeMux: ['%v']", ws)
 		log.Print(errMsg)
 		return errors.New(errMsg)
 	}
@@ -168,7 +168,7 @@ func (c *Container) Remove(ws *WebService) error {
 // This may be a security issue as it exposes sourcecode information.
 func logStackOnRecover(panicReason interface{}, httpWriter http.ResponseWriter) {
 	var buffer bytes.Buffer
-	buffer.WriteString(fmt.Sprintf("[restful] recover from panic situation: - %v\r\n", panicReason))
+	buffer.WriteString(fmt.Sprintf("recover from panic situation: - %v\r\n", panicReason))
 	for i := 2; ; i += 1 {
 		_, file, line, ok := runtime.Caller(i)
 		if !ok {
@@ -220,20 +220,6 @@ func (c *Container) dispatch(httpWriter http.ResponseWriter, httpRequest *http.R
 		}()
 	}
 
-	// Detect if compression is needed
-	// assume without compression, test for override
-	if c.contentEncodingEnabled {
-		doCompress, encoding := wantsCompressedResponse(httpRequest)
-		if doCompress {
-			var err error
-			writer, err = NewCompressingResponseWriter(httpWriter, encoding)
-			if err != nil {
-				log.Print("[restful] unable to install compressor: ", err)
-				httpWriter.WriteHeader(http.StatusInternalServerError)
-				return
-			}
-		}
-	}
 	// Find best match Route ; err is non nil if no match was found
 	var webService *WebService
 	var route *Route
@@ -245,6 +231,26 @@ func (c *Container) dispatch(httpWriter http.ResponseWriter, httpRequest *http.R
 			c.webServices,
 			httpRequest)
 	}()
+
+	// Detect if compression is needed
+	// assume without compression, test for override
+	contentEncodingEnabled := c.contentEncodingEnabled
+	if route != nil && route.contentEncodingEnabled != nil {
+		contentEncodingEnabled = *route.contentEncodingEnabled
+	}
+	if contentEncodingEnabled {
+		doCompress, encoding := wantsCompressedResponse(httpRequest)
+		if doCompress {
+			var err error
+			writer, err = NewCompressingResponseWriter(httpWriter, encoding)
+			if err != nil {
+				log.Print("unable to install compressor: ", err)
+				httpWriter.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+		}
+	}
+
 	if err != nil {
 		// a non-200 response has already been written
 		// run container filters anyway ; they should not touch the response...

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

@@ -45,14 +45,14 @@ func (c CurlyRouter) SelectRoute(
 
 // selectRoutes return a collection of Route from a WebService that matches the path tokens from the request.
 func (c CurlyRouter) selectRoutes(ws *WebService, requestTokens []string) sortableCurlyRoutes {
-	candidates := sortableCurlyRoutes{}
+	candidates := make(sortableCurlyRoutes, 0, 8)
 	for _, each := range ws.routes {
 		matches, paramCount, staticCount := c.matchesRouteByPathTokens(each.pathParts, requestTokens)
 		if matches {
 			candidates.add(curlyRoute{each, paramCount, staticCount}) // TODO make sure Routes() return pointers?
 		}
 	}
-	sort.Sort(sort.Reverse(candidates))
+	sort.Sort(candidates)
 	return candidates
 }
 

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

@@ -11,6 +11,7 @@ type curlyRoute struct {
 	staticCount int
 }
 
+// sortableCurlyRoutes orders by most parameters and path elements first.
 type sortableCurlyRoutes []curlyRoute
 
 func (s *sortableCurlyRoutes) add(route curlyRoute) {
@@ -18,6 +19,7 @@ func (s *sortableCurlyRoutes) add(route curlyRoute) {
 }
 
 func (s sortableCurlyRoutes) routes() (routes []Route) {
+	routes = make([]Route, 0, len(s))
 	for _, each := range s {
 		routes = append(routes, each.route) // TODO change return type
 	}
@@ -31,22 +33,22 @@ func (s sortableCurlyRoutes) Swap(i, j int) {
 	s[i], s[j] = s[j], s[i]
 }
 func (s sortableCurlyRoutes) Less(i, j int) bool {
-	ci := s[i]
-	cj := s[j]
+	a := s[j]
+	b := s[i]
 
 	// primary key
-	if ci.staticCount < cj.staticCount {
+	if a.staticCount < b.staticCount {
 		return true
 	}
-	if ci.staticCount > cj.staticCount {
+	if a.staticCount > b.staticCount {
 		return false
 	}
 	// secundary key
-	if ci.paramCount < cj.paramCount {
+	if a.paramCount < b.paramCount {
 		return true
 	}
-	if ci.paramCount > cj.paramCount {
+	if a.paramCount > b.paramCount {
 		return false
 	}
-	return ci.route.Path < cj.route.Path
+	return a.route.Path < b.route.Path
 }

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

@@ -66,8 +66,8 @@ func (RouterJSR311) extractParams(pathExpr *pathExpression, matches []string) ma
 
 // http://jsr311.java.net/nonav/releases/1.1/spec/spec3.html#x3-360003.7.2
 func (r RouterJSR311) detectRoute(routes []Route, httpRequest *http.Request) (*Route, error) {
-	ifOk := []Route{}
-	for _, each := range routes {
+	candidates := make([]*Route, 0, 8)
+	for i, each := range routes {
 		ok := true
 		for _, fn := range each.If {
 			if !fn(httpRequest) {
@@ -76,10 +76,10 @@ func (r RouterJSR311) detectRoute(routes []Route, httpRequest *http.Request) (*R
 			}
 		}
 		if ok {
-			ifOk = append(ifOk, each)
+			candidates = append(candidates, &routes[i])
 		}
 	}
-	if len(ifOk) == 0 {
+	if len(candidates) == 0 {
 		if trace {
 			traceLogger.Printf("no Route found (from %d) that passes conditional checks", len(routes))
 		}
@@ -87,54 +87,58 @@ func (r RouterJSR311) detectRoute(routes []Route, httpRequest *http.Request) (*R
 	}
 
 	// http method
-	methodOk := []Route{}
-	for _, each := range ifOk {
+	previous := candidates
+	candidates = candidates[:0]
+	for _, each := range previous {
 		if httpRequest.Method == each.Method {
-			methodOk = append(methodOk, each)
+			candidates = append(candidates, each)
 		}
 	}
-	if len(methodOk) == 0 {
+	if len(candidates) == 0 {
 		if trace {
-			traceLogger.Printf("no Route found (in %d routes) that matches HTTP method %s\n", len(routes), httpRequest.Method)
+			traceLogger.Printf("no Route found (in %d routes) that matches HTTP method %s\n", len(previous), httpRequest.Method)
 		}
 		return nil, NewError(http.StatusMethodNotAllowed, "405: Method Not Allowed")
 	}
-	inputMediaOk := methodOk
 
 	// content-type
 	contentType := httpRequest.Header.Get(HEADER_ContentType)
-	inputMediaOk = []Route{}
-	for _, each := range methodOk {
+	previous = candidates
+	candidates = candidates[:0]
+	for _, each := range previous {
 		if each.matchesContentType(contentType) {
-			inputMediaOk = append(inputMediaOk, each)
+			candidates = append(candidates, each)
 		}
 	}
-	if len(inputMediaOk) == 0 {
+	if len(candidates) == 0 {
 		if trace {
-			traceLogger.Printf("no Route found (from %d) that matches HTTP Content-Type: %s\n", len(methodOk), contentType)
+			traceLogger.Printf("no Route found (from %d) that matches HTTP Content-Type: %s\n", len(previous), contentType)
+		}
+		if httpRequest.ContentLength > 0 {
+			return nil, NewError(http.StatusUnsupportedMediaType, "415: Unsupported Media Type")
 		}
-		return nil, NewError(http.StatusUnsupportedMediaType, "415: Unsupported Media Type")
 	}
 
 	// accept
-	outputMediaOk := []Route{}
+	previous = candidates
+	candidates = candidates[:0]
 	accept := httpRequest.Header.Get(HEADER_Accept)
 	if len(accept) == 0 {
 		accept = "*/*"
 	}
-	for _, each := range inputMediaOk {
+	for _, each := range previous {
 		if each.matchesAccept(accept) {
-			outputMediaOk = append(outputMediaOk, each)
+			candidates = append(candidates, each)
 		}
 	}
-	if len(outputMediaOk) == 0 {
+	if len(candidates) == 0 {
 		if trace {
-			traceLogger.Printf("no Route found (from %d) that matches HTTP Accept: %s\n", len(inputMediaOk), accept)
+			traceLogger.Printf("no Route found (from %d) that matches HTTP Accept: %s\n", len(previous), accept)
 		}
 		return nil, NewError(http.StatusNotAcceptable, "406: Not Acceptable")
 	}
 	// return r.bestMatchByMedia(outputMediaOk, contentType, accept), nil
-	return &outputMediaOk[0], nil
+	return candidates[0], nil
 }
 
 // http://jsr311.java.net/nonav/releases/1.1/spec/spec3.html#x3-360003.7.2

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

@@ -22,7 +22,10 @@ func insertMime(l []mime, e mime) []mime {
 	return append(l, e)
 }
 
+const qFactorWeightingKey = "q"
+
 // sortedMimes returns a list of mime sorted (desc) by its specified quality.
+// e.g. text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
 func sortedMimes(accept string) (sorted []mime) {
 	for _, each := range strings.Split(accept, ",") {
 		typeAndQuality := strings.Split(strings.Trim(each, " "), ";")
@@ -30,14 +33,16 @@ func sortedMimes(accept string) (sorted []mime) {
 			sorted = insertMime(sorted, mime{typeAndQuality[0], 1.0})
 		} else {
 			// take factor
-			parts := strings.Split(typeAndQuality[1], "=")
-			if len(parts) == 2 {
-				f, err := strconv.ParseFloat(parts[1], 64)
+			qAndWeight := strings.Split(typeAndQuality[1], "=")
+			if len(qAndWeight) == 2 && strings.Trim(qAndWeight[0], " ") == qFactorWeightingKey {
+				f, err := strconv.ParseFloat(qAndWeight[1], 64)
 				if err != nil {
 					traceLogger.Printf("unable to parse quality in %s, %v", each, err)
 				} else {
 					sorted = insertMime(sorted, mime{typeAndQuality[0], f})
 				}
+			} else {
+				sorted = insertMime(sorted, mime{typeAndQuality[0], 1.0})
 			}
 		}
 	}

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

@@ -174,10 +174,15 @@ func (r *Response) WriteHeaderAndJson(status int, value interface{}, contentType
 	return writeJSON(r, status, contentType, value)
 }
 
-// WriteError write the http status and the error string on the response.
+// WriteError write the http status and the error string on the response. err can be nil.
 func (r *Response) WriteError(httpStatus int, err error) error {
 	r.err = err
-	return r.WriteErrorString(httpStatus, err.Error())
+	if err == nil {
+		r.WriteErrorString(httpStatus, "")
+	} else {
+		r.WriteErrorString(httpStatus, err.Error())
+	}
+	return err
 }
 
 // WriteServiceError is a convenience method for a responding with a status and a ServiceError

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

@@ -38,6 +38,7 @@ type Route struct {
 	Operation               string
 	ParameterDocs           []*Parameter
 	ResponseErrors          map[int]ResponseError
+	DefaultResponse         *ResponseError
 	ReadSample, WriteSample interface{} // structs that model an example request or response payload
 
 	// Extra information used to store custom information about the route.
@@ -45,6 +46,9 @@ type Route struct {
 
 	// marks a route as deprecated
 	Deprecated bool
+
+	//Overrides the container.contentEncodingEnabled
+	contentEncodingEnabled *bool
 }
 
 // Initialize for Route
@@ -74,28 +78,36 @@ func (r *Route) dispatchWithFilters(wrappedRequest *Request, wrappedResponse *Re
 	}
 }
 
+func stringTrimSpaceCutset(r rune) bool {
+	return r == ' '
+}
+
 // Return whether the mimeType matches to what this Route can produce.
 func (r Route) matchesAccept(mimeTypesWithQuality string) bool {
-	parts := strings.Split(mimeTypesWithQuality, ",")
-	for _, each := range parts {
-		var withoutQuality string
-		if strings.Contains(each, ";") {
-			withoutQuality = strings.Split(each, ";")[0]
+	remaining := mimeTypesWithQuality
+	for {
+		var mimeType string
+		if end := strings.Index(remaining, ","); end == -1 {
+			mimeType, remaining = remaining, ""
 		} else {
-			withoutQuality = each
+			mimeType, remaining = remaining[:end], remaining[end+1:]
 		}
-		// trim before compare
-		withoutQuality = strings.Trim(withoutQuality, " ")
-		if withoutQuality == "*/*" {
+		if quality := strings.Index(mimeType, ";"); quality != -1 {
+			mimeType = mimeType[:quality]
+		}
+		mimeType = strings.TrimFunc(mimeType, stringTrimSpaceCutset)
+		if mimeType == "*/*" {
 			return true
 		}
 		for _, producibleType := range r.Produces {
-			if producibleType == "*/*" || producibleType == withoutQuality {
+			if producibleType == "*/*" || producibleType == mimeType {
 				return true
 			}
 		}
+		if len(remaining) == 0 {
+			return false
+		}
 	}
-	return false
 }
 
 // Return whether this Route can consume content with a type specified by mimeTypes (can be empty).
@@ -116,29 +128,33 @@ func (r Route) matchesContentType(mimeTypes string) bool {
 		mimeTypes = MIME_OCTET
 	}
 
-	parts := strings.Split(mimeTypes, ",")
-	for _, each := range parts {
-		var contentType string
-		if strings.Contains(each, ";") {
-			contentType = strings.Split(each, ";")[0]
+	remaining := mimeTypes
+	for {
+		var mimeType string
+		if end := strings.Index(remaining, ","); end == -1 {
+			mimeType, remaining = remaining, ""
 		} else {
-			contentType = each
+			mimeType, remaining = remaining[:end], remaining[end+1:]
 		}
-		// trim before compare
-		contentType = strings.Trim(contentType, " ")
+		if quality := strings.Index(mimeType, ";"); quality != -1 {
+			mimeType = mimeType[:quality]
+		}
+		mimeType = strings.TrimFunc(mimeType, stringTrimSpaceCutset)
 		for _, consumeableType := range r.Consumes {
-			if consumeableType == "*/*" || consumeableType == contentType {
+			if consumeableType == "*/*" || consumeableType == mimeType {
 				return true
 			}
 		}
+		if len(remaining) == 0 {
+			return false
+		}
 	}
-	return false
 }
 
 // Tokenize an URL path using the slash separator ; the result does not have empty tokens
 func tokenizePath(path string) []string {
 	if "/" == path {
-		return []string{}
+		return nil
 	}
 	return strings.Split(strings.Trim(path, "/"), "/")
 }
@@ -147,3 +163,8 @@ func tokenizePath(path string) []string {
 func (r Route) String() string {
 	return r.Method + " " + r.Path
 }
+
+// EnableContentEncoding (default=false) allows for GZIP or DEFLATE encoding of responses. Overrides the container.contentEncodingEnabled value.
+func (r Route) EnableContentEncoding(enabled bool) {
+	r.contentEncodingEnabled = &enabled
+}

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

@@ -35,8 +35,10 @@ type RouteBuilder struct {
 	readSample, writeSample interface{}
 	parameters              []*Parameter
 	errorMap                map[int]ResponseError
+	defaultResponse         *ResponseError
 	metadata                map[string]interface{}
 	deprecated              bool
+	contentEncodingEnabled  *bool
 }
 
 // Do evaluates each argument with the RouteBuilder itself.
@@ -164,7 +166,7 @@ func (b *RouteBuilder) Returns(code int, message string, model interface{}) *Rou
 		Code:      code,
 		Message:   message,
 		Model:     model,
-		IsDefault: false,
+		IsDefault: false, // this field is deprecated, use default response instead.
 	}
 	// lazy init because there is no NewRouteBuilder (yet)
 	if b.errorMap == nil {
@@ -174,17 +176,11 @@ 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.
+// DefaultReturns is a special Returns call that sets the default of the response.
 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,
+	b.defaultResponse = &ResponseError{
+		Message: message,
+		Model:   model,
 	}
 	return b
 }
@@ -238,6 +234,12 @@ func (b *RouteBuilder) If(condition RouteSelectionConditionFunction) *RouteBuild
 	return b
 }
 
+// ContentEncodingEnabled allows you to override the Containers value for auto-compressing this route response.
+func (b *RouteBuilder) ContentEncodingEnabled(enabled bool) *RouteBuilder {
+	b.contentEncodingEnabled = &enabled
+	return b
+}
+
 // If no specific Route path then set to rootPath
 // If no specific Produces then set to rootProduces
 // If no specific Consumes then set to rootConsumes
@@ -261,11 +263,11 @@ func (b *RouteBuilder) typeNameHandler(handler TypeNameHandleFunction) *RouteBui
 func (b *RouteBuilder) Build() Route {
 	pathExpr, err := newPathExpression(b.currentPath)
 	if err != nil {
-		log.Printf("[restful] Invalid path:%s because:%v", b.currentPath, err)
+		log.Printf("Invalid path:%s because:%v", b.currentPath, err)
 		os.Exit(1)
 	}
 	if b.function == nil {
-		log.Printf("[restful] No function specified for route:" + b.currentPath)
+		log.Printf("No function specified for route:" + b.currentPath)
 		os.Exit(1)
 	}
 	operationName := b.operation
@@ -274,24 +276,27 @@ func (b *RouteBuilder) Build() Route {
 		operationName = nameOfFunction(b.function)
 	}
 	route := Route{
-		Method:         b.httpMethod,
-		Path:           concatPath(b.rootPath, b.currentPath),
-		Produces:       b.produces,
-		Consumes:       b.consumes,
-		Function:       b.function,
-		Filters:        b.filters,
-		If:             b.conditions,
-		relativePath:   b.currentPath,
-		pathExpr:       pathExpr,
-		Doc:            b.doc,
-		Notes:          b.notes,
-		Operation:      operationName,
-		ParameterDocs:  b.parameters,
-		ResponseErrors: b.errorMap,
-		ReadSample:     b.readSample,
-		WriteSample:    b.writeSample,
-		Metadata:       b.metadata,
-		Deprecated:     b.deprecated}
+		Method:                 b.httpMethod,
+		Path:                   concatPath(b.rootPath, b.currentPath),
+		Produces:               b.produces,
+		Consumes:               b.consumes,
+		Function:               b.function,
+		Filters:                b.filters,
+		If:                     b.conditions,
+		relativePath:           b.currentPath,
+		pathExpr:               pathExpr,
+		Doc:                    b.doc,
+		Notes:                  b.notes,
+		Operation:              operationName,
+		ParameterDocs:          b.parameters,
+		ResponseErrors:         b.errorMap,
+		DefaultResponse:        b.defaultResponse,
+		ReadSample:             b.readSample,
+		WriteSample:            b.writeSample,
+		Metadata:               b.metadata,
+		Deprecated:             b.deprecated,
+		contentEncodingEnabled: b.contentEncodingEnabled,
+	}
 	route.postBuild()
 	return route
 }

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

@@ -60,7 +60,7 @@ func reflectTypeName(sample interface{}) string {
 func (w *WebService) compilePathExpression() {
 	compiled, err := newPathExpression(w.rootPath)
 	if err != nil {
-		log.Printf("[restful] invalid path:%s because:%v", w.rootPath, err)
+		log.Printf("invalid path:%s because:%v", w.rootPath, err)
 		os.Exit(1)
 	}
 	w.pathExpr = compiled