「Yogin」实现错误恢复和基本鉴权

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("in main recover: %v\n", r)
        }
    }()
    go func() {
        defer println("in goroutine")
        panic("goroutine panic")
    }()

    time.Sleep(1 * time.Second)
}
// in goroutine
// panic: goroutine panic

func main() {
    defer fmt.Println("in main 1")
    
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("in recover 1: %v\n", r)
        }
        
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("in recover 2: %v\n", r)
            }
            panic("panic again and again")
        }()
        
        panic("panic again")
    }()
    
    defer fmt.Println("in main 2")
    
    panic("panic once")
}

// in main 2
// in recover 1: panic once
// in recover 2: panic again
// in main 1
//     panic: panic once [recovered]
//     panic: panic again [recovered]
//     panic: panic again and again

func main() {
    defer func() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Printf("in defer defer recover: %v\n", r)
            }
        }()

        func() {
            if r := recover(); r != nil {
                fmt.Printf("in defer func recover: %v\n", r)
            }
        }()
    }()
    defer recover()
    panic("panic")
}
// panic: panic

func main() {
    defer func() {
        defer recover()
    }()
    panic("panic")
}
// 无报错

func main() {
    defer fmt.Println("in main 1")

    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("in recover: %v\n", r)
        }
    }()

    defer func() {
        panic("panic")
    }()

    defer fmt.Println("in main 2")
}
// in main 2
// in recover: panic
// in main 1

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("in recover 2: %v\n", r)
        }
    }()
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("in recover 1: %v\n", r)
        }
    }()

    defer func() {
        panic("panic 2")
    }()
    defer func() {
        panic("panic 1")
    }()

    panic("panic 0")
}
// in recover 1: panic 2

// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
func Recovery() HandlerFunc {
    return func(c *Context) {
        defer func() {
            if err := recover(); err != nil {
                // handle recovery ... 
            }
        }()

        c.Next()
    }
}

// RecoveryFunc defines the function passable to CustomRecovery.
type RecoveryFunc func(c *Context, err interface{})

func defaultHandleRecovery(c *Context, err interface{}) {
    c.AbortWithStatus(http.StatusInternalServerError)
}

// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
func Recovery() HandlerFunc {
    logger := log.New(DefaultErrorWriter, "\n\n\x1b[31m", log.LstdFlags)

    return func(c *Context) {
        defer func() {
            if err := recover(); err != nil {
                // Check for a broken connection, as it is not really a
                // condition that warrants a panic stack trace.
                brokenPipe := false
                if ne, ok := err.(*net.OpError); ok {
                    var se *os.SyscallError
                    if errors.As(ne, &se) {
                        if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
                            brokenPipe = true
                        }
                    }
                }

                stack := stack(3)
                httpRequest, _ := httputil.DumpRequest(c.Request, false)
                headersToStr := string(httpRequest)
                if brokenPipe {
                    logger.Printf("%s\n%s%s", err, headersToStr, reset)
                } else {
                    logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
                                time.Now().Format("2006/01/02 - 15:04:05"), headersToStr, err, stack, reset)
                }

                if brokenPipe {
                    // If the connection is dead, we can't write a status to it.
                    c.Error(err.(error))
                    c.Abort()
                } else {
                    defaultHandleRecovery(c, err)
                }
            }
        }()

        c.Next()
    }
}

// stack returns a nicely formatted stack frame, skipping skip frames.
func stack(skip int) string {
    var pcs [32]uintptr
    n := runtime.Callers(skip, pcs[:])

    var b strings.Builder
    b.WriteString("Traceback:")

    frames := runtime.CallersFrames(pcs[:n])
    for {
        frame, more := frames.Next()
        b.WriteString(fmt.Sprintf("\n\t%s:%d", frame.File, frame.Line))
        if !more {
            break
        }
    }
    return b.String()
}

func BasicAuth(accounts Accounts) HandlerFunc {
    pairs := processAccounts(accounts)
    return func(c *Context) {
        // find and validate auth token, and get username from pairs
        user, found := pairs.searchCredential(c.GetHeader("Authorization"))
        if !found {
            c.Header("WWW-Authenticate", basicRealm)
            c.AbortWithStatus(http.StatusUnauthorized)
            return
        }
        // set username
        c.Set(AuthUserKey, user)
        c.Next()
    }
}

// Accounts defines a key/value for user/pass list of authorized logins.
type Accounts map[string]string

type authPair struct {
    value string
    user  string
}

type authPairs []authPair

func processAccounts(accounts Accounts) authPairs {
    length := len(accounts)
    assert1(length > 0, "Empty list of authorized credentials")

    pairs := make(authPairs, 0, length)
    for user, password := range accounts {
        assert1(user != "", "User can not be empty")

        value := secretHash(user, password)
        pairs = append(pairs, authPair{
            value: value,
            user:  user,
        })
    }
    return pairs
}

func (a authPairs) searchCredential(authValue string) (string, bool) {
    if authValue == "" {
        return "", false
    }
    for _, pair := range a {
        if subtle.ConstantTimeCompare([]byte(pair.value), []byte(authValue)) == 1 {
            return pair.user, true
        }
    }
    return "", false
}

accounts := Accounts{
    "foo":    "bar",
}
secrets := map[string]interface{}{
    "foo":    map[string]interface{}{"email": "foo@bar.com", "phone": "123433"},
}
const noSecret = "NO SECRET :("
const publicInfo = "PUBLIC INFO :)"

r := Default()

// login interface, return secret token
r.POST("/login", func(c *Context) {
    user := c.PostForm("user")
    password := c.PostForm("password")
    if pwd, ok := accounts[user]; ok {
        if password == pwd {
            c.String(http.StatusOK, secretHash(user, password))
            return
        }
    }
    c.Forbidden().WithString("wrong user or password")
})

// routes under authorized group requires user to login first
authorized := r.Group("/admin", BasicAuth(accounts))

authorized.GET("/secrets", func(c *Context) {
    // get user, it was set by the BasicAuth middleware
    user := c.MustGet(AuthUserKey).(string)
    if secret, ok := secrets[user]; ok {
        c.OK().WithJSON(H{"user": user, "secret": secret})
    } else {
        c.OK().WithJSON(H{"user": user, "secret": noSecret})
    }
})

// test legal users
user := "foo"
password := "bar"
var token string
{
    req := httptest.NewRequest(http.MethodPost, "/login", nil)
    req.PostForm = make(url.Values)
    req.PostForm["user"] = []string{user}
    req.PostForm["password"] = []string{password}
    w := httptest.NewRecorder()
    r.ServeHTTP(w, req)
    token = w.Body.String()
}

{
    req := httptest.NewRequest(http.MethodGet, "/admin/secrets", nil)
    req.Header.Set("Authorization", token)
    w := httptest.NewRecorder()
    r.ServeHTTP(w, req)
}