diff options
Diffstat (limited to 'vendor/github.com')
4 files changed, 91 insertions, 160 deletions
diff --git a/vendor/github.com/KimMachineGun/automemlimit/README.md b/vendor/github.com/KimMachineGun/automemlimit/README.md index 804ee7b08..55d40a432 100644 --- a/vendor/github.com/KimMachineGun/automemlimit/README.md +++ b/vendor/github.com/KimMachineGun/automemlimit/README.md @@ -32,6 +32,11 @@ package main import "github.com/KimMachineGun/automemlimit/memlimit" func init() { + memlimit.SetGoMemLimitWithOpts( + memlimit.WithRatio(0.9), + memlimit.WithEnv(), + memlimit.WithProvider(memlimit.FromCgroup), + ) memlimit.SetGoMemLimitWithEnv() memlimit.SetGoMemLimit(0.9) memlimit.SetGoMemLimitWithProvider(memlimit.Limit(1024*1024), 0.9) diff --git a/vendor/github.com/KimMachineGun/automemlimit/memlimit/memlimit.go b/vendor/github.com/KimMachineGun/automemlimit/memlimit/memlimit.go index d2492ae9f..4ab0fc6f8 100644 --- a/vendor/github.com/KimMachineGun/automemlimit/memlimit/memlimit.go +++ b/vendor/github.com/KimMachineGun/automemlimit/memlimit/memlimit.go @@ -2,6 +2,7 @@ package memlimit import ( "errors" + "fmt" "io" "log" "math" @@ -25,60 +26,121 @@ var ( ErrNoCgroup = errors.New("process is not in cgroup") // ErrCgroupsNotSupported is returned when the system does not support cgroups. ErrCgroupsNotSupported = errors.New("cgroups is not supported on this system") - - logger = log.New(io.Discard, "", log.LstdFlags) ) -// SetGoMemLimitWithEnv sets GOMEMLIMIT with the value from the environment variable. -// You can configure how much memory of the cgroup's memory limit to set as GOMEMLIMIT -// through AUTOMEMLIMIT in the half-open range (0.0,1.0]. +type config struct { + logger *log.Logger + ratio float64 + env bool + provider Provider +} + +// Option is a function that configures the behavior of SetGoMemLimitWithOptions. +type Option func(cfg *config) + +// WithRatio configures the ratio of the memory limit to set as GOMEMLIMIT. // -// If AUTOMEMLIMIT is not set, it defaults to 0.9. (10% is the headroom for memory sources the Go runtime is unaware of.) -// If GOMEMLIMIT is already set or AUTOMEMLIMIT=off, this function does nothing. -func SetGoMemLimitWithEnv() { +// Default: 0.9 +func WithRatio(ratio float64) Option { + return func(cfg *config) { + cfg.ratio = ratio + } +} + +// WithEnv configures whether to use environment variables. +// +// Default: false +func WithEnv() Option { + return func(cfg *config) { + cfg.env = true + } +} + +// WithProvider configures the provider. +// +// Default: FromCgroup +func WithProvider(provider Provider) Option { + return func(cfg *config) { + cfg.provider = provider + } +} + +// SetGoMemLimitWithOpts sets GOMEMLIMIT with options. +// +// Options: +// - WithRatio +// - WithEnv (see more SetGoMemLimitWithEnv) +// - WithProvider +func SetGoMemLimitWithOpts(opts ...Option) (_ int64, _err error) { + cfg := &config{ + logger: log.New(io.Discard, "", log.LstdFlags), + ratio: defaultAUTOMEMLIMIT, + env: false, + provider: FromCgroup, + } + if os.Getenv(envAUTOMEMLIMIT_DEBUG) == "true" { + cfg.logger = log.Default() + } + for _, opt := range opts { + opt(cfg) + } + defer func() { + if _err != nil { + cfg.logger.Println(_err) + } + }() + snapshot := debug.SetMemoryLimit(-1) defer func() { err := recover() if err != nil { - logger.Printf("panic during SetGoMemLimitWithEnv, rolling back to previous value %d: %v\n", snapshot, err) + if _err != nil { + cfg.logger.Println(_err) + } + _err = fmt.Errorf("panic during setting the Go's memory limit, rolling back to previous value %d: %v", snapshot, err) debug.SetMemoryLimit(snapshot) } }() - if os.Getenv(envAUTOMEMLIMIT_DEBUG) == "true" { - logger = log.Default() - } - if val, ok := os.LookupEnv(envGOMEMLIMIT); ok { - logger.Printf("GOMEMLIMIT is set already, skipping: %s\n", val) + cfg.logger.Printf("GOMEMLIMIT is set already, skipping: %s\n", val) return } - ratio := defaultAUTOMEMLIMIT + ratio := cfg.ratio if val, ok := os.LookupEnv(envAUTOMEMLIMIT); ok { if val == "off" { - logger.Printf("AUTOMEMLIMIT is set to off, skipping\n") + cfg.logger.Printf("AUTOMEMLIMIT is set to off, skipping\n") return } _ratio, err := strconv.ParseFloat(val, 64) if err != nil { - logger.Printf("cannot parse AUTOMEMLIMIT: %s\n", val) - return + return 0, fmt.Errorf("cannot parse AUTOMEMLIMIT: %s", val) } ratio = _ratio } if ratio <= 0 || ratio > 1 { - logger.Printf("invalid AUTOMEMLIMIT: %f\n", ratio) - return + return 0, fmt.Errorf("invalid AUTOMEMLIMIT: %f", ratio) } - limit, err := SetGoMemLimit(ratio) + limit, err := SetGoMemLimitWithProvider(cfg.provider, ratio) if err != nil { - logger.Printf("failed to set GOMEMLIMIT: %v\n", err) - return + return 0, fmt.Errorf("failed to set GOMEMLIMIT: %w", err) } - logger.Printf("GOMEMLIMIT=%d\n", limit) + cfg.logger.Printf("GOMEMLIMIT=%d\n", limit) + + return limit, nil +} + +// SetGoMemLimitWithEnv sets GOMEMLIMIT with the value from the environment variable. +// You can configure how much memory of the cgroup's memory limit to set as GOMEMLIMIT +// through AUTOMEMLIMIT in the half-open range (0.0,1.0]. +// +// If AUTOMEMLIMIT is not set, it defaults to 0.9. (10% is the headroom for memory sources the Go runtime is unaware of.) +// If GOMEMLIMIT is already set or AUTOMEMLIMIT=off, this function does nothing. +func SetGoMemLimitWithEnv() { + _, _ = SetGoMemLimitWithOpts(WithEnv()) } // SetGoMemLimit sets GOMEMLIMIT with the value from the cgroup's memory limit and given ratio. diff --git a/vendor/github.com/ulule/limiter/v3/drivers/middleware/gin/middleware.go b/vendor/github.com/ulule/limiter/v3/drivers/middleware/gin/middleware.go deleted file mode 100644 index 23bad417a..000000000 --- a/vendor/github.com/ulule/limiter/v3/drivers/middleware/gin/middleware.go +++ /dev/null @@ -1,65 +0,0 @@ -package gin - -import ( - "strconv" - - "github.com/gin-gonic/gin" - - "github.com/ulule/limiter/v3" -) - -// Middleware is the middleware for gin. -type Middleware struct { - Limiter *limiter.Limiter - OnError ErrorHandler - OnLimitReached LimitReachedHandler - KeyGetter KeyGetter - ExcludedKey func(string) bool -} - -// NewMiddleware return a new instance of a gin middleware. -func NewMiddleware(limiter *limiter.Limiter, options ...Option) gin.HandlerFunc { - middleware := &Middleware{ - Limiter: limiter, - OnError: DefaultErrorHandler, - OnLimitReached: DefaultLimitReachedHandler, - KeyGetter: DefaultKeyGetter, - ExcludedKey: nil, - } - - for _, option := range options { - option.apply(middleware) - } - - return func(ctx *gin.Context) { - middleware.Handle(ctx) - } -} - -// Handle gin request. -func (middleware *Middleware) Handle(c *gin.Context) { - key := middleware.KeyGetter(c) - if middleware.ExcludedKey != nil && middleware.ExcludedKey(key) { - c.Next() - return - } - - context, err := middleware.Limiter.Get(c, key) - if err != nil { - middleware.OnError(c, err) - c.Abort() - return - } - - c.Header("X-RateLimit-Limit", strconv.FormatInt(context.Limit, 10)) - c.Header("X-RateLimit-Remaining", strconv.FormatInt(context.Remaining, 10)) - c.Header("X-RateLimit-Reset", strconv.FormatInt(context.Reset, 10)) - - if context.Reached { - middleware.OnLimitReached(c) - c.Abort() - return - } - - c.Next() -} diff --git a/vendor/github.com/ulule/limiter/v3/drivers/middleware/gin/options.go b/vendor/github.com/ulule/limiter/v3/drivers/middleware/gin/options.go deleted file mode 100644 index 604c6bc68..000000000 --- a/vendor/github.com/ulule/limiter/v3/drivers/middleware/gin/options.go +++ /dev/null @@ -1,71 +0,0 @@ -package gin - -import ( - "net/http" - - "github.com/gin-gonic/gin" -) - -// Option is used to define Middleware configuration. -type Option interface { - apply(*Middleware) -} - -type option func(*Middleware) - -func (o option) apply(middleware *Middleware) { - o(middleware) -} - -// ErrorHandler is an handler used to inform when an error has occurred. -type ErrorHandler func(c *gin.Context, err error) - -// WithErrorHandler will configure the Middleware to use the given ErrorHandler. -func WithErrorHandler(handler ErrorHandler) Option { - return option(func(middleware *Middleware) { - middleware.OnError = handler - }) -} - -// DefaultErrorHandler is the default ErrorHandler used by a new Middleware. -func DefaultErrorHandler(c *gin.Context, err error) { - panic(err) -} - -// LimitReachedHandler is an handler used to inform when the limit has exceeded. -type LimitReachedHandler func(c *gin.Context) - -// WithLimitReachedHandler will configure the Middleware to use the given LimitReachedHandler. -func WithLimitReachedHandler(handler LimitReachedHandler) Option { - return option(func(middleware *Middleware) { - middleware.OnLimitReached = handler - }) -} - -// DefaultLimitReachedHandler is the default LimitReachedHandler used by a new Middleware. -func DefaultLimitReachedHandler(c *gin.Context) { - c.String(http.StatusTooManyRequests, "Limit exceeded") -} - -// KeyGetter will define the rate limiter key given the gin Context. -type KeyGetter func(c *gin.Context) string - -// WithKeyGetter will configure the Middleware to use the given KeyGetter. -func WithKeyGetter(handler KeyGetter) Option { - return option(func(middleware *Middleware) { - middleware.KeyGetter = handler - }) -} - -// DefaultKeyGetter is the default KeyGetter used by a new Middleware. -// It returns the Client IP address. -func DefaultKeyGetter(c *gin.Context) string { - return c.ClientIP() -} - -// WithExcludedKey will configure the Middleware to ignore key(s) using the given function. -func WithExcludedKey(handler func(string) bool) Option { - return option(func(middleware *Middleware) { - middleware.ExcludedKey = handler - }) -} |