Pi66

Home | Repos | About | Blog | Gaza

gallon
Flask-inspired web application server written in Go with Lua scripting
git clone https://git.pi66.xyz/gallon

About | Files | Commits | Refs | License


perf: optimize request handling and restructure http and lua packages

Author: pi66
Date: 2026-10-29 17:25
commit: c8590991

- build request tables lazily using metatables
- speed up worker acquisition with a non-blocking fast path
- use each worker's own routes and handlers
- prevent infinite recursion when the 500 error handler fails
- return a 500 response when a handler panics
- rename `state.Server` to `state.HttpServer` and group routes and hooks under `Handlers`
- replace registration methods with a function map and split `handlers.go` out of `lua.go`
- simplify Lua-to-Go conversion into a single pass

Stat

M example.lua 2 +1 -1
M src/http/handler.go 90 +55 -35
M src/http/http.go 18 +9 -9
D src/http/lua.go 69 +0 -69
M src/http/pool.go 32 +16 -16
D src/http/request.go 132 +0 -132
D src/http/response.go 20 +0 -20
A src/http/route.go 74 +74 -0
M src/jinja/jinja.go 4 +2 -2
M src/lua/converter.go 83 +48 -35
M src/lua/error_handler.go 84 +76 -8
A src/lua/handlers.go 28 +28 -0
D src/lua/helpers.go 83 +0 -83
M src/lua/jinja.go 65 +28 -37
M src/lua/log.go 26 +6 -20
M src/lua/lua.go 56 +34 -22
D src/lua/middleware.go 17 +0 -17
A src/lua/request_to_table.go 148 +148 -0
D src/lua/route.go 14 +0 -14
M src/lua/server.go 79 +46 -33
A src/state/parser.go 9 +9 -0
M src/state/state.go 43 +24 -19

Diff

diff --git a/example.lua b/example.lua
index 78ad335..f04f835 100644
--- a/example.lua
+++ b/example.lua
@@ -56,4 +56,4 @@ gallon.route("/jinja/string", function(req)
     ), 200, {["Content-Type"] = "text/html"}
 end)

-gallon.run({host = "localhost", port = 8081, workers = 4, gc = 200}) +gallon.run({host = "localhost", port = 8081, workers = 4, gc = 400}) diff --git a/src/http/handler.go b/src/http/handler.go index 2993d42..5dccd3f 100644 --- a/src/http/handler.go +++ b/src/http/handler.go @@ -1,53 +1,73 @@ package http

import ( - "fmt" + "errors" ...

Show all

diff --git a/example.lua b/example.lua
index 78ad335..f04f835 100644
--- a/example.lua
+++ b/example.lua
@@ -56,4 +56,4 @@ gallon.route("/jinja/string", function(req)
     ), 200, {["Content-Type"] = "text/html"}
 end)

-gallon.run({host = "localhost", port = 8081, workers = 4, gc = 200}) +gallon.run({host = "localhost", port = 8081, workers = 4, gc = 400}) diff --git a/src/http/handler.go b/src/http/handler.go index 2993d42..5dccd3f 100644 --- a/src/http/handler.go +++ b/src/http/handler.go @@ -1,53 +1,73 @@ package http

import ( - "fmt" + "errors" "net/http" - "os" - "strconv" + + "gallon/src/lua"

. "github.com/pixel2175/errs"

+ glua "github.com/yuin/gopher-lua" )

