mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-05 10:02:47 +00:00
bee8458a2d
* feat: add rate limit middleware * chore: update vendor dir * chore: update readme with new dependency * chore: add rate limit infos to swagger.md file * refactor: add ipv6 mask limiter option Add IPv6 CIDR /64 mask * refactor: increase rate limit to 1000 Address https://github.com/superseriousbusiness/gotosocial/pull/741#discussion_r945584800 Co-authored-by: tobi <31960611+tsmethurst@users.noreply.github.com>
178 lines
4.1 KiB
Go
178 lines
4.1 KiB
Go
package errors
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"path"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// Frame represents a program counter inside a stack frame.
|
|
// For historical reasons if Frame is interpreted as a uintptr
|
|
// its value represents the program counter + 1.
|
|
type Frame uintptr
|
|
|
|
// pc returns the program counter for this frame;
|
|
// multiple frames may have the same PC value.
|
|
func (f Frame) pc() uintptr { return uintptr(f) - 1 }
|
|
|
|
// file returns the full path to the file that contains the
|
|
// function for this Frame's pc.
|
|
func (f Frame) file() string {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return "unknown"
|
|
}
|
|
file, _ := fn.FileLine(f.pc())
|
|
return file
|
|
}
|
|
|
|
// line returns the line number of source code of the
|
|
// function for this Frame's pc.
|
|
func (f Frame) line() int {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return 0
|
|
}
|
|
_, line := fn.FileLine(f.pc())
|
|
return line
|
|
}
|
|
|
|
// name returns the name of this function, if known.
|
|
func (f Frame) name() string {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return "unknown"
|
|
}
|
|
return fn.Name()
|
|
}
|
|
|
|
// Format formats the frame according to the fmt.Formatter interface.
|
|
//
|
|
// %s source file
|
|
// %d source line
|
|
// %n function name
|
|
// %v equivalent to %s:%d
|
|
//
|
|
// Format accepts flags that alter the printing of some verbs, as follows:
|
|
//
|
|
// %+s function name and path of source file relative to the compile time
|
|
// GOPATH separated by \n\t (<funcname>\n\t<path>)
|
|
// %+v equivalent to %+s:%d
|
|
func (f Frame) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 's':
|
|
switch {
|
|
case s.Flag('+'):
|
|
io.WriteString(s, f.name())
|
|
io.WriteString(s, "\n\t")
|
|
io.WriteString(s, f.file())
|
|
default:
|
|
io.WriteString(s, path.Base(f.file()))
|
|
}
|
|
case 'd':
|
|
io.WriteString(s, strconv.Itoa(f.line()))
|
|
case 'n':
|
|
io.WriteString(s, funcname(f.name()))
|
|
case 'v':
|
|
f.Format(s, 's')
|
|
io.WriteString(s, ":")
|
|
f.Format(s, 'd')
|
|
}
|
|
}
|
|
|
|
// MarshalText formats a stacktrace Frame as a text string. The output is the
|
|
// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
|
|
func (f Frame) MarshalText() ([]byte, error) {
|
|
name := f.name()
|
|
if name == "unknown" {
|
|
return []byte(name), nil
|
|
}
|
|
return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
|
|
}
|
|
|
|
// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
|
|
type StackTrace []Frame
|
|
|
|
// Format formats the stack of Frames according to the fmt.Formatter interface.
|
|
//
|
|
// %s lists source files for each Frame in the stack
|
|
// %v lists the source file and line number for each Frame in the stack
|
|
//
|
|
// Format accepts flags that alter the printing of some verbs, as follows:
|
|
//
|
|
// %+v Prints filename, function, and line number for each Frame in the stack.
|
|
func (st StackTrace) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
switch {
|
|
case s.Flag('+'):
|
|
for _, f := range st {
|
|
io.WriteString(s, "\n")
|
|
f.Format(s, verb)
|
|
}
|
|
case s.Flag('#'):
|
|
fmt.Fprintf(s, "%#v", []Frame(st))
|
|
default:
|
|
st.formatSlice(s, verb)
|
|
}
|
|
case 's':
|
|
st.formatSlice(s, verb)
|
|
}
|
|
}
|
|
|
|
// formatSlice will format this StackTrace into the given buffer as a slice of
|
|
// Frame, only valid when called with '%s' or '%v'.
|
|
func (st StackTrace) formatSlice(s fmt.State, verb rune) {
|
|
io.WriteString(s, "[")
|
|
for i, f := range st {
|
|
if i > 0 {
|
|
io.WriteString(s, " ")
|
|
}
|
|
f.Format(s, verb)
|
|
}
|
|
io.WriteString(s, "]")
|
|
}
|
|
|
|
// stack represents a stack of program counters.
|
|
type stack []uintptr
|
|
|
|
func (s *stack) Format(st fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
switch {
|
|
case st.Flag('+'):
|
|
for _, pc := range *s {
|
|
f := Frame(pc)
|
|
fmt.Fprintf(st, "\n%+v", f)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *stack) StackTrace() StackTrace {
|
|
f := make([]Frame, len(*s))
|
|
for i := 0; i < len(f); i++ {
|
|
f[i] = Frame((*s)[i])
|
|
}
|
|
return f
|
|
}
|
|
|
|
func callers() *stack {
|
|
const depth = 32
|
|
var pcs [depth]uintptr
|
|
n := runtime.Callers(3, pcs[:])
|
|
var st stack = pcs[0:n]
|
|
return &st
|
|
}
|
|
|
|
// funcname removes the path prefix component of a function's name reported by func.Name().
|
|
func funcname(name string) string {
|
|
i := strings.LastIndex(name, "/")
|
|
name = name[i+1:]
|
|
i = strings.Index(name, ".")
|
|
return name[i+1:]
|
|
}
|