设计如何请求这些终点

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《设计如何请求这些终点》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

我不知道如何使用所需的参数发出“访问”、“时钟”和“审核”请求。您能否指导我如何提出这些请求？

package main

import (
    "crypto/sha256"
    "crypto/subtle"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "sync"
    "time"
)

const secret = "galumphing"

// Required parameters for the request
type params struct {
    Act       string
    Nonce     string
    Signature string
    Timeout   int64
    Offset    int
}

var (
    auditLock sync.Mutex
    auditBase int
    auditLog  []string
)

var (
    seenLock sync.Mutex
    seenMap  = map[string]bool{}
)

var (
    clockAsk  = make(chan bool)
    clockTime = make(chan int64, 1)
)

func main() {
    // Endpoints available
    http.HandleFunc("/903/access", handleAccess)
    http.HandleFunc("/903/clock", handleClock)
    http.HandleFunc("/903/audit", handleAudit)

    err := http.ListenAndServe(os.Args[1], nil)
    if err != nil {
        log.Fatal(err)
    }
}

func checkCapacity(w http.ResponseWriter) (ok bool) {
    auditLock.Lock()
    defer auditLock.Unlock()

    if len(auditLog) > 10 {
        w.WriteHeader(http.StatusServiceUnavailable)
        return
    }

    ok = true
    return
}

func audit(r *http.Request, params params, ok bool) {
    auditLock.Lock()
    defer auditLock.Unlock()

    auditLog = append(auditLog, fmt.Sprintf("%v %q %q", ok, r.URL.Path, params.Act))
}

func parse(w http.ResponseWriter, r *http.Request) (params params, ok bool) {
    defer func() {
        if !ok {
            audit(r, params, false)
        }
    }()

    w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Max-Age", "3600")

    if r.Method != "POST" {
        w.Header().Set("Allow", "POST, OPTIONS")
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
        } else {
            w.WriteHeader(http.StatusMethodNotAllowed)
        }
        return
    }

    err := json.NewDecoder(r.Body).Decode(¶ms)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        log.Printf("%s: %v", r.URL.Path, err)
        return
    }

    h := sha256.New()
    fmt.Fprintf(h, "%s\r\n%s\r\n%s\r\n%s", r.URL.Path, params.Act, params.Nonce, secret)
    sig := base64.StdEncoding.EncodeToString(h.Sum(nil))
    if subtle.ConstantTimeCompare([]byte(sig), []byte(params.Signature)) != 1 {
        w.WriteHeader(http.StatusForbidden)
        return
    }

    seenLock.Lock()
    seen := seenMap[params.Signature]
    if !seen {
        seenMap[params.Signature] = true
    }
    seenLock.Unlock()
    if seen {
        w.WriteHeader(http.StatusForbidden)
        return
    }

    ok = true
    return
}

func handleAccess(w http.ResponseWriter, r *http.Request) {
    if !checkCapacity(w) {
        return
    }

    params, ok := parse(w, r)
    if !ok {
        return
    }

    switch params.Act {
    case "begin":
        if params.Timeout < 0 || params.Timeout > 250000 {
            w.WriteHeader(http.StatusBadRequest)
            audit(r, params, false)
            return
        }

        timer := time.NewTimer(time.Duration(params.Timeout) * time.Microsecond)

        select {
        case clockAsk <- true: // https://golang.org/ref/spec#Send_statements
            w.WriteHeader(http.StatusNoContent)
            audit(r, params, true)

        case <-timer.C:
            w.WriteHeader(http.StatusConflict)
            audit(r, params, false)
            return
        }

        go func() {
            <-timer.C

            select {
            case <-clockTime:
            default:
            }
        }()

    case "end":
        if params.Timeout < 0 {
            w.WriteHeader(http.StatusBadRequest)
            audit(r, params, false)
            return
        }

        timer := time.NewTimer(time.Duration(params.Timeout) * time.Microsecond)

        select {
        case value := <-clockTime: // https://golang.org/ref/spec#Receive_operator
            w.Header().Set("Content-Type", "text/plain")
            w.WriteHeader(http.StatusOK)
            fmt.Fprintln(w, value)
            audit(r, params, true)

        case <-timer.C:
            w.WriteHeader(http.StatusConflict)
            audit(r, params, false)
        }

    default:
        w.WriteHeader(http.StatusBadRequest)
        audit(r, params, false)
    }
}

