Skip to content

GitLab

Commit f462635a authored by ale's avatar ale
Browse files
Options

Upgrade more dependencies

parent 9e4b95f8
Pipeline #1430 passed with stages
          in 1 minute and 40 seconds
          Expand all Hide whitespace changes
          Inline Side-by-side
          Showing with 2242 additions and 14729 deletions
          vendor/github.com/cenkalti/backoff/context.go
          View file @ f462635a
          ......@@ -51,9 +51,13 @@ func (b *backOffContext) Context() context.Context {
          func (b *backOffContext) NextBackOff() time.Duration {
          select {
          case <-b.Context().Done():
          case <-b.ctx.Done():
          return Stop
          default:
          return b.BackOff.NextBackOff()
          }
          next := b.BackOff.NextBackOff()
          if deadline, ok := b.ctx.Deadline(); ok && deadline.Sub(time.Now()) < next {
          return Stop
          }
          return next
          }
          vendor/github.com/cenkalti/backoff/exponential.go
          View file @ f462635a
          ......@@ -63,7 +63,6 @@ type ExponentialBackOff struct {
          currentInterval time.Duration
          startTime time.Time
          random *rand.Rand
          }
          // Clock is an interface that returns current time for BackOff.
          ......@@ -89,7 +88,6 @@ func NewExponentialBackOff() *ExponentialBackOff {
          MaxInterval: DefaultMaxInterval,
          MaxElapsedTime: DefaultMaxElapsedTime,
          Clock: SystemClock,
          random: rand.New(rand.NewSource(time.Now().UnixNano())),
          }
          b.Reset()
          return b
          ......@@ -118,10 +116,7 @@ func (b *ExponentialBackOff) NextBackOff() time.Duration {
          return Stop
          }
          defer b.incrementCurrentInterval()
          if b.random == nil {
          b.random = rand.New(rand.NewSource(time.Now().UnixNano()))
          }
          return getRandomValueFromInterval(b.RandomizationFactor, b.random.Float64(), b.currentInterval)
          return getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval)
          }
          // GetElapsedTime returns the elapsed time since an ExponentialBackOff instance
          ......
          vendor/github.com/cenkalti/backoff/retry.go
          View file @ f462635a
          ......@@ -41,7 +41,7 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
          return permanent.Err
          }
          if next = b.NextBackOff(); next == Stop {
          if next = cb.NextBackOff(); next == Stop {
          return err
          }
          ......
          vendor/github.com/gogo/protobuf/LICENSE deleted 100644 → 0
          View file @ 9e4b95f8
          Copyright (c) 2013, The GoGo Authors. All rights reserved.
          Protocol Buffers for Go with Gadgets
          Go support for Protocol Buffers - Google's data interchange format
          Copyright 2010 The Go Authors. All rights reserved.
          https://github.com/golang/protobuf
          Redistribution and use in source and binary forms, with or without
          modification, are permitted provided that the following conditions are
          met:
          * Redistributions of source code must retain the above copyright
          notice, this list of conditions and the following disclaimer.
          * Redistributions in binary form must reproduce the above
          copyright notice, this list of conditions and the following disclaimer
          in the documentation and/or other materials provided with the
          distribution.
          * Neither the name of Google Inc. nor the names of its
          contributors may be used to endorse or promote products derived from
          this software without specific prior written permission.
          THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          vendor/github.com/gogo/protobuf/proto/Makefile deleted 100644 → 0
          View file @ 9e4b95f8
          # Go support for Protocol Buffers - Google's data interchange format
          #
          # Copyright 2010 The Go Authors. All rights reserved.
          # https://github.com/golang/protobuf
          #
          # Redistribution and use in source and binary forms, with or without
          # modification, are permitted provided that the following conditions are
          # met:
          #
          # * Redistributions of source code must retain the above copyright
          # notice, this list of conditions and the following disclaimer.
          # * Redistributions in binary form must reproduce the above
          # copyright notice, this list of conditions and the following disclaimer
          # in the documentation and/or other materials provided with the
          # distribution.
          # * Neither the name of Google Inc. nor the names of its
          # contributors may be used to endorse or promote products derived from
          # this software without specific prior written permission.
          #
          # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          install:
          go install
          test: install generate-test-pbs
          go test
          generate-test-pbs:
          make install
          make -C test_proto
          make -C proto3_proto
          make
          vendor/github.com/gogo/protobuf/proto/clone.go deleted 100644 → 0
          View file @ 9e4b95f8
          // Go support for Protocol Buffers - Google's data interchange format
          //
          // Copyright 2011 The Go Authors. All rights reserved.
          // https://github.com/golang/protobuf
          //
          // Redistribution and use in source and binary forms, with or without
          // modification, are permitted provided that the following conditions are
          // met:
          //
          // * Redistributions of source code must retain the above copyright
          // notice, this list of conditions and the following disclaimer.
          // * Redistributions in binary form must reproduce the above
          // copyright notice, this list of conditions and the following disclaimer
          // in the documentation and/or other materials provided with the
          // distribution.
          // * Neither the name of Google Inc. nor the names of its
          // contributors may be used to endorse or promote products derived from
          // this software without specific prior written permission.
          //
          // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          // Protocol buffer deep copy and merge.
          // TODO: RawMessage.
          package proto
          import (
          "fmt"
          "log"
          "reflect"
          "strings"
          )
          // Clone returns a deep copy of a protocol buffer.
          func Clone(src Message) Message {
          in := reflect.ValueOf(src)
          if in.IsNil() {
          return src
          }
          out := reflect.New(in.Type().Elem())
          dst := out.Interface().(Message)
          Merge(dst, src)
          return dst
          }
          // Merger is the interface representing objects that can merge messages of the same type.
          type Merger interface {
          // Merge merges src into this message.
          // Required and optional fields that are set in src will be set to that value in dst.
          // Elements of repeated fields will be appended.
          //
          // Merge may panic if called with a different argument type than the receiver.
          Merge(src Message)
          }
          // generatedMerger is the custom merge method that generated protos will have.
          // We must add this method since a generate Merge method will conflict with
          // many existing protos that have a Merge data field already defined.
          type generatedMerger interface {
          XXX_Merge(src Message)
          }
          // Merge merges src into dst.
          // Required and optional fields that are set in src will be set to that value in dst.
          // Elements of repeated fields will be appended.
          // Merge panics if src and dst are not the same type, or if dst is nil.
          func Merge(dst, src Message) {
          if m, ok := dst.(Merger); ok {
          m.Merge(src)
          return
          }
          in := reflect.ValueOf(src)
          out := reflect.ValueOf(dst)
          if out.IsNil() {
          panic("proto: nil destination")
          }
          if in.Type() != out.Type() {
          panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
          }
          if in.IsNil() {
          return // Merge from nil src is a noop
          }
          if m, ok := dst.(generatedMerger); ok {
          m.XXX_Merge(src)
          return
          }
          mergeStruct(out.Elem(), in.Elem())
          }
          func mergeStruct(out, in reflect.Value) {
          sprop := GetProperties(in.Type())
          for i := 0; i < in.NumField(); i++ {
          f := in.Type().Field(i)
          if strings.HasPrefix(f.Name, "XXX_") {
          continue
          }
          mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
          }
          if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {
          emOut := out.Addr().Interface().(extensionsBytes)
          bIn := emIn.GetExtensions()
          bOut := emOut.GetExtensions()
          *bOut = append(*bOut, *bIn...)
          } else if emIn, err := extendable(in.Addr().Interface()); err == nil {
          emOut, _ := extendable(out.Addr().Interface())
          mIn, muIn := emIn.extensionsRead()
          if mIn != nil {
          mOut := emOut.extensionsWrite()
          muIn.Lock()
          mergeExtension(mOut, mIn)
          muIn.Unlock()
          }
          }
          uf := in.FieldByName("XXX_unrecognized")
          if !uf.IsValid() {
          return
          }
          uin := uf.Bytes()
          if len(uin) > 0 {
          out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
          }
          }
          // mergeAny performs a merge between two values of the same type.
          // viaPtr indicates whether the values were indirected through a pointer (implying proto2).
          // prop is set if this is a struct field (it may be nil).
          func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
          if in.Type() == protoMessageType {
          if !in.IsNil() {
          if out.IsNil() {
          out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
          } else {
          Merge(out.Interface().(Message), in.Interface().(Message))
          }
          }
          return
          }
          switch in.Kind() {
          case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
          reflect.String, reflect.Uint32, reflect.Uint64:
          if !viaPtr && isProto3Zero(in) {
          return
          }
          out.Set(in)
          case reflect.Interface:
          // Probably a oneof field; copy non-nil values.
          if in.IsNil() {
          return
          }
          // Allocate destination if it is not set, or set to a different type.
          // Otherwise we will merge as normal.
          if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
          out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
          }
          mergeAny(out.Elem(), in.Elem(), false, nil)
          case reflect.Map:
          if in.Len() == 0 {
          return
          }
          if out.IsNil() {
          out.Set(reflect.MakeMap(in.Type()))
          }
          // For maps with value types of *T or []byte we need to deep copy each value.
          elemKind := in.Type().Elem().Kind()
          for _, key := range in.MapKeys() {
          var val reflect.Value
          switch elemKind {
          case reflect.Ptr:
          val = reflect.New(in.Type().Elem().Elem())
          mergeAny(val, in.MapIndex(key), false, nil)
          case reflect.Slice:
          val = in.MapIndex(key)
          val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
          default:
          val = in.MapIndex(key)
          }
          out.SetMapIndex(key, val)
          }
          case reflect.Ptr:
          if in.IsNil() {
          return
          }
          if out.IsNil() {
          out.Set(reflect.New(in.Elem().Type()))
          }
          mergeAny(out.Elem(), in.Elem(), true, nil)
          case reflect.Slice:
          if in.IsNil() {
          return
          }
          if in.Type().Elem().Kind() == reflect.Uint8 {
          // []byte is a scalar bytes field, not a repeated field.
          // Edge case: if this is in a proto3 message, a zero length
          // bytes field is considered the zero value, and should not
          // be merged.
          if prop != nil && prop.proto3 && in.Len() == 0 {
          return
          }
          // Make a deep copy.
          // Append to []byte{} instead of []byte(nil) so that we never end up
          // with a nil result.
          out.SetBytes(append([]byte{}, in.Bytes()...))
          return
          }
          n := in.Len()
          if out.IsNil() {
          out.Set(reflect.MakeSlice(in.Type(), 0, n))
          }
          switch in.Type().Elem().Kind() {
          case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
          reflect.String, reflect.Uint32, reflect.Uint64:
          out.Set(reflect.AppendSlice(out, in))
          default:
          for i := 0; i < n; i++ {
          x := reflect.Indirect(reflect.New(in.Type().Elem()))
          mergeAny(x, in.Index(i), false, nil)
          out.Set(reflect.Append(out, x))
          }
          }
          case reflect.Struct:
          mergeStruct(out, in)
          default:
          // unknown type, so not a protocol buffer
          log.Printf("proto: don't know how to copy %v", in)
          }
          }
          func mergeExtension(out, in map[int32]Extension) {
          for extNum, eIn := range in {
          eOut := Extension{desc: eIn.desc}
          if eIn.value != nil {
          v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
          mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
          eOut.value = v.Interface()
          }
          if eIn.enc != nil {
          eOut.enc = make([]byte, len(eIn.enc))
          copy(eOut.enc, eIn.enc)
          }
          out[extNum] = eOut
          }
          }
          vendor/github.com/gogo/protobuf/proto/custom_gogo.go deleted 100644 → 0
          View file @ 9e4b95f8
          // Protocol Buffers for Go with Gadgets
          //
          // Copyright (c) 2018, The GoGo Authors. All rights reserved.
          // http://github.com/gogo/protobuf
          //
          // Redistribution and use in source and binary forms, with or without
          // modification, are permitted provided that the following conditions are
          // met:
          //
          // * Redistributions of source code must retain the above copyright
          // notice, this list of conditions and the following disclaimer.
          // * Redistributions in binary form must reproduce the above
          // copyright notice, this list of conditions and the following disclaimer
          // in the documentation and/or other materials provided with the
          // distribution.
          //
          // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          package proto
          import "reflect"
          type custom interface {
          Marshal() ([]byte, error)
          Unmarshal(data []byte) error
          Size() int
          }
          var customType = reflect.TypeOf((*custom)(nil)).Elem()
          vendor/github.com/gogo/protobuf/proto/decode.go deleted 100644 → 0
          View file @ 9e4b95f8
          // Go support for Protocol Buffers - Google's data interchange format
          //
          // Copyright 2010 The Go Authors. All rights reserved.
          // https://github.com/golang/protobuf
          //
          // Redistribution and use in source and binary forms, with or without
          // modification, are permitted provided that the following conditions are
          // met:
          //
          // * Redistributions of source code must retain the above copyright
          // notice, this list of conditions and the following disclaimer.
          // * Redistributions in binary form must reproduce the above
          // copyright notice, this list of conditions and the following disclaimer
          // in the documentation and/or other materials provided with the
          // distribution.
          // * Neither the name of Google Inc. nor the names of its
          // contributors may be used to endorse or promote products derived from
          // this software without specific prior written permission.
          //
          // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
          // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
          // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
          // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
          // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
          // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
          // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
          // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
          // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
          // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          package proto
          /*
          * Routines for decoding protocol buffer data to construct in-memory representations.
          */
          import (
          "errors"
          "fmt"
          "io"
          )
          // errOverflow is returned when an integer is too large to be represented.
          var errOverflow = errors.New("proto: integer overflow")
          // ErrInternalBadWireType is returned by generated code when an incorrect
          // wire type is encountered. It does not get returned to user code.
          var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
          // DecodeVarint reads a varint-encoded integer from the slice.
          // It returns the integer and the number of bytes consumed, or
          // zero if there is not enough.
          // This is the format for the
          // int32, int64, uint32, uint64, bool, and enum
          // protocol buffer types.
          func DecodeVarint(buf []byte) (x uint64, n int) {
          for shift := uint(0); shift < 64; shift += 7 {
          if n >= len(buf) {
          return 0, 0
          }
          b := uint64(buf[n])
          n++
          x |= (b & 0x7F) << shift
          if (b & 0x80) == 0 {
          return x, n
          }
          }
          // The number is too large to represent in a 64-bit value.
          return 0, 0
          }
          func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
          i := p.index
          l := len(p.buf)
          for shift := uint(0); shift < 64; shift += 7 {
          if i >= l {
          err = io.ErrUnexpectedEOF
          return
          }
          b := p.buf[i]
          i++
          x |= (uint64(b) & 0x7F) << shift
          if b < 0x80 {
          p.index = i
          return
          }
          }
          // The number is too large to represent in a 64-bit value.
          err = errOverflow
          return
          }
          // DecodeVarint reads a varint-encoded integer from the Buffer.
          // This is the format for the
          // int32, int64, uint32, uint64, bool, and enum
          // protocol buffer types.
          func (p *Buffer) DecodeVarint() (x uint64, err error) {
          i := p.index
          buf := p.buf
          if i >= len(buf) {
          return 0, io.ErrUnexpectedEOF
          } else if buf[i] < 0x80 {
          p.index++
          return uint64(buf[i]), nil
          } else if len(buf)-i < 10 {
          return p.decodeVarintSlow()
          }
          var b uint64
          // we already checked the first byte
          x = uint64(buf[i]) - 0x80
          i++
          b = uint64(buf[i])
          i++
          x += b << 7
          if b&0x80 == 0 {
          goto done
          }
          x -= 0x80 << 7
          b = uint64(buf[i])
          i++
          x += b << 14
          if b&0x80 == 0 {
          goto done
          }
          x -= 0x80 << 14
          b = uint64(buf[i])
          i++
          x += b << 21
          if b&0x80 == 0 {
          goto done