Re-think integration vendoring

- remove docker/docker from  Traefik vendor (unused)
- use `ignore` for all Traefik vendor in integration glide.
- defined only integration specific version of the dependencies.

integration/vendor/github.com/xeipuuv/gojsonpointer/pointer.go

@@ -52,35 +52,24 @@ type implStruct struct {
 	outError   error
 }
 
-func NewJsonPointer(jsonPointerString string) (JsonPointer, error) {
-
-	var p JsonPointer
-	err := p.parse(jsonPointerString)
-	return p, err
-
-}
-
 type JsonPointer struct {
 	referenceTokens []string
 }
 
-// "Constructor", parses the given string JSON pointer
-func (p *JsonPointer) parse(jsonPointerString string) error {
+// NewJsonPointer parses the given string JSON pointer and returns an object
+func NewJsonPointer(jsonPointerString string) (p JsonPointer, err error) {
 
-	var err error
-
-	if jsonPointerString != const_empty_pointer {
-		if !strings.HasPrefix(jsonPointerString, const_pointer_separator) {
-			err = errors.New(const_invalid_start)
-		} else {
-			referenceTokens := strings.Split(jsonPointerString, const_pointer_separator)
-			for _, referenceToken := range referenceTokens[1:] {
-				p.referenceTokens = append(p.referenceTokens, referenceToken)
-			}
-		}
+	// Pointer to the root of the document
+	if len(jsonPointerString) == 0 {
+		// Keep referenceTokens nil
+		return
+	}
+	if jsonPointerString[0] != '/' {
+		return p, errors.New(const_invalid_start)
 	}
 
-	return err
+	p.referenceTokens = strings.Split(jsonPointerString[1:], const_pointer_separator)
+	return
 }
 
 // Uses the pointer to retrieve a value from a JSON document
@@ -119,64 +108,55 @@ func (p *JsonPointer) implementation(i *implStruct) {
 
 	for ti, token := range p.referenceTokens {
 
-		decodedToken := decodeReferenceToken(token)
 		isLastToken := ti == len(p.referenceTokens)-1
 
-		rValue := reflect.ValueOf(node)
-		kind = rValue.Kind()
+		switch v := node.(type) {
 
-		switch kind {
-
-		case reflect.Map:
-			m := node.(map[string]interface{})
-			if _, ok := m[decodedToken]; ok {
-				node = m[decodedToken]
+		case map[string]interface{}:
+			decodedToken := decodeReferenceToken(token)
+			if _, ok := v[decodedToken]; ok {
+				node = v[decodedToken]
 				if isLastToken && i.mode == "SET" {
-					m[decodedToken] = i.setInValue
+					v[decodedToken] = i.setInValue
 				}
 			} else {
-				i.outError = errors.New(fmt.Sprintf("Object has no key '%s'", token))
-				i.getOutKind = kind
+				i.outError = fmt.Errorf("Object has no key '%s'", decodedToken)
+				i.getOutKind = reflect.Map
 				i.getOutNode = nil
 				return
 			}
 
-		case reflect.Slice:
-			s := node.([]interface{})
+		case []interface{}:
 			tokenIndex, err := strconv.Atoi(token)
 			if err != nil {
-				i.outError = errors.New(fmt.Sprintf("Invalid array index '%s'", token))
-				i.getOutKind = kind
+				i.outError = fmt.Errorf("Invalid array index '%s'", token)
+				i.getOutKind = reflect.Slice
 				i.getOutNode = nil
 				return
 			}
-			sLength := len(s)
-			if tokenIndex < 0 || tokenIndex >= sLength {
-				i.outError = errors.New(fmt.Sprintf("Out of bound array[0,%d] index '%d'", sLength, tokenIndex))
-				i.getOutKind = kind
+			if tokenIndex < 0 || tokenIndex >= len(v) {
+				i.outError = fmt.Errorf("Out of bound array[0,%d] index '%d'", len(v), tokenIndex)
+				i.getOutKind = reflect.Slice
 				i.getOutNode = nil
 				return
 			}
 
-			node = s[tokenIndex]
+			node = v[tokenIndex]
 			if isLastToken && i.mode == "SET" {
-				s[tokenIndex] = i.setInValue
+				v[tokenIndex] = i.setInValue
 			}
 
 		default:
-			i.outError = errors.New(fmt.Sprintf("Invalid token reference '%s'", token))
-			i.getOutKind = kind
+			i.outError = fmt.Errorf("Invalid token reference '%s'", token)
+			i.getOutKind = reflect.ValueOf(node).Kind()
 			i.getOutNode = nil
 			return
 		}
 
 	}
 
-	rValue := reflect.ValueOf(node)
-	kind = rValue.Kind()
-
 	i.getOutNode = node
-	i.getOutKind = kind
+	i.getOutKind = reflect.ValueOf(node).Kind()
 	i.outError = nil
 }
 
@@ -197,21 +177,14 @@ func (p *JsonPointer) String() string {
 // ~1 => /
 // ... and vice versa
 
-const (
-	const_encoded_reference_token_0 = `~0`
-	const_encoded_reference_token_1 = `~1`
-	const_decoded_reference_token_0 = `~`
-	const_decoded_reference_token_1 = `/`
-)
-
 func decodeReferenceToken(token string) string {
-	step1 := strings.Replace(token, const_encoded_reference_token_1, const_decoded_reference_token_1, -1)
-	step2 := strings.Replace(step1, const_encoded_reference_token_0, const_decoded_reference_token_0, -1)
+	step1 := strings.Replace(token, `~1`, `/`, -1)
+	step2 := strings.Replace(step1, `~0`, `~`, -1)
 	return step2
 }
 
 func encodeReferenceToken(token string) string {
-	step1 := strings.Replace(token, const_decoded_reference_token_1, const_encoded_reference_token_1, -1)
-	step2 := strings.Replace(step1, const_decoded_reference_token_0, const_encoded_reference_token_0, -1)
+	step1 := strings.Replace(token, `~`, `~0`, -1)
+	step2 := strings.Replace(step1, `/`, `~1`, -1)
 	return step2
 }

integration/vendor/github.com/xeipuuv/gojsonschema/errors.go

@@ -1,10 +1,20 @@
 package gojsonschema
 
 import (
-	"fmt"
-	"strings"
+	"bytes"
+	"sync"
+	"text/template"
 )
 
+var errorTemplates errorTemplate = errorTemplate{template.New("errors-new"), sync.RWMutex{}}
+
+// template.Template is not thread-safe for writing, so some locking is done
+// sync.RWMutex is used for efficiently locking when new templates are created
+type errorTemplate struct {
+	*template.Template
+	sync.RWMutex
+}
+
 type (
 	// RequiredError. ErrorDetails: property string
 	RequiredError struct {
@@ -227,16 +237,47 @@ func newError(err ResultError, context *jsonContext, value interface{}, locale l
 	err.SetValue(value)
 	err.SetDetails(details)
 	details["field"] = err.Field()
+
+	if _, exists := details["context"]; !exists && context != nil {
+		details["context"] = context.String()
+	}
+
 	err.SetDescription(formatErrorDescription(d, details))
 }
 
-// formatErrorDescription takes a string in this format: %field% is required
-// and converts it to a string with replacements. The fields come from
-// the ErrorDetails struct and vary for each type of error.
+// formatErrorDescription takes a string in the default text/template
+// format and converts it to a string with replacements. The fields come
+// from the ErrorDetails struct and vary for each type of error.
 func formatErrorDescription(s string, details ErrorDetails) string {
-	for name, val := range details {
-		s = strings.Replace(s, "%"+strings.ToLower(name)+"%", fmt.Sprintf("%v", val), -1)
+
+	var tpl *template.Template
+	var descrAsBuffer bytes.Buffer
+	var err error
+
+	errorTemplates.RLock()
+	tpl = errorTemplates.Lookup(s)
+	errorTemplates.RUnlock()
+
+	if tpl == nil {
+		errorTemplates.Lock()
+		tpl = errorTemplates.New(s)
+
+		if ErrorTemplateFuncs != nil {
+			tpl.Funcs(ErrorTemplateFuncs)
+		}
+
+		tpl, err = tpl.Parse(s)
+		errorTemplates.Unlock()
+
+		if err != nil {
+			return err.Error()
+		}
 	}
 
-	return s
+	err = tpl.Execute(&descrAsBuffer, details)
+	if err != nil {
+		return err.Error()
+	}
+
+	return descrAsBuffer.String()
 }

integration/vendor/github.com/xeipuuv/gojsonschema/format_checkers.go

@@ -52,9 +52,12 @@ type (
 	// http://tools.ietf.org/html/rfc3339#section-5.6
 	DateTimeFormatChecker struct{}
 
-	// URIFormatCheckers validates a URI with a valid Scheme per RFC3986
+	// URIFormatChecker validates a URI with a valid Scheme per RFC3986
 	URIFormatChecker struct{}
 
+	// URIReferenceFormatChecker validates a URI or relative-reference per RFC3986
+	URIReferenceFormatChecker struct{}
+
 	// HostnameFormatChecker validates a hostname is in the correct format
 	HostnameFormatChecker struct{}
 
@@ -70,14 +73,15 @@ var (
 	// so library users can add custom formatters
 	FormatCheckers = FormatCheckerChain{
 		formatters: map[string]FormatChecker{
-			"date-time": DateTimeFormatChecker{},
-			"hostname":  HostnameFormatChecker{},
-			"email":     EmailFormatChecker{},
-			"ipv4":      IPV4FormatChecker{},
-			"ipv6":      IPV6FormatChecker{},
-			"uri":       URIFormatChecker{},
-			"uuid":      UUIDFormatChecker{},
-			"regex":     UUIDFormatChecker{},
+			"date-time": 	 DateTimeFormatChecker{},
+			"hostname":  	 HostnameFormatChecker{},
+			"email":     	 EmailFormatChecker{},
+			"ipv4":      	 IPV4FormatChecker{},
+			"ipv6":      	 IPV6FormatChecker{},
+			"uri":       	 URIFormatChecker{},
+			"uri-reference": URIReferenceFormatChecker{},
+			"uuid":      	 UUIDFormatChecker{},
+			"regex":     	 RegexFormatChecker{},
 		},
 	}
 
@@ -173,6 +177,11 @@ func (f URIFormatChecker) IsFormat(input string) bool {
 	return true
 }
 
+func (f URIReferenceFormatChecker) IsFormat(input string) bool {
+	_, err := url.Parse(input)
+	return err == nil
+}
+
 func (f HostnameFormatChecker) IsFormat(input string) bool {
 	return rxHostname.MatchString(input) && len(input) < 256
 }

integration/vendor/github.com/xeipuuv/gojsonschema/jsonLoader.go

@@ -38,6 +38,7 @@ import (
 	"runtime"
 	"strings"
 
+
 	"github.com/xeipuuv/gojsonreference"
 )
 
@@ -101,7 +102,9 @@ func (l *jsonReferenceLoader) JsonReference() (gojsonreference.JsonReference, er
 }
 
 func (l *jsonReferenceLoader) LoaderFactory() JSONLoaderFactory {
-	return &DefaultJSONLoaderFactory{}
+	return &FileSystemJSONLoaderFactory{
+		fs: l.fs,
+	}
 }
 
 // NewReferenceLoader returns a JSON reference loader using the given source and the local OS file system.
@@ -173,7 +176,7 @@ func (l *jsonReferenceLoader) loadFromHTTP(address string) (interface{}, error)
 
 	// must return HTTP Status 200 OK
 	if resp.StatusCode != http.StatusOK {
-		return nil, errors.New(formatErrorDescription(Locale.httpBadStatus(), ErrorDetails{"status": resp.Status}))
+		return nil, errors.New(formatErrorDescription(Locale.HttpBadStatus(), ErrorDetails{"status": resp.Status}))
 	}
 
 	bodyBuff, err := ioutil.ReadAll(resp.Body)
@@ -291,6 +294,36 @@ func (l *jsonGoLoader) LoadJSON() (interface{}, error) {
 
 }
 
+type jsonIOLoader struct {
+	buf *bytes.Buffer
+}
+
+func NewReaderLoader(source io.Reader) (*jsonIOLoader, io.Reader) {
+	buf := &bytes.Buffer{}
+	return &jsonIOLoader{buf: buf}, io.TeeReader(source, buf)
+}
+
+func NewWriterLoader(source io.Writer) (*jsonIOLoader, io.Writer) {
+	buf := &bytes.Buffer{}
+	return &jsonIOLoader{buf: buf}, io.MultiWriter(source, buf)
+}
+
+func (l *jsonIOLoader) JsonSource() interface{} {
+	return l.buf.String()
+}
+
+func (l *jsonIOLoader) LoadJSON() (interface{}, error) {
+	return decodeJsonUsingNumber(l.buf)
+}
+
+func (l *jsonIOLoader) JsonReference() (gojsonreference.JsonReference, error) {
+	return gojsonreference.NewJsonReference("#")
+}
+
+func (l *jsonIOLoader) LoaderFactory() JSONLoaderFactory {
+	return &DefaultJSONLoaderFactory{}
+}
+
 func decodeJsonUsingNumber(r io.Reader) (interface{}, error) {
 
 	var document interface{}
@@ -302,7 +335,7 @@ func decodeJsonUsingNumber(r io.Reader) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-
+	
 	return document, nil
 
 }

integration/vendor/github.com/xeipuuv/gojsonschema/locales.go

@@ -26,7 +26,7 @@
 package gojsonschema
 
 type (
-	// locale is an interface for definining custom error strings
+	// locale is an interface for defining custom error strings
 	locale interface {
 		Required() string
 		InvalidType() string
@@ -73,7 +73,8 @@ type (
 		ReferenceMustBeCanonical() string
 		NotAValidType() string
 		Duplicated() string
-		httpBadStatus() string
+		HttpBadStatus() string
+		ParseError() string
 
 		// ErrorFormat
 		ErrorFormat() string
@@ -84,11 +85,11 @@ type (
 )
 
 func (l DefaultLocale) Required() string {
-	return `%property% is required`
+	return `{{.property}} is required`
 }
 
 func (l DefaultLocale) InvalidType() string {
-	return `Invalid type. Expected: %expected%, given: %given%`
+	return `Invalid type. Expected: {{.expected}}, given: {{.given}}`
 }
 
 func (l DefaultLocale) NumberAnyOf() string {
@@ -108,15 +109,15 @@ func (l DefaultLocale) NumberNot() string {
 }
 
 func (l DefaultLocale) MissingDependency() string {
-	return `Has a dependency on %dependency%`
+	return `Has a dependency on {{.dependency}}`
 }
 
 func (l DefaultLocale) Internal() string {
-	return `Internal Error %error%`
+	return `Internal Error {{.error}}`
 }
 
 func (l DefaultLocale) Enum() string {
-	return `%field% must be one of the following: %allowed%`
+	return `{{.field}} must be one of the following: {{.allowed}}`
 }
 
 func (l DefaultLocale) ArrayNoAdditionalItems() string {
@@ -128,141 +129,146 @@ func (l DefaultLocale) ArrayNotEnoughItems() string {
 }
 
 func (l DefaultLocale) ArrayMinItems() string {
-	return `Array must have at least %min% items`
+	return `Array must have at least {{.min}} items`
 }
 
 func (l DefaultLocale) ArrayMaxItems() string {
-	return `Array must have at most %max% items`
+	return `Array must have at most {{.max}} items`
 }
 
 func (l DefaultLocale) Unique() string {
-	return `%type% items must be unique`
+	return `{{.type}} items must be unique`
 }
 
 func (l DefaultLocale) ArrayMinProperties() string {
-	return `Must have at least %min% properties`
+	return `Must have at least {{.min}} properties`
 }
 
 func (l DefaultLocale) ArrayMaxProperties() string {
-	return `Must have at most %max% properties`
+	return `Must have at most {{.max}} properties`
 }
 
 func (l DefaultLocale) AdditionalPropertyNotAllowed() string {
-	return `Additional property %property% is not allowed`
+	return `Additional property {{.property}} is not allowed`
 }
 
 func (l DefaultLocale) InvalidPropertyPattern() string {
-	return `Property "%property%" does not match pattern %pattern%`
+	return `Property "{{.property}}" does not match pattern {{.pattern}}`
 }
 
 func (l DefaultLocale) StringGTE() string {
-	return `String length must be greater than or equal to %min%`
+	return `String length must be greater than or equal to {{.min}}`
 }
 
 func (l DefaultLocale) StringLTE() string {
-	return `String length must be less than or equal to %max%`
+	return `String length must be less than or equal to {{.max}}`
 }
 
 func (l DefaultLocale) DoesNotMatchPattern() string {
-	return `Does not match pattern '%pattern%'`
+	return `Does not match pattern '{{.pattern}}'`
 }
 
 func (l DefaultLocale) DoesNotMatchFormat() string {
-	return `Does not match format '%format%'`
+	return `Does not match format '{{.format}}'`
 }
 
 func (l DefaultLocale) MultipleOf() string {
-	return `Must be a multiple of %multiple%`
+	return `Must be a multiple of {{.multiple}}`
 }
 
 func (l DefaultLocale) NumberGTE() string {
-	return `Must be greater than or equal to %min%`
+	return `Must be greater than or equal to {{.min}}`
 }
 
 func (l DefaultLocale) NumberGT() string {
-	return `Must be greater than %min%`
+	return `Must be greater than {{.min}}`
 }
 
 func (l DefaultLocale) NumberLTE() string {
-	return `Must be less than or equal to %max%`
+	return `Must be less than or equal to {{.max}}`
 }
 
 func (l DefaultLocale) NumberLT() string {
-	return `Must be less than %max%`
+	return `Must be less than {{.max}}`
 }
 
 // Schema validators
 func (l DefaultLocale) RegexPattern() string {
-	return `Invalid regex pattern '%pattern%'`
+	return `Invalid regex pattern '{{.pattern}}'`
 }
 
 func (l DefaultLocale) GreaterThanZero() string {
-	return `%number% must be strictly greater than 0`
+	return `{{.number}} must be strictly greater than 0`
 }
 
 func (l DefaultLocale) MustBeOfA() string {
-	return `%x% must be of a %y%`
+	return `{{.x}} must be of a {{.y}}`
 }
 
 func (l DefaultLocale) MustBeOfAn() string {
-	return `%x% must be of an %y%`
+	return `{{.x}} must be of an {{.y}}`
 }
 
 func (l DefaultLocale) CannotBeUsedWithout() string {
-	return `%x% cannot be used without %y%`
+	return `{{.x}} cannot be used without {{.y}}`
 }
 
 func (l DefaultLocale) CannotBeGT() string {
-	return `%x% cannot be greater than %y%`
+	return `{{.x}} cannot be greater than {{.y}}`
 }
 
 func (l DefaultLocale) MustBeOfType() string {
-	return `%key% must be of type %type%`
+	return `{{.key}} must be of type {{.type}}`
 }
 
 func (l DefaultLocale) MustBeValidRegex() string {
-	return `%key% must be a valid regex`
+	return `{{.key}} must be a valid regex`
 }
 
 func (l DefaultLocale) MustBeValidFormat() string {
-	return `%key% must be a valid format %given%`
+	return `{{.key}} must be a valid format {{.given}}`
 }
 
 func (l DefaultLocale) MustBeGTEZero() string {
-	return `%key% must be greater than or equal to 0`
+	return `{{.key}} must be greater than or equal to 0`
 }
 
 func (l DefaultLocale) KeyCannotBeGreaterThan() string {
-	return `%key% cannot be greater than %y%`
+	return `{{.key}} cannot be greater than {{.y}}`
 }
 
 func (l DefaultLocale) KeyItemsMustBeOfType() string {
-	return `%key% items must be %type%`
+	return `{{.key}} items must be {{.type}}`
 }
 
 func (l DefaultLocale) KeyItemsMustBeUnique() string {
-	return `%key% items must be unique`
+	return `{{.key}} items must be unique`
 }
 
 func (l DefaultLocale) ReferenceMustBeCanonical() string {
-	return `Reference %reference% must be canonical`
+	return `Reference {{.reference}} must be canonical`
 }
 
 func (l DefaultLocale) NotAValidType() string {
-	return `%type% is not a valid type -- `
+	return `has a primitive type that is NOT VALID -- given: {{.given}} Expected valid values are:{{.expected}}`
 }
 
 func (l DefaultLocale) Duplicated() string {
-	return `%type% type is duplicated`
+	return `{{.type}} type is duplicated`
 }
 
-func (l DefaultLocale) httpBadStatus() string {
-	return `Could not read schema from HTTP, response status is %status%`
+func (l DefaultLocale) HttpBadStatus() string {
+	return `Could not read schema from HTTP, response status is {{.status}}`
 }
 
 // Replacement options: field, description, context, value
 func (l DefaultLocale) ErrorFormat() string {
-	return `%field%: %description%`
+	return `{{.field}}: {{.description}}`
+}
+
+//Parse error
+func (l DefaultLocale) ParseError() string {
+	return `Expected: %expected%, given: Invalid JSON`
 }
 
 const (

integration/vendor/github.com/xeipuuv/gojsonschema/result.go

@@ -48,6 +48,7 @@ type (
 		Value() interface{}
 		SetDetails(ErrorDetails)
 		Details() ErrorDetails
+		String() string
 	}
 
 	// ResultErrorFields holds the fields for each ResultError implementation.

integration/vendor/github.com/xeipuuv/gojsonschema/schema.go

@@ -31,6 +31,7 @@ import (
 	"errors"
 	"reflect"
 	"regexp"
+	"text/template"
 
 	"github.com/xeipuuv/gojsonreference"
 )
@@ -39,6 +40,9 @@ var (
 	// Locale is the default locale to use
 	// Library users can overwrite with their own implementation
 	Locale locale = DefaultLocale{}
+
+	// ErrorTemplateFuncs allows you to define custom template funcs for use in localization.
+	ErrorTemplateFuncs template.FuncMap
 )
 
 func NewSchema(l JSONLoader) (*Schema, error) {
@@ -103,10 +107,9 @@ func (d *Schema) parseSchema(documentNode interface{}, currentSchema *subSchema)
 
 	if !isKind(documentNode, reflect.Map) {
 		return errors.New(formatErrorDescription(
-			Locale.InvalidType(),
+			Locale.ParseError(),
 			ErrorDetails{
-				"expected": TYPE_OBJECT,
-				"given":    STRING_SCHEMA,
+				"expected": STRING_SCHEMA,
 			},
 		))
 	}

integration/vendor/github.com/xeipuuv/gojsonschema/schemaType.go

@@ -44,7 +44,7 @@ func (t *jsonSchemaType) IsTyped() bool {
 func (t *jsonSchemaType) Add(etype string) error {
 
 	if !isStringInSlice(JSON_TYPES, etype) {
-		return errors.New(formatErrorDescription(Locale.NotAValidType(), ErrorDetails{"type": etype}))
+		return errors.New(formatErrorDescription(Locale.NotAValidType(), ErrorDetails{"given": "/" + etype + "/", "expected": JSON_TYPES}))
 	}
 
 	if t.Contains(etype) {

integration/vendor/github.com/xeipuuv/gojsonschema/validation.go

@@ -568,7 +568,7 @@ func (v *subSchema) validateObject(currentSubSchema *subSchema, value map[string
 							result.addError(
 								new(AdditionalPropertyNotAllowedError),
 								context,
-								value,
+								value[pk],
 								ErrorDetails{"property": pk},
 							)
 						}
@@ -579,7 +579,7 @@ func (v *subSchema) validateObject(currentSubSchema *subSchema, value map[string
 							result.addError(
 								new(AdditionalPropertyNotAllowedError),
 								context,
-								value,
+								value[pk],
 								ErrorDetails{"property": pk},
 							)
 						}
@@ -631,7 +631,7 @@ func (v *subSchema) validateObject(currentSubSchema *subSchema, value map[string
 				result.addError(
 					new(InvalidPropertyPatternError),
 					context,
-					value,
+					value[pk],
 					ErrorDetails{
 						"property": pk,
 						"pattern":  currentSubSchema.PatternPropertiesString(),