Update k8s client-go to v6.0.0 (#1340)

* Update k8s client-go to v6.0.0

This fix updates k8s client-go to v6.0.0 as CoreDNS is supported
in 1.9 and v6.0.0 is the recommended version.

There are quite some massive changes that need to be made:
1. k8s.io/client-go/pkg/api/v1 has been changed to k8s.io/api/v1 (repo changed from `client-go` to `api`)
2. kubernetes.Clientset adds one extra layer, so that `kubernetes.Clientset.Services()` and like has been changed to `kubernetes.Clientset.CoreV1().Services()`

Also, we have to stick with specific commits of `k8s.io/apimachinery` and the newly introduced `k8s.io/api`
because go dep still could not figure out the right version to fetch.
Signed-off-by: Yong Tang <yong.tang.github@outlook.com>

* Update vendor with `dep ensure --update` and `dep prune`
Signed-off-by: Yong Tang <yong.tang.github@outlook.com>

Gopkg.toml

@@ -19,10 +19,15 @@ ignored = [
     name = "github.com/ugorji/go"
     revision = "8c0409fcbb70099c748d71f714529204975f6c3f"
 
-# client-go 4.0.0 uses apimachinery 1fd2e63a9a370677308a42f24fd40c86438afddf (see Godep.json)
+# client-go 6.0.0 uses apimachinery 180eddb345a5be3a157cea1c624700ad5bd27b8f
+# and api 11147472b7c934c474a2c484af3c0c5210b7a3af (see Godep.json). go dep
+# is unable to match Godep.json automatically so have to specify here.
 [[constraint]]
     name = "k8s.io/client-go"
-    version = "v4.0.0"
+    version = "v6.0.0"
 [[override]]
     name = "k8s.io/apimachinery"
-    revision = "1fd2e63a9a370677308a42f24fd40c86438afddf"
+    revision = "180eddb345a5be3a157cea1c624700ad5bd27b8f"
+[[override]]
+    name = "k8s.io/api"
+    revision = "11147472b7c934c474a2c484af3c0c5210b7a3af"

plugin/federation/kubernetes_api_test.go

@@ -3,8 +3,8 @@ package federation
 import (
 	"github.com/coredns/coredns/plugin/kubernetes"
 
+	api "k8s.io/api/core/v1"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
-	api "k8s.io/client-go/pkg/api/v1"
 )
 
 type APIConnFederationTest struct{}

plugin/kubernetes/autopath.go

@@ -4,7 +4,7 @@ import (
 	"github.com/coredns/coredns/plugin"
 	"github.com/coredns/coredns/request"
 
-	api "k8s.io/client-go/pkg/api/v1"
+	api "k8s.io/api/core/v1"
 )
 
 // AutoPath implements the AutoPathFunc call from the autopath plugin.

plugin/kubernetes/controller.go

@@ -6,8 +6,8 @@ import (
 	"sync"
 	"time"
 
+	api "k8s.io/api/core/v1"
 	"k8s.io/client-go/kubernetes"
-	api "k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/tools/cache"
 
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -164,7 +164,7 @@ func serviceListFunc(c *kubernetes.Clientset, ns string, s *labels.Selector) fun
 		if s != nil {
 			opts.LabelSelector = (*s).String()
 		}
-		listV1, err := c.Services(ns).List(opts)
+		listV1, err := c.CoreV1().Services(ns).List(opts)
 		if err != nil {
 			return nil, err
 		}
@@ -177,7 +177,7 @@ func podListFunc(c *kubernetes.Clientset, ns string, s *labels.Selector) func(me
 		if s != nil {
 			opts.LabelSelector = (*s).String()
 		}
-		listV1, err := c.Pods(ns).List(opts)
+		listV1, err := c.CoreV1().Pods(ns).List(opts)
 		if err != nil {
 			return nil, err
 		}
@@ -190,7 +190,7 @@ func serviceWatchFunc(c *kubernetes.Clientset, ns string, s *labels.Selector) fu
 		if s != nil {
 			options.LabelSelector = (*s).String()
 		}
-		w, err := c.Services(ns).Watch(options)
+		w, err := c.CoreV1().Services(ns).Watch(options)
 		if err != nil {
 			return nil, err
 		}
@@ -203,7 +203,7 @@ func podWatchFunc(c *kubernetes.Clientset, ns string, s *labels.Selector) func(o
 		if s != nil {
 			options.LabelSelector = (*s).String()
 		}
-		w, err := c.Pods(ns).Watch(options)
+		w, err := c.CoreV1().Pods(ns).Watch(options)
 		if err != nil {
 			return nil, err
 		}
@@ -216,7 +216,7 @@ func endpointsListFunc(c *kubernetes.Clientset, ns string, s *labels.Selector) f
 		if s != nil {
 			opts.LabelSelector = (*s).String()
 		}
-		listV1, err := c.Endpoints(ns).List(opts)
+		listV1, err := c.CoreV1().Endpoints(ns).List(opts)
 		if err != nil {
 			return nil, err
 		}
@@ -229,7 +229,7 @@ func endpointsWatchFunc(c *kubernetes.Clientset, ns string, s *labels.Selector)
 		if s != nil {
 			options.LabelSelector = (*s).String()
 		}
-		w, err := c.Endpoints(ns).Watch(options)
+		w, err := c.CoreV1().Endpoints(ns).Watch(options)
 		if err != nil {
 			return nil, err
 		}
@@ -393,7 +393,7 @@ func (dns *dnsControl) EndpointsList() (eps []*api.Endpoints) {
 // returned. This query causes a roundtrip to the k8s API server, so use
 // sparingly. Currently this is only used for Federation.
 func (dns *dnsControl) GetNodeByName(name string) (*api.Node, error) {
-	v1node, err := dns.client.Nodes().Get(name, meta.GetOptions{})
+	v1node, err := dns.client.CoreV1().Nodes().Get(name, meta.GetOptions{})
 	if err != nil {
 		return &api.Node{}, err
 	}
@@ -404,7 +404,7 @@ func (dns *dnsControl) GetNodeByName(name string) (*api.Node, error) {
 // error is returned. This query causes a roundtrip to the k8s API server, so
 // use sparingly.
 func (dns *dnsControl) GetNamespaceByName(name string) (*api.Namespace, error) {
-	v1ns, err := dns.client.Namespaces().Get(name, meta.GetOptions{})
+	v1ns, err := dns.client.CoreV1().Namespaces().Get(name, meta.GetOptions{})
 	if err != nil {
 		return &api.Namespace{}, err
 	}

plugin/kubernetes/handler_test.go

@@ -8,8 +8,8 @@ import (
 
 	"github.com/miekg/dns"
 	"golang.org/x/net/context"
+	api "k8s.io/api/core/v1"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
-	api "k8s.io/client-go/pkg/api/v1"
 )
 
 var dnsTestCases = []test.Case{

plugin/kubernetes/kubernetes.go

@@ -17,10 +17,10 @@ import (
 	"github.com/coredns/coredns/request"
 
 	"github.com/miekg/dns"
+	api "k8s.io/api/core/v1"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/client-go/kubernetes"
-	api "k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"

plugin/kubernetes/kubernetes_test.go

@@ -7,8 +7,8 @@ import (
 	"github.com/coredns/coredns/request"
 
 	"github.com/miekg/dns"
+	api "k8s.io/api/core/v1"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
-	api "k8s.io/client-go/pkg/api/v1"
 )
 
 func TestWildcard(t *testing.T) {

plugin/kubernetes/ns.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 
 	"github.com/miekg/dns"
-	api "k8s.io/client-go/pkg/api/v1"
+	api "k8s.io/api/core/v1"
 )
 
 func isDefaultNS(name, zone string) bool {

plugin/kubernetes/ns_test.go

@@ -3,8 +3,8 @@ package kubernetes
 import (
 	"testing"
 
+	api "k8s.io/api/core/v1"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
-	api "k8s.io/client-go/pkg/api/v1"
 )
 
 type APIConnTest struct{}

plugin/kubernetes/reverse_test.go

@@ -8,8 +8,8 @@ import (
 
 	"github.com/miekg/dns"
 	"golang.org/x/net/context"
+	api "k8s.io/api/core/v1"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
-	api "k8s.io/client-go/pkg/api/v1"
 )
 
 type APIConnReverseTest struct{}

vendor/github.com/asaskevich/govalidator/.travis.yml

-language: go
-
-go:
-  - 1.1
-  - 1.2
-  - 1.3
-  - 1.4
-  - 1.5
-  - 1.6
-  - tip
-
-notifications:
-  email:
-    - bwatas@gmail.com

vendor/github.com/asaskevich/govalidator/CONTRIBUTING.md

-#### Support
-If you do have a contribution to the package, feel free to create a Pull Request or an Issue.
-
-#### What to contribute
-If you don't know what to do, there are some features and functions that need to be done
-
-- [ ] Refactor code
-- [ ] Edit docs and [README](https://github.com/asaskevich/govalidator/README.md): spellcheck, grammar and typo check
-- [ ] Create actual list of contributors and projects that currently using this package
-- [ ] Resolve [issues and bugs](https://github.com/asaskevich/govalidator/issues)
-- [ ] Update actual [list of functions](https://github.com/asaskevich/govalidator#list-of-functions)
-- [ ] Update [list of validators](https://github.com/asaskevich/govalidator#validatestruct-2) that available for `ValidateStruct` and add new
-- [ ] Implement new validators: `IsFQDN`, `IsIMEI`, `IsPostalCode`, `IsISIN`, `IsISRC` etc
-- [ ] Implement [validation by maps](https://github.com/asaskevich/govalidator/issues/224)
-- [ ] Implement fuzzing testing
-- [ ] Implement some struct/map/array utilities
-- [ ] Implement map/array validation
-- [ ] Implement benchmarking
-- [ ] Implement batch of examples
-- [ ] Look at forks for new features and fixes
-
-#### Advice
-Feel free to create what you want, but keep in mind when you implement new features:
-- Code must be clear and readable, names of variables/constants clearly describes what they are doing
-- Public functions must be documented and described in source file and added to README.md to the list of available functions
-- There are must be unit-tests for any new functions and improvements
\ No newline at end of file

vendor/github.com/asaskevich/govalidator/LICENSE

-The MIT License (MIT)
-
-Copyright (c) 2014 Alex Saskevich
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
\ No newline at end of file

vendor/github.com/asaskevich/govalidator/arrays.go

-package govalidator
-
-// Iterator is the function that accepts element of slice/array and its index
-type Iterator func(interface{}, int)
-
-// ResultIterator is the function that accepts element of slice/array and its index and returns any result
-type ResultIterator func(interface{}, int) interface{}
-
-// ConditionIterator is the function that accepts element of slice/array and its index and returns boolean
-type ConditionIterator func(interface{}, int) bool
-
-// Each iterates over the slice and apply Iterator to every item
-func Each(array []interface{}, iterator Iterator) {
-	for index, data := range array {
-		iterator(data, index)
-	}
-}
-
-// Map iterates over the slice and apply ResultIterator to every item. Returns new slice as a result.
-func Map(array []interface{}, iterator ResultIterator) []interface{} {
-	var result = make([]interface{}, len(array))
-	for index, data := range array {
-		result[index] = iterator(data, index)
-	}
-	return result
-}
-
-// Find iterates over the slice and apply ConditionIterator to every item. Returns first item that meet ConditionIterator or nil otherwise.
-func Find(array []interface{}, iterator ConditionIterator) interface{} {
-	for index, data := range array {
-		if iterator(data, index) {
-			return data
-		}
-	}
-	return nil
-}
-
-// Filter iterates over the slice and apply ConditionIterator to every item. Returns new slice.
-func Filter(array []interface{}, iterator ConditionIterator) []interface{} {
-	var result = make([]interface{}, 0)
-	for index, data := range array {
-		if iterator(data, index) {
-			result = append(result, data)
-		}
-	}
-	return result
-}
-
-// Count iterates over the slice and apply ConditionIterator to every item. Returns count of items that meets ConditionIterator.
-func Count(array []interface{}, iterator ConditionIterator) int {
-	count := 0
-	for index, data := range array {
-		if iterator(data, index) {
-			count = count + 1
-		}
-	}
-	return count
-}

vendor/github.com/asaskevich/govalidator/arrays_test.go

-package govalidator
-
-import "testing"
-
-func TestEach(t *testing.T) {
-	// TODO Maybe refactor?
-	t.Parallel()
-	acc := 0
-	data := []interface{}{1, 2, 3, 4, 5}
-	var fn Iterator = func(value interface{}, index int) {
-		acc = acc + value.(int)
-	}
-	Each(data, fn)
-	if acc != 15 {
-		t.Errorf("Expected Each(..) to be %v, got %v", 15, acc)
-	}
-}
-
-func ExampleEach() {
-	data := []interface{}{1, 2, 3, 4, 5}
-	var fn Iterator = func(value interface{}, index int) {
-		println(value.(int))
-	}
-	Each(data, fn)
-}
-
-func TestMap(t *testing.T) {
-	// TODO Maybe refactor?
-	t.Parallel()
-	data := []interface{}{1, 2, 3, 4, 5}
-	var fn ResultIterator = func(value interface{}, index int) interface{} {
-		return value.(int) * 3
-	}
-	result := Map(data, fn)
-	for i, d := range result {
-		if d != fn(data[i], i) {
-			t.Errorf("Expected Map(..) to be %v, got %v", fn(data[i], i), d)
-		}
-	}
-}
-
-func ExampleMap() {
-	data := []interface{}{1, 2, 3, 4, 5}
-	var fn ResultIterator = func(value interface{}, index int) interface{} {
-		return value.(int) * 3
-	}
-	_ = Map(data, fn) // result = []interface{}{1, 6, 9, 12, 15}
-}
-
-func TestFind(t *testing.T) {
-	// TODO Maybe refactor?
-	t.Parallel()
-	findElement := 96
-	data := []interface{}{1, 2, 3, 4, findElement, 5}
-	var fn1 ConditionIterator = func(value interface{}, index int) bool {
-		return value.(int) == findElement
-	}
-	var fn2 ConditionIterator = func(value interface{}, index int) bool {
-		value, _ = value.(string)
-		return value == "govalidator"
-	}
-	val1 := Find(data, fn1)
-	val2 := Find(data, fn2)
-	if val1 != findElement {
-		t.Errorf("Expected Find(..) to be %v, got %v", findElement, val1)
-	}
-	if val2 != nil {
-		t.Errorf("Expected Find(..) to be %v, got %v", nil, val2)
-	}
-}
-
-func TestFilter(t *testing.T) {
-	// TODO Maybe refactor?
-	t.Parallel()
-	data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	answer := []interface{}{2, 4, 6, 8, 10}
-	var fn ConditionIterator = func(value interface{}, index int) bool {
-		return value.(int)%2 == 0
-	}
-	result := Filter(data, fn)
-	for i := range result {
-		if result[i] != answer[i] {
-			t.Errorf("Expected Filter(..) to be %v, got %v", answer[i], result[i])
-		}
-	}
-}
-
-func ExampleFilter() {
-	data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	var fn ConditionIterator = func(value interface{}, index int) bool {
-		return value.(int)%2 == 0
-	}
-	_ = Filter(data, fn) // result = []interface{}{2, 4, 6, 8, 10}
-}
-
-func TestCount(t *testing.T) {
-	// TODO Maybe refactor?
-	t.Parallel()
-	data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	count := 5
-	var fn ConditionIterator = func(value interface{}, index int) bool {
-		return value.(int)%2 == 0
-	}
-	result := Count(data, fn)
-	if result != count {
-		t.Errorf("Expected Count(..) to be %v, got %v", count, result)
-	}
-}
-
-func ExampleCount() {
-	data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	var fn ConditionIterator = func(value interface{}, index int) bool {
-		return value.(int)%2 == 0
-	}
-	_ = Count(data, fn) // result = 5
-}

vendor/github.com/asaskevich/govalidator/converter.go

-package govalidator
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-)
-
-// ToString convert the input to a string.
-func ToString(obj interface{}) string {
-	res := fmt.Sprintf("%v", obj)
-	return string(res)
-}
-
-// ToJSON convert the input to a valid JSON string
-func ToJSON(obj interface{}) (string, error) {
-	res, err := json.Marshal(obj)
-	if err != nil {
-		res = []byte("")
-	}
-	return string(res), err
-}
-
-// ToFloat convert the input string to a float, or 0.0 if the input is not a float.
-func ToFloat(str string) (float64, error) {
-	res, err := strconv.ParseFloat(str, 64)
-	if err != nil {
-		res = 0.0
-	}
-	return res, err
-}
-
-// ToInt convert the input string to an integer, or 0 if the input is not an integer.
-func ToInt(str string) (int64, error) {
-	res, err := strconv.ParseInt(str, 0, 64)
-	if err != nil {
-		res = 0
-	}
-	return res, err
-}
-
-// ToBoolean convert the input string to a boolean.
-func ToBoolean(str string) (bool, error) {
-	return strconv.ParseBool(str)
-}

vendor/github.com/asaskevich/govalidator/converter_test.go

-package govalidator
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestToInt(t *testing.T) {
-	tests := []string{"1000", "-123", "abcdef", "100000000000000000000000000000000000000000000"}
-	expected := []int64{1000, -123, 0, 0}
-	for i := 0; i < len(tests); i++ {
-		result, _ := ToInt(tests[i])
-		if result != expected[i] {
-			t.Log("Case ", i, ": expected ", expected[i], " when result is ", result)
-			t.FailNow()
-		}
-	}
-}
-
-func TestToBoolean(t *testing.T) {
-	tests := []string{"true", "1", "True", "false", "0", "abcdef"}
-	expected := []bool{true, true, true, false, false, false}
-	for i := 0; i < len(tests); i++ {
-		res, _ := ToBoolean(tests[i])
-		if res != expected[i] {
-			t.Log("Case ", i, ": expected ", expected[i], " when result is ", res)
-			t.FailNow()
-		}
-	}
-}
-
-func toString(t *testing.T, test interface{}, expected string) {
-	res := ToString(test)
-	if res != expected {
-		t.Log("Case ToString: expected ", expected, " when result is ", res)
-		t.FailNow()
-	}
-}
-
-func TestToString(t *testing.T) {
-	toString(t, "str123", "str123")
-	toString(t, 123, "123")
-	toString(t, 12.3, "12.3")
-	toString(t, true, "true")
-	toString(t, 1.5+10i, "(1.5+10i)")
-	// Sprintf function not guarantee that maps with equal keys always will be equal in string  representation
-	//toString(t, struct{ Keys map[int]int }{Keys: map[int]int{1: 2, 3: 4}}, "{map[1:2 3:4]}")
-}
-
-func TestToFloat(t *testing.T) {
-	tests := []string{"", "123", "-.01", "10.", "string", "1.23e3", ".23e10"}
-	expected := []float64{0, 123, -0.01, 10.0, 0, 1230, 0.23e10}
-	for i := 0; i < len(tests); i++ {
-		res, _ := ToFloat(tests[i])
-		if res != expected[i] {
-			t.Log("Case ", i, ": expected ", expected[i], " when result is ", res)
-			t.FailNow()
-		}
-	}
-}
-
-func TestToJSON(t *testing.T) {
-	tests := []interface{}{"test", map[string]string{"a": "b", "b": "c"}, func() error { return fmt.Errorf("Error") }}
-	expected := [][]string{
-		{"\"test\"", "<nil>"},
-		{"{\"a\":\"b\",\"b\":\"c\"}", "<nil>"},
-		{"", "json: unsupported type: func() error"},
-	}
-	for i, test := range tests {
-		actual, err := ToJSON(test)
-		if actual != expected[i][0] {
-			t.Errorf("Expected toJSON(%v) to return '%v', got '%v'", test, expected[i][0], actual)
-		}
-		if fmt.Sprintf("%v", err) != expected[i][1] {
-			t.Errorf("Expected error returned from toJSON(%v) to return '%v', got '%v'", test, expected[i][1], fmt.Sprintf("%v", err))
-		}
-	}
-}

vendor/github.com/asaskevich/govalidator/error.go

-package govalidator
-
-import "strings"
-
-// Errors is an array of multiple errors and conforms to the error interface.
-type Errors []error
-
-// Errors returns itself.
-func (es Errors) Errors() []error {
-	return es
-}
-
-func (es Errors) Error() string {
-	var errs []string
-	for _, e := range es {
-		errs = append(errs, e.Error())
-	}
-	return strings.Join(errs, ";")
-}
-
-// Error encapsulates a name, an error and whether there's a custom error message or not.
-type Error struct {
-	Name                     string
-	Err                      error
-	CustomErrorMessageExists bool
-
-	// Validator indicates the name of the validator that failed
-	Validator string
-}
-
-func (e Error) Error() string {
-	if e.CustomErrorMessageExists {
-		return e.Err.Error()
-	}
-	return e.Name + ": " + e.Err.Error()
-}

vendor/github.com/asaskevich/govalidator/error_test.go

-package govalidator
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestErrorsToString(t *testing.T) {
-	t.Parallel()
-	customErr := &Error{Name: "Custom Error Name", Err: fmt.Errorf("stdlib error")}
-	customErrWithCustomErrorMessage := &Error{Name: "Custom Error Name 2", Err: fmt.Errorf("Bad stuff happened"), CustomErrorMessageExists: true}
-
-	var tests = []struct {
-		param1   Errors
-		expected string
-	}{
-		{Errors{}, ""},
-		{Errors{fmt.Errorf("Error 1")}, "Error 1"},
-		{Errors{fmt.Errorf("Error 1"), fmt.Errorf("Error 2")}, "Error 1;Error 2"},
-		{Errors{customErr, fmt.Errorf("Error 2")}, "Custom Error Name: stdlib error;Error 2"},
-		{Errors{fmt.Errorf("Error 123"), customErrWithCustomErrorMessage}, "Error 123;Bad stuff happened"},
-	}
-	for _, test := range tests {
-		actual := test.param1.Error()
-		if actual != test.expected {
-			t.Errorf("Expected Error() to return '%v', got '%v'", test.expected, actual)
-		}
-	}
-}

vendor/github.com/asaskevich/govalidator/numerics.go

-package govalidator
-
-import (
-	"math"
-	"reflect"
-)
-
-// Abs returns absolute value of number
-func Abs(value float64) float64 {
-	return math.Abs(value)
-}
-
-// Sign returns signum of number: 1 in case of value > 0, -1 in case of value < 0, 0 otherwise
-func Sign(value float64) float64 {
-	if value > 0 {
-		return 1
-	} else if value < 0 {
-		return -1
-	} else {
-		return 0
-	}
-}
-
-// IsNegative returns true if value < 0
-func IsNegative(value float64) bool {
-	return value < 0
-}
-
-// IsPositive returns true if value > 0
-func IsPositive(value float64) bool {
-	return value > 0
-}
-
-// IsNonNegative returns true if value >= 0
-func IsNonNegative(value float64) bool {
-	return value >= 0
-}
-
-// IsNonPositive returns true if value <= 0
-func IsNonPositive(value float64) bool {
-	return value <= 0
-}
-
-// InRange returns true if value lies between left and right border
-func InRangeInt(value, left, right int) bool {
-	if left > right {
-		left, right = right, left
-	}
-	return value >= left && value <= right
-}
-
-// InRange returns true if value lies between left and right border
-func InRangeFloat32(value, left, right float32) bool {
-	if left > right {
-		left, right = right, left
-	}
-	return value >= left && value <= right
-}
-
-// InRange returns true if value lies between left and right border
-func InRangeFloat64(value, left, right float64) bool {
-	if left > right {
-		left, right = right, left
-	}
-	return value >= left && value <= right
-}
-
-// InRange returns true if value lies between left and right border, generic type to handle int, float32 or float64, all types must the same type
-func InRange(value interface{}, left interface{}, right interface{}) bool {
-
-	reflectValue := reflect.TypeOf(value).Kind()
-	reflectLeft := reflect.TypeOf(left).Kind()
-	reflectRight := reflect.TypeOf(right).Kind()
-
-	if reflectValue == reflect.Int && reflectLeft == reflect.Int && reflectRight == reflect.Int {
-		return InRangeInt(value.(int), left.(int), right.(int))
-	} else if reflectValue == reflect.Float32 && reflectLeft == reflect.Float32 && reflectRight == reflect.Float32 {
-		return InRangeFloat32(value.(float32), left.(float32), right.(float32))
-	} else if reflectValue == reflect.Float64 && reflectLeft == reflect.Float64 && reflectRight == reflect.Float64 {
-		return InRangeFloat64(value.(float64), left.(float64), right.(float64))
-	} else {
-		return false
-	}
-}
-
-// IsWhole returns true if value is whole number
-func IsWhole(value float64) bool {
-	return math.Remainder(value, 1) == 0
-}
-
-// IsNatural returns true if value is natural number (positive and whole)
-func IsNatural(value float64) bool {
-	return IsWhole(value) && IsPositive(value)
-}

vendor/github.com/asaskevich/govalidator/numerics_test.go

-package govalidator
-
-import "testing"
-
-func TestAbs(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected float64
-	}{
-		{0, 0},
-		{-1, 1},
-		{10, 10},
-		{3.14, 3.14},
-		{-96, 96},
-		{-10e-12, 10e-12},
-	}
-	for _, test := range tests {
-		actual := Abs(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected Abs(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestSign(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected float64
-	}{
-		{0, 0},
-		{-1, -1},
-		{10, 1},
-		{3.14, 1},
-		{-96, -1},
-		{-10e-12, -1},
-	}
-	for _, test := range tests {
-		actual := Sign(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected Sign(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestIsNegative(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected bool
-	}{
-		{0, false},
-		{-1, true},
-		{10, false},
-		{3.14, false},
-		{-96, true},
-		{-10e-12, true},
-	}
-	for _, test := range tests {
-		actual := IsNegative(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected IsNegative(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestIsNonNegative(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected bool
-	}{
-		{0, true},
-		{-1, false},
-		{10, true},
-		{3.14, true},
-		{-96, false},
-		{-10e-12, false},
-	}
-	for _, test := range tests {
-		actual := IsNonNegative(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected IsNonNegative(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestIsPositive(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected bool
-	}{
-		{0, false},
-		{-1, false},
-		{10, true},
-		{3.14, true},
-		{-96, false},
-		{-10e-12, false},
-	}
-	for _, test := range tests {
-		actual := IsPositive(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected IsPositive(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestIsNonPositive(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected bool
-	}{
-		{0, true},
-		{-1, true},
-		{10, false},
-		{3.14, false},
-		{-96, true},
-		{-10e-12, true},
-	}
-	for _, test := range tests {
-		actual := IsNonPositive(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected IsNonPositive(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestIsWhole(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected bool
-	}{
-		{0, true},
-		{-1, true},
-		{10, true},
-		{3.14, false},
-		{-96, true},
-		{-10e-12, false},
-	}
-	for _, test := range tests {
-		actual := IsWhole(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected IsWhole(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestIsNatural(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		expected bool
-	}{
-		{0, false},
-		{-1, false},
-		{10, true},
-		{3.14, false},
-		{96, true},
-		{-10e-12, false},
-	}
-	for _, test := range tests {
-		actual := IsNatural(test.param)
-		if actual != test.expected {
-			t.Errorf("Expected IsNatural(%v) to be %v, got %v", test.param, test.expected, actual)
-		}
-	}
-}
-
-func TestInRangeInt(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    int
-		left     int
-		right    int
-		expected bool
-	}{
-		{0, 0, 0, true},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, true},
-		{0, 0, 1, true},
-		{0, -1, 0, true},
-		{0, 0, -1, true},
-		{0, 10, 5, false},
-	}
-	for _, test := range tests {
-		actual := InRangeInt(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRangeInt(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-}
-
-func TestInRangeFloat32(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float32
-		left     float32
-		right    float32
-		expected bool
-	}{
-		{0, 0, 0, true},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, true},
-		{0, 0, 1, true},
-		{0, -1, 0, true},
-		{0, 0, -1, true},
-		{0, 10, 5, false},
-	}
-	for _, test := range tests {
-		actual := InRangeFloat32(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRangeFloat32(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-}
-
-func TestInRangeFloat64(t *testing.T) {
-	t.Parallel()
-
-	var tests = []struct {
-		param    float64
-		left     float64
-		right    float64
-		expected bool
-	}{
-		{0, 0, 0, true},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, true},
-		{0, 0, 1, true},
-		{0, -1, 0, true},
-		{0, 0, -1, true},
-		{0, 10, 5, false},
-	}
-	for _, test := range tests {
-		actual := InRangeFloat64(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRangeFloat64(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-}
-
-func TestInRange(t *testing.T) {
-	t.Parallel()
-
-	var testsInt = []struct {
-		param    int
-		left     int
-		right    int
-		expected bool
-	}{
-		{0, 0, 0, true},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, true},
-		{0, 0, 1, true},
-		{0, -1, 0, true},
-		{0, 0, -1, true},
-		{0, 10, 5, false},
-	}
-	for _, test := range testsInt {
-		actual := InRange(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-
-	var testsFloat32 = []struct {
-		param    float32
-		left     float32
-		right    float32
-		expected bool
-	}{
-		{0, 0, 0, true},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, true},
-		{0, 0, 1, true},
-		{0, -1, 0, true},
-		{0, 0, -1, true},
-		{0, 10, 5, false},
-	}
-	for _, test := range testsFloat32 {
-		actual := InRange(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-
-	var testsFloat64 = []struct {
-		param    float64
-		left     float64
-		right    float64
-		expected bool
-	}{
-		{0, 0, 0, true},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, true},
-		{0, 0, 1, true},
-		{0, -1, 0, true},
-		{0, 0, -1, true},
-		{0, 10, 5, false},
-	}
-	for _, test := range testsFloat64 {
-		actual := InRange(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-
-	var testsTypeMix = []struct {
-		param    int
-		left     float64
-		right    float64
-		expected bool
-	}{
-		{0, 0, 0, false},
-		{1, 0, 0, false},
-		{-1, 0, 0, false},
-		{0, -1, 1, false},
-		{0, 0, 1, false},
-		{0, -1, 0, false},
-		{0, 0, -1, false},
-		{0, 10, 5, false},
-	}
-	for _, test := range testsTypeMix {
-		actual := InRange(test.param, test.left, test.right)
-		if actual != test.expected {
-			t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual)
-		}
-	}
-}

vendor/github.com/asaskevich/govalidator/patterns.go

-package govalidator
-
-import "regexp"
-
-// Basic regular expressions for validating strings
-const (
-	Email          string = "^(((([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+(\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.)+(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.?$"
-	CreditCard     string = "^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})$"
-	ISBN10         string = "^(?:[0-9]{9}X|[0-9]{10})$"
-	ISBN13         string = "^(?:[0-9]{13})$"
-	UUID3          string = "^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$"
-	UUID4          string = "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-	UUID5          string = "^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-	UUID           string = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
-	Alpha          string = "^[a-zA-Z]+$"
-	Alphanumeric   string = "^[a-zA-Z0-9]+$"
-	Numeric        string = "^[0-9]+$"
-	Int            string = "^(?:[-+]?(?:0|[1-9][0-9]*))$"
-	Float          string = "^(?:[-+]?(?:[0-9]+))?(?:\\.[0-9]*)?(?:[eE][\\+\\-]?(?:[0-9]+))?$"
-	Hexadecimal    string = "^[0-9a-fA-F]+$"
-	Hexcolor       string = "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
-	RGBcolor       string = "^rgb\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*\\)$"
-	ASCII          string = "^[\x00-\x7F]+$"
-	Multibyte      string = "[^\x00-\x7F]"
-	FullWidth      string = "[^\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]"
-	HalfWidth      string = "[\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]"
-	Base64         string = "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{4})$"
-	PrintableASCII string = "^[\x20-\x7E]+$"
-	DataURI        string = "^data:.+\\/(.+);base64$"
-	Latitude       string = "^[-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?)$"
-	Longitude      string = "^[-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?)$"
-	DNSName        string = `^([a-zA-Z0-9_]{1}[a-zA-Z0-9_-]{0,62}){1}(\.[a-zA-Z0-9_]{1}[a-zA-Z0-9_-]{0,62})*[\._]?$`
-	IP             string = `(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))`
-	URLSchema      string = `((ftp|tcp|udp|wss?|https?):\/\/)`
-	URLUsername    string = `(\S+(:\S*)?@)`
-	URLPath        string = `((\/|\?|#)[^\s]*)`
-	URLPort        string = `(:(\d{1,5}))`
-	URLIP          string = `([1-9]\d?|1\d\d|2[01]\d|22[0-3])(\.(1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.([0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))`
-	URLSubdomain   string = `((www\.)|([a-zA-Z0-9]([-\.][-\._a-zA-Z0-9]+)*))`
-	URL            string = `^` + URLSchema + `?` + URLUsername + `?` + `((` + URLIP + `|(\[` + IP + `\])|(([a-zA-Z0-9]([a-zA-Z0-9-_]+)?[a-zA-Z0-9]([-\.][a-zA-Z0-9]+)*)|(` + URLSubdomain + `?))?(([a-zA-Z\x{00a1}-\x{ffff}0-9]+-?-?)*[a-zA-Z\x{00a1}-\x{ffff}0-9]+)(?:\.([a-zA-Z\x{00a1}-\x{ffff}]{1,}))?))\.?` + URLPort + `?` + URLPath + `?$`
-	SSN            string = `^\d{3}[- ]?\d{2}[- ]?\d{4}$`
-	WinPath        string = `^[a-zA-Z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*$`
-	UnixPath       string = `^(/[^/\x00]*)+/?$`
-	Semver         string = "^v?(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(-(0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(\\.(0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\\+[0-9a-zA-Z-]+(\\.[0-9a-zA-Z-]+)*)?$"
-	tagName        string = "valid"
-)
-
-// Used by IsFilePath func
-const (
-	// Unknown is unresolved OS type
-	Unknown = iota
-	// Win is Windows type
-	Win
-	// Unix is *nix OS types
-	Unix
-)
-
-var (
-	rxEmail          = regexp.MustCompile(Email)
-	rxCreditCard     = regexp.MustCompile(CreditCard)
-	rxISBN10         = regexp.MustCompile(ISBN10)
-	rxISBN13         = regexp.MustCompile(ISBN13)
-	rxUUID3          = regexp.MustCompile(UUID3)
-	rxUUID4          = regexp.MustCompile(UUID4)
-	rxUUID5          = regexp.MustCompile(UUID5)
-	rxUUID           = regexp.MustCompile(UUID)
-	rxAlpha          = regexp.MustCompile(Alpha)
-	rxAlphanumeric   = regexp.MustCompile(Alphanumeric)
-	rxNumeric        = regexp.MustCompile(Numeric)
-	rxInt            = regexp.MustCompile(Int)
-	rxFloat          = regexp.MustCompile(Float)
-	rxHexadecimal    = regexp.MustCompile(Hexadecimal)
-	rxHexcolor       = regexp.MustCompile(Hexcolor)
-	rxRGBcolor       = regexp.MustCompile(RGBcolor)
-	rxASCII          = regexp.MustCompile(ASCII)
-	rxPrintableASCII = regexp.MustCompile(PrintableASCII)
-	rxMultibyte      = regexp.MustCompile(Multibyte)
-	rxFullWidth      = regexp.MustCompile(FullWidth)
-	rxHalfWidth      = regexp.MustCompile(HalfWidth)
-	rxBase64         = regexp.MustCompile(Base64)
-	rxDataURI        = regexp.MustCompile(DataURI)
-	rxLatitude       = regexp.MustCompile(Latitude)
-	rxLongitude      = regexp.MustCompile(Longitude)
-	rxDNSName        = regexp.MustCompile(DNSName)
-	rxURL            = regexp.MustCompile(URL)
-	rxSSN            = regexp.MustCompile(SSN)
-	rxWinPath        = regexp.MustCompile(WinPath)
-	rxUnixPath       = regexp.MustCompile(UnixPath)
-	rxSemver         = regexp.MustCompile(Semver)
-)

vendor/github.com/asaskevich/govalidator/utils.go

-package govalidator
-
-import (
-	"errors"
-	"fmt"
-	"html"
-	"math"
-	"path"
-	"regexp"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-// Contains check if the string contains the substring.
-func Contains(str, substring string) bool {
-	return strings.Contains(str, substring)
-}
-
-// Matches check if string matches the pattern (pattern is regular expression)
-// In case of error return false
-func Matches(str, pattern string) bool {
-	match, _ := regexp.MatchString(pattern, str)
-	return match
-}
-
-// LeftTrim trim characters from the left-side of the input.
-// If second argument is empty, it's will be remove leading spaces.
-func LeftTrim(str, chars string) string {
-	if chars == "" {
-		return strings.TrimLeftFunc(str, unicode.IsSpace)
-	}
-	r, _ := regexp.Compile("^[" + chars + "]+")
-	return r.ReplaceAllString(str, "")
-}
-
-// RightTrim trim characters from the right-side of the input.
-// If second argument is empty, it's will be remove spaces.
-func RightTrim(str, chars string) string {
-	if chars == "" {
-		return strings.TrimRightFunc(str, unicode.IsSpace)
-	}
-	r, _ := regexp.Compile("[" + chars + "]+$")
-	return r.ReplaceAllString(str, "")
-}
-
-// Trim trim characters from both sides of the input.
-// If second argument is empty, it's will be remove spaces.
-func Trim(str, chars string) string {
-	return LeftTrim(RightTrim(str, chars), chars)
-}
-
-// WhiteList remove characters that do not appear in the whitelist.
-func WhiteList(str, chars string) string {
-	pattern := "[^" + chars + "]+"
-	r, _ := regexp.Compile(pattern)
-	return r.ReplaceAllString(str, "")
-}
-
-// BlackList remove characters that appear in the blacklist.
-func BlackList(str, chars string) string {
-	pattern := "[" + chars + "]+"
-	r, _ := regexp.Compile(pattern)
-	return r.ReplaceAllString(str, "")
-}
-
-// StripLow remove characters with a numerical value < 32 and 127, mostly control characters.
-// If keep_new_lines is true, newline characters are preserved (\n and \r, hex 0xA and 0xD).
-func StripLow(str string, keepNewLines bool) string {
-	chars := ""
-	if keepNewLines {
-		chars = "\x00-\x09\x0B\x0C\x0E-\x1F\x7F"
-	} else {
-		chars = "\x00-\x1F\x7F"
-	}
-	return BlackList(str, chars)
-}
-
-// ReplacePattern replace regular expression pattern in string
-func ReplacePattern(str, pattern, replace string) string {
-	r, _ := regexp.Compile(pattern)
-	return r.ReplaceAllString(str, replace)
-}
-
-// Escape replace <, >, & and " with HTML entities.
-var Escape = html.EscapeString
-
-func addSegment(inrune, segment []rune) []rune {
-	if len(segment) == 0 {
-		return inrune
-	}
-	if len(inrune) != 0 {
-		inrune = append(inrune, '_')
-	}
-	inrune = append(inrune, segment...)
-	return inrune
-}
-
-// UnderscoreToCamelCase converts from underscore separated form to camel case form.
-// Ex.: my_func => MyFunc
-func UnderscoreToCamelCase(s string) string {
-	return strings.Replace(strings.Title(strings.Replace(strings.ToLower(s), "_", " ", -1)), " ", "", -1)
-}
-
-// CamelCaseToUnderscore converts from camel case form to underscore separated form.
-// Ex.: MyFunc => my_func
-func CamelCaseToUnderscore(str string) string {
-	var output []rune
-	var segment []rune
-	for _, r := range str {
-		if !unicode.IsLower(r) && string(r) != "_" {
-			output = addSegment(output, segment)
-			segment = nil
-		}
-		segment = append(segment, unicode.ToLower(r))
-	}
-	output = addSegment(output, segment)
-	return string(output)
-}
-
-// Reverse return reversed string
-func Reverse(s string) string {
-	r := []rune(s)
-	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
-		r[i], r[j] = r[j], r[i]
-	}
-	return string(r)
-}
-
-// GetLines split string by "\n" and return array of lines
-func GetLines(s string) []string {
-	return strings.Split(s, "\n")
-}
-
-// GetLine return specified line of multiline string
-func GetLine(s string, index int) (string, error) {
-	lines := GetLines(s)
-	if index < 0 || index >= len(lines) {
-		return "", errors.New("line index out of bounds")
-	}
-	return lines[index], nil
-}
-
-// RemoveTags remove all tags from HTML string
-func RemoveTags(s string) string {
-	return ReplacePattern(s, "<[^>]*>", "")
-}
-
-// SafeFileName return safe string that can be used in file names
-func SafeFileName(str string) string {
-	name := strings.ToLower(str)
-	name = path.Clean(path.Base(name))
-	name = strings.Trim(name, " ")
-	separators, err := regexp.Compile(`[ &_=+:]`)
-	if err == nil {
-		name = separators.ReplaceAllString(name, "-")
-	}
-	legal, err := regexp.Compile(`[^[:alnum:]-.]`)
-	if err == nil {
-		name = legal.ReplaceAllString(name, "")
-	}
-	for strings.Contains(name, "--") {
-		name = strings.Replace(name, "--", "-", -1)
-	}
-	return name
-}
-
-// NormalizeEmail canonicalize an email address.
-// The local part of the email address is lowercased for all domains; the hostname is always lowercased and
-// the local part of the email address is always lowercased for hosts that are known to be case-insensitive (currently only GMail).
-// Normalization follows special rules for known providers: currently, GMail addresses have dots removed in the local part and
-// are stripped of tags (e.g. some.one+tag@gmail.com becomes someone@gmail.com) and all @googlemail.com addresses are
-// normalized to @gmail.com.
-func NormalizeEmail(str string) (string, error) {
-	if !IsEmail(str) {
-		return "", fmt.Errorf("%s is not an email", str)
-	}
-	parts := strings.Split(str, "@")
-	parts[0] = strings.ToLower(parts[0])
-	parts[1] = strings.ToLower(parts[1])
-	if parts[1] == "gmail.com" || parts[1] == "googlemail.com" {
-		parts[1] = "gmail.com"
-		parts[0] = strings.Split(ReplacePattern(parts[0], `\.`, ""), "+")[0]
-	}
-	return strings.Join(parts, "@"), nil
-}
-
-// Truncate a string to the closest length without breaking words.
-func Truncate(str string, length int, ending string) string {
-	var aftstr, befstr string
-	if len(str) > length {
-		words := strings.Fields(str)
-		before, present := 0, 0
-		for i := range words {
-			befstr = aftstr
-			before = present
-			aftstr = aftstr + words[i] + " "
-			present = len(aftstr)
-			if present > length && i != 0 {
-				if (length - before) < (present - length) {
-					return Trim(befstr, " /\\.,\"'#!?&@+-") + ending
-				}
-				return Trim(aftstr, " /\\.,\"'#!?&@+-") + ending
-			}
-		}
-	}
-
-	return str
-}
-
-// PadLeft pad left side of string if size of string is less then indicated pad length
-func PadLeft(str string, padStr string, padLen int) string {
-	return buildPadStr(str, padStr, padLen, true, false)
-}
-
-// PadRight pad right side of string if size of string is less then indicated pad length
-func PadRight(str string, padStr string, padLen int) string {
-	return buildPadStr(str, padStr, padLen, false, true)
-}
-
-// PadBoth pad sides of string if size of string is less then indicated pad length
-func PadBoth(str string, padStr string, padLen int) string {
-	return buildPadStr(str, padStr, padLen, true, true)
-}
-
-// PadString either left, right or both sides, not the padding string can be unicode and more then one
-// character
-func buildPadStr(str string, padStr string, padLen int, padLeft bool, padRight bool) string {
-
-	// When padded length is less then the current string size
-	if padLen < utf8.RuneCountInString(str) {
-		return str
-	}
-
-	padLen -= utf8.RuneCountInString(str)
-
-	targetLen := padLen
-
-	targetLenLeft := targetLen
-	targetLenRight := targetLen
-	if padLeft && padRight {
-		targetLenLeft = padLen / 2
-		targetLenRight = padLen - targetLenLeft
-	}
-
-	strToRepeatLen := utf8.RuneCountInString(padStr)
-
-	repeatTimes := int(math.Ceil(float64(targetLen) / float64(strToRepeatLen)))
-	repeatedString := strings.Repeat(padStr, repeatTimes)
-
-	leftSide := ""
-	if padLeft {
-		leftSide = repeatedString[0:targetLenLeft]
-	}
-
-	rightSide := ""
-	if padRight {
-		rightSide = repeatedString[0:targetLenRight]
-	}
-
-	return leftSide + str + rightSide
-}

vendor/github.com/asaskevich/govalidator/wercker.yml

-box: golang
-build:
-  steps:
-    - setup-go-workspace
-
-    - script:
-        name: go get
-        code: |
-          go version
-          go get -t ./...
-
-    - script:
-        name: go test
-        code: |
-          go test -race ./...

vendor/github.com/coreos/etcd/.gitignore

 /agent-*
 /coverage
+/covdir
 /gopath
 /gopath.proto
 /go-bindata
+/release
 /machine*
 /bin
+.Dockerfile-test
 .vagrant
 *.etcd
+*.log
 /etcd
 *.swp
 /hack/insta-discovery/.env
 *.test
 tools/functional-tester/docker/bin
+hack/scripts-dev/docker-dns/.Dockerfile
+hack/scripts-dev/docker-dns-srv/.Dockerfile
 hack/tls-setup/certs
 .idea

vendor/github.com/coreos/etcd/.semaphore.sh

@@ -2,7 +2,7 @@
 
 TEST_SUFFIX=$(date +%s | base64 | head -c 15)
 
-TEST_OPTS="RELEASE_TEST=y INTEGRATION=y PASSES='build unit release integration_e2e functional' MANUAL_VER=v3.2.9"
+TEST_OPTS="RELEASE_TEST=y INTEGRATION=y PASSES='build unit release integration_e2e functional' MANUAL_VER=v3.2.11"
 if [ "$TEST_ARCH" == "386" ]; then
 	TEST_OPTS="GOARCH=386 PASSES='build unit integration_e2e'"
 fi
@@ -13,4 +13,4 @@ docker run \
 	gcr.io/etcd-development/etcd-test:go1.8.5 \
 	/bin/bash -c "${TEST_OPTS} ./test 2>&1 | tee test-${TEST_SUFFIX}.log"
 
-! egrep "(--- FAIL:|panic: test timed out|appears to have leaked|Too many goroutines)" -B50 -A10 test-${TEST_SUFFIX}.log
+! egrep "(--- FAIL:|panic: test timed out|appears to have leaked)" -B50 -A10 test-${TEST_SUFFIX}.log

vendor/github.com/coreos/etcd/glide.lock

-hash: 94008ff434d6e211d8dbd412d81f123c5f43bb41b5267a50612ff34b8879b796
-updated: 2017-12-04T14:22:51.678346-08:00
+hash: 57308341a6ff76ce7960119ca6f589d2f5476c056f1f38f9a32552d9e68509d8
+updated: 2017-12-19T13:02:46.509863-08:00
 imports:
 - name: github.com/beorn7/perks
   version: 4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9
@@ -149,7 +149,7 @@ imports:
   - googleapis/api/annotations
   - googleapis/rpc/status
 - name: google.golang.org/grpc
-  version: 9a2334748bab9638f1480ad4f0ac6ac0c6c3a486
+  version: 5b3c4e850e90a4cf6a20ebd46c8b32a0a3afcb9e
   subpackages:
   - balancer
   - codes

vendor/github.com/coreos/etcd/glide.yaml

@@ -40,7 +40,7 @@ import:
 - package: github.com/google/btree
   version: 925471ac9e2131377a91e1595defec898166fe49
 - package: github.com/grpc-ecosystem/grpc-gateway
-  version: v1.3
+  version: v1.3.0
   subpackages:
   - runtime
   - runtime/internal
@@ -97,7 +97,7 @@ import:
   subpackages:
   - rate
 - package: google.golang.org/grpc
-  version: v1.7.4
+  version: v1.7.5
   subpackages:
   - codes
   - credentials

vendor/github.com/coreos/etcd/test

@@ -148,7 +148,7 @@ function e2e_pass {
 
 function integration_extra {
 	go test -timeout 15m -v ${RACE} -cpu 1,2,4 "$@" "${REPO_PATH}/client/integration"
-	go test -timeout 15m -v ${RACE} -cpu 1,2,4 "$@" "${REPO_PATH}/clientv3/integration"
+	go test -timeout 20m -v ${RACE} -cpu 1,2,4 "$@" "${REPO_PATH}/clientv3/integration"
 }
 
 function integration_e2e_pass {

vendor/github.com/coreos/etcd/version/version.go

@@ -26,7 +26,7 @@ import (
 var (
 	// MinClusterVersion is the min cluster version this etcd binary is compatible with.
 	MinClusterVersion = "3.0.0"
-	Version           = "3.2.11"
+	Version           = "3.2.13"
 	APIVersion        = "unknown"
 
 	// Git SHA Value will be set during build

vendor/github.com/docker/distribution/.gitignore

-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof
-
-# never checkin from the bin file (for now)
-bin/*
-
-# Test key files
-*.pem
-
-# Cover profiles
-*.out
-
-# Editor/IDE specific files.
-*.sublime-project
-*.sublime-workspace

vendor/github.com/docker/distribution/.mailmap

-Stephen J Day <stephen.day@docker.com>  Stephen Day <stevvooe@users.noreply.github.com>
-Stephen J Day <stephen.day@docker.com>  Stephen Day <stevvooe@gmail.com>
-Olivier Gambier <olivier@docker.com>    Olivier Gambier <dmp42@users.noreply.github.com>
-Brian Bland <brian.bland@docker.com>    Brian Bland <r4nd0m1n4t0r@gmail.com>
-Brian Bland <brian.bland@docker.com> Brian Bland <brian.t.bland@gmail.com>
-Josh Hawn <josh.hawn@docker.com>        Josh Hawn <jlhawn@berkeley.edu>
-Richard Scothern <richard.scothern@docker.com> Richard <richard.scothern@gmail.com>
-Richard Scothern <richard.scothern@docker.com> Richard Scothern <richard.scothern@gmail.com>
-Andrew Meredith <andymeredith@gmail.com> Andrew Meredith <kendru@users.noreply.github.com>
-harche <p.harshal@gmail.com> harche <harche@users.noreply.github.com>
-Jessie Frazelle <jessie@docker.com>  <jfrazelle@users.noreply.github.com>
-Sharif Nassar <sharif@mrwacky.com> Sharif Nassar <mrwacky42@users.noreply.github.com>
-Sven Dowideit <SvenDowideit@home.org.au> Sven Dowideit <SvenDowideit@users.noreply.github.com>
-Vincent Giersch <vincent.giersch@ovh.net> Vincent Giersch <vincent@giersch.fr>
-davidli <wenquan.li@hp.com> davidli <wenquan.li@hpe.com>
-Omer Cohen <git@omer.io> Omer Cohen <git@omerc.net>
-Eric Yang <windfarer@gmail.com> Eric Yang <Windfarer@users.noreply.github.com>
-Nikita Tarasov <nikita@mygento.ru> Nikita <luckyraul@users.noreply.github.com>
-Misty Stanley-Jones <misty@docker.com>  Misty Stanley-Jones <misty@apache.org>

vendor/github.com/docker/distribution/AUTHORS

-Aaron Lehmann <aaron.lehmann@docker.com>
-Aaron Schlesinger <aschlesinger@deis.com>
-Aaron Vinson <avinson.public@gmail.com>
-Adam Duke <adam.v.duke@gmail.com>
-Adam Enger <adamenger@gmail.com>
-Adrian Mouat <adrian.mouat@gmail.com>
-Ahmet Alp Balkan <ahmetalpbalkan@gmail.com>
-Alex Chan <alex.chan@metaswitch.com>
-Alex Elman <aelman@indeed.com>
-Alexey Gladkov <gladkov.alexey@gmail.com>
-allencloud <allen.sun@daocloud.io>
-amitshukla <ashukla73@hotmail.com>
-Amy Lindburg <amy.lindburg@docker.com>
-Andrew Hsu <andrewhsu@acm.org>
-Andrew Meredith <andymeredith@gmail.com>
-Andrew T Nguyen <andrew.nguyen@docker.com>
-Andrey Kostov <kostov.andrey@gmail.com>
-Andy Goldstein <agoldste@redhat.com>
-Anis Elleuch <vadmeste@gmail.com>
-Antonio Mercado <amercado@thinknode.com>
-Antonio Murdaca <runcom@redhat.com>
-Anton Tiurin <noxiouz@yandex.ru>
-Anusha Ragunathan <anusha@docker.com>
-a-palchikov <deemok@gmail.com>
-Arien Holthuizen <aholthuizen@schubergphilis.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Arthur Baars <arthur@semmle.com>
-Asuka Suzuki <hello@tanksuzuki.com>
-Avi Miller <avi.miller@oracle.com>
-Ayose Cazorla <ayosec@gmail.com>
-BadZen <dave.trombley@gmail.com>
-Ben Bodenmiller <bbodenmiller@hotmail.com>
-Ben Firshman <ben@firshman.co.uk>
-bin liu <liubin0329@gmail.com>
-Brian Bland <brian.bland@docker.com>
-burnettk <burnettk@gmail.com>
-Carson A <ca@carsonoid.net>
-Cezar Sa Espinola <cezarsa@gmail.com>
-Charles Smith <charles.smith@docker.com>
-Chris Dillon <squarism@gmail.com>
-cuiwei13 <cuiwei13@pku.edu.cn>
-cyli <cyli@twistedmatrix.com>
-Daisuke Fujita <dtanshi45@gmail.com>
-Daniel Huhn <daniel@danielhuhn.de>
-Darren Shepherd <darren@rancher.com>
-Dave Trombley <dave.trombley@gmail.com>
-Dave Tucker <dt@docker.com>
-David Lawrence <david.lawrence@docker.com>
-davidli <wenquan.li@hp.com>
-David Verhasselt <david@crowdway.com>
-David Xia <dxia@spotify.com>
-Dejan Golja <dejan@golja.org>
-Derek McGowan <derek@mcgstyle.net>
-Diogo Mónica <diogo.monica@gmail.com>
-DJ Enriquez <dj.enriquez@infospace.com>
-Donald Huang <don.hcd@gmail.com>
-Doug Davis <dug@us.ibm.com>
-Edgar Lee <edgar.lee@docker.com>
-Eric Yang <windfarer@gmail.com>
-Fabio Berchtold <jamesclonk@jamesclonk.ch>
-Fabio Huser <fabio@fh1.ch>
-farmerworking <farmerworking@gmail.com>
-Felix Yan <felixonmars@archlinux.org>
-Florentin Raud <florentin.raud@gmail.com>
-Frank Chen <frankchn@gmail.com>
-Frederick F. Kautz IV <fkautz@alumni.cmu.edu>
-gabriell nascimento <gabriell@bluesoft.com.br>
-Gleb Schukin <gschukin@ptsecurity.com>
-harche <p.harshal@gmail.com>
-Henri Gomez <henri.gomez@gmail.com>
-Hua Wang <wanghua.humble@gmail.com>
-Hu Keping <hukeping@huawei.com>
-HuKeping <hukeping@huawei.com>
-Ian Babrou <ibobrik@gmail.com>
-igayoso <igayoso@gmail.com>
-Jack Griffin <jackpg14@gmail.com>
-James Findley <jfindley@fastmail.com>
-Jason Freidman <jason.freidman@gmail.com>
-Jason Heiss <jheiss@aput.net>
-Jeff Nickoloff <jeff@allingeek.com>
-Jess Frazelle <acidburn@google.com>
-Jessie Frazelle <jessie@docker.com>
-jhaohai <jhaohai@foxmail.com>
-Jianqing Wang <tsing@jianqing.org>
-Jihoon Chung <jihoon@gmail.com>
-Joao Fernandes <joao.fernandes@docker.com>
-John Mulhausen <john@docker.com>
-John Starks <jostarks@microsoft.com>
-Jonathan Boulle <jonathanboulle@gmail.com>
-Jon Johnson <jonjohnson@google.com>
-Jon Poler <jonathan.poler@apcera.com>
-Jordan Liggitt <jliggitt@redhat.com>
-Josh Chorlton <josh.chorlton@docker.com>
-Josh Hawn <josh.hawn@docker.com>
-Julien Fernandez <julien.fernandez@gmail.com>
-Keerthan Mala <kmala@engineyard.com>
-Kelsey Hightower <kelsey.hightower@gmail.com>
-Kenneth Lim <kennethlimcp@gmail.com>
-Kenny Leung <kleung@google.com>
-Ke Xu <leonhartx.k@gmail.com>
-liuchang0812 <liuchang0812@gmail.com>
-Liu Hua <sdu.liu@huawei.com>
-Li Yi <denverdino@gmail.com>
-Lloyd Ramey <lnr0626@gmail.com>
-Louis Kottmann <louis.kottmann@gmail.com>
-Luke Carpenter <x@rubynerd.net>
-Marcus Martins <marcus@docker.com>
-Mary Anthony <mary@docker.com>
-Matt Bentley <mbentley@mbentley.net>
-Matt Duch <matt@learnmetrics.com>
-Matthew Green <greenmr@live.co.uk>
-Matt Moore <mattmoor@google.com>
-Matt Robenolt <matt@ydekproductions.com>
-Michael Prokop <mika@grml.org>
-Michal Minar <miminar@redhat.com>
-Michal Minář <miminar@redhat.com>
-Mike Brown <brownwm@us.ibm.com>
-Miquel Sabaté <msabate@suse.com>
-Misty Stanley-Jones <misty@docker.com>
-Morgan Bauer <mbauer@us.ibm.com>
-moxiegirl <mary@docker.com>
-Nathan Sullivan <nathan@nightsys.net>
-nevermosby <robolwq@qq.com>
-Nghia Tran <tcnghia@gmail.com>
-Nikita Tarasov <nikita@mygento.ru>
-Noah Treuhaft <noah.treuhaft@docker.com>
-Nuutti Kotivuori <nuutti.kotivuori@poplatek.fi>
-Oilbeater <liumengxinfly@gmail.com>
-Olivier Gambier <olivier@docker.com>
-Olivier Jacques <olivier.jacques@hp.com>
-Omer Cohen <git@omer.io>
-Patrick Devine <patrick.devine@docker.com>
-Phil Estes <estesp@linux.vnet.ibm.com>
-Philip Misiowiec <philip@atlashealth.com>
-Pierre-Yves Ritschard <pyr@spootnik.org>
-Qiao Anran <qiaoanran@gmail.com>
-Randy Barlow <randy@electronsweatshop.com>
-Richard Scothern <richard.scothern@docker.com>
-Rodolfo Carvalho <rhcarvalho@gmail.com>
-Rusty Conover <rusty@luckydinosaur.com>
-Sean Boran <Boran@users.noreply.github.com>
-Sebastiaan van Stijn <github@gone.nl>
-Sebastien Coavoux <s.coavoux@free.fr>
-Serge Dubrouski <sergeyfd@gmail.com>
-Sharif Nassar <sharif@mrwacky.com>
-Shawn Falkner-Horine <dreadpirateshawn@gmail.com>
-Shreyas Karnik <karnik.shreyas@gmail.com>
-Simon Thulbourn <simon+github@thulbourn.com>
-spacexnice <yaoyao.xyy@alibaba-inc.com>
-Spencer Rinehart <anubis@overthemonkey.com>
-Stan Hu <stanhu@gmail.com>
-Stefan Majewsky <stefan.majewsky@sap.com>
-Stefan Weil <sw@weilnetz.de>
-Stephen J Day <stephen.day@docker.com>
-Sungho Moon <sungho.moon@navercorp.com>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sylvain Baubeau <sbaubeau@redhat.com>
-Ted Reed <ted.reed@gmail.com>
-tgic <farmer1992@gmail.com>
-Thomas Sjögren <konstruktoid@users.noreply.github.com>
-Tianon Gravi <admwiggin@gmail.com>
-Tibor Vass <teabee89@gmail.com>
-Tonis Tiigi <tonistiigi@gmail.com>
-Tony Holdstock-Brown <tony@docker.com>
-Trevor Pounds <trevor.pounds@gmail.com>
-Troels Thomsen <troels@thomsen.io>
-Victoria Bialas <victoria.bialas@docker.com>
-Victor Vieux <vieux@docker.com>
-Vincent Batts <vbatts@redhat.com>
-Vincent Demeester <vincent@sbr.pm>
-Vincent Giersch <vincent.giersch@ovh.net>
-weiyuan.yl <weiyuan.yl@alibaba-inc.com>
-W. Trevor King <wking@tremily.us>
-xg.song <xg.song@venusource.com>
-xiekeyang <xiekeyang@huawei.com>
-Yann ROBERT <yann.robert@anantaplex.fr>
-yaoyao.xyy <yaoyao.xyy@alibaba-inc.com>
-yixi zhang <yixi@memsql.com>
-yuexiao-wang <wang.yuexiao@zte.com.cn>
-yuzou <zouyu7@huawei.com>
-zhouhaibing089 <zhouhaibing089@gmail.com>
-姜继忠 <jizhong.jiangjz@alibaba-inc.com>

vendor/github.com/docker/distribution/Dockerfile

-FROM golang:1.7-alpine
-
-ENV DISTRIBUTION_DIR /go/src/github.com/docker/distribution
-ENV DOCKER_BUILDTAGS include_oss include_gcs
-
-RUN set -ex \
-    && apk add --no-cache make git
-
-WORKDIR $DISTRIBUTION_DIR
-COPY . $DISTRIBUTION_DIR
-COPY cmd/registry/config-dev.yml /etc/docker/registry/config.yml
-
-RUN make PREFIX=/go clean binaries
-
-VOLUME ["/var/lib/registry"]
-EXPOSE 5000
-ENTRYPOINT ["registry"]
-CMD ["serve", "/etc/docker/registry/config.yml"]

vendor/github.com/docker/distribution/coverpkg.sh

-#!/usr/bin/env bash
-# Given a subpackage and the containing package, figures out which packages
-# need to be passed to `go test -coverpkg`:  this includes all of the
-# subpackage's dependencies within the containing package, as well as the
-# subpackage itself.
-DEPENDENCIES="$(go list -f $'{{range $f := .Deps}}{{$f}}\n{{end}}' ${1} | grep ${2} | grep -v github.com/docker/distribution/vendor)"
-echo "${1} ${DEPENDENCIES}" | xargs echo -n | tr ' ' ','

vendor/github.com/docker/distribution/digest/digester_resumable_test.go

-// +build !noresumabledigest
-
-package digest
-
-import (
-	"testing"
-
-	"github.com/stevvooe/resumable"
-	_ "github.com/stevvooe/resumable/sha256"
-)
-
-// TestResumableDetection just ensures that the resumable capability of a hash
-// is exposed through the digester type, which is just a hash plus a Digest
-// method.
-func TestResumableDetection(t *testing.T) {
-	d := Canonical.New()
-
-	if _, ok := d.Hash().(resumable.Hash); !ok {
-		t.Fatalf("expected digester to implement resumable.Hash: %#v, %v", d, d.Hash())
-	}
-}