Fix reactor_close_fd to use context for subinterpreter support

Added context parameter to reactor_close_fd NIF so it can properly
switch to the subinterpreter's thread state before calling Python.

Author: benoitc

c_src/py_event_loop.c

@@ -3267,7 +3267,7 @@ ERL_NIF_TERM nif_reactor_init_connection(ErlNifEnv *env, int argc,
 }
 
 /**
- * reactor_close_fd(FdRef) -> ok | {error, Reason}
+ * reactor_close_fd(ContextRef, FdRef) -> ok | {error, Reason}
  *
  * Close an FD and clean up the protocol handler.
  * Calls Python's erlang_reactor.close_connection(fd) if registered.
@@ -3276,8 +3276,13 @@ ERL_NIF_TERM nif_reactor_close_fd(ErlNifEnv *env, int argc,
                                    const ERL_NIF_TERM argv[]) {
     (void)argc;
 
+    py_context_t *ctx;
+    if (!enif_get_resource(env, argv[0], PY_CONTEXT_RESOURCE_TYPE, (void **)&ctx)) {
+        return make_error(env, "invalid_context");
+    }
+
     fd_resource_t *fd_res;
-    if (!enif_get_resource(env, argv[0], FD_RESOURCE_TYPE, (void **)&fd_res)) {
+    if (!enif_get_resource(env, argv[1], FD_RESOURCE_TYPE, (void **)&fd_res)) {
         return make_error(env, "invalid_fd_ref");
     }
 
@@ -3293,20 +3298,21 @@ ERL_NIF_TERM nif_reactor_close_fd(ErlNifEnv *env, int argc,
 
     /* Call Python to clean up protocol handler */
     if (fd >= 0) {
-        gil_guard_t guard = gil_acquire();
-
-        PyObject *reactor_module = PyImport_ImportModule("erlang.reactor");
-        if (reactor_module != NULL) {
-            PyObject *result = PyObject_CallMethod(reactor_module,
-                                                    "close_connection", "i", fd);
-            Py_XDECREF(result);
-            Py_DECREF(reactor_module);
-            PyErr_Clear();  /* Ignore errors during cleanup */
-        } else {
-            PyErr_Clear();
-        }
+        py_context_guard_t guard = py_context_acquire(ctx);
+        if (guard.acquired) {
+            PyObject *reactor_module = PyImport_ImportModule("erlang.reactor");
+            if (reactor_module != NULL) {
+                PyObject *result = PyObject_CallMethod(reactor_module,
+                                                        "close_connection", "i", fd);
+                Py_XDECREF(result);
+                Py_DECREF(reactor_module);
+                PyErr_Clear();  /* Ignore errors during cleanup */
+            } else {
+                PyErr_Clear();
+            }
 
-        gil_release(guard);
+            py_context_release(&guard);
+        }
     }
 
     /* Take ownership for cleanup */

c_src/py_event_loop.h

@@ -862,7 +862,7 @@ ERL_NIF_TERM nif_reactor_init_connection(ErlNifEnv *env, int argc,
 /**
  * @brief Close FD and cleanup Python protocol
  *
- * NIF: reactor_close_fd(FdRef) -> ok | {error, Reason}
+ * NIF: reactor_close_fd(ContextRef, FdRef) -> ok | {error, Reason}
  */
 ERL_NIF_TERM nif_reactor_close_fd(ErlNifEnv *env, int argc,
                                    const ERL_NIF_TERM argv[]);

c_src/py_nif.c

@@ -3876,7 +3876,7 @@ static ErlNifFunc nif_funcs[] = {
     {"reactor_on_read_ready", 2, nif_reactor_on_read_ready, ERL_NIF_DIRTY_JOB_CPU_BOUND},
     {"reactor_on_write_ready", 2, nif_reactor_on_write_ready, ERL_NIF_DIRTY_JOB_CPU_BOUND},
     {"reactor_init_connection", 3, nif_reactor_init_connection, ERL_NIF_DIRTY_JOB_CPU_BOUND},
-    {"reactor_close_fd", 1, nif_reactor_close_fd, 0}
+    {"reactor_close_fd", 2, nif_reactor_close_fd, 0}
 };
 
 ERL_NIF_INIT(py_nif, nif_funcs, load, NULL, upgrade, unload)

src/py_nif.erl

@@ -188,7 +188,7 @@
     reactor_on_read_ready/2,
     reactor_on_write_ready/2,
     reactor_init_connection/3,
-    reactor_close_fd/1
+    reactor_close_fd/2
 ]).
 
 -on_load(load_nif/0).
@@ -1524,8 +1524,9 @@ reactor_init_connection(_ContextRef, _Fd, _ClientInfo) ->
 %% Calls Python's erlang_reactor.close_connection(fd) to clean up
 %% the protocol handler, then closes the FD.
 %%
+%% @param ContextRef Context resource reference
 %% @param FdRef FD resource reference
 %% @returns ok | {error, Reason}
--spec reactor_close_fd(reference()) -> ok | {error, term()}.
-reactor_close_fd(_FdRef) ->
+-spec reactor_close_fd(reference(), reference()) -> ok | {error, term()}.
+reactor_close_fd(_ContextRef, _FdRef) ->
     ?NIF_STUB.

src/py_reactor_context.erl

@@ -468,12 +468,13 @@ handle_async_write_ready(Fd, State) ->
 %% @private
 close_connection(Fd, FdRes, State) ->
     #state{
+        ref = Ref,
         connections = Conns,
         active_connections = Active
     } = State,
 
     %% Close via NIF (cleans up Python protocol handler)
-    py_nif:reactor_close_fd(FdRes),
+    py_nif:reactor_close_fd(Ref, FdRes),
 
     %% Remove from connections map
     NewConns = maps:remove(Fd, Conns),
@@ -489,7 +490,7 @@ cleanup(State) ->
 
     %% Close all connections
     maps:foreach(fun(_Fd, #{fd_ref := FdRef}) ->
-        py_nif:reactor_close_fd(FdRef)
+        py_nif:reactor_close_fd(Ref, FdRef)
     end, Conns),
 
     %% Destroy Python context