optimize

Author: dunglas

cgi.go

@@ -212,7 +212,7 @@ func addPreparedEnvToServer(fc *frankenPHPContext, trackVarsArray *C.zval) {
 //export go_register_variables
 func go_register_variables(threadIndex C.uintptr_t, trackVarsArray *C.zval) {
 	thread := phpThreads[threadIndex]
-	fc := thread.context().Value(contextKey).(*frankenPHPContext)
+	fc := thread.frankenPHPContext()
 
 	if fc.request != nil {
 		addKnownVariablesToServer(thread, fc, trackVarsArray)
@@ -279,7 +279,7 @@ func splitPos(path string, splitPath []string) int {
 //export go_update_request_info
 func go_update_request_info(threadIndex C.uintptr_t, info *C.sapi_request_info) C.bool {
 	thread := phpThreads[threadIndex]
-	fc := thread.context().Value(contextKey).(*frankenPHPContext)
+	fc := thread.frankenPHPContext()
 	request := fc.request
 
 	if request == nil {

context.go

@@ -38,6 +38,11 @@ type frankenPHPContext struct {
 	startedAt time.Time
 }
 
+type contextHolder struct {
+	ctx  			  context.Context
+	frankenPHPContext *frankenPHPContext
+}
+
 // fromContext extracts the frankenPHPContext from a context.
 func fromContext(ctx context.Context) (fctx *frankenPHPContext, ok bool) {
 	fctx, ok = ctx.Value(contextKey).(*frankenPHPContext)

frankenphp.go

@@ -274,7 +274,7 @@ func Init(options ...Option) error {
 		return err
 	}
 
-	regularRequestChan = make(chan context.Context, opt.numThreads-workerThreadCount)
+	regularRequestChan = make(chan contextHolder, opt.numThreads-workerThreadCount)
 	regularThreads = make([]*phpThread, 0, opt.numThreads-workerThreadCount)
 	for i := 0; i < opt.numThreads-workerThreadCount; i++ {
 		convertToRegularThread(getInactivePHPThread())
@@ -346,6 +346,8 @@ func ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) error
 	ctx := request.Context()
 	fc, ok := fromContext(ctx)
 
+	ch := contextHolder{ctx, fc}
+
 	if !ok {
 		return ErrInvalidRequest
 	}
@@ -358,17 +360,17 @@ func ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) error
 
 	// Detect if a worker is available to handle this request
 	if fc.worker != nil {
-		return fc.worker.handleRequest(ctx)
+		return fc.worker.handleRequest(ch)
 	}
 
 	// If no worker was available, send the request to non-worker threads
-	return handleRequestWithRegularPHPThreads(ctx)
+	return handleRequestWithRegularPHPThreads(ch)
 }
 
 //export go_ub_write
 func go_ub_write(threadIndex C.uintptr_t, cBuf *C.char, length C.int) (C.size_t, C.bool) {
-	ctx := phpThreads[threadIndex].context()
-	fc := ctx.Value(contextKey).(*frankenPHPContext)
+	thread := phpThreads[threadIndex]
+	fc := thread.frankenPHPContext()
 
 	if fc.isDone {
 		return 0, C.bool(true)
@@ -383,14 +385,27 @@ func go_ub_write(threadIndex C.uintptr_t, cBuf *C.char, length C.int) (C.size_t,
 		writer = fc.responseWriter
 	}
 
+	var ctx context.Context
+
 	i, e := writer.Write(unsafe.Slice((*byte)(unsafe.Pointer(cBuf)), length))
-	if e != nil && fc.logger.Enabled(ctx, slog.LevelWarn) {
-		fc.logger.LogAttrs(ctx, slog.LevelWarn, "write error", slog.Any("error", e))
+	if e != nil {
+		ctx = thread.context()
+
+		if fc.logger.Enabled(ctx, slog.LevelWarn) {
+			fc.logger.LogAttrs(ctx, slog.LevelWarn, "write error", slog.Any("error", e))
+		}
 	}
 
-	if fc.responseWriter == nil && fc.logger.Enabled(ctx, slog.LevelInfo) {
+	if fc.responseWriter == nil {
 		// probably starting a worker script, log the output
-		fc.logger.LogAttrs(ctx, slog.LevelInfo, writer.(*bytes.Buffer).String())
+
+		if ctx == nil {
+			ctx = thread.context()
+		}
+
+		if fc.logger.Enabled(ctx, slog.LevelInfo) {
+			fc.logger.LogAttrs(ctx, slog.LevelInfo, writer.(*bytes.Buffer).String())
+		}
 	}
 
 	return C.size_t(i), C.bool(fc.clientHasClosed())
@@ -400,7 +415,7 @@ func go_ub_write(threadIndex C.uintptr_t, cBuf *C.char, length C.int) (C.size_t,
 func go_apache_request_headers(threadIndex C.uintptr_t) (*C.go_string, C.size_t) {
 	thread := phpThreads[threadIndex]
 	ctx := thread.context()
-	fc := ctx.Value(contextKey).(*frankenPHPContext)
+	fc := thread.frankenPHPContext()
 
 	if fc.responseWriter == nil {
 		// worker mode, not handling a request
@@ -477,13 +492,12 @@ func splitRawHeader(rawHeader *C.char, length int) (string, string) {
 
 //export go_write_headers
 func go_write_headers(threadIndex C.uintptr_t, status C.int, headers *C.zend_llist) C.bool {
-	ctx := phpThreads[threadIndex].context()
-	if ctx == nil {
+	thread := phpThreads[threadIndex]
+	fc := thread.frankenPHPContext()
+	if fc == nil {
 		return C.bool(false)
 	}
 
-	fc := ctx.Value(contextKey).(*frankenPHPContext)
-
 	if fc.isDone {
 		return C.bool(false)
 	}
@@ -506,6 +520,8 @@ func go_write_headers(threadIndex C.uintptr_t, status C.int, headers *C.zend_lli
 	// go panics on invalid status code
 	// https://github.com/golang/go/blob/9b8742f2e79438b9442afa4c0a0139d3937ea33f/src/net/http/server.go#L1162
 	if goStatus < 100 || goStatus > 999 {
+		ctx := thread.context()
+
 		if logger.Enabled(ctx, slog.LevelWarn) {
 			logger.LogAttrs(ctx, slog.LevelWarn, "Invalid response status code", slog.Int("status_code", goStatus))
 		}
@@ -528,13 +544,12 @@ func go_write_headers(threadIndex C.uintptr_t, status C.int, headers *C.zend_lli
 
 //export go_sapi_flush
 func go_sapi_flush(threadIndex C.uintptr_t) bool {
-	ctx := phpThreads[threadIndex].context()
-	if ctx == nil {
+	thread := phpThreads[threadIndex]
+	fc := thread.frankenPHPContext()
+	if fc == nil {
 		return false
 	}
 
-	fc := ctx.Value(contextKey).(*frankenPHPContext)
-
 	if fc.responseWriter == nil {
 		return false
 	}
@@ -543,16 +558,20 @@ func go_sapi_flush(threadIndex C.uintptr_t) bool {
 		return true
 	}
 
-	if err := http.NewResponseController(fc.responseWriter).Flush(); err != nil && logger.Enabled(ctx, slog.LevelWarn) {
-		logger.LogAttrs(ctx, slog.LevelWarn, "the current responseWriter is not a flusher, if you are not using a custom build, please report this issue", slog.Any("error", err))
+	if err := http.NewResponseController(fc.responseWriter).Flush(); err != nil {
+		ctx := thread.context()
+
+		if logger.Enabled(ctx, slog.LevelWarn) {
+			logger.LogAttrs(ctx, slog.LevelWarn, "the current responseWriter is not a flusher, if you are not using a custom build, please report this issue", slog.Any("error", err))
+		}
 	}
 
 	return false
 }
 
 //export go_read_post
 func go_read_post(threadIndex C.uintptr_t, cBuf *C.char, countBytes C.size_t) (readBytes C.size_t) {
-	fc := phpThreads[threadIndex].context().Value(contextKey).(*frankenPHPContext)
+	fc := phpThreads[threadIndex].frankenPHPContext()
 
 	if fc.responseWriter == nil {
 		return 0
@@ -571,7 +590,7 @@ func go_read_post(threadIndex C.uintptr_t, cBuf *C.char, countBytes C.size_t) (r
 
 //export go_read_cookies
 func go_read_cookies(threadIndex C.uintptr_t) *C.char {
-	request := phpThreads[threadIndex].context().Value(contextKey).(*frankenPHPContext).request
+	request := phpThreads[threadIndex].frankenPHPContext().request
 	if request == nil {
 		return nil
 	}
@@ -615,7 +634,7 @@ func go_log(message *C.char, level C.int) {
 
 //export go_is_context_done
 func go_is_context_done(threadIndex C.uintptr_t) C.bool {
-	return C.bool(phpThreads[threadIndex].context().Value(contextKey).(*frankenPHPContext).isDone)
+	return C.bool(phpThreads[threadIndex].frankenPHPContext().isDone)
 }
 
 // ExecuteScriptCLI executes the PHP script passed as parameter.

frankenphp_test.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"flag"
 	"fmt"
 	"io"
 	"log"
@@ -136,6 +137,16 @@ func testPost(url string, body string, handler func(http.ResponseWriter, *http.R
 	return testRequest(req, handler, t)
 }
 
+func TestMain(m *testing.M) {
+	flag.Parse()
+
+	if !testing.Verbose() {
+		slog.SetDefault(slog.New(slog.DiscardHandler))
+	}
+
+	os.Exit(m.Run())
+}
+
 func TestHelloWorld_module(t *testing.T) { testHelloWorld(t, nil) }
 func TestHelloWorld_worker(t *testing.T) {
 	testHelloWorld(t, &testOptions{workerScript: "index.php"})

phpthread.go

@@ -16,7 +16,7 @@ import (
 type phpThread struct {
 	runtime.Pinner
 	threadIndex  int
-	requestChan  chan context.Context
+	requestChan  chan contextHolder
 	drainChan    chan struct{}
 	handlerMu    sync.Mutex
 	handler      threadHandler
@@ -30,12 +30,13 @@ type threadHandler interface {
 	beforeScriptExecution() string
 	afterScriptExecution(exitStatus int)
 	context() context.Context
+	frankenPHPContext() *frankenPHPContext
 }
 
 func newPHPThread(threadIndex int) *phpThread {
 	return &phpThread{
 		threadIndex: threadIndex,
-		requestChan: make(chan context.Context),
+		requestChan: make(chan contextHolder),
 		state:       newThreadState(),
 	}
 }
@@ -104,6 +105,10 @@ func (thread *phpThread) transitionToNewHandler() string {
 	return thread.handler.beforeScriptExecution()
 }
 
+func (thread *phpThread) frankenPHPContext() *frankenPHPContext {
+	return thread.handler.frankenPHPContext()
+}
+
 func (thread *phpThread) context() context.Context {
 	return thread.handler.context()
 }

threadinactive.go

@@ -39,6 +39,10 @@ func (handler *inactiveThread) afterScriptExecution(int) {
 	panic("inactive threads should not execute scripts")
 }
 
+func (handler *inactiveThread) frankenPHPContext() *frankenPHPContext {
+	return nil
+}
+
 func (handler *inactiveThread) context() context.Context {
 	return nil
 }

threadregular.go

@@ -9,15 +9,16 @@ import (
 // executes PHP scripts in a web context
 // implements the threadHandler interface
 type regularThread struct {
+	contextHolder
+
 	state  *threadState
 	thread *phpThread
-	ctx    context.Context
 }
 
 var (
 	regularThreads     []*phpThread
 	regularThreadMu    = &sync.RWMutex{}
-	regularRequestChan chan context.Context
+	regularRequestChan chan contextHolder
 )
 
 func convertToRegularThread(thread *phpThread) {
@@ -47,10 +48,14 @@ func (handler *regularThread) beforeScriptExecution() string {
 	panic("unexpected state: " + handler.state.name())
 }
 
-func (handler *regularThread) afterScriptExecution(int) {
+func (handler *regularThread) afterScriptExecution(_ int) {
 	handler.afterRequest()
 }
 
+func (handler *regularThread) frankenPHPContext() *frankenPHPContext {
+	return handler.contextHolder.frankenPHPContext
+}
+
 func (handler *regularThread) context() context.Context {
 	return handler.ctx
 }
@@ -65,37 +70,35 @@ func (handler *regularThread) waitForRequest() string {
 
 	handler.state.markAsWaiting(true)
 
-	var ctx context.Context
+	var ch contextHolder
 	select {
 	case <-handler.thread.drainChan:
 		// go back to beforeScriptExecution
 		return handler.beforeScriptExecution()
-	case ctx = <-regularRequestChan:
+	case ch = <-regularRequestChan:
 	}
 
-	handler.ctx = ctx
+	handler.ctx = ch.ctx
+	handler.contextHolder.frankenPHPContext = ch.frankenPHPContext
 	handler.state.markAsWaiting(false)
 
 	// set the scriptFilename that should be executed
-	return ctx.Value(contextKey).(*frankenPHPContext).scriptFilename
+	return handler.contextHolder.frankenPHPContext.scriptFilename
 }
 
 func (handler *regularThread) afterRequest() {
-	fc := handler.ctx.Value(contextKey).(*frankenPHPContext)
-
-	fc.closeContext()
+	handler.contextHolder.frankenPHPContext.closeContext()
+	handler.contextHolder.frankenPHPContext = nil
 	handler.ctx = nil
 }
 
-func handleRequestWithRegularPHPThreads(ctx context.Context) error {
+func handleRequestWithRegularPHPThreads(ch contextHolder) error {
 	metrics.StartRequest()
 
-	fc := ctx.Value(contextKey).(*frankenPHPContext)
-
 	select {
-	case regularRequestChan <- ctx:
+	case regularRequestChan <- ch:
 		// a thread was available to handle the request immediately
-		<-fc.done
+		<-ch.frankenPHPContext.done
 		metrics.StopRequest()
 
 		return nil
@@ -107,19 +110,19 @@ func handleRequestWithRegularPHPThreads(ctx context.Context) error {
 	metrics.QueuedRequest()
 	for {
 		select {
-		case regularRequestChan <- ctx:
+		case regularRequestChan <- ch:
 			metrics.DequeuedRequest()
-			<-fc.done
+			<-ch.frankenPHPContext.done
 			metrics.StopRequest()
 
 			return nil
-		case scaleChan <- fc:
+		case scaleChan <- ch.frankenPHPContext:
 			// the request has triggered scaling, continue to wait for a thread
 		case <-timeoutChan(maxWaitTime):
 			// the request has timed out stalling
 			metrics.DequeuedRequest()
 
-			fc.reject(ErrMaxWaitTimeExceeded)
+			ch.frankenPHPContext.reject(ErrMaxWaitTimeExceeded)
 
 			return ErrMaxWaitTimeExceeded
 		}

threadtasks_test.go

@@ -65,6 +65,10 @@ func (handler *taskThread) afterScriptExecution(_ int) {
 	panic("task threads should not execute scripts")
 }
 
+func (handler *taskThread) frankenPHPContext() *frankenPHPContext {
+	return nil
+}
+
 func (handler *taskThread) context() context.Context {
 	return nil
 }