get things up and running

Signed-off-by: Robert Landers <landers.robert@gmail.com>

Author: withinboredom

cli/auth/resource.go

@@ -5,18 +5,25 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/bottledcode/durable-php/cli/appcontext"
-	"github.com/bottledcode/durable-php/cli/glue"
-	"github.com/bottledcode/durable-php/cli/ids"
-	"github.com/nats-io/nats.go/jetstream"
-	"go.uber.org/zap"
 	"net/http"
 	"os"
 	"slices"
 	"sync"
 	"time"
+
+	"github.com/bottledcode/durable-php/cli/appcontext"
+	"github.com/bottledcode/durable-php/cli/glue"
+	"github.com/bottledcode/durable-php/cli/ids"
+	"github.com/nats-io/nats.go/jetstream"
+	"go.uber.org/zap"
 )
 
+// LocalMessageSender is a function type for sending local messages
+type LocalMessageSender func(method, stateId string, context map[string]interface{}) (interface{}, error)
+
+// SendLocalMessage is a global function pointer that gets set by the build package
+var SendLocalMessage LocalMessageSender
+
 // Resource represents a resource with owners, shares, mode, expiration, and revision.
 // It allows operations such as updating, sharing ownership, applying permissions,
 // checking permissions, and serializing/deserializing to/from bytes.
