update cadvisor to v0.31.0

vendor/github.com/Rican7/retry/.travis.yml

@@ -0,0 +1,39 @@
+language: go
+
+go:
+    - 1.6
+    - tip
+
+sudo: false
+
+before_install:
+    # Install tools necessary to report code-coverage to Coveralls.io
+    - go get github.com/mattn/goveralls
+
+    # Export some environment variables
+    - export GO_TEST_COVERAGE_FILE_NAME='coverage.out'
+
+install:
+    # Get all imported packages
+    - make install-deps install-deps-dev
+
+    # Basic build errors
+    - make build
+
+script:
+    # Lint
+    - make format-lint
+    - make import-lint
+    - make copyright-lint
+
+    # Run tests
+    - make test-with-coverage-profile
+
+after_success:
+    # Report our code-coverage to Coveralls.io
+    - goveralls -service=travis-ci -coverprofile="${GO_TEST_COVERAGE_FILE_NAME}"
+
+matrix:
+    allow_failures:
+        - go: tip
+    fast_finish: true

vendor/github.com/Rican7/retry/BUILD

@@ -0,0 +1,29 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["retry.go"],
+    importmap = "k8s.io/kubernetes/vendor/github.com/Rican7/retry",
+    importpath = "github.com/Rican7/retry",
+    visibility = ["//visibility:public"],
+    deps = ["//vendor/github.com/Rican7/retry/strategy:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//vendor/github.com/Rican7/retry/backoff:all-srcs",
+        "//vendor/github.com/Rican7/retry/jitter:all-srcs",
+        "//vendor/github.com/Rican7/retry/strategy:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Rican7/retry/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2016 Trevor N. Suarez (Rican7)
+
+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.

vendor/github.com/Rican7/retry/Makefile

@@ -0,0 +1,83 @@
+# Define some VCS context
+PARENT_BRANCH ?= master
+
+# Set the mode for code-coverage
+GO_TEST_COVERAGE_MODE ?= count
+GO_TEST_COVERAGE_FILE_NAME ?= coverage.out
+
+# Set flags for `gofmt`
+GOFMT_FLAGS ?= -s
+
+# Set a default `min_confidence` value for `golint`
+GOLINT_MIN_CONFIDENCE ?= 0.3
+
+
+all: install-deps build install
+
+clean:
+	go clean -i -x ./...
+
+build:
+	go build -v ./...
+
+install:
+	go install ./...
+
+install-deps:
+	go get -d -t ./...
+
+install-deps-dev: install-deps
+	go get github.com/golang/lint/golint
+	go get golang.org/x/tools/cmd/goimports
+
+update-deps:
+	go get -d -t -u ./...
+
+update-deps-dev: update-deps
+	go get -u github.com/golang/lint/golint
+	go get -u golang.org/x/tools/cmd/goimports
+
+test:
+	go test -v ./...
+
+test-with-coverage:
+	go test -cover ./...
+
+test-with-coverage-formatted:
+	go test -cover ./... | column -t | sort -r
+
+test-with-coverage-profile:
+	echo "mode: ${GO_TEST_COVERAGE_MODE}" > ${GO_TEST_COVERAGE_FILE_NAME}
+	for package in $$(go list ./...); do \
+		go test -covermode ${GO_TEST_COVERAGE_MODE} -coverprofile "coverage_$${package##*/}.out" "$${package}"; \
+		sed '1d' "coverage_$${package##*/}.out" >> ${GO_TEST_COVERAGE_FILE_NAME}; \
+	done
+
+format-lint:
+	errors=$$(gofmt -l ${GOFMT_FLAGS} .); if [ "$${errors}" != "" ]; then echo "$${errors}"; exit 1; fi
+
+import-lint:
+	errors=$$(goimports -l .); if [ "$${errors}" != "" ]; then echo "$${errors}"; exit 1; fi
+
+style-lint:
+	errors=$$(golint -min_confidence=${GOLINT_MIN_CONFIDENCE} ./...); if [ "$${errors}" != "" ]; then echo "$${errors}"; exit 1; fi
+
+copyright-lint:
+	@old_dates=$$(git diff --diff-filter=ACMRTUXB --name-only "${PARENT_BRANCH}" | xargs grep -E '[Cc]opyright(\s+)[©Cc]?(\s+)[0-9]{4}' | grep -E -v "[Cc]opyright(\s+)[©Cc]?(\s+)$$(date '+%Y')"); if [ "$${old_dates}" != "" ]; then printf "The following files contain outdated copyrights:\n$${old_dates}\n\nThis can be fixed with 'make copyright-fix'\n"; exit 1; fi
+
+lint: install-deps-dev format-lint import-lint style-lint copyright-lint
+
+format-fix:
+	gofmt -w ${GOFMT_FLAGS} .
+
+import-fix:
+	goimports -w .
+
+copyright-fix:
+	@git diff --diff-filter=ACMRTUXB --name-only "${PARENT_BRANCH}" | xargs -I '_FILENAME' -- sh -c 'sed -i.bak "s/\([Cc]opyright\([[:space:]][©Cc]\{0,1\}[[:space:]]*\)\)[0-9]\{4\}/\1"$$(date '+%Y')"/g" _FILENAME && rm _FILENAME.bak'
+
+vet:
+	go vet ./...
+
+
+.PHONY: all clean build install install-deps install-deps-dev update-deps update-deps-dev test test-with-coverage test-with-coverage-formatted test-with-coverage-profile format-lint import-lint style-lint copyright-lint lint format-fix import-fix copyright-fix vet

vendor/github.com/Rican7/retry/README.md

@@ -0,0 +1,101 @@
+# retry
+
+[![Build Status](https://travis-ci.org/Rican7/retry.svg?branch=master)](https://travis-ci.org/Rican7/retry)
+[![Coverage Status](https://coveralls.io/repos/github/Rican7/retry/badge.svg)](https://coveralls.io/github/Rican7/retry)
+[![Go Report Card](https://goreportcard.com/badge/Rican7/retry)](http://goreportcard.com/report/Rican7/retry)
+[![GoDoc](https://godoc.org/github.com/Rican7/retry?status.png)](https://godoc.org/github.com/Rican7/retry)
+[![Latest Stable Version](https://img.shields.io/github/release/Rican7/retry.svg?style=flat)](https://github.com/Rican7/retry/releases)
+
+A simple, stateless, functional mechanism to perform actions repetitively until successful.
+
+
+## Project Status
+
+This project is currently in "pre-release". While the code is heavily tested, the API may change.
+Vendor (commit or lock) this dependency if you plan on using it.
+
+
+## Install
+
+`go get github.com/Rican7/retry`
+
+
+## Examples
+
+### Basic
+
+```go
+retry.Retry(func(attempt uint) error {
+	return nil // Do something that may or may not cause an error
+})
+```
+
+### File Open
+
+```go
+const logFilePath = "/var/log/myapp.log"
+
+var logFile *os.File
+
+err := retry.Retry(func(attempt uint) error {
+	var err error
+
+	logFile, err = os.Open(logFilePath)
+
+	return err
+})
+
+if nil != err {
+	log.Fatalf("Unable to open file %q with error %q", logFilePath, err)
+}
+
+logFile.Chdir() // Do something with the file
+```
+
+### HTTP request with strategies and backoff
+
+```go
+var response *http.Response
+
+action := func(attempt uint) error {
+	var err error
+
+	response, err = http.Get("https://api.github.com/repos/Rican7/retry")
+
+	if nil == err && nil != response && response.StatusCode > 200 {
+		err = fmt.Errorf("failed to fetch (attempt #%d) with status code: %d", attempt, response.StatusCode)
+	}
+
+	return err
+}
+
+err := retry.Retry(
+	action,
+	strategy.Limit(5),
+	strategy.Backoff(backoff.Fibonacci(10*time.Millisecond)),
+)
+
+if nil != err {
+	log.Fatalf("Failed to fetch repository with error %q", err)
+}
+```
+
+### Retry with backoff jitter
+
+```go
+action := func(attempt uint) error {
+	return errors.New("something happened")
+}
+
+seed := time.Now().UnixNano()
+random := rand.New(rand.NewSource(seed))
+
+retry.Retry(
+	action,
+	strategy.Limit(5),
+	strategy.BackoffWithJitter(
+		backoff.BinaryExponential(10*time.Millisecond),
+		jitter.Deviation(random, 0.5),
+	),
+)
+```

vendor/github.com/Rican7/retry/backoff/BUILD

@@ -0,0 +1,23 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["backoff.go"],
+    importmap = "k8s.io/kubernetes/vendor/github.com/Rican7/retry/backoff",
+    importpath = "github.com/Rican7/retry/backoff",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Rican7/retry/backoff/backoff.go

@@ -0,0 +1,67 @@
+// Package backoff provides stateless methods of calculating durations based on
+// a number of attempts made.
+//
+// Copyright © 2016 Trevor N. Suarez (Rican7)
+package backoff
+
+import (
+	"math"
+	"time"
+)
+
+// Algorithm defines a function that calculates a time.Duration based on
+// the given retry attempt number.
+type Algorithm func(attempt uint) time.Duration
+
+// Incremental creates a Algorithm that increments the initial duration
+// by the given increment for each attempt.
+func Incremental(initial, increment time.Duration) Algorithm {
+	return func(attempt uint) time.Duration {
+		return initial + (increment * time.Duration(attempt))
+	}
+}
+
+// Linear creates a Algorithm that linearly multiplies the factor
+// duration by the attempt number for each attempt.
+func Linear(factor time.Duration) Algorithm {
+	return func(attempt uint) time.Duration {
+		return (factor * time.Duration(attempt))
+	}
+}
+
+// Exponential creates a Algorithm that multiplies the factor duration by
+// an exponentially increasing factor for each attempt, where the factor is
+// calculated as the given base raised to the attempt number.
+func Exponential(factor time.Duration, base float64) Algorithm {
+	return func(attempt uint) time.Duration {
+		return (factor * time.Duration(math.Pow(base, float64(attempt))))
+	}
+}
+
+// BinaryExponential creates a Algorithm that multiplies the factor
+// duration by an exponentially increasing factor for each attempt, where the
+// factor is calculated as `2` raised to the attempt number (2^attempt).
+func BinaryExponential(factor time.Duration) Algorithm {
+	return Exponential(factor, 2)
+}
+
+// Fibonacci creates a Algorithm that multiplies the factor duration by
+// an increasing factor for each attempt, where the factor is the Nth number in
+// the Fibonacci sequence.
+func Fibonacci(factor time.Duration) Algorithm {
+	return func(attempt uint) time.Duration {
+		return (factor * time.Duration(fibonacciNumber(attempt)))
+	}
+}
+
+// fibonacciNumber calculates the Fibonacci sequence number for the given
+// sequence position.
+func fibonacciNumber(n uint) uint {
+	if 0 == n {
+		return 0
+	} else if 1 == n {
+		return 1
+	} else {
+		return fibonacciNumber(n-1) + fibonacciNumber(n-2)
+	}
+}

vendor/github.com/Rican7/retry/jitter/BUILD

@@ -0,0 +1,23 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["jitter.go"],
+    importmap = "k8s.io/kubernetes/vendor/github.com/Rican7/retry/jitter",
+    importpath = "github.com/Rican7/retry/jitter",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Rican7/retry/jitter/jitter.go

@@ -0,0 +1,89 @@
+// Package jitter provides methods of transforming durations.
+//
+// Copyright © 2016 Trevor N. Suarez (Rican7)
+package jitter
+
+import (
+	"math"
+	"math/rand"
+	"time"
+)
+
+// Transformation defines a function that calculates a time.Duration based on
+// the given duration.
+type Transformation func(duration time.Duration) time.Duration
+
+// Full creates a Transformation that transforms a duration into a result
+// duration in [0, n) randomly, where n is the given duration.
+//
+// The given generator is what is used to determine the random transformation.
+// If a nil generator is passed, a default one will be provided.
+//
+// Inspired by https://www.awsarchitectureblog.com/2015/03/backoff.html
+func Full(generator *rand.Rand) Transformation {
+	random := fallbackNewRandom(generator)
+
+	return func(duration time.Duration) time.Duration {
+		return time.Duration(random.Int63n(int64(duration)))
+	}
+}
+
+// Equal creates a Transformation that transforms a duration into a result
+// duration in [n/2, n) randomly, where n is the given duration.
+//
+// The given generator is what is used to determine the random transformation.
+// If a nil generator is passed, a default one will be provided.
+//
+// Inspired by https://www.awsarchitectureblog.com/2015/03/backoff.html
+func Equal(generator *rand.Rand) Transformation {
+	random := fallbackNewRandom(generator)
+
+	return func(duration time.Duration) time.Duration {
+		return (duration / 2) + time.Duration(random.Int63n(int64(duration))/2)
+	}
+}
+
+// Deviation creates a Transformation that transforms a duration into a result
+// duration that deviates from the input randomly by a given factor.
+//
+// The given generator is what is used to determine the random transformation.
+// If a nil generator is passed, a default one will be provided.
+//
+// Inspired by https://developers.google.com/api-client-library/java/google-http-java-client/backoff
+func Deviation(generator *rand.Rand, factor float64) Transformation {
+	random := fallbackNewRandom(generator)
+
+	return func(duration time.Duration) time.Duration {
+		min := int64(math.Floor(float64(duration) * (1 - factor)))
+		max := int64(math.Ceil(float64(duration) * (1 + factor)))
+
+		return time.Duration(random.Int63n(max-min) + min)
+	}
+}
+
+// NormalDistribution creates a Transformation that transforms a duration into a
+// result duration based on a normal distribution of the input and the given
+// standard deviation.
+//
+// The given generator is what is used to determine the random transformation.
+// If a nil generator is passed, a default one will be provided.
+func NormalDistribution(generator *rand.Rand, standardDeviation float64) Transformation {
+	random := fallbackNewRandom(generator)
+
+	return func(duration time.Duration) time.Duration {
+		return time.Duration(random.NormFloat64()*standardDeviation + float64(duration))
+	}
+}
+
+// fallbackNewRandom returns the passed in random instance if it's not nil,
+// and otherwise returns a new random instance seeded with the current time.
+func fallbackNewRandom(random *rand.Rand) *rand.Rand {
+	// Return the passed in value if it's already not null
+	if nil != random {
+		return random
+	}
+
+	seed := time.Now().UnixNano()
+
+	return rand.New(rand.NewSource(seed))
+}

vendor/github.com/Rican7/retry/retry.go

@@ -0,0 +1,36 @@
+// Package retry provides a simple, stateless, functional mechanism to perform
+// actions repetitively until successful.
+//
+// Copyright © 2016 Trevor N. Suarez (Rican7)
+package retry
+
+import "github.com/Rican7/retry/strategy"
+
+// Action defines a callable function that package retry can handle.
+type Action func(attempt uint) error
+
+// Retry takes an action and performs it, repetitively, until successful.
+//
+// Optionally, strategies may be passed that assess whether or not an attempt
+// should be made.
+func Retry(action Action, strategies ...strategy.Strategy) error {
+	var err error
+
+	for attempt := uint(0); (0 == attempt || nil != err) && shouldAttempt(attempt, strategies...); attempt++ {
+		err = action(attempt)
+	}
+
+	return err
+}
+
+// shouldAttempt evaluates the provided strategies with the given attempt to
+// determine if the Retry loop should make another attempt.
+func shouldAttempt(attempt uint, strategies ...strategy.Strategy) bool {
+	shouldAttempt := true
+
+	for i := 0; shouldAttempt && i < len(strategies); i++ {
+		shouldAttempt = shouldAttempt && strategies[i](attempt)
+	}
+
+	return shouldAttempt
+}

vendor/github.com/Rican7/retry/strategy/BUILD

@@ -0,0 +1,27 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["strategy.go"],
+    importmap = "k8s.io/kubernetes/vendor/github.com/Rican7/retry/strategy",
+    importpath = "github.com/Rican7/retry/strategy",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/Rican7/retry/backoff:go_default_library",
+        "//vendor/github.com/Rican7/retry/jitter:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Rican7/retry/strategy/strategy.go

@@ -0,0 +1,85 @@
+// Package strategy provides a way to change the way that retry is performed.
+//
+// Copyright © 2016 Trevor N. Suarez (Rican7)
+package strategy
+
+import (
+	"time"
+
+	"github.com/Rican7/retry/backoff"
+	"github.com/Rican7/retry/jitter"
+)
+
+// Strategy defines a function that Retry calls before every successive attempt
+// to determine whether it should make the next attempt or not. Returning `true`
+// allows for the next attempt to be made. Returning `false` halts the retrying
+// process and returns the last error returned by the called Action.
+//
+// The strategy will be passed an "attempt" number on each successive retry
+// iteration, starting with a `0` value before the first attempt is actually
+// made. This allows for a pre-action delay, etc.
+type Strategy func(attempt uint) bool
+
+// Limit creates a Strategy that limits the number of attempts that Retry will
+// make.
+func Limit(attemptLimit uint) Strategy {
+	return func(attempt uint) bool {
+		return (attempt <= attemptLimit)
+	}
+}
+
+// Delay creates a Strategy that waits the given duration before the first
+// attempt is made.
+func Delay(duration time.Duration) Strategy {
+	return func(attempt uint) bool {
+		if 0 == attempt {
+			time.Sleep(duration)
+		}
+
+		return true
+	}
+}
+
+// Wait creates a Strategy that waits the given durations for each attempt after
+// the first. If the number of attempts is greater than the number of durations
+// provided, then the strategy uses the last duration provided.
+func Wait(durations ...time.Duration) Strategy {
+	return func(attempt uint) bool {
+		if 0 < attempt && 0 < len(durations) {
+			durationIndex := int(attempt - 1)
+
+			if len(durations) <= durationIndex {
+				durationIndex = len(durations) - 1
+			}
+
+			time.Sleep(durations[durationIndex])
+		}
+
+		return true
+	}
+}
+
+// Backoff creates a Strategy that waits before each attempt, with a duration as
+// defined by the given backoff.Algorithm.
+func Backoff(algorithm backoff.Algorithm) Strategy {
+	return BackoffWithJitter(algorithm, noJitter())
+}
+
+// BackoffWithJitter creates a Strategy that waits before each attempt, with a
+// duration as defined by the given backoff.Algorithm and jitter.Transformation.
+func BackoffWithJitter(algorithm backoff.Algorithm, transformation jitter.Transformation) Strategy {
+	return func(attempt uint) bool {
+		if 0 < attempt {
+			time.Sleep(transformation(algorithm(attempt)))
+		}
+
+		return true
+	}
+}
+
+// noJitter creates a jitter.Transformation that simply returns the input.
+func noJitter() jitter.Transformation {
+	return func(duration time.Duration) time.Duration {
+		return duration
+	}
+}