func handleClock(w http.ResponseWriter, r *http.Request) {
    if !checkCapacity(w) {
        return
    }

    params, ok := parse(w, r)
    if !ok {
        return
    }

    switch params.Act {
    case "observe":
        if params.Timeout != 0 {
            w.WriteHeader(http.StatusBadRequest)
            audit(r, params, false)
            return
        }

        select {
        case <-clockAsk: // https://golang.org/ref/spec#Receive_operator
            select {
            case clockTime <- time.Now().Unix(): // https://golang.org/ref/spec#Send_statements
            default:
            }

        default:
        }

        w.WriteHeader(http.StatusNoContent)
        audit(r, params, true)

    default:
        w.WriteHeader(http.StatusBadRequest)
        audit(r, params, false)
    }
}

func handleAudit(w http.ResponseWriter, r *http.Request) {
    params, ok := parse(w, r)
    if !ok {
        return
    }

    ok = false

    func() {
        auditLock.Lock()
        defer auditLock.Unlock()

        switch params.Act {
        case "":
            if params.Offset != 0 {
                w.WriteHeader(http.StatusBadRequest)
                return
            }

            w.Header().Set("Content-Type", "text/plain")
            w.WriteHeader(http.StatusOK)
            fmt.Fprintln(w, auditBase)

        case "burble":
            if params.Offset < auditBase || params.Offset > auditBase+len(auditLog) {
                w.WriteHeader(http.StatusBadRequest)
                return
            }

            w.Header().Set("Content-Type", "text/plain")
            w.WriteHeader(http.StatusOK)

            for i := params.Offset - auditBase; i < len(auditLog); i++ {
                fmt.Fprintf(w, "%d %s\n", auditBase+i, auditLog[i])
            }

        case "chortle":
            if params.Offset > auditBase+len(auditLog) {
                w.WriteHeader(http.StatusBadRequest)
                return
            }

            if params.Offset > auditBase {
                auditLog = auditLog[params.Offset-auditBase:] // https://golang.org/ref/spec#Slice_expressions
                auditBase = params.Offset
            }

            w.WriteHeader(http.StatusNoContent)

        default:
            w.WriteHeader(http.StatusBadRequest)
            return
        }

        ok = true
    }()

    audit(r, params, ok)
}

解决方案

有几种方法可以解决这个问题。您可以使用 postman 等工具，也可以仅从命令行使用 curl 向端点发送发布请求。这是我用来命中端点的curl命令（我使用端口8080进行测试），-d标志后面的位是请求正文：

curl -x post http://localhost:8080/903/access -d '{"act": "act", "nonce": "nonce", "signature": "signature", "timeout": 64、“偏移量”：0}'

我确实修改了代码以删除大部分逻辑。此请求仅显示当前代码如何解析请求正文的示例。如果您对处理程序函数中的其他一些逻辑如何工作更感兴趣，请告诉我，我可以编辑我的回复。这是我用于测试的代码：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
)

// Required parameters for the request
type params struct {
    Act       string
    Nonce     string
    Signature string
    Timeout   int64
    Offset    int
}

func main() {
    // Endpoints available
    http.HandleFunc("/903/access", handleAccess)

    err := http.ListenAndServe(os.Args[1], nil)
    if err != nil {
        log.Fatal(err)
    }
}

func parse(w http.ResponseWriter, r *http.Request) (params params, ok bool) {
    w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Max-Age", "3600")

    if r.Method != "POST" {
        w.Header().Set("Allow", "POST, OPTIONS")
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
        } else {
            w.WriteHeader(http.StatusMethodNotAllowed)
        }
        return
    }

    err := json.NewDecoder(r.Body).Decode(¶ms)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        log.Printf("%s: %v", r.URL.Path, err)
        return
    }

    return
}

func handleAccess(w http.ResponseWriter, r *http.Request) {
    params, _ := parse(w, r)

    fmt.Printf("%+v\n", params)
}

这是我在完成所有操作后收到的输出：

{act:act nonce:nonce 签名:signature 超时:64 偏移量:0}

好了，本文到此结束，带大家了解了《设计如何请求这些终点》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！