Skip to content

GitLab

G
go-sso
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 4888 additions and 43401 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
          This diff is collapsed.
          vendor/github.com/gogo/protobuf/proto/discard.go deleted 100644 → 0
          View file @ 9e4b95f8
          This diff is collapsed.
          vendor/github.com/gogo/protobuf/proto/duration.go deleted 100644 → 0
          View file @ 9e4b95f8
          // Go support for Protocol Buffers - Google's data interchange format
          //
          // Copyright 2016 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
          // This file implements conversions between google.protobuf.Duration
          // and time.Duration.
          import (
          "errors"
          "fmt"
          "time"
          )
          const (
          // Range of a Duration in seconds, as specified in
          // google/protobuf/duration.proto. This is about 10,000 years in seconds.
          maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
          minSeconds = -maxSeconds
          )
          // validateDuration determines whether the Duration is valid according to the
          // definition in google/protobuf/duration.proto. A valid Duration
          // may still be too large to fit into a time.Duration (the range of Duration
          // is about 10,000 years, and the range of time.Duration is about 290).
          func validateDuration(d *duration) error {
          if d == nil {
          return errors.New("duration: nil Duration")
          }
          if d.Seconds < minSeconds || d.Seconds > maxSeconds {
          return fmt.Errorf("duration: %#v: seconds out of range", d)
          }
          if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
          return fmt.Errorf("duration: %#v: nanos out of range", d)
          }
          // Seconds and Nanos must have the same sign, unless d.Nanos is zero.
          if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
          return fmt.Errorf("duration: %#v: seconds and nanos have different signs", d)
          }
          return nil
          }
          // DurationFromProto converts a Duration to a time.Duration. DurationFromProto
          // returns an error if the Duration is invalid or is too large to be
          // represented in a time.Duration.
          func durationFromProto(p *duration) (time.Duration, error) {
          if err := validateDuration(p); err != nil {
          return 0, err
          }
          d := time.Duration(p.Seconds) * time.Second
          if int64(d/time.Second) != p.Seconds {
          return 0, fmt.Errorf("duration: %#v is out of range for time.Duration", p)
          }
          if p.Nanos != 0 {
          d += time.Duration(p.Nanos)
          if (d < 0) != (p.Nanos < 0) {
          return 0, fmt.Errorf("duration: %#v is out of range for time.Duration", p)
          }