errors

Author: dunglas

context.go

@@ -150,9 +150,9 @@ func (fc *frankenPHPContext) clientHasClosed() bool {
 }
 
 // reject sends a response with the given status code and message
-func (fc *frankenPHPContext) reject(statusCode int, message string) {
+func (fc *frankenPHPContext) reject(statusCode int, message string) error {
 	if fc.isDone {
-		return
+		return nil
 	}
 
 	rw := fc.responseWriter
@@ -166,6 +166,8 @@ func (fc *frankenPHPContext) reject(statusCode int, message string) {
 	}
 
 	fc.closeContext()
+
+	return ErrMaxTimeExceeded
 }
 
 func (fc *frankenPHPContext) rejectBadRequest(message string) {

frankenphp.go

@@ -51,6 +51,7 @@ var (
 	ErrRequestContextCreation = errors.New("error during request context creation")
 	ErrScriptExecution        = errors.New("error during PHP script execution")
 	ErrNotRunning             = errors.New("FrankenPHP is not running. For proper configuration visit: https://frankenphp.dev/docs/config/#caddyfile-config")
+	ErrMaxTimeExceeded        = errors.New("max request handling time exceeded")
 
 	isRunning        bool
 	onServerShutdown []func()
@@ -66,31 +67,31 @@ var (
 type syslogLevel int
 
 const (
-	emerg   syslogLevel = iota // system is unusable
-	alert                      // action must be taken immediately
-	crit                       // critical conditions
-	err                        // error conditions
-	warning                    // warning conditions
-	notice                     // normal but significant condition
-	info                       // informational
-	debug                      // debug-level messages
+	syslogLevelEmerg  syslogLevel = iota // system is unusable
+	syslogLevelAlert                     // action must be taken immediately
+	syslogLevelCrit                      // critical conditions
+	syslogLevelErr                       // error conditions
+	syslogLevelWarn                      // warning conditions
+	syslogLevelNotice                    // normal but significant condition
+	syslogLevelInfo                      // informational
+	syslogLevelDebug                     // debug-level messages
 )
 
 func (l syslogLevel) String() string {
 	switch l {
-	case emerg:
+	case syslogLevelEmerg:
 		return "emerg"
-	case alert:
+	case syslogLevelAlert:
 		return "alert"
-	case crit:
+	case syslogLevelCrit:
 		return "crit"
-	case err:
+	case syslogLevelErr:
 		return "err"
-	case warning:
+	case syslogLevelWarn:
 		return "warning"
-	case notice:
+	case syslogLevelNotice:
 		return "notice"
-	case debug:
+	case syslogLevelDebug:
 		return "debug"
 	default:
 		return "info"
@@ -337,14 +338,11 @@ func ServeHTTP(responseWriter http.ResponseWriter, request *http.Request) error
 
 	// Detect if a worker is available to handle this request
 	if fc.worker != nil {
-		fc.worker.handleRequest(fc)
-
-		return nil
+		return fc.worker.handleRequest(fc)
 	}
 
 	// If no worker was available, send the request to non-worker threads
-	handleRequestWithRegularPHPThreads(fc)
-	return nil
+	return handleRequestWithRegularPHPThreads(fc)
 }
 
 //export go_ub_write
@@ -561,19 +559,19 @@ func go_log(message *C.char, level C.int) {
 	m := C.GoString(message)
 
 	var le syslogLevel
-	if level < C.int(emerg) || level > C.int(debug) {
-		le = info
+	if level < C.int(syslogLevelEmerg) || level > C.int(syslogLevelDebug) {
+		le = syslogLevelInfo
 	} else {
 		le = syslogLevel(level)
 	}
 
 	switch le {
-	case emerg, alert, crit, err:
+	case syslogLevelEmerg, syslogLevelAlert, syslogLevelCrit, syslogLevelErr:
 		logger.LogAttrs(context.Background(), slog.LevelError, m, slog.String("syslog_level", syslogLevel(level).String()))
 
-	case warning:
+	case syslogLevelWarn:
 		logger.LogAttrs(context.Background(), slog.LevelWarn, m, slog.String("syslog_level", syslogLevel(level).String()))
-	case debug:
+	case syslogLevelDebug:
 		logger.LogAttrs(context.Background(), slog.LevelDebug, m, slog.String("syslog_level", syslogLevel(level).String()))
 
 	default:

threadregular.go

@@ -84,14 +84,15 @@ func (handler *regularThread) afterRequest() {
 	handler.requestContext = nil
 }
 
-func handleRequestWithRegularPHPThreads(fc *frankenPHPContext) {
+func handleRequestWithRegularPHPThreads(fc *frankenPHPContext) error {
 	metrics.StartRequest()
 	select {
 	case regularRequestChan <- fc:
 		// a thread was available to handle the request immediately
 		<-fc.done
 		metrics.StopRequest()
-		return
+
+		return nil
 	default:
 		// no thread was available
 	}
@@ -104,14 +105,15 @@ func handleRequestWithRegularPHPThreads(fc *frankenPHPContext) {
 			metrics.DequeuedRequest()
 			<-fc.done
 			metrics.StopRequest()
-			return
+
+			return nil
 		case scaleChan <- fc:
 			// the request has triggered scaling, continue to wait for a thread
 		case <-timeoutChan(maxWaitTime):
 			// the request has timed out stalling
 			metrics.DequeuedRequest()
-			fc.reject(504, "Gateway Timeout")
-			return
+
+			return fc.reject(504, "Gateway Timeout")
 		}
 	}
 }

worker.go

@@ -223,7 +223,7 @@ func (worker *worker) countThreads() int {
 	return l
 }
 
-func (worker *worker) handleRequest(fc *frankenPHPContext) {
+func (worker *worker) handleRequest(fc *frankenPHPContext) error {
 	metrics.StartWorkerRequest(worker.name)
 
 	// dispatch requests to all worker threads in order
@@ -234,7 +234,8 @@ func (worker *worker) handleRequest(fc *frankenPHPContext) {
 			worker.threadMutex.RUnlock()
 			<-fc.done
 			metrics.StopWorkerRequest(worker.name, time.Since(fc.startedAt))
-			return
+
+			return nil
 		default:
 			// thread is busy, continue
 		}
@@ -249,14 +250,15 @@ func (worker *worker) handleRequest(fc *frankenPHPContext) {
 			metrics.DequeuedWorkerRequest(worker.name)
 			<-fc.done
 			metrics.StopWorkerRequest(worker.name, time.Since(fc.startedAt))
-			return
+
+			return nil
 		case scaleChan <- fc:
 			// the request has triggered scaling, continue to wait for a thread
 		case <-timeoutChan(maxWaitTime):
-			metrics.DequeuedWorkerRequest(worker.name)
 			// the request has timed out stalling
-			fc.reject(504, "Gateway Timeout")
-			return
+			metrics.DequeuedWorkerRequest(worker.name)
+
+			return fc.reject(504, "Gateway Timeout")
 		}
 	}
 }

workerextension.go

@@ -50,7 +50,7 @@ func (w *extensionWorkers) SendMessage(message any, rw http.ResponseWriter) (any
 	fc.responseWriter = rw
 	fc.handlerParameters = message
 
-	w.internalWorker.handleRequest(fc)
+	err := w.internalWorker.handleRequest(fc)
 
-	return fc.handlerReturn, nil
+	return fc.handlerReturn, err
 }