-func (s *Server) route(path string) http.HandlerFunc { - return func(rw http.ResponseWriter, r *http.Request) { - w, ok := s.acquire(r) - if !ok { - return - } - - resp, err := run(w, w.st.Server.Routes[path], r, true) - TryV(resp, err, func(err error) error { - fmt.Fprintln(os.Stderr, err) - resp = errorPage(w, r, http.StatusInternalServerError) - return nil - }) +var errNoHandler = errors.New("route has no handler")

- s.release(w) - resp.Write(rw) - } +type Response struct { + Body string + Status int + Headers map[string]string + Redirect string }

-func (s *Server) notFound(rw http.ResponseWriter, r *http.Request) { - w, ok := s.acquire(r) - if !ok { - return +func run(w *worker, fn *glua.LFunction, r *http.Request, hooks bool) (resp Response, err error) { + defer Catch(&err) + + if fn == nil { + return resp, errNoHandler }

- resp := errorPage(w, r, http.StatusNotFound) - s.release(w) - resp.Write(rw) -} + L, srv := w.luaContext, w.server + req, res := lua.RequestToTable(L, r), L.CreateTable(0, 0)

-func errorPage(w *worker, r *http.Request, code int) Response { - resp := Response{Body: http.StatusText(code)} + if hooks && srv.Handlers.BeforeRequest != nil { + TryE(invoke(L, srv.Handlers.BeforeRequest, 0, req, res)) + }

- if fn := w.st.Server.ErrorHandlers[strconv.Itoa(code)]; fn != nil { - if got, err := run(w, fn, r, false); err == nil { - resp = got - } + resp = TryV(handle(L, fn, req, res)) + if hooks && srv.Handlers.AfterRequest != nil { + TryE(invoke(L, srv.Handlers.AfterRequest, 0, req, res)) } + return resp, nil +} + +func invoke(L *glua.LState, fn *glua.LFunction, nret int, req, res glua.LValue) error { + L.Push(fn) + L.Push(req) + L.Push(res) + return L.PCall(2, nret, nil) +} + +func handle(L *glua.LState, fn *glua.LFunction, req, res glua.LValue) (resp Response, err error) { + defer Catch(&err) + + top := L.GetTop() + defer L.SetTop(top) + TryE(invoke(L, fn, 3, req, res)) + body, status, headers := L.Get(-3), L.Get(-2), L.Get(-1) + + resp = Response{Status: http.StatusOK}

- resp.Status = code - return resp + if body != glua.LNil { + resp.Body = body.String() + } + if n, ok := status.(glua.LNumber); ok { + resp.Status = int(n) + } + if t, ok := headers.(*glua.LTable); ok { + resp.Headers = make(map[string]string) + t.ForEach(func(k, v glua.LValue) { + resp.Headers[k.String()] = v.String() + }) + } + return resp, nil } diff --git a/src/http/http.go b/src/http/http.go index b3b83b4..a37c498 100644 --- a/src/http/http.go +++ b/src/http/http.go @@ -2,11 +2,12 @@ package http

import ( "fmt" + "gallon/src/log" + "gallon/src/state" "net/http" "runtime/debug" "strings"

- "gallon/src/state" . "github.com/pixel2175/errs" )

@@ -16,29 +17,28 @@ type Server struct { }

func Start(st *state.State) { - if !st.Server.IsRunning { - return + if !st.HttpServer.IsRunning { + log.Die("HTTP server is not running; call gallon.run()") } - s := &Server{st: st} - s.initWorkers(s.st.Server.Workers) - + s.initWorkers() mux := http.NewServeMux()

- for path := range s.st.Server.Routes { + for path := range s.st.HttpServer.Handlers.Routes { if path == "/" || strings.HasSuffix(path, " /") { mux.HandleFunc(path+"{$}", s.route(path)) } else { mux.HandleFunc(path, s.route(path)) } } - mux.HandleFunc("/", s.notFound)

if s.st.GC > 0 {
	debug.SetGCPercent(st.GC)
}

- addr := fmt.Sprintf("%s:%d", s.st.Server.Host, s.st.Server.Port) + addr := fmt.Sprintf("%s:%d", s.st.HttpServer.Host, s.st.HttpServer.Port) + log.Info("Server Starts on: %s", addr) TryE(http.ListenAndServe(addr, mux)) + } diff --git a/src/http/lua.go b/src/http/lua.go deleted file mode 100644 index f152188..0000000 --- a/src/http/lua.go +++ /dev/null @@ -1,69 +0,0 @@ -package http - -import ( - "gallon/src/log" - "net/http" - - . "github.com/pixel2175/errs" - glua "github.com/yuin/gopher-lua" -) - -func run(w *worker, fn *glua.LFunction, r *http.Request, hooks bool) (resp Response, err error) { - defer Catch(&err) - L := w.st.LuaContext - req, res := newRequest(L, w.reqMT, r), L.NewTable() - - if hooks { - TryE(call(L, w.st.Server.BeforeRequest, req, res)) - } - - resp = TryV(callResponse(L, fn, req, res)) - - if hooks { - TryE(call(L, w.st.Server.AfterRequest, req, res)) - } - return resp, nil -} - -func call(L *glua.LState, fn *glua.LFunction, req glua.LValue, res *glua.LTable) error { - if fn == nil { - return nil - } - return L.CallByParam(glua.P{Fn: fn, NRet: 0, Protect: true}, req, res) -} - -func callResponse(L *glua.LState, fn *glua.LFunction, req glua.LValue, res *glua.LTable) (resp Response, err error) { - defer Catch(&err) - - if fn == nil { - log.Info("OS") - } - - TryE(L.CallByParam(glua.P{Fn: fn, NRet: 3, Protect: true}, req, res)) - body, status, headers := L.Get(-3), L.Get(-2), L.Get(-1) - L.Pop(3) - - resp = Response{Status: http.StatusOK} - - switch b := body.(type) { - case glua.LString: - resp.Body = string(b) - default: - if body != glua.LNil { - resp.Body = body.String() - } - } - - if n, ok := status.(glua.LNumber); ok { - resp.Status = int(n) - } - - if t, ok := headers.(*glua.LTable); ok { - resp.Headers = make(map[string]string) - t.ForEach(func(k, v glua.LValue) { - resp.Headers[k.String()] = v.String() - }) - } - - return resp, nil -} diff --git a/src/http/pool.go b/src/http/pool.go index df759c1..4a1e395 100644 --- a/src/http/pool.go +++ b/src/http/pool.go @@ -1,40 +1,40 @@ package http

import ( - "net/http" - "gallon/src/lua" "gallon/src/state" + "net/http"

glua "github.com/yuin/gopher-lua"

)

type worker struct { - st *state.State - reqMT *glua.LTable + server *state.HttpServer + luaContext *glua.LState }

-func (s *Server) initWorkers(n int) { +func (s *Server) initWorkers() { + n := s.st.HttpServer.Workers s.workers = make(chan *worker, n)

for range n {

- st := &state.State{ - Server: &state.Server{ - Routes: map[string]*glua.LFunction{}, - ErrorHandlers: map[string]*glua.LFunction{}, - }, - Args: s.st.Args, - Proto: s.st.Proto, - } - lua.InitLua(st) + st := state.Init() + st.Proto = s.st.Proto + lua.InitLua(&st) + s.workers <- &worker{ - st: st, - reqMT: registerRequestType(st.LuaContext), + server: st.HttpServer, + luaContext: st.LuaContext, } } }

func (s *Server) acquire(r *http.Request) (*worker, bool) { + select { + case w := <-s.workers: + return w, true + default: + } select { case w := <-s.workers: return w, true diff --git a/src/http/request.go b/src/http/request.go deleted file mode 100644 index 01a73e3..0000000 --- a/src/http/request.go +++ /dev/null @@ -1,132 +0,0 @@ -package http - -import ( - "bytes" - "io" - "net/http" - "regexp" - - glua "github.com/yuin/gopher-lua" -) - -var wildcard = regexp.MustCompile(`{(\w+)(?:...)?}`) - -type request struct { - r *http.Request - body []byte - read bool - cache map[string]glua.LValue -} - -func registerRequestType(L *glua.LState) *glua.LTable { - mt := L.NewTypeMetatable("request") - L.SetField(mt, "__index", L.NewFunction(requestIndex)) - return mt -} - -func newRequest(L *glua.LState, mt *glua.LTable, r *http.Request) glua.LValue { - ud := L.NewUserData() - ud.Value = &request{r: r} - L.SetMetatable(ud, mt) - return ud -} - -func requestIndex(L *glua.LState) int { - q := L.CheckUserData(1).Value.(*request) - key := L.CheckString(2) - - v, ok := q.cache[key] - if !ok { - v = q.field(L, key) - if q.cache == nil { - q.cache = map[string]glua.LValue{} - } - q.cache[key] = v - } - L.Push(v) - return 1 -} - -func (q *request) field(L *glua.LState, key string) glua.LValue { - r := q.r - switch key { - case "method": - return glua.LString(r.Method) - case "path": - return glua.LString(r.URL.Path) - case "url": - return glua.LString(r.URL.String()) - case "pattern": - return glua.LString(r.Pattern) - case "host": - return glua.LString(r.Host) - case "proto": - return glua.LString(r.Proto) - case "remote_addr": - return glua.LString(r.RemoteAddr) - case "raw_query": - return glua.LString(r.URL.RawQuery) - case "content_length": - return glua.LNumber(r.ContentLength) - case "body": - return glua.LString(q.readBody()) - case "headers": - return lists(L, r.Header) - case "query": - return lists(L, r.URL.Query()) - case "form": - q.readBody() - r.ParseForm() - return lists(L, r.Form) - case "cookies": - return cookies(L, r) - case "path_value": - return pathValue(L, r) - } - return glua.LNil -} - -func (q *request) readBody() []byte { - if !q.read { - q.body, _ = io.ReadAll(q.r.Body) - q.r.Body = io.NopCloser(bytes.NewReader(q.body)) - q.read = true - } - return q.body -} - -func lists(L *glua.LState, m map[string][]string) *glua.LTable { - t := L.NewTable() - for k, values := range m { - list := L.NewTable() - for _, v := range values { - list.Append(glua.LString(v)) - } - t.RawSetString(k, list) - } - return t -} - -func cookies(L *glua.LState, r *http.Request) *glua.LTable { - t := L.NewTable() - for _, c := range r.Cookies() { - t.RawSetString(c.Name, glua.LString(c.Value)) - } - return t -} - -func pathValue(L *glua.LState, r *http.Request) *glua.LFunction { - return L.NewFunction(func(L *glua.LState) int { - if L.GetTop() > 0 { - L.Push(glua.LString(r.PathValue(L.CheckString(1)))) - return 1 - } - - all := L.NewTable() - for _, m := range wildcard.FindAllStringSubmatch(r.Pattern, -1) { - all.RawSetString(m[1], glua.LString(r.PathValue(m[1]))) - } - L.Push(all) - return 1 - }) -} diff --git a/src/http/response.go b/src/http/response.go deleted file mode 100644 index 2c2c658..0000000 --- a/src/http/response.go +++ /dev/null @@ -1,20 +0,0 @@ -package http - -import ( - "io" - "net/http" -) - -type Response struct { - Body string - Status int - Headers map[string]string -} - -func (resp Response) Write(w http.ResponseWriter) { - for k, v := range resp.Headers { - w.Header().Set(k, v) - } - w.WriteHeader(resp.Status) - io.WriteString(w, resp.Body) -} diff --git a/src/http/route.go b/src/http/route.go new file mode 100644 index 0000000..40015fe --- /dev/null +++ b/src/http/route.go @@ -0,0 +1,74 @@ +package http + +import ( + "fmt" + "gallon/src/log" + "io" + "net/http" + "os" + + . "github.com/pixel2175/errs" +) + +func (s *Server) route(path string) http.HandlerFunc { + return func(rw http.ResponseWriter, r *http.Request) { + var err error + defer Catch(&err, func(err *error) { + log.Warn(log.Title("ERROR"), "%s", (*err).Error()) + http.Error(rw, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) + *err = nil + }) + worker, ok := s.acquire(r) + if !ok { + return + } + defer s.release(worker) + route := worker.server.Handlers.Routes[path] + resp, err := run(worker, route.Func, r, true) + TryV(resp, err, func(err error) error { + fmt.Fprintln(os.Stderr, err) + resp = errorPage(worker, r, http.StatusInternalServerError) + return nil + }) + + Write(resp, rw) + + } +} + +func (s *Server) notFound(rw http.ResponseWriter, r *http.Request) { + worker, ok := s.acquire(r) + if !ok { + return + } + defer s.release(worker) + + resp := errorPage(worker, r, http.StatusNotFound) + Write(resp, rw) +} + +func Write(resp Response, w http.ResponseWriter) { + for k, v := range resp.Headers { + w.Header().Set(k, v) + } + w.WriteHeader(resp.Status) + io.WriteString(w, resp.Body) +} + +func errorPage(worker *worker, r *http.Request, code int) Response { + resp := Response{Body: http.StatusText(code)} + if fn := worker.server.Handlers.ErrorHandlers[code]; fn != nil { + res, err := run(worker, fn, r, true) + switch { + case err == nil: + resp = res + case code != http.StatusInternalServerError: + fmt.Fprintln(os.Stderr, err) + return errorPage(worker, r, http.StatusInternalServerError) + default: + fmt.Fprintln(os.Stderr, err) + } + } + resp.Status = code + return resp +} diff --git a/src/jinja/jinja.go b/src/jinja/jinja.go index 9bbf236..79ff511 100644 --- a/src/jinja/jinja.go +++ b/src/jinja/jinja.go @@ -59,8 +59,8 @@ func RenderFile(j *state.Jinja, name string, data map[string]any) (result string func render(tpl *exec.Template, data map[string]any) (result string, err error) { ctx := exec.NewContext(data)

- v,e := tpl.ExecuteToString(ctx) - result = TryV(v,e, func(err *error) { + v, e := tpl.ExecuteToString(ctx) + result = TryV(v, e, func(err *error) { if syntaxErr, ok := errors.AsType[*parser.SyntaxError](*err); ok { *err = fmt.Errorf( "Jinja syntax error:\n- Line=%d, Column=%d\n- %s", diff --git a/src/lua/converter.go b/src/lua/converter.go index 8650edf..1c86504 100644 --- a/src/lua/converter.go +++ b/src/lua/converter.go @@ -4,36 +4,16 @@ import ( glua "github.com/yuin/gopher-lua" )

-func luaTableToMap(table *glua.LTable) map[string]any { - result := make(map[string]any) - - table.ForEach(func(key, value glua.LValue) { - if k, ok := key.(glua.LString); ok { - result[string(k)] = luaValueToGo(value) - } - }) - - return result -} - -func luaValueToGo(value glua.LValue) any { +func toGo(value glua.LValue) any { switch v := value.(type) { - case *glua.LTable: - if n := v.Len(); n > 0 && isArray(v, n) { - result := make([]any, n) - for i := range result { - result[i] = luaValueToGo(v.RawGetInt(i + 1)) - } - return result - } - return luaTableToMap(v) - case glua.LString: return string(v) case glua.LNumber: return float64(v) case glua.LBool: return bool(v) + case *glua.LTable: + return tableToGo(v) case *glua.LNilType: return nil default: @@ -41,21 +21,54 @@ func luaValueToGo(value glua.LValue) any { } }

-func isArray(table *glua.LTable, n int) bool { - count := 0 +func toMap(t *glua.LTable) map[string]any { + m := make(map[string]any)

- for k, _ := table.Next(glua.LNil); k != glua.LNil; k, _ = table.Next(k) { - num, ok := k.(glua.LNumber) - if !ok { - return false + t.ForEach(func(k, v glua.LValue) { + if s, ok := k.(glua.LString); ok { + m[string(s)] = toGo(v) } + })

- i := int(num) - if float64(i) != float64(num) || i < 1 || i > n { - return false - } - count++ + return m +} + +func tableToGo(t *glua.LTable) any { + n := t.Len() + + var arr []any + if n > 0 { + arr = make([]any, n) }

- return count == n + var m map[string]any + ints, mixed := 0, false + + t.ForEach(func(k, v glua.LValue) { + switch k := k.(type) { + case glua.LString: + if m == nil { + m = make(map[string]any) + } + m[string(k)] = toGo(v) + case glua.LNumber: + i := int(k) + if float64(i) == float64(k) && i >= 1 && i <= n { + arr[i-1] = toGo(v) + ints++ + } else { + mixed = true + } + default: + mixed = true + } + }) + + if n > 0 && ints == n && m == nil && !mixed { + return arr + } + if m == nil { + return map[string]any{} + } + return m } diff --git a/src/lua/error_handler.go b/src/lua/error_handler.go index f184049..b2a9ee6 100644 --- a/src/lua/error_handler.go +++ b/src/lua/error_handler.go @@ -1,15 +1,83 @@ package lua

import ( - "strconv" - + "fmt" + . "github.com/pixel2175/errs" glua "github.com/yuin/gopher-lua" + "os" + "strconv" + "strings" )

-func (self *Lua) registerErrorHandler() { - self.Gallon.RawSetString("error_handler", self.Context.NewFunction(func(L *glua.LState) int { - code := strconv.Itoa(L.CheckInt(1)) - self.State.Server.ErrorHandlers[code] = L.CheckFunction(2) - return 0 - })) +func describeLuaError(path string, err error) error { + src, readErr := os.ReadFile(path) + if readErr != nil { + return fmt.Errorf("%s: %w", path, err) + } + + lines := strings.Split(string(src), "\n") + + var b strings.Builder + fmt.Fprintf(&b, "%s\n\n", err.Error()) + + if line, ok := extractLine(err.Error()); ok && line > 0 && line <= len(lines) { + writeSnippet(&b, lines, line) + } else { + writeTail(&b, lines) + writeHints(&b, string(src)) + } + + return fmt.Errorf("%s", b.String()) +} + +func extractLine(msg string) (int, bool) { + for p := range strings.SplitSeq(msg, ":") { + if n, err := strconv.Atoi(strings.TrimSpace(p)); err == nil { + return n, true + } + } + return 0, false +} + +func writeSnippet(b *strings.Builder, lines []string, line int) { + start, end := max(0, line-3), min(len(lines), line+2) + for i := start; i < end; i++ { + marker := " " + if i == line-1 { + marker = "> " + } + fmt.Fprintf(b, "%s%4d | %s\n", marker, i+1, lines[i]) + } +} + +func writeTail(b *strings.Builder, lines []string) { + start := max(0, len(lines)-6) + fmt.Fprintln(b, " (error at EOF, showing end of file)") + for i := start; i < len(lines); i++ { + fmt.Fprintf(b, " %4d | %s\n", i+1, lines[i]) + } +} + +func writeHints(b *strings.Builder, src string) { + if o, c := strings.Count(src, "{"), strings.Count(src, "}"); o != c { + fmt.Fprintf(b, "\n hint: %d '{' vs %d '}' — likely an unclosed block\n", o, c) + } + if f, e := strings.Count(src, "function"), strings.Count(src, "end"); f > e { + fmt.Fprintf(b, " hint: %d 'function' vs %d 'end' — likely a missing 'end'\n", f, e) + } + if strings.Count(src, `"`)%2 != 0 { + fmt.Fprintln(b, " hint: odd number of '&#34;' — likely an unterminated string") + } +} + +func (self *Lua) loadFile(path string) { + fn, lerr := self.State.LuaContext.LoadFile(path) + fn = TryV(fn, lerr, func(err error) error { + return describeLuaError(path, err) + }) + + self.State.LuaContext.Push(fn) + TryE(self.State.LuaContext.PCall(0, glua.MultRet, nil), func(err error) error { + return describeLuaError(path, err) + }) } diff --git a/src/lua/handlers.go b/src/lua/handlers.go new file mode 100644 index 0000000..fea017b --- /dev/null +++ b/src/lua/handlers.go @@ -0,0 +1,28 @@ +package lua + +import ( + "gallon/src/state" + + glua "github.com/yuin/gopher-lua" +) + +func (self *Lua) route(L *glua.LState) int { + self.State.HttpServer.Handlers.Routes[L.CheckString(1)] = state.Route{Func: L.CheckFunction(2)} + return 0 +} + +func (self *Lua) beforeRequest(L *glua.LState) int { + self.State.HttpServer.Handlers.BeforeRequest = L.CheckFunction(1) + return 0 +} + +func (self *Lua) afterRequest(L *glua.LState) int { + self.State.HttpServer.Handlers.AfterRequest = L.CheckFunction(1) + return 0 +} + +func (self *Lua) errorHandler(L *glua.LState) int { + code := L.CheckInt(1) + self.State.HttpServer.Handlers.ErrorHandlers[code] = L.CheckFunction(2) + return 0 +} diff --git a/src/lua/helpers.go b/src/lua/helpers.go deleted file mode 100644 index e68d733..0000000 --- a/src/lua/helpers.go +++ /dev/null @@ -1,83 +0,0 @@ -package lua - -import ( - "fmt" - . "github.com/pixel2175/errs" - glua "github.com/yuin/gopher-lua" - "os" - "strconv" - "strings" -) - -func describeLuaError(path string, err error) error { - src, readErr := os.ReadFile(path) - if readErr != nil { - return fmt.Errorf("%s: %w", path, err) - } - - lines := strings.Split(string(src), "\n") - - var b strings.Builder - fmt.Fprintf(&b, "%s\n\n", err.Error()) - - if line, ok := extractLine(err.Error()); ok && line > 0 && line <= len(lines) { - writeSnippet(&b, lines, line) - } else { - writeTail(&b, lines) - writeHints(&b, string(src)) - } - - return fmt.Errorf("%s", b.String()) -} - -func extractLine(msg string) (int, bool) { - for p := range strings.SplitSeq(msg, ":") { - if n, err := strconv.Atoi(strings.TrimSpace(p)); err == nil { - return n, true - } - } - return 0, false -} - -func writeSnippet(b *strings.Builder, lines []string, line int) { - start, end := max(0, line-3), min(len(lines), line+2) - for i := start; i < end; i++ { - marker := " " - if i == line-1 { - marker = "> " - } - fmt.Fprintf(b, "%s%4d | %s\n", marker, i+1, lines[i]) - } -} - -func writeTail(b *strings.Builder, lines []string) { - start := max(0, len(lines)-6) - fmt.Fprintln(b, " (error at EOF, showing end of file)") - for i := start; i < len(lines); i++ { - fmt.Fprintf(b, " %4d | %s\n", i+1, lines[i]) - } -} - -func writeHints(b *strings.Builder, src string) { - if o, c := strings.Count(src, "{"), strings.Count(src, "}"); o != c { - fmt.Fprintf(b, "\n hint: %d '{' vs %d '}' — likely an unclosed block\n", o, c) - } - if f, e := strings.Count(src, "function"), strings.Count(src, "end"); f > e { - fmt.Fprintf(b, " hint: %d 'function' vs %d 'end' — likely a missing 'end'\n", f, e) - } - if strings.Count(src, `"`)%2 != 0 { - fmt.Fprintln(b, " hint: odd number of '&#34;' — likely an unterminated string") - } -} - -func (self *Lua) loadFile(path string) { - fn, lerr := self.State.LuaContext.LoadFile(path) - fn = TryV(fn, lerr, func(err *error) { - *err = describeLuaError(path, *err) - }) - - self.State.LuaContext.Push(fn) - TryE(self.State.LuaContext.PCall(0, glua.MultRet, nil), func(err *error) { - *err = describeLuaError(path, *err) - }) -} diff --git a/src/lua/jinja.go b/src/lua/jinja.go index 39ee746..adfe61c 100644 --- a/src/lua/jinja.go +++ b/src/lua/jinja.go @@ -4,72 +4,63 @@ import ( "gallon/src/jinja" "gallon/src/state"

- . "github.com/pixel2175/errs" glua "github.com/yuin/gopher-lua" )

-func (self *Lua) ensureJinja() { - if self.State.Jinja == nil { - self.State.Jinja = &state.Jinja{} +func (self *Lua) jinjaState() *state.Jinja { + j := self.State.Jinja + if j == nil { + j = &state.Jinja{} + self.State.Jinja = j } - - if self.State.Jinja.Loader == nil || self.State.Jinja.Config == nil { - jinja.Init(self.State.Jinja) + if j.Loader == nil || j.Config == nil { + jinja.Init(j) } + return j }

-func (self *Lua) luaJinjaRenderTemplate(L *glua.LState) int { - self.ensureJinja() +func (self *Lua) jinjaRender(L *glua.LState) int { + j := self.jinjaState()

name := L.CheckString(1)

- data := L.OptTable(2, L.NewTable()) + data := toMap(L.OptTable(2, L.NewTable()))

- result, err := jinja.RenderFile(self.State.Jinja, name, luaTableToMap(data)) - result = TryV(result, err, func(err *error) { - L.RaiseError("jinja.render_template: %v", *err) - }) + result, err := jinja.RenderFile(j, name, data) + if err != nil { + L.RaiseError("jinja.render_template: %v", err) + }

L.Push(glua.LString(result))
return 1

}

-func (self *Lua) luaJinjaRenderTemplateFromString(L *glua.LState) int { - self.ensureJinja() +func (self *Lua) jinjaRenderString(L *glua.LState) int { + j := self.jinjaState()

content := L.CheckString(1)

- data := L.OptTable(2, L.NewTable()) + data := toMap(L.OptTable(2, L.NewTable()))

- result, err := jinja.RenderString(self.State.Jinja, content, luaTableToMap(data)) - - result = TryV(result, err, func(err *error) { - L.RaiseError("jinja.render_template_from_string: %v", *err) - }) + result, err := jinja.RenderString(j, content, data) + if err != nil { + L.RaiseError("jinja.render_template_from_string: %v", err) + }

L.Push(glua.LString(result))
return 1

}

-func (self *Lua) luaJinjaSetTemplateDir(L *glua.LState) int { +func (self *Lua) jinjaSetTemplateDir(L *glua.LState) int { dir := L.CheckString(1)

if self.State.Jinja == nil {
	self.State.Jinja = &#38;state.Jinja{}
}

+ j := self.State.Jinja

- self.State.Jinja.TemplatesDir = dir - self.State.Jinja.Loader = nil - self.State.Jinja.Config = nil - jinja.Init(self.State.Jinja) + j.TemplatesDir = dir + j.Loader = nil + j.Config = nil + jinja.Init(j)

return 0

} -func (self *Lua) registerJinja() { - jinjaTable := self.Context.NewTable() - self.Context.SetFuncs(jinjaTable, map[string]glua.LGFunction{ - "render_template": self.luaJinjaRenderTemplate, - "render_template_from_string": self.luaJinjaRenderTemplateFromString, - "set_template_dir": self.luaJinjaSetTemplateDir, - }) - - self.Gallon.RawSetString("jinja", jinjaTable) -} diff --git a/src/lua/log.go b/src/lua/log.go index 7a32c90..96198a4 100644 --- a/src/lua/log.go +++ b/src/lua/log.go @@ -6,31 +6,17 @@ import ( glua "github.com/yuin/gopher-lua" )

-func (self *Lua) luaLogDie(L *glua.LState) int { - msg := L.CheckString(1) - log.Die(msg) +func (self *Lua) logInfo(L *glua.LState) int { + log.Info("%s", L.CheckString(1)) return 0 }

-func (self *Lua) luaLogWarn(L *glua.LState) int { - msg := L.CheckString(1) - log.Warn(msg) +func (self *Lua) logWarn(L *glua.LState) int { + log.Warn(L.CheckString(1)) return 0 }

-func (self *Lua) luaLogInfo(L *glua.LState) int { - msg := L.CheckString(1) - log.Info("%s", msg) +func (self *Lua) logDie(L *glua.LState) int { + log.Die(L.CheckString(1)) return 0 } - -func (self *Lua) registerLog() { - logTable := self.Context.NewTable() - self.Context.SetFuncs(logTable, map[string]glua.LGFunction{ - "info": self.luaLogInfo, - "warn": self.luaLogWarn, - "die": self.luaLogDie, - }) - - self.Gallon.RawSetString("log", logTable) -} diff --git a/src/lua/lua.go b/src/lua/lua.go index 1d81068..f0f966a 100644 --- a/src/lua/lua.go +++ b/src/lua/lua.go @@ -16,6 +16,8 @@ type Lua struct { Gallon *glua.LTable }

+type funcs = map[string]glua.LGFunction + func Compile(path string) *glua.FunctionProto { var err error defer Catch(&err, func(err *error) { @@ -23,43 +25,53 @@ func Compile(path string) *glua.FunctionProto { })

f := TryV(os.Open(path))

- defer f.Close()

chunk := TryV(parse.Parse(f, path))

- p := TryV(glua.Compile(chunk, path)) - return p + return TryV(glua.Compile(chunk, path)) }

func InitLua(st *state.State) { - st.LuaContext = glua.NewState(glua.Options{ + L := glua.NewState(glua.Options{ RegistrySize: 1024, - RegistryMaxSize: 1024 * 20, + RegistryMaxSize: 20 * 1024, CallStackSize: 64, }) + st.LuaContext = L

- self := Lua{ - State: st, - Context: st.LuaContext, - } - - self.registerGallon() + self := &Lua{State: st, Context: L, Gallon: L.NewTable()} + self.register()

- L := st.LuaContext L.Push(L.NewFunctionFromProto(st.Proto)) TryE(L.PCall(0, glua.MultRet, nil)) - }

-func (self *Lua) registerGallon() { - self.Gallon = self.State.LuaContext.NewTable() +func (self *Lua) register() { + self.Context.SetFuncs(self.Gallon, funcs{ + "run": self.run, + "route": self.route, + "before_request": self.beforeRequest, + "after_request": self.afterRequest, + "error_handler": self.errorHandler, + }) + + self.sub("jinja", funcs{ + "render_template": self.jinjaRender, + "render_template_from_string": self.jinjaRenderString, + "set_template_dir": self.jinjaSetTemplateDir, + })

- self.registerRun() - self.registerMiddleware() - self.registerRoutes() - self.registerErrorHandler() - self.registerJinja() - self.registerLog() + self.sub("log", funcs{ + "info": self.logInfo, + "warn": self.logWarn, + "die": self.logDie, + }) + + self.Context.SetGlobal("gallon", self.Gallon) +}

- self.State.LuaContext.SetGlobal("gallon", self.Gallon) +func (self *Lua) sub(name string, f funcs) { + t := self.Context.NewTable() + self.Context.SetFuncs(t, f) + self.Gallon.RawSetString(name, t) } diff --git a/src/lua/middleware.go b/src/lua/middleware.go deleted file mode 100644 index 4c7c473..0000000 --- a/src/lua/middleware.go +++ /dev/null @@ -1,17 +0,0 @@ -package lua - -import ( - glua "github.com/yuin/gopher-lua" -) - -func (self *Lua) registerMiddleware() { - self.Gallon.RawSetString("before_request", self.Context.NewFunction(func(L *glua.LState) int { - self.State.Server.BeforeRequest = L.CheckFunction(1) - return 0 - })) - - self.Gallon.RawSetString("after_request", self.Context.NewFunction(func(L *glua.LState) int { - self.State.Server.AfterRequest = L.CheckFunction(1) - return 0 - })) -} diff --git a/src/lua/request_to_table.go b/src/lua/request_to_table.go new file mode 100644 index 0000000..ec37e18 --- /dev/null +++ b/src/lua/request_to_table.go @@ -0,0 +1,148 @@ +package lua + +import ( + "bytes" + "io" + "net/http" + "strings" + + glua "github.com/yuin/gopher-lua" +) + +type reqCtx struct { + r *http.Request + body []byte + read bool + pathFn *glua.LFunction +} + +func RequestToTable(L *glua.LState, r *http.Request) *glua.LTable { + mt, ok := L.GetTypeMetatable("gallon.req").(*glua.LTable) + if !ok { + mt = newReqMeta(L) + } + ctx := mt.RawGetString("__ctx").(*glua.LUserData).Value.(*reqCtx) + ctx.r, ctx.body, ctx.read = r, nil, false + + t := L.CreateTable(0, 16) + L.SetMetatable(t, mt) + return t +} + +func newReqMeta(L *glua.LState) *glua.LTable { + ctx := &reqCtx{} + ctx.pathFn = L.NewFunction(ctx.pathValue) + + mt := L.NewTypeMetatable("gallon.req") + ud := L.NewUserData() + ud.Value = ctx + mt.RawSetString("__ctx", ud) + mt.RawSetString("__index", L.NewFunction(func(L *glua.LState) int { + t, key := L.CheckTable(1), L.CheckString(2) + v := ctx.field(L, key) + if v != glua.LNil { + t.RawSetString(key, v) + } + L.Push(v) + return 1 + })) + return mt +} + +func (c *reqCtx) readBody() { + if c.read { + return + } + c.read = true + if c.r.Body != nil && c.r.Body != http.NoBody { + c.body, _ = io.ReadAll(c.r.Body) + c.r.Body = io.NopCloser(bytes.NewReader(c.body)) + } +} + +func (c *reqCtx) field(L *glua.LState, k string) glua.LValue { + r := c.r + switch k { + case "method": + return glua.LString(r.Method) + case "path": + return glua.LString(r.URL.Path) + case "url": + return glua.LString(r.URL.String()) + case "pattern": + return glua.LString(r.Pattern) + case "host": + return glua.LString(r.Host) + case "proto": + return glua.LString(r.Proto) + case "remote_addr": + return glua.LString(r.RemoteAddr) + case "raw_query": + return glua.LString(r.URL.RawQuery) + case "content_length": + return glua.LNumber(r.ContentLength) + case "body": + c.readBody() + return glua.LString(c.body) + case "headers": + return list(L, r.Header) + case "query": + return list(L, r.URL.Query()) + case "form": + c.readBody() + r.ParseForm() + if c.body != nil { + r.Body = io.NopCloser(bytes.NewReader(c.body)) + } + return list(L, r.Form) + case "cookies": + cs := r.Cookies() + t := L.CreateTable(0, len(cs)) + for _, ck := range cs { + t.RawSetString(ck.Name, glua.LString(ck.Value)) + } + return t + case "path_value": + return c.pathFn + } + return glua.LNil +} + +func (c *reqCtx) pathValue(L *glua.LState) int { + r := c.r + if L.GetTop() > 0 { + L.Push(glua.LString(r.PathValue(L.CheckString(1)))) + return 1 + } + all := L.CreateTable(0, 0) + p := r.Pattern + // i hate my life + for { + i := strings.IndexByte(p, '{') + if i < 0 { + break + } + j := strings.IndexByte(p[i:], '}') + if j < 0 { + break + } + if name := strings.TrimSuffix(p[i+1:i+j], "..."); name != "$" { + all.RawSetString(name, glua.LString(r.PathValue(name))) + } + p = p[i+j+1:] + } + L.Push(all) + return 1 +} + +func list(L *glua.LState, m map[string][]string) *glua.LTable { + t := L.CreateTable(0, len(m)) + for k, vs := range m { + l := L.CreateTable(len(vs), 0) + for _, v := range vs { + l.Append(glua.LString(v)) + } + t.RawSetString(k, l) + } + return t +} diff --git a/src/lua/route.go b/src/lua/route.go deleted file mode 100644 index 54db49b..0000000 --- a/src/lua/route.go +++ /dev/null @@ -1,14 +0,0 @@ -package lua - -import ( - glua "github.com/yuin/gopher-lua" -) - -func (self *Lua) registerRoutes() { - - self.Gallon.RawSetString("route", self.Context.NewFunction(func(L *glua.LState) int { - path := L.CheckString(1) - self.State.Server.Routes[path] = L.CheckFunction(2) - return 0 - })) -} diff --git a/src/lua/server.go b/src/lua/server.go index 5bd6f72..8b91b1e 100644 --- a/src/lua/server.go +++ b/src/lua/server.go @@ -7,37 +7,50 @@ import ( glua "github.com/yuin/gopher-lua" )

-func (self *Lua) registerRun() { - self.Gallon.RawSetString("run", self.Context.NewFunction(func(L *glua.LState) int { - opts := L.CheckTable(1) - srv := self.State.Server - - srv.Workers = 4 - self.State.GC = -1 - if n, err := strconv.Atoi(os.Getenv("G_WORKERS")); err == nil && n > 0 { - srv.Workers = n - } - - if host, ok := opts.RawGetString("host").(glua.LString); ok { - srv.Host = string(host) - } - if port, ok := opts.RawGetString("port").(glua.LNumber); ok { - srv.Port = int(port) - } - if n, ok := opts.RawGetString("workers").(glua.LNumber); ok { - if n < 1 { - L.ArgError(1, "workers must be at least 1") - } - srv.Workers = int(n) - } - if n, ok := opts.RawGetString("gc").(glua.LNumber); ok { - if n < 1 { - L.ArgError(1, "gc must be at least 1") - } - self.State.GC = int(n) - } - - srv.IsRunning = true - return 0 - })) +func optString(t *glua.LTable, key string) (string, bool) { + s, ok := t.RawGetString(key).(glua.LString) + return string(s), ok +} + +func optInt(t *glua.LTable, key string) (int, bool) { + n, ok := t.RawGetString(key).(glua.LNumber) + return int(n), ok +} + +func optPositive(L *glua.LState, t *glua.LTable, key string) (int, bool) { + n, ok := t.RawGetString(key).(glua.LNumber) + if !ok { + return 0, false + } + if n < 1 { + L.ArgError(1, key+" must be at least 1") + } + return int(n), true +} + +func (self *Lua) run(L *glua.LState) int { + opts := L.CheckTable(1) + srv := self.State.HttpServer + + srv.Workers = 4 + if n, err := strconv.Atoi(os.Getenv("G_WORKERS")); err == nil && n > 0 { + srv.Workers = n + } + self.State.GC = -1 + + if host, ok := optString(opts, "host"); ok { + srv.Host = host + } + if port, ok := optInt(opts, "port"); ok { + srv.Port = port + } + if n, ok := optPositive(L, opts, "workers"); ok { + srv.Workers = n + } + if n, ok := optPositive(L, opts, "gc"); ok { + self.State.GC = n + } + + srv.IsRunning = true + return 0 } diff --git a/src/state/parser.go b/src/state/parser.go new file mode 100644 index 0000000..a25f0b6 --- /dev/null +++ b/src/state/parser.go @@ -0,0 +1,9 @@ +package state + +type CmdRun struct { + MainPoint string `arg:"positional" default:"main.lua" help:"main lua file"` +} + +type Args struct { + Run *CmdRun `arg:"subcommand:run" help:"Run web server"` +} diff --git a/src/state/state.go b/src/state/state.go index d5a1828..4a006b8 100644 --- a/src/state/state.go +++ b/src/state/state.go @@ -6,50 +6,55 @@ import ( glua "github.com/yuin/gopher-lua" )

-type CmdRun struct { - MainPoint string `arg:"positional" default:"main.lua" help:"main lua file"` +type Route struct { + Func *glua.LFunction + Body string + Status int + Headers map[string]string + Redirect string }

-type Args struct { - Run *CmdRun `arg:"subcommand:run" help:"Run web server"` +type Handlers struct { + ErrorHandlers map[int]*glua.LFunction + Routes map[string]Route + BeforeRequest *glua.LFunction + AfterRequest *glua.LFunction }

-type Server struct { +type HttpServer struct { IsRunning bool Host string Port int Workers int - - ErrorHandlers map[string]*glua.LFunction - Routes map[string]*glua.LFunction - BeforeRequest *glua.LFunction - AfterRequest *glua.LFunction + Handlers Handlers } type Jinja struct { - Loader loaders.Loader - Config *config.Config + Loader loaders.Loader + Config *config.Config TemplatesDir string }

type State struct { - Server *Server + HttpServer *HttpServer Args *Args Jinja *Jinja

LuaContext &#42;glua.LState
Proto      &#42;glua.FunctionProto

- GC int + GC int }

func Init() State { st := State{ - Args: &Args{}, + Args: &Args{}, Jinja: &Jinja{}, - Server: &Server{ - IsRunning: false, - Routes: make(map[string]*glua.LFunction), - ErrorHandlers: make(map[string]*glua.LFunction), + HttpServer: &HttpServer{ + IsRunning: false, + Handlers: Handlers{ + Routes: make(map[string]Route), + ErrorHandlers: make(map[int]*glua.LFunction), + }, }, }

// Created by Pi66

// Copyright ©Pi66 2026