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
Show less
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"
...
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 '"' — 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 '"' — 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 = &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 *glua.LState
Proto *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),
+ },
},
}