sevenhill/QSfera
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bump google.golang.org/grpc from 1.58.3 to 1.59.0

Browse Source 
Bumps [google.golang.org/grpc](https://github.com/grpc/grpc-go) from 1.58.3 to 1.59.0.
- [Release notes](https://github.com/grpc/grpc-go/releases)
- [Commits](https://github.com/grpc/grpc-go/compare/v1.58.3...v1.59.0)

---
updated-dependencies:
- dependency-name: google.golang.org/grpc
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
This commit is contained in:
dependabot[bot]
2023-10-25 09:22:28 +02:00
committed by Ralf Haferkamp
parent 1bdb3dbb2b
commit 1fd333ce3c
29 changed files with 387 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/github.com/golang/glog/glog.go
Generated Vendored
-29
View File
@@ -92,7 +92,6 @@ import (
"strconv"
"sync"
"sync/atomic"
"syscall"
"time"
"github.com/golang/glog/internal/logsink"
@@ -524,34 +523,6 @@ func fatalf(depth int, format string, args ...any) {
os.Exit(2) // Exit with the same code as the default SIGABRT handler.
}
// abortProcess attempts to kill the current process in a way that will dump the
// currently-running goroutines someplace useful (Coroner or stderr).
//
// It does this by sending SIGABRT to the current process. Unfortunately, the
// signal may or may not be delivered to the current thread; in order to do that
// portably, we would need to add a cgo dependency and call pthread_kill.
//
// If successful, abortProcess does not return.
func abortProcess() error {
p, err := os.FindProcess(os.Getpid())
if err != nil {
return err
}
if err := p.Signal(syscall.SIGABRT); err != nil {
return err
}
// Sent the signal. Now we wait for it to arrive and any SIGABRT handlers to
// run (and eventually terminate the process themselves).
//
// We could just "select{}" here, but there's an outside chance that would
// trigger the runtime's deadlock detector if there happen not to be any
// background goroutines running. So we'll sleep a while first to give
// the signal some time.
time.Sleep(10 * time.Second)
select {}
}
// Fatal logs to the FATAL, ERROR, WARNING, and INFO logs,
// including a stack trace of all running goroutines, then calls os.Exit(2).
// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
vendor/github.com/golang/glog/glog_file.go
Generated Vendored
+11 -5
View File
@@ -132,6 +132,11 @@ func create(tag string, t time.Time) (f *os.File, filename string, err error) {
symlink := filepath.Join(dir, link)
os.Remove(symlink) // ignore err
os.Symlink(name, symlink) // ignore err
if *logLink != "" {
lsymlink := filepath.Join(*logLink, link)
os.Remove(lsymlink) // ignore err
os.Symlink(fname, lsymlink) // ignore err
}
return f, fname, nil
}
lastErr = err
@@ -153,8 +158,6 @@ var sinks struct {
}
func init() {
sinks.stderr.w = os.Stderr
// Register stderr first: that way if we crash during file-writing at least
// the log will have gone somewhere.
logsink.TextSinks = append(logsink.TextSinks, &sinks.stderr, &sinks.file)
@@ -167,7 +170,7 @@ func init() {
// if they meet certain conditions.
type stderrSink struct {
mu sync.Mutex
w io.Writer
w io.Writer // if nil Emit uses os.Stderr directly
}
// Enabled implements logsink.Text.Enabled. It returns true if any of the
@@ -182,8 +185,11 @@ func (s *stderrSink) Enabled(m *logsink.Meta) bool {
func (s *stderrSink) Emit(m *logsink.Meta, data []byte) (n int, err error) {
s.mu.Lock()
defer s.mu.Unlock()
dn, err := s.w.Write(data)
w := s.w
if w == nil {
w = os.Stderr
}
dn, err := w.Write(data)
n += dn
return n, err
}
vendor/github.com/golang/glog/glog_file_linux.go
Generated Vendored
+39
View File
@@ -0,0 +1,39 @@
// Go support for leveled logs, analogous to https://github.com/google/glog.
//
// Copyright 2023 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build linux
package glog
import (
"errors"
"runtime"
"syscall"
)
// abortProcess attempts to kill the current process in a way that will dump the
// currently-running goroutines someplace useful (like stderr).
//
// It does this by sending SIGABRT to the current thread.
//
// If successful, abortProcess does not return.
func abortProcess() error {
runtime.LockOSThread()
if err := syscall.Tgkill(syscall.Getpid(), syscall.Gettid(), syscall.SIGABRT); err != nil {
return err
}
return errors.New("log: killed current thread with SIGABRT, but still running")
}
vendor/github.com/golang/glog/glog_file_other.go
Generated Vendored
+30
View File
@@ -0,0 +1,30 @@
// Go support for leveled logs, analogous to https://github.com/google/glog.
//
// Copyright 2023 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build !(unix || windows)
package glog
import (
"fmt"
"runtime"
)
// abortProcess returns an error on platforms that presumably don't support signals.
func abortProcess() error {
return fmt.Errorf("not sending SIGABRT (%s/%s does not support signals), falling back", runtime.GOOS, runtime.GOARCH)
}
vendor/github.com/golang/glog/glog_file_posix.go
Generated Vendored
+53
View File
@@ -0,0 +1,53 @@
// Go support for leveled logs, analogous to https://github.com/google/glog.
//
// Copyright 2023 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build (unix || windows) && !linux
package glog
import (
"os"
"syscall"
"time"
)
// abortProcess attempts to kill the current process in a way that will dump the
// currently-running goroutines someplace useful (like stderr).
//
// It does this by sending SIGABRT to the current process. Unfortunately, the
// signal may or may not be delivered to the current thread; in order to do that
// portably, we would need to add a cgo dependency and call pthread_kill.
//
// If successful, abortProcess does not return.
func abortProcess() error {
p, err := os.FindProcess(os.Getpid())
if err != nil {
return err
}
if err := p.Signal(syscall.SIGABRT); err != nil {
return err
}
// Sent the signal. Now we wait for it to arrive and any SIGABRT handlers to
// run (and eventually terminate the process themselves).
//
// We could just "select{}" here, but there's an outside chance that would
// trigger the runtime's deadlock detector if there happen not to be any
// background goroutines running. So we'll sleep a while first to give
// the signal some time.
time.Sleep(10 * time.Second)
select {}
}
vendor/github.com/golang/glog/glog_flags.go
Generated Vendored
+6 -3
View File
@@ -133,6 +133,11 @@ func (l *Level) Set(value string) error {
type vModuleFlag struct{ *verboseFlags }
func (f vModuleFlag) String() string {
// Do not panic on the zero value.
// https://groups.google.com/g/golang-nuts/c/Atlr8uAjn6U/m/iId17Td5BQAJ.
if f.verboseFlags == nil {
return ""
}
f.mu.Lock()
defer f.mu.Unlock()
@@ -192,9 +197,7 @@ func (f *verboseFlags) levelForPC(pc uintptr) Level {
file, _ := fn.FileLine(pc)
// The file is something like /a/b/c/d.go. We want just the d for
// regular matches, /a/b/c/d for full matches.
if strings.HasSuffix(file, ".go") {
file = file[:len(file)-3]
}
file = strings.TrimSuffix(file, ".go")
full := file
if slash := strings.LastIndex(file, "/"); slash >= 0 {
file = file[slash+1:]