@@ -139,19 +146,41 @@ func (r *Resource) getOrCreatePermissions(id *ids.StateId, ctx context.Context,
 	if cached, found := cache.Load(id.Name()); found {
 		perms = cached.(CreatePermissions)
 	} else {
-		result, err := os.CreateTemp("", "")
-		if err != nil {
-			return perms, err
-		}
-		defer os.Remove(result.Name())
-		result.Close()
-
-		glu := glue.NewGlue(ctx.Value("bootstrap").(string), glue.GetPermissions, make([]any, 0), result.Name())
-		env := map[string]string{"STATE_ID": id.String()}
-		_, headers, _, _ := glu.Execute(ctx, make(http.Header), logger, env, nil, id, ids.SystemSource)
-		data := headers.Get("Permissions")
-		if err = json.Unmarshal([]byte(data), &perms); err != nil {
-			return perms, err
+		if SendLocalMessage != nil {
+			// Use the new local message system
+			contextData := map[string]interface{}{
+				"bootstrap": ctx.Value("bootstrap"),
+			}
+
+			response, err := SendLocalMessage("getPermissions", id.String(), contextData)
+			if err != nil {
+				return perms, err
+			}
+
+			// The response should be JSON string
+			if responseStr, ok := response.(string); ok {
+				if err = json.Unmarshal([]byte(responseStr), &perms); err != nil {
+					return perms, err
+				}
+			} else {
+				return perms, errors.New("invalid response format from local message")
+			}
+		} else {
+			// Fallback to old glue system
+			result, err := os.CreateTemp("", "")
+			if err != nil {
+				return perms, err
+			}
+			defer os.Remove(result.Name())
+			result.Close()
+
+			glu := glue.NewGlue(ctx.Value("bootstrap").(string), glue.GetPermissions, make([]any, 0), result.Name())
+			env := map[string]string{"STATE_ID": id.String()}
+			_, headers, _, _ := glu.Execute(ctx, make(http.Header), logger, env, nil, id, ids.SystemSource)
+			data := headers.Get("Permissions")
+			if err = json.Unmarshal([]byte(data), &perms); err != nil {
+				return perms, err
+			}
 		}
 		cache.Store(id.Name(), perms)
 	}

cli/ext/build/ext.c

@@ -28,14 +28,28 @@ static inline ext_object *ext_object_from_obj(zend_object *obj) {
 }
 
 static zend_object *ext_create_object(zend_class_entry *ce) {
-    ext_object *intern = ecalloc(1, sizeof(ext_object) + zend_object_properties_size(ce));
+    fprintf(stderr, "[C DEBUG] ext_create_object called!\n");
+    fflush(stderr);
+    
+    /* Always allocate without properties due to corrupted class entry */
+    ext_object *intern = ecalloc(1, sizeof(ext_object));
+    
+    fprintf(stderr, "[C DEBUG] About to call zend_object_std_init\n");
+    fflush(stderr);
 
     zend_object_std_init(&intern->std, ce);
-    object_properties_init(&intern->std, ce);
+    
+    fprintf(stderr, "[C DEBUG] zend_object_std_init completed\n");
+    fflush(stderr);
+    
+    /* Skip object_properties_init due to corrupted class entry */
 
     intern->std.handlers = &object_handlers_ext;
     intern->go_handle = 0; /* will be set in __construct */
 
+    fprintf(stderr, "[C DEBUG] ext_create_object returning\n");
+    fflush(stderr);
+
     return &intern->std;
 }
 
@@ -57,19 +71,43 @@ void init_object_handlers() {
 }
 
 static zend_class_entry *Worker_ce = NULL;
-static ext_object *current_worker = NULL;
+static __thread uintptr_t current_go_worker_handle = 0; /* Thread-local Go worker handle */
 
 PHP_METHOD(Bottledcode_DurablePhp_Ext_Worker, __construct) {
+    fprintf(stderr, "[C DEBUG] Constructor called\n");
+    fflush(stderr);
+    
     ZEND_PARSE_PARAMETERS_NONE();
 
+    fprintf(stderr, "[C DEBUG] Constructor parameters parsed\n");
+    fflush(stderr);
+
     ext_object *intern = ext_object_from_obj(Z_OBJ_P(ZEND_THIS));
 
+    fprintf(stderr, "[C DEBUG] Got intern object, go_handle=%lu\n", intern->go_handle);
+    fflush(stderr);
+
     /* Constructor is called more than once, make it no-op */
     if (intern->go_handle != 0) {
+        fprintf(stderr, "[C DEBUG] Constructor already called, returning\n");
+        fflush(stderr);
         return;
     }
 
-    intern->go_handle = create_Worker_object();
+    /* Use the thread-local Go worker handle if available */
+    if (current_go_worker_handle != 0) {
+        fprintf(stderr, "[C DEBUG] Constructor using thread-local handle %lu\n", current_go_worker_handle);
+        fflush(stderr);
+        intern->go_handle = current_go_worker_handle;
+    } else {
+        /* Fallback: create a new Worker object */
+        fprintf(stderr, "[C DEBUG] Constructor creating new Worker object\n");
+        fflush(stderr);
+        intern->go_handle = create_Worker_object();
+    }
+    
+    fprintf(stderr, "[C DEBUG] Constructor completed\n");
+    fflush(stderr);
 }
 
 
@@ -220,13 +258,36 @@ PHP_METHOD(Bottledcode_DurablePhp_Ext_Worker, delete) {
 }
 
 PHP_METHOD(Bottledcode_DurablePhp_Ext_Worker, GetCurrent) {
+    fprintf(stderr, "[C DEBUG] GetCurrent method entry\n");
+    fflush(stderr);
+    
     ZEND_PARSE_PARAMETERS_NONE();
 
-    if (current_worker == NULL) {
+    fprintf(stderr, "[C DEBUG] GetCurrent called, thread-local handle=%lu\n", current_go_worker_handle);
+    fflush(stderr);
+    
+    /* If no thread-local worker handle, return NULL */
+    if (current_go_worker_handle == 0) {
+        fprintf(stderr, "[C DEBUG] No thread-local handle, returning NULL\n");
+        fflush(stderr);
         RETURN_NULL();
     }
 
-    RETURN_OBJ_COPY(&current_worker->std);
+    fprintf(stderr, "[C DEBUG] About to create Worker object with object_init_ex\n");
+    fflush(stderr);
+    
+    /* Create a new Worker object - PHP constructor will pick up the thread-local handle */
+    zval obj;
+    if (object_init_ex(&obj, Worker_ce) != SUCCESS) {
+        fprintf(stderr, "[C DEBUG] object_init_ex failed\n");
+        fflush(stderr);
+        RETURN_NULL();
+    }
+    
+    fprintf(stderr, "[C DEBUG] object_init_ex succeeded, returning object\n");
+    fflush(stderr);
+    
+    RETURN_ZVAL(&obj, 0, 0);
 }
 
 void register_all_classes() {
@@ -241,37 +302,34 @@ void register_all_classes() {
 
 /* Function to set the current worker from Go */
 void set_current_worker_handle(uintptr_t handle) {
-    if (current_worker != NULL) {
-        /* Release previous worker */
-        zend_object_release(&current_worker->std);
-        current_worker = NULL;
-    }
-    
-    if (handle != 0) {
-        /* Create a new Worker object and set its handle */
-        zend_object *obj = ext_create_object(Worker_ce);
-        current_worker = ext_object_from_obj(obj);
-        current_worker->go_handle = handle;
-        
-        /* Add ref to keep it alive */
-        GC_ADDREF(&current_worker->std);
-    }
+    fprintf(stderr, "[C DEBUG] Setting thread-local worker handle to %lu\n", handle);
+    fflush(stderr);
+    current_go_worker_handle = handle;
+}
+
+/* Function to get current worker handle */
+uintptr_t get_current_worker_handle() {
+    return current_go_worker_handle;
 }
 
 /* Function to clear current worker */
 void clear_current_worker() {
-    if (current_worker != NULL) {
-        zend_object_release(&current_worker->std);
-        current_worker = NULL;
-    }
+    fprintf(stderr, "[C DEBUG] Clearing thread-local worker handle\n");
+    fflush(stderr);
+    current_go_worker_handle = 0;
 }
 
 PHP_MINIT_FUNCTION(ext) {
-    register_all_classes();
+    fprintf(stderr, "[C DEBUG] MINIT starting\n");
+    fflush(stderr);
 
+    register_all_classes();
+    fprintf(stderr, "[C DEBUG] Classes registered\n");
+    fflush(stderr);
 
     go_init_module();
-    
+    fprintf(stderr, "[C DEBUG] Go module initialized\n");
+    fflush(stderr);
 
     return SUCCESS;
 }