Also add a function handler.

Author: scr-oath

http/api_test.go

@@ -262,3 +262,13 @@ func TestMTLSServerWithClient(t *testing.T) {
 	)
 	assert.NotZero(t, tests.RunLuaTestFile(t, preload, "test/test_mtls_server_with_client.lua"))
 }
+
+func TestServer(t *testing.T) {
+	preload := tests.SeveralPreloadFuncs(
+		lua_http.Preload,
+		lua_time.Preload,
+		inspect.Preload,
+		plugin.Preload,
+	)
+	assert.NotZero(t, tests.RunLuaTestFile(t, preload, "test/test_server.lua"))
+}

http/loader.go

@@ -49,10 +49,11 @@ func Loader(L *lua.LState) int {
 	http_server_ud := L.NewTypeMetatable(`http_server_ud`)
 	L.SetGlobal(`http_server_ud`, http_server_ud)
 	L.SetField(http_server_ud, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
-		"accept":           server.Accept,
-		"addr":             server.Addr,
-		"do_handle_file":   server.HandleFile,
-		"do_handle_string": server.HandleString,
+		"accept":             server.Accept,
+		"addr":               server.Addr,
+		"do_handle_file":     server.HandleFile,
+		"do_handle_string":   server.HandleString,
+		"do_handle_function": server.HandleFunction,
 	}))
 
 	t := L.NewTable()

http/server/loader.go

@@ -30,10 +30,11 @@ func Loader(L *lua.LState) int {
 	http_server_ud := L.NewTypeMetatable(`http_server_ud`)
 	L.SetGlobal(`http_server_ud`, http_server_ud)
 	L.SetField(http_server_ud, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
-		"accept":           Accept,
-		"addr":             Addr,
-		"do_handle_file":   HandleFile,
-		"do_handle_string": HandleString,
+		"accept":             Accept,
+		"addr":               Addr,
+		"do_handle_file":     HandleFile,
+		"do_handle_string":   HandleString,
+		"do_handle_function": HandleFunction,
 	}))
 
 	t := L.NewTable()

http/server/server.go

@@ -236,6 +236,7 @@ func HandleFile(L *lua.LState) int {
 		case data := <-s.serveData:
 			go func(sData *serveData, filename string) {
 				state := newHandlerState(data)
+				defer state.Close()
 				if err := state.DoFile(filename); err != nil {
 					log.Printf("[ERROR] handle file %s: %s\n", filename, err.Error())
 					data.done <- true
@@ -248,7 +249,7 @@ func HandleFile(L *lua.LState) int {
 	return 0
 }
 
-// HandleString lua http_server_ud:handler_string(body)
+// HandleString lua http_server_ud:handle_string(body)
 func HandleString(L *lua.LState) int {
 	s := checkServer(L, 1)
 	body := L.CheckString(2)
@@ -257,6 +258,7 @@ func HandleString(L *lua.LState) int {
 		case data := <-s.serveData:
 			go func(sData *serveData, content string) {
 				state := newHandlerState(sData)
+				defer state.Close()
 				if err := state.DoString(content); err != nil {
 					log.Printf("[ERROR] handle: %s\n", err.Error())
 					data.done <- true
@@ -268,6 +270,48 @@ func HandleString(L *lua.LState) int {
 	return 0
 }
 
+// HandleFunction lua http_server_ud:handle_function(func(response, request))
+func HandleFunction(L *lua.LState) int {
+	s := checkServer(L, 1)
+	f := L.CheckFunction(2)
+	if len(f.Upvalues) > 0 {
+		L.ArgError(2, "cannot pass closures")
+	}
+
+	// Stash any args to pass to the function beyond response and request
+	var args []lua.LValue
+	top := L.GetTop()
+	for i := 3; i <= top; i++ {
+		args = append(args, L.Get(i))
+	}
+
+	for {
+		select {
+		case data := <-s.serveData:
+			go func(sData *serveData) {
+				state := newHandlerState(sData)
+				defer state.Close()
+				response := state.GetGlobal("response")
+				request := state.GetGlobal("request")
+				f := state.NewFunctionFromProto(f.Proto)
+				state.Push(f)
+				state.Push(response)
+				state.Push(request)
+				// Push any extra args
+				for _, arg := range args {
+					state.Push(arg)
+				}
+				if err := state.PCall(2+len(args), 0, nil); err != nil {
+					log.Printf("[ERROR] handle: %s\n", err.Error())
+					data.done <- true
+					log.Printf("[ERROR] closed connection\n")
+				}
+				state.Pop(state.GetTop())
+			}(data)
+		}
+	}
+}
+
 // ServeHTTP interface realisation
 func (s *luaServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	doneChan := make(chan bool)

http/test/test_mtls_server_with_client.lua

@@ -14,12 +14,11 @@ function TestMTLSServerWithClient(t)
         }
         assert(not err, tostring(err))
         addr_ch:send(server:addr())
-        while true do
-            local request, response = server:accept()
+        server:do_handle_string([=[
             response:code(200)
             response:write("OK\n")
             response:done()
-        end
+        ]=])
     ]]
     local server_plugin = plugin.do_string(server_body, addr_ch)
     server_plugin:run()

http/test/test_server.lua

@@ -0,0 +1,35 @@
+local http = require 'http'
+local plugin = require 'plugin'
+local time = require 'time'
+local inspect = require 'inspect'
+
+function Test_do_handle_function(t)
+    local addr_ch = channel.make(1)
+    local server_body = [[
+        local addr_ch = unpack(arg)
+        local http = require 'http'
+        local server, err = http.server {}
+        assert(not err, tostring(err))
+        addr_ch:send(server:addr())
+        server:do_handle_function(function(response, request)
+            print(string.format("response = %s", response))
+            response:write("OK\n")
+            response:code(200)
+            response:done()
+        end)
+    ]]
+    local server_plugin = plugin.do_string(server_body, addr_ch)
+    server_plugin:run()
+    time.sleep(1)
+    local server_plugin_error = server_plugin:error()
+    assert(not server_plugin_error, tostring(server_plugin_error))
+    local ok, addr = addr_ch:receive(1)
+    assert(ok, "addr not ok")
+    local tURL = string.format("http://%s/", addr)
+
+    local client = http.client()
+    local req = http.request('GET', tURL)
+    local resp, err = client:do_request(req)
+    assert(not err, tostring(err))
+    assert(resp.code == 200, tostring(resp.code))
+end