Update kubernetes version to 759ba487b33a7566111622e19de607aba45a7342.
Signed-off-by: Lantao Liu <lantaol@google.com>
This commit is contained in:
Lantao Liu
parent
aa3635c75a
commit
e12da22015
@ -2,4 +2,4 @@ RUNC_VERSION=e775f0fba3ea329b8b766451c892c41a3d49594d
|
||||
CNI_VERSION=v0.6.0
|
||||
CONTAINERD_VERSION=c1c2aafffec89aefaff2ba80b81be2277b2903dd
|
||||
CRITEST_VERSION=d452f7fe9ef7ccc5ec63a8306cf838510cb83441
|
||||
KUBERNETES_VERSION=aa9417ce910a7f508c9e8575263c2b280343a704
|
||||
KUBERNETES_VERSION=759ba487b33a7566111622e19de607aba45a7342
|
||||
|
||||
@ -56,6 +56,6 @@ k8s.io/api f30e293246921de7f4ee46bb65b8762b2f890fc4
|
||||
k8s.io/apimachinery b166f81f5c4c88402ae23a0d0944c6ad08bffd3b
|
||||
k8s.io/apiserver b2a8ad67a002d27c8945573abb80b4be543f2a1f
|
||||
k8s.io/client-go db8228460e2de17f5d3a9a453f61dde0ba86545a
|
||||
k8s.io/kubernetes aa9417ce910a7f508c9e8575263c2b280343a704
|
||||
k8s.io/kubernetes 759ba487b33a7566111622e19de607aba45a7342
|
||||
k8s.io/utils 1f5ba483856f60b34bb29864d4129a8065d1c83b
|
||||
k8s.io/kube-openapi 2fbf05e337e56c983d9df1220b9e67cf132a1669 https://github.com/kubernetes/kube-openapi.git
|
||||
k8s.io/kube-openapi 2fbf05e337e56c983d9df1220b9e67cf132a1669
|
||||
|
||||
21
vendor/github.com/jpillora/backoff/LICENSE
generated
vendored
21
vendor/github.com/jpillora/backoff/LICENSE
generated
vendored
@ -1,21 +0,0 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2017 Jaime Pillora
|
||||
|
||||
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.
|
||||
119
vendor/github.com/jpillora/backoff/README.md
generated
vendored
119
vendor/github.com/jpillora/backoff/README.md
generated
vendored
@ -1,119 +0,0 @@
|
||||
# Backoff
|
||||
|
||||
A simple exponential backoff counter in Go (Golang)
|
||||
|
||||
[](https://godoc.org/github.com/jpillora/backoff) [](https://circleci.com/gh/jpillora/backoff)
|
||||
|
||||
### Install
|
||||
|
||||
```
|
||||
$ go get -v github.com/jpillora/backoff
|
||||
```
|
||||
|
||||
### Usage
|
||||
|
||||
Backoff is a `time.Duration` counter. It starts at `Min`. After every call to `Duration()` it is multiplied by `Factor`. It is capped at `Max`. It returns to `Min` on every call to `Reset()`. `Jitter` adds randomness ([see below](#example-using-jitter)). Used in conjunction with the `time` package.
|
||||
|
||||
---
|
||||
|
||||
#### Simple example
|
||||
|
||||
``` go
|
||||
|
||||
b := &backoff.Backoff{
|
||||
//These are the defaults
|
||||
Min: 100 * time.Millisecond,
|
||||
Max: 10 * time.Second,
|
||||
Factor: 2,
|
||||
Jitter: false,
|
||||
}
|
||||
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
|
||||
fmt.Printf("Reset!\n")
|
||||
b.Reset()
|
||||
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
```
|
||||
|
||||
```
|
||||
100ms
|
||||
200ms
|
||||
400ms
|
||||
Reset!
|
||||
100ms
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Example using `net` package
|
||||
|
||||
``` go
|
||||
b := &backoff.Backoff{
|
||||
Max: 5 * time.Minute,
|
||||
}
|
||||
|
||||
for {
|
||||
conn, err := net.Dial("tcp", "example.com:5309")
|
||||
if err != nil {
|
||||
d := b.Duration()
|
||||
fmt.Printf("%s, reconnecting in %s", err, d)
|
||||
time.Sleep(d)
|
||||
continue
|
||||
}
|
||||
//connected
|
||||
b.Reset()
|
||||
conn.Write([]byte("hello world!"))
|
||||
// ... Read ... Write ... etc
|
||||
conn.Close()
|
||||
//disconnected
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Example using `Jitter`
|
||||
|
||||
Enabling `Jitter` adds some randomization to the backoff durations. [See Amazon's writeup of performance gains using jitter](http://www.awsarchitectureblog.com/2015/03/backoff.html). Seeding is not necessary but doing so gives repeatable results.
|
||||
|
||||
```go
|
||||
import "math/rand"
|
||||
|
||||
b := &backoff.Backoff{
|
||||
Jitter: true,
|
||||
}
|
||||
|
||||
rand.Seed(42)
|
||||
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
|
||||
fmt.Printf("Reset!\n")
|
||||
b.Reset()
|
||||
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
fmt.Printf("%s\n", b.Duration())
|
||||
```
|
||||
|
||||
```
|
||||
100ms
|
||||
106.600049ms
|
||||
281.228155ms
|
||||
Reset!
|
||||
100ms
|
||||
104.381845ms
|
||||
214.957989ms
|
||||
```
|
||||
|
||||
#### Documentation
|
||||
|
||||
https://godoc.org/github.com/jpillora/backoff
|
||||
|
||||
#### Credits
|
||||
|
||||
Forked from some JavaScript written by [@tj](https://github.com/tj)
|
||||
88
vendor/github.com/jpillora/backoff/backoff.go
generated
vendored
88
vendor/github.com/jpillora/backoff/backoff.go
generated
vendored
@ -1,88 +0,0 @@
|
||||
// Package backoff provides an exponential-backoff implementation.
|
||||
package backoff
|
||||
|
||||
import (
|
||||
"math"
|
||||
"math/rand"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Backoff is a time.Duration counter, starting at Min. After every call to
|
||||
// the Duration method the current timing is multiplied by Factor, but it
|
||||
// never exceeds Max.
|
||||
//
|
||||
// Backoff is not generally concurrent-safe, but the ForAttempt method can
|
||||
// be used concurrently.
|
||||
type Backoff struct {
|
||||
//Factor is the multiplying factor for each increment step
|
||||
attempt, Factor float64
|
||||
//Jitter eases contention by randomizing backoff steps
|
||||
Jitter bool
|
||||
//Min and Max are the minimum and maximum values of the counter
|
||||
Min, Max time.Duration
|
||||
}
|
||||
|
||||
// Duration returns the duration for the current attempt before incrementing
|
||||
// the attempt counter. See ForAttempt.
|
||||
func (b *Backoff) Duration() time.Duration {
|
||||
d := b.ForAttempt(b.attempt)
|
||||
b.attempt++
|
||||
return d
|
||||
}
|
||||
|
||||
const maxInt64 = float64(math.MaxInt64 - 512)
|
||||
|
||||
// ForAttempt returns the duration for a specific attempt. This is useful if
|
||||
// you have a large number of independent Backoffs, but don't want use
|
||||
// unnecessary memory storing the Backoff parameters per Backoff. The first
|
||||
// attempt should be 0.
|
||||
//
|
||||
// ForAttempt is concurrent-safe.
|
||||
func (b *Backoff) ForAttempt(attempt float64) time.Duration {
|
||||
// Zero-values are nonsensical, so we use
|
||||
// them to apply defaults
|
||||
min := b.Min
|
||||
if min <= 0 {
|
||||
min = 100 * time.Millisecond
|
||||
}
|
||||
max := b.Max
|
||||
if max <= 0 {
|
||||
max = 10 * time.Second
|
||||
}
|
||||
if min >= max {
|
||||
// short-circuit
|
||||
return max
|
||||
}
|
||||
factor := b.Factor
|
||||
if factor <= 0 {
|
||||
factor = 2
|
||||
}
|
||||
//calculate this duration
|
||||
minf := float64(min)
|
||||
durf := minf * math.Pow(factor, attempt)
|
||||
if b.Jitter {
|
||||
durf = rand.Float64()*(durf-minf) + minf
|
||||
}
|
||||
//ensure float64 wont overflow int64
|
||||
if durf > maxInt64 {
|
||||
return max
|
||||
}
|
||||
dur := time.Duration(durf)
|
||||
//keep within bounds
|
||||
if dur < min {
|
||||
return min
|
||||
} else if dur > max {
|
||||
return max
|
||||
}
|
||||
return dur
|
||||
}
|
||||
|
||||
// Reset restarts the current attempt counter at zero.
|
||||
func (b *Backoff) Reset() {
|
||||
b.attempt = 0
|
||||
}
|
||||
|
||||
// Attempt returns the current attempt counter value.
|
||||
func (b *Backoff) Attempt() float64 {
|
||||
return b.attempt
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user