120 lines
3.5 KiB
Go
120 lines
3.5 KiB
Go
package host
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/Tencent/WeKnora/pluginsdk/pluginapi"
|
|
)
|
|
|
|
// GatewayPrefix starts the paths a plugin host serves its plugins under:
|
|
// /p/{pluginId}/{version}/{protocol path}.
|
|
const GatewayPrefix = "/p/"
|
|
|
|
// maxGatewayBody bounds one relayed request: a parse call carries the whole
|
|
// document.
|
|
const maxGatewayBody = 512 << 20
|
|
|
|
// Gateway serves the plugins this host runs to the other WeKnora nodes, at
|
|
// /p/{pluginId}/{version}/... Requests must be signed with the cluster key
|
|
// (pluginapi.Sign over the body); answers, streams included, are relayed as
|
|
// the plugin gives them.
|
|
func (m *Manager) Gateway(key []byte) http.Handler {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
})
|
|
mux.HandleFunc(GatewayPrefix, func(w http.ResponseWriter, r *http.Request) {
|
|
m.inFlight.Add(1)
|
|
defer m.inFlight.Add(-1)
|
|
m.relay(w, r, key)
|
|
})
|
|
return mux
|
|
}
|
|
|
|
func gatewayError(w http.ResponseWriter, e *pluginapi.Error) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(e.Code.HTTPStatus())
|
|
_ = json.NewEncoder(w).Encode(pluginapi.ErrorBody{Error: *e})
|
|
}
|
|
|
|
func (m *Manager) relay(w http.ResponseWriter, r *http.Request, key []byte) {
|
|
body, err := io.ReadAll(io.LimitReader(r.Body, maxGatewayBody+1))
|
|
if err != nil {
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeBadRequest, "read request: %v", err))
|
|
return
|
|
}
|
|
if len(body) > maxGatewayBody {
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeBadRequest, "request is over %d bytes", maxGatewayBody))
|
|
return
|
|
}
|
|
err = pluginapi.VerifySignature(key, r.Header.Get(pluginapi.TimestampHeader),
|
|
r.Header.Get(pluginapi.SignatureHeader), body, time.Now())
|
|
if err != nil {
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeUnauthorized, "gateway: %v", err))
|
|
return
|
|
}
|
|
parts := strings.SplitN(strings.TrimPrefix(r.URL.Path, GatewayPrefix), "/", 3)
|
|
if len(parts) < 3 || parts[0] == "" || parts[1] == "" {
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeNotFound, "no endpoint %s", r.URL.Path))
|
|
return
|
|
}
|
|
id, version, path := parts[0], parts[1], "/"+parts[2]
|
|
m.mu.Lock()
|
|
p := m.procs[id]
|
|
m.mu.Unlock()
|
|
if p == nil || p.spec.m.Version != version {
|
|
// The caller's view of this host is a heartbeat old; it retries
|
|
// elsewhere.
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeUnavailable, "this host does not run %s@%s", id, version))
|
|
return
|
|
}
|
|
c, err := p.Client()
|
|
if err != nil {
|
|
if pe, ok := pluginapi.AsError(err); ok {
|
|
gatewayError(w, pe)
|
|
} else {
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeUnavailable, "%v", err))
|
|
}
|
|
return
|
|
}
|
|
var sent []byte
|
|
if len(body) > 0 {
|
|
sent = body
|
|
}
|
|
resp, err := c.Raw(r.Context(), r.Method, path, sent, r.Header.Get(pluginapi.RequestIDHeader))
|
|
if err != nil {
|
|
gatewayError(w, pluginapi.Errorf(pluginapi.CodeUnavailable, "%v", err))
|
|
return
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
if ct := resp.Header.Get("Content-Type"); ct != "" {
|
|
w.Header().Set("Content-Type", ct)
|
|
}
|
|
w.WriteHeader(resp.StatusCode)
|
|
flusher, _ := w.(http.Flusher)
|
|
buf := make([]byte, 32<<10)
|
|
for {
|
|
n, err := resp.Body.Read(buf)
|
|
if n > 0 {
|
|
if _, werr := w.Write(buf[:n]); werr != nil {
|
|
return
|
|
}
|
|
// Stream events go out as the plugin writes them.
|
|
if flusher != nil && bytes.IndexByte(buf[:n], '\n') >= 0 {
|
|
flusher.Flush()
|
|
}
|
|
}
|
|
if err != nil {
|
|
if flusher != nil {
|
|
flusher.Flush()
|
|
}
|
|
return
|
|
}
|
|
}
|
|
}
|