Altair-sh
141 lines
3.2 KiB
Go
141 lines
3.2 KiB
Go
package http
|
|
|
|
import (
|
|
"bufio"
|
|
"errors"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"serveg/internal/log"
|
|
sh "serveg/internal/string_helper"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
const maxHeaderBytes = 16 * 1024
|
|
const initialWriteBufCap = 512
|
|
|
|
type mapStrStr map[string]string
|
|
type HeadersMap map[string]string
|
|
type ConnCallback func(req *Request) *Response
|
|
|
|
type Connection struct {
|
|
Timeout time.Duration
|
|
|
|
log *log.LoggerContext
|
|
callback ConnCallback
|
|
socket *net.TCPConn
|
|
r *bufio.Reader
|
|
wbuf sh.StringBuilder
|
|
|
|
// allocated in Connection once
|
|
// hidden to prevent using before ReadRequest/SendResponse
|
|
_req Request // reset by ReadRequest
|
|
_res Response // reset by CreateResponse and ReadRequest
|
|
}
|
|
|
|
const defaultTimeout = 30 * time.Second
|
|
|
|
func NewConnection(
|
|
socket *net.TCPConn,
|
|
logger *log.LoggerContext,
|
|
callback ConnCallback,
|
|
) *Connection {
|
|
return &Connection{
|
|
Timeout: defaultTimeout,
|
|
log: logger,
|
|
callback: callback,
|
|
socket: socket,
|
|
r: bufio.NewReaderSize(socket, maxHeaderBytes),
|
|
wbuf: sh.StringBuilder{Buf: make([]byte, 0, initialWriteBufCap)},
|
|
_req: Request{
|
|
QueryParams: make(mapStrStr),
|
|
Headers: make(HeadersMap),
|
|
},
|
|
_res: Response{
|
|
Headers: make(HeadersMap),
|
|
},
|
|
}
|
|
}
|
|
|
|
func (conn *Connection) Start() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
conn.log.Error("panic: ", r)
|
|
}
|
|
_ = conn.socket.Close()
|
|
conn.log.Info("connection closed")
|
|
}()
|
|
|
|
for {
|
|
err := conn.socket.SetDeadline(time.Now().Add(conn.Timeout))
|
|
if err != nil {
|
|
conn.log.Warn(err)
|
|
return
|
|
}
|
|
|
|
var res *Response
|
|
var req *Request
|
|
req, err = conn.ReadRequest()
|
|
if err != nil {
|
|
// invalid request
|
|
if httpErr, ok := errors.AsType[*HttpError](err); ok {
|
|
conn.log.Warn(err)
|
|
res = conn.CreateErrorResponse(req, true, httpErr)
|
|
} else {
|
|
conn.logError(err)
|
|
conn.lingeringClose()
|
|
return
|
|
}
|
|
} else {
|
|
// valid request
|
|
conn.log.Info(req.Method, " ", req.Url, " ", req.Protocol)
|
|
conn.log.Trace("request headers: ", HeadersToString(req.Headers, SecretHeaders))
|
|
res = conn.callback(req)
|
|
if req.HasUnreadBody() {
|
|
res = conn.CreateErrorResponse(req, true, ErrHasUnreadBody)
|
|
}
|
|
}
|
|
|
|
conn.log.Info("sending response: ", res.Status,
|
|
" content-length: ", res.Headers["content-length"])
|
|
conn.log.Trace("response headers: ", HeadersToString(res.Headers, SecretHeaders))
|
|
err = conn.sendResponse(res)
|
|
if err != nil {
|
|
conn.logError(err)
|
|
return
|
|
}
|
|
|
|
// it is set by CreateResponse
|
|
if res.Headers["connection"] == "close" {
|
|
conn.lingeringClose()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (conn *Connection) logError(err error) {
|
|
if errors.Is(err, os.ErrDeadlineExceeded) {
|
|
conn.log.Info("time out")
|
|
} else if errors.Is(err, io.EOF) ||
|
|
errors.Is(err, syscall.EPIPE) ||
|
|
errors.Is(err, syscall.ECONNRESET) {
|
|
|
|
conn.log.Info("closed by client")
|
|
} else {
|
|
conn.log.Error(err)
|
|
}
|
|
}
|
|
|
|
// lingeringClose: shut down our side, then drain the client's unread data,
|
|
// so close() doesn't send RST and destroy the response before it's read.
|
|
// Limits: 500 ms, 32 KB
|
|
func (conn *Connection) lingeringClose() {
|
|
conn.log.Info("lingering close")
|
|
if conn.socket.CloseWrite() != nil {
|
|
return
|
|
}
|
|
_ = conn.socket.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
|
|
_, _ = io.Copy(io.Discard, io.LimitReader(conn.socket, 32*1024))
|
|
}
|