ston1th/vipman
0
0
Fork 0
Code Issues 2 Releases Activity

added etcd support

Browse source
This commit is contained in:
ston1th 2020-11-15 18:39:16 +01:00
commit 85a8ba23bd
21 changed files with 767 additions and 247 deletions
Download patch file Download diff file Expand all files Collapse all files

15
pkg/cluster/cluster.go
View file

@ -8,7 +8,8 @@ import (
)
type Cluster interface {
Start(logr.Logger, *config.Config) error
Start(*config.Config) error
SetCallbacks(Callbacks) error
Stepdown()
Stop()
}
@ -19,7 +20,13 @@ type KV interface {
Delete(k string) error
}
type Callbacks struct {
Leader func(context.Context, KV)
Follower func(context.Context, KV)
type CallbackContext interface {
logr.Logger
KV
ID() string
}
type Callbacks struct {
Leader func(context.Context, CallbackContext)
Follower func(context.Context, CallbackContext)
}

19
pkg/config/ca.go Normal file
View file

@ -0,0 +1,19 @@
package config
import (
"crypto/x509"
"io/ioutil"
)
func LoadCertPool(file string) (p *x509.CertPool, err error) {
if file == "" {
return
}
buf, err := ioutil.ReadFile(file)
if err != nil {
return
}
p = x509.NewCertPool()
p.AppendCertsFromPEM(buf)
return
}

87
pkg/config/config.go
View file

@ -4,13 +4,19 @@ import (
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"gopkg.in/yaml.v2"
)
const (
RaftDir = "raft"
RaftPort = 7001
RaftDir = "raft"
RaftPort = 7001
RaftLogLevel = "off"
EtcdLogLevel = "error"
EtcdPrefix = "/vipman"
)
func ParseFile(file string) (cfg *Config, err error) {
@ -35,14 +41,24 @@ func Validate(c *Config) error {
if len(c.VirtualIPs) == 0 {
return errors.New("missing virtualIPs config")
}
if c.LeaderHook != "" {
if !filepath.IsAbs(c.LeaderHook) {
return errors.New("leaderHook path must be absolute")
}
}
if c.FollowerHook != "" {
if !filepath.IsAbs(c.FollowerHook) {
return errors.New("followerHook path must be absolute")
}
}
raft := c.Cluster.Raft
if raft != nil {
if raft.LogLevel == "" {
raft.LogLevel = RaftLogLevel
}
if raft.Dir == "" {
raft.Dir = RaftDir
}
if raft.Level == "" {
raft.Level = "off"
}
if raft.ID == "" {
return errors.New("missing raft.id config")
}
@ -63,7 +79,29 @@ func Validate(c *Config) error {
}
etcd := c.Cluster.Etcd
if etcd != nil {
if etcd.LogLevel == "" {
etcd.LogLevel = EtcdLogLevel
}
if len(etcd.Endpoints) == 0 {
return errors.New("missing etcd.endpoints config")
}
if etcd.Prefix == "" {
etcd.Prefix = EtcdPrefix
} else {
if !strings.HasPrefix(etcd.Prefix, "/") {
etcd.Prefix = "/" + etcd.Prefix
}
if strings.HasSuffix(etcd.Prefix, "/") {
etcd.Prefix = strings.TrimSuffix(etcd.Prefix, "/")
}
}
if etcd.ClusterName == "" {
return errors.New("missing etcd.clusterName config")
} else {
if strings.HasSuffix(etcd.ClusterName, "/") {
etcd.ClusterName = strings.TrimSuffix(etcd.ClusterName, "/")
}
}
}
if raft == nil && etcd == nil {
return errors.New("missing cluster config: raft or etcd")
@ -75,17 +113,12 @@ func Validate(c *Config) error {
}
type Config struct {
VirtualIPs []string `yaml:"virtualIPs"`
Interface string `yaml:"interface,omitempty"`
IPLabel string `yaml:"label,omitempty"`
LeaderHook string `yaml:"leaderHook,omitempty"`
FollowerHook string `yaml:"followerHook,omitempty"`
Cluster Cluster `yaml:"cluster"`
VirtualIPs []string `yaml:"virtualIPs"`
Interface string `yaml:"interface,omitempty"`
Label string `yaml:"label,omitempty"`
LeaderHook string `yaml:"leaderHook,omitempty"`
FollowerHook string `yaml:"followerHook,omitempty"`
Cluster Cluster `yaml:"cluster"`
}
type Cluster struct {
@ -94,17 +127,17 @@ type Cluster struct {
}
type Raft struct {
Dir string `yaml:"dir,omitempty"`
ID string `yaml:"id"`
Address string `yaml:"address"`
Level string `yaml:"level"`
Peers []RaftPeer `yaml:"peers"`
TLS *TLS `yaml:"tls,omitempty"`
Dir string `yaml:"dir,omitempty"`
ID string `yaml:"id"`
Address string `yaml:"address"`
Peers []RaftPeer `yaml:"peers"`
TLS *TLS `yaml:"tls,omitempty"`
LogLevel string `yaml:"logLevel,omitempty"`
}
type TLS struct {
Cert string `yaml:"cert"`
Key string `yaml:"key"`
Cert string `yaml:"cert,omitempty"`
Key string `yaml:"key,omitempty"`
CA string `yaml:"ca,omitempty"`
Insecure bool `yaml:"insecure,omitempty"`
}
@ -119,4 +152,8 @@ type Etcd struct {
Endpoints []string `yaml:"endpoints"`
Prefix string `yaml:"prefix"`
ClusterName string `yaml:"clusterName"`
Username string `yaml:"username,omitempty"`
Password string `yaml:"password,omitempty"`
TLS *TLS `yaml:"tls,omitempty"`
LogLevel string `yaml:"logLevel,omitempty"`
}

88
pkg/controller/vip.go Normal file
View file

@ -0,0 +1,88 @@
package controller
import (
"context"
"os/exec"
"time"
"git.giftfish.de/ston1th/vipman/pkg/cluster"
"git.giftfish.de/ston1th/vipman/pkg/config"
"git.giftfish.de/ston1th/vipman/pkg/vip"
"github.com/go-logr/logr"
)
func NewVIPController(cfg *config.Config) (callbacks cluster.Callbacks, err error) {
n, err := vip.NewNetworkWithLabel(cfg.Interface, cfg.Label)
if err != nil {
return
}
callbacks = cluster.Callbacks{
Leader: func(ctx context.Context, cc cluster.CallbackContext) {
t := time.NewTicker(time.Second * 10)
if cfg.LeaderHook != "" {
go func() {
err := exec.CommandContext(ctx, cfg.LeaderHook).Run()
if err != nil {
cc.Error(err, "error running hook", "leaderHook", cfg.LeaderHook)
}
}()
}
for {
cc.Info("leading", "id", cc.ID())
addIPs(cc, n, cfg.VirtualIPs)
select {
case <-ctx.Done():
t.Stop()
deleteIPs(cc, n, cfg.VirtualIPs)
cc.Info("leading canceled", "id", cc.ID())
return
case <-t.C:
}
}
},
Follower: func(ctx context.Context, cc cluster.CallbackContext) {
t := time.NewTicker(time.Second * 10)
if cfg.FollowerHook != "" {
go func() {
err := exec.CommandContext(ctx, cfg.FollowerHook).Run()
if err != nil {
cc.Error(err, "error running hook", "followerHook", cfg.FollowerHook)
}
}()
}
for {
cc.Info("following", "id", cc.ID())
//TODO
//deleteIPs(cc, n, cfg.VirtualIPs)
select {
case <-ctx.Done():
t.Stop()
cc.Info("following canceled", "id", cc.ID())
return
case <-t.C:
}
}
},
}
return
}
func addIPs(log logr.Logger, n *vip.Network, cidrs []string) error {
for _, cidr := range cidrs {
err := n.AddIP(cidr)
if err != nil {
log.Error(err, "adding ip", "interface", n.Interface(), "ip", cidr)
}
}
return nil
}
func deleteIPs(log logr.Logger, n *vip.Network, cidrs []string) error {
for _, cidr := range cidrs {
err := n.DeleteIP(cidr)
if err != nil {
log.Error(err, "deleting ip", "interface", n.Interface(), "ip", cidr)
}
}
return nil
}

55
pkg/etcd/cluster.go Normal file
View file

@ -0,0 +1,55 @@
package etcd
import (
"errors"
"git.giftfish.de/ston1th/vipman/pkg/cluster"
//"go.etcd.io/etcd/clientv3"
"github.com/coreos/etcd/clientv3"
"github.com/go-logr/logr"
)
type Cluster struct {
logr.Logger
cluster.KV
cli *clientv3.Client
stepdown chan struct{}
stop chan struct{}
done chan struct{}
callbacks cluster.Callbacks
id string
keyID string
session bool
cancelSession func()
}
func NewCluster(log logr.Logger) cluster.Cluster {
return &Cluster{
Logger: log,
KV: &kv{},
stepdown: make(chan struct{}, 1),
stop: make(chan struct{}, 1),
done: make(chan struct{}, 1),
}
}
func (c *Cluster) SetCallbacks(callbacks cluster.Callbacks) error {
c.callbacks = callbacks
return c.checkConfig()
}
func (c *Cluster) ID() string {
return c.id
}
func (c *Cluster) checkConfig() error {
if c.callbacks.Leader == nil {
return errors.New("Leader callback is nil")
}
if c.callbacks.Follower == nil {
return errors.New("Follower callback is nil")
}
return nil
}

217
pkg/etcd/etcd.go Normal file
View file

@ -0,0 +1,217 @@
package etcd
import (
"context"
"crypto/tls"
"fmt"
"time"
"git.giftfish.de/ston1th/vipman/pkg/config"
"git.giftfish.de/ston1th/vipman/pkg/util"
"github.com/coreos/etcd/clientv3"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
//"go.etcd.io/etcd/clientv3"
"go.etcd.io/etcd/clientv3/concurrency"
)
func (c *Cluster) Start(etcdcfg *config.Config) error {
err := c.checkConfig()
if err != nil {
return err
}
cfg := etcdcfg.Cluster.Etcd
var level zapcore.Level
err = level.Set(cfg.LogLevel)
if err != nil {
return err
}
al := zap.NewAtomicLevel()
al.SetLevel(level)
var tlsConfig *tls.Config
if cfg.TLS != nil {
ca, err := config.LoadCertPool(cfg.TLS.CA)
if err != nil {
return err
}
tlsConfig = &tls.Config{
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: cfg.TLS.Insecure,
RootCAs: ca,
}
}
c.cli, err = clientv3.New(clientv3.Config{
Endpoints: cfg.Endpoints,
TLS: tlsConfig,
DialTimeout: time.Second * 5,
Username: cfg.Username,
Password: cfg.Password,
LogConfig: &zap.Config{
Level: al,
Encoding: "console",
DisableCaller: true,
DisableStacktrace: true,
EncoderConfig: zap.NewDevelopmentEncoderConfig(),
OutputPaths: []string{"stderr"},
ErrorOutputPaths: []string{"stderr"},
},
})
if err != nil {
return err
}
ctxSsession, cancelSession := context.WithCancel(context.Background())
c.cancelSession = cancelSession
s, err := concurrency.NewSession(c.cli,
concurrency.WithContext(ctxSsession),
concurrency.WithTTL(10),
)
if err != nil {
return err
}
c.session = true
prefix := cfg.Prefix + "/" + cfg.ClusterName
c.id = fmt.Sprintf("%x", s.Lease())
c.keyID = fmt.Sprintf("%s/%s", prefix, c.id)
e := concurrency.NewElection(s, prefix)
ctxCampaign, cancelCampaign := context.WithCancel(context.Background())
go func() {
errc := make(chan error, 1)
for {
go func() {
errc <- e.Campaign(ctxCampaign, "leader")
}()
select {
case err := <-errc:
if err != nil {
time.Sleep(time.Second)
}
case <-ctxCampaign.Done():
return
}
}
}()
t := time.NewTicker(time.Second)
ctx, cancel := context.WithCancel(context.Background())
ctxObserve, cancelObserve := context.WithCancel(context.Background())
leading := false
following := false
leaderChan := c.observe(ctxObserve, e.Observe(ctxObserve))
for {
if !leading && c.leaderID(e.Leader(ctxObserve)) == c.keyID {
leading = true
go c.leader(ctx)
} else if !following && !leading {
following = true
go c.follower(ctx)
}
select {
case <-t.C:
case leader := <-leaderChan:
if leader {
if following {
cancel()
following = false
ctx, cancel = context.WithCancel(context.Background())
}
if !leading {
leading = true
go c.leader(ctx)
}
} else {
if leading {
cancel()
leading = false
ctx, cancel = context.WithCancel(context.Background())
}
if !following {
following = true
go c.follower(ctx)
}
}
case <-c.stepdown:
cancel()
ctx, cancel = context.WithCancel(context.Background())
ctxResign, _ := context.WithTimeout(context.Background(), time.Second*2)
e.Resign(ctxResign)
case <-c.stop:
t.Stop()
cancelObserve()
cancelCampaign()
cancel()
if leading {
ctxResign, _ := context.WithTimeout(context.Background(), time.Second*2)
e.Resign(ctxResign)
}
s.Close()
close(c.done)
return nil
}
}
return nil
}
func (c *Cluster) leaderID(r *clientv3.GetResponse, err error) string {
if err != nil {
return ""
}
if len(r.Kvs) == 0 {
return ""
}
return string(r.Kvs[0].Key)
}
func (c *Cluster) observe(ctx context.Context, resp <-chan clientv3.GetResponse) <-chan bool {
leader := make(chan bool)
go func() {
for {
select {
case r := <-resp:
if c.leaderID(&r, nil) == c.keyID {
leader <- true
} else {
leader <- false
}
case <-ctx.Done():
return
}
}
}()
return leader
}
func (c *Cluster) Stepdown() {
select {
case c.stepdown <- struct{}{}:
case <-time.After(time.Second * 2):
}
}
func (c *Cluster) Stop() {
if !c.session {
c.cancelSession()
return
}
close(c.stop)
<-c.done
c.cli.Close()
}
func (c *Cluster) leader(ctx context.Context) {
defer func() {
util.HandleCrash()
}()
c.callbacks.Leader(ctx, c)
}
func (c *Cluster) follower(ctx context.Context) {
defer func() {
util.HandleCrash()
}()
c.callbacks.Follower(ctx, c)
}

18
pkg/etcd/kv.go Normal file
View file

@ -0,0 +1,18 @@
package etcd
//TODO
type kv struct {
}
func (kv *kv) Get(k string) []byte {
return nil
}
func (kv *kv) Set(k string, v []byte) error {
return nil
}
func (kv *kv) Delete(k string) error {
return nil
}

54
pkg/raft/cluster.go
View file

@ -4,33 +4,53 @@ import (
"errors"
"git.giftfish.de/ston1th/vipman/pkg/cluster"
"github.com/go-logr/logr"
"github.com/hashicorp/raft"
)
type Cluster struct {
kv *KV
r *raft.Raft
logr.Logger
cluster.KV
r *raft.Raft
kvm *kv
stepdown chan struct{}
stop chan struct{}
done chan struct{}
Callbacks cluster.Callbacks
callbacks cluster.Callbacks
id string
}
func NewCluster(callbacks cluster.Callbacks) (cluster.Cluster, error) {
if callbacks.Leader == nil {
return nil, errors.New("Leader is nil")
}
if callbacks.Follower == nil {
return nil, errors.New("Follower is nil")
func NewCluster(log logr.Logger) cluster.Cluster {
kvm := &kv{
m: make(map[string][]byte),
}
return &Cluster{
kv: &KV{
m: make(map[string][]byte),
},
stepdown: make(chan struct{}, 1),
stop: make(chan struct{}, 1),
done: make(chan struct{}, 1),
Callbacks: callbacks,
}, nil
Logger: log,
KV: kvm,
kvm: kvm,
stepdown: make(chan struct{}, 1),
stop: make(chan struct{}, 1),
done: make(chan struct{}, 1),
}
}
func (c *Cluster) ID() string {
return c.id
}
func (c *Cluster) SetCallbacks(callbacks cluster.Callbacks) error {
c.callbacks = callbacks
return c.checkConfig()
}
func (c *Cluster) checkConfig() error {
if c.callbacks.Leader == nil {
return errors.New("Leader callback is nil")
}
if c.callbacks.Follower == nil {
return errors.New("Follower callback is nil")
}
return nil
}

8
pkg/raft/fsm.go
View file

@ -27,7 +27,7 @@ type raftCmd struct {
V []byte
}
type fsm KV
type fsm kv
func (f *fsm) Apply(l *raft.Log) interface{} {
var c raftCmd
@ -49,7 +49,7 @@ func (f *fsm) Apply(l *raft.Log) interface{} {
func (f *fsm) Snapshot() (raft.FSMSnapshot, error) {
f.mu.Lock()
defer f.mu.Unlock()
m := make(kv)
m := make(kvm)
for k, v := range f.m {
m[k] = v
}
@ -57,7 +57,7 @@ func (f *fsm) Snapshot() (raft.FSMSnapshot, error) {
}
func (f *fsm) Restore(rc io.ReadCloser) error {
o := make(kv)
o := make(kvm)
if err := msgpack.NewDecoder(rc).Decode(&o); err != nil {
return err
}
@ -78,7 +78,7 @@ func (f *fsm) applyDelete(k string) {
}
type fsmSnapshot struct {
m kv
m kvm
}
func (f *fsmSnapshot) Persist(sink raft.SnapshotSink) error {

12
pkg/raft/kv.go
View file

@ -10,21 +10,21 @@ import (
var ErrNotLeader = errors.New("not leader")
type kv map[string][]byte
type kvm map[string][]byte
type KV struct {
type kv struct {
mu sync.Mutex
m kv
m kvm
r *raft.Raft
}
func (kv *KV) Get(k string) []byte {
func (kv *kv) Get(k string) []byte {
kv.mu.Lock()
defer kv.mu.Unlock()
return kv.m[k]
}
func (kv *KV) Set(k string, v []byte) error {
func (kv *kv) Set(k string, v []byte) error {
if kv.r.State() != raft.Leader {
return ErrNotLeader
}
@ -40,7 +40,7 @@ func (kv *KV) Set(k string, v []byte) error {
}
// Delete deletes the given key.
func (kv *KV) Delete(k string) error {
func (kv *kv) Delete(k string) error {
if kv.r.State() != raft.Leader {
return ErrNotLeader
}

74
pkg/raft/raft.go
View file

@ -4,32 +4,27 @@ import (
"context"
"fmt"
"net"
"net/http"
"os"
"path/filepath"
"runtime"
"time"
"git.giftfish.de/ston1th/raftbbolt"
"git.giftfish.de/ston1th/vipman/pkg/config"
"git.giftfish.de/ston1th/vipman/pkg/raft/tls"
"github.com/go-logr/logr"
"git.giftfish.de/ston1th/vipman/pkg/util"
hclog "github.com/hashicorp/go-hclog"
"github.com/hashicorp/raft"
"k8s.io/klog/v2"
)
type raftLog string
func (r *raftLog) Write(p []byte) (n int, err error) {
return os.Stdout.Write(append([]byte(*r), p...))
}
func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
func (c *Cluster) Start(raftcfg *config.Config) error {
err := c.checkConfig()
if err != nil {
return err
}
cfg := raftcfg.Cluster.Raft
hcl := hclog.New(&hclog.LoggerOptions{
Name: "raft",
Level: hclog.LevelFromString(cfg.Level),
Level: hclog.LevelFromString(cfg.LogLevel),
Output: hclog.DefaultOutput,
TimeFormat: "I0102 15:04:05.000000",
})
@ -38,19 +33,20 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
rc.ProtocolVersion = 3
rc.LocalID = raft.ServerID(cfg.ID)
rc.Logger = hcl
c.id = cfg.ID
pool := 3
timeout := 10 * time.Second
var transport *raft.NetworkTransport
if cfg.TLS != nil {
log.Info("transport: tls")
c.V(1).Info("setup", "transport", "tls")
s, err := tls.NewStream(cfg)
if err != nil {
return err
}
transport = raft.NewNetworkTransportWithLogger(s, pool, timeout, hcl)
} else {
log.Info("transport: tcp")
c.V(1).Info("setup", "transport", "tcp")
address, err := net.ResolveTCPAddr("tcp", cfg.Address)
if err != nil {
return err
@ -104,16 +100,13 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
}
}
// Create RAFT instance
c.r, err = raft.NewRaft(rc, (*fsm)(c.kv), logStore, stableStore, snapshots, transport)
c.r, err = raft.NewRaft(rc, (*fsm)(c.kvm), logStore, stableStore, snapshots, transport)
if err != nil {
return err
}
c.kv.r = c.r
c.kvm.r = c.r
t := time.NewTicker(time.Second)
time.Sleep(time.Second * 3)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
leading := false
@ -128,6 +121,7 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
}
select {
case <-t.C:
case leader := <-c.r.LeaderCh():
if leader {
if following {
@ -163,7 +157,6 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
}
close(c.done)
return nil
case <-t.C:
}
}
return nil
@ -171,49 +164,16 @@ func (c *Cluster) Start(log logr.Logger, raftcfg *config.Config) error {
func (c *Cluster) leader(ctx context.Context) {
defer func() {
handleCrash()
util.HandleCrash()
}()
c.Callbacks.Leader(ctx, c.kv)
c.callbacks.Leader(ctx, c)
}
func (c *Cluster) follower(ctx context.Context) {
defer func() {
handleCrash()
util.HandleCrash()
}()
c.Callbacks.Follower(ctx, c.kv)
}
var reallyCrash = false
func handleCrash() {
if r := recover(); r != nil {
logPanic(r)
if reallyCrash {
panic(r)
}
}
}
// logPanic logs the caller tree when a panic occurs (except in the special case of http.ErrAbortHandler).
func logPanic(r interface{}) {
if r == http.ErrAbortHandler {
// honor the http.ErrAbortHandler sentinel panic value:
// ErrAbortHandler is a sentinel panic value to abort a handler.
// While any panic from ServeHTTP aborts the response to the client,
// panicking with ErrAbortHandler also suppresses logging of a stack trace to the server's error log.
return
}
// Same as stdlib http server code. Manually allocate stack trace buffer size
// to prevent excessively large logs
const size = 64 << 10
stacktrace := make([]byte, size)
stacktrace = stacktrace[:runtime.Stack(stacktrace, false)]
if _, ok := r.(string); ok {
klog.Errorf("Observed a panic: %s\n%s", r, stacktrace)
} else {
klog.Errorf("Observed a panic: %#v (%v)\n%s", r, r, stacktrace)
}
c.callbacks.Follower(ctx, c)
}
func (c *Cluster) Stepdown() {

16
pkg/raft/tls/stream.go
View file

@ -3,7 +3,6 @@ package tls
import (
"crypto/tls"
"crypto/x509"
"io/ioutil"
"net"
"time"
@ -20,19 +19,6 @@ var (
}
)
func loadCertPool(file string) (p *x509.CertPool, err error) {
if file == "" {
return
}
buf, err := ioutil.ReadFile(file)
if err != nil {
return
}
p = x509.NewCertPool()
p.AppendCertsFromPEM(buf)
return
}
type stream struct {
net.Listener
insecure bool
@ -44,7 +30,7 @@ func NewStream(cfg *config.Raft) (s *stream, err error) {
if err != nil {
return
}
ca, err := loadCertPool(cfg.TLS.CA)
ca, err := config.LoadCertPool(cfg.TLS.CA)
if err != nil {
return
}

41
pkg/util/crash.go Normal file
View file

@ -0,0 +1,41 @@
package util
import (
"net/http"
"runtime"
"k8s.io/klog/v2"
)
var reallyCrash = true
func HandleCrash() {
if r := recover(); r != nil {
logPanic(r)
if reallyCrash {
panic(r)
}
}
}
// logPanic logs the caller tree when a panic occurs (except in the special case of http.ErrAbortHandler).
func logPanic(r interface{}) {
if r == http.ErrAbortHandler {
// honor the http.ErrAbortHandler sentinel panic value:
// ErrAbortHandler is a sentinel panic value to abort a handler.
// While any panic from ServeHTTP aborts the response to the client,
// panicking with ErrAbortHandler also suppresses logging of a stack trace to the server's error log.
return
}
// Same as stdlib http server code. Manually allocate stack trace buffer size
// to prevent excessively large logs
const size = 64 << 10
stacktrace := make([]byte, size)
stacktrace = stacktrace[:runtime.Stack(stacktrace, false)]
if _, ok := r.(string); ok {
klog.Errorf("Observed a panic: %s\n%s", r, stacktrace)
} else {
klog.Errorf("Observed a panic: %#v (%v)\n%s", r, r, stacktrace)
}
}