mod-wsgi-standalone 6.0.0.dev4__tar.gz → 6.0.0.dev5__tar.gz

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mod_wsgi-standalone
-Version: 6.0.0.dev4
+Version: 6.0.0.dev5
 Summary: Installer for Apache/mod_wsgi.
 Home-page: https://www.modwsgi.org/
 Author: Graham Dumpleton

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/mod_wsgi_standalone.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mod_wsgi-standalone
-Version: 6.0.0.dev4
+Version: 6.0.0.dev5
 Summary: Installer for Apache/mod_wsgi.
 Home-page: https://www.modwsgi.org/
 Author: Graham Dumpleton

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/src/diagnostics/environ.py

@@ -15,10 +15,16 @@ def application(environ, start_response):
     input = environ["wsgi.input"]
     output = StringIO()
 
-    print(f"PID: {os.getpid()}", file=output)
-    print(f"UID: {os.getuid()}", file=output)
-    print(f"GID: {os.getgid()}", file=output)
-    print(f"CWD: {os.getcwd()}", file=output)
+    if os.name != "nt":
+        print(f"PID: {os.getpid()}", file=output)
+        print(f"UID: {os.getuid()}", file=output)
+        print(f"GID: {os.getgid()}", file=output)
+        print(f"CWD: {os.getcwd()}", file=output)
+        print(file=output)
+
+    print(f"STDOUT: {sys.stdout.name}", file=output)
+    print(f"STDERR: {sys.stderr.name}", file=output)
+    print(f'ERRORS: {environ["wsgi.errors"].name}', file=output)
     print(file=output)
 
     print(f"python.version: {sys.version!r}", file=output)
@@ -36,19 +42,8 @@ def application(environ, start_response):
 
     print(f"mod_wsgi.maximum_processes: {mod_wsgi.maximum_processes}", file=output)
     print(f"mod_wsgi.threads_per_process: {mod_wsgi.threads_per_process}", file=output)
-    print(f"mod_wsgi.process_metrics: {mod_wsgi.process_metrics()}", file=output)
-    print(f"mod_wsgi.server_metrics: {mod_wsgi.server_metrics()}", file=output)
     print(file=output)
 
-    metrics = mod_wsgi.server_metrics()
-
-    if metrics:
-        for process in metrics["processes"]:
-            for worker in process["workers"]:
-                print(worker["status"], file=output, end="")
-        print(file=output)
-        print(file=output)
-
     print(f"apache.description: {apache.description}", file=output)
     print(f"apache.build_date: {apache.build_date}", file=output)
     print(f"apache.mpm_name: {apache.mpm_name}", file=output)
@@ -56,16 +51,18 @@ def application(environ, start_response):
     print(f"apache.threads_per_process: {apache.threads_per_process}", file=output)
     print(file=output)
 
-    print(f"PATH: {sys.path}", file=output)
+    print(f'PATH: {os.environ.get("PATH")}', file=output)
     print(file=output)
 
-    print(f"LANG: {os.environ.get('LANG')}", file=output)
-    print(f"LC_ALL: {os.environ.get('LC_ALL')}", file=output)
+    print(f'LANG: {os.environ.get("LANG")}', file=output)
+    print(f'LC_ALL: {os.environ.get("LC_ALL")}', file=output)
     print(f"sys.getdefaultencoding(): {sys.getdefaultencoding()}", file=output)
     print(f"sys.getfilesystemencoding(): {sys.getfilesystemencoding()}", file=output)
     print(f"locale.getlocale(): {locale.getlocale()}", file=output)
     print(f"locale.getdefaultlocale(): {locale.getdefaultlocale()}", file=output)
-    print(f"locale.getpreferredencoding(): {locale.getpreferredencoding()}", file=output)
+    print(
+        f"locale.getpreferredencoding(): {locale.getpreferredencoding()}", file=output
+    )
     print(file=output)
 
     for key in sorted(environ):

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/src/express/apache.py

@@ -816,6 +816,10 @@ APACHE_SETENV_CONFIG = """
 SetEnv '%(name)s' '%(value)s'
 """
 
+APACHE_PYTHON_WARNINGS_CONFIG = """
+WSGIPythonWarnings '%(spec)s'
+"""
+
 APACHE_PASSENV_CONFIG = """
 PassEnv '%(name)s'
 """
@@ -982,6 +986,11 @@ def generate_apache_config(options):
                 print(APACHE_SETENV_CONFIG % dict(name=name, value=value),
                         file=fp)
 
+        if options['python_warnings']:
+            for spec in options['python_warnings']:
+                print(APACHE_PYTHON_WARNINGS_CONFIG % dict(spec=spec),
+                        file=fp)
+
         if options['passenv_variables']:
             for name in options['passenv_variables']:
                 print(APACHE_PASSENV_CONFIG % dict(name=name), file=fp)

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/src/express/options.py

@@ -751,6 +751,17 @@ add_option('all', '--python-eggs', metavar='DIRECTORY-PATH',
         'unpacking of Python eggs. Defaults to a sub directory of '
         'the server root directory.')
 
+add_option('all', '--python-warnings', action='append', default=[],
+        metavar='SPEC', help='Add an entry to the Python warnings filter '
+        'using the standard -W syntax (action:message:category:module:lineno). '
+        'May be specified multiple times; each entry is emitted as a '
+        'separate WSGIPythonWarnings directive in the generated '
+        'configuration. The most common form is just an action: '
+        'default, error, always, module, once, or ignore. For example '
+        '--python-warnings error converts every warning into an '
+        'exception, which is useful for catching deprecation regressions '
+        'in CI.')
+
 add_option('unix', '--shell-executable', default=SHELL,
         metavar='FILE-PATH', help='Override the path to the shell '
         'used in the \'apachectl\' script. The \'bash\' shell will '

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/src/server/wsgi_daemon.c

@@ -886,6 +886,23 @@ const char *wsgi_set_accept_mutex(cmd_parms *cmd, void *mconfig,
 static apr_file_t *wsgi_signal_pipe_in = NULL;
 static apr_file_t *wsgi_signal_pipe_out = NULL;
 
+/*
+ * Dedicated pipe carrying SIGHUP / SIGUSR2 bytes from the signal
+ * handler to the signal dispatcher thread. Independent of the
+ * shutdown pipe above so that long-running subscriber callbacks
+ * cannot delay the daemon main thread's detection of shutdown
+ * signals. Write end is set non-blocking after creation so the
+ * signal handler can never deadlock on a full pipe buffer; the
+ * trade-off is that signals arriving faster than subscribers
+ * consume them are silently dropped, which matches the
+ * not-refcounted semantics of Unix signals themselves.
+ */
+
+static apr_file_t *wsgi_signal_event_pipe_in = NULL;
+static apr_file_t *wsgi_signal_event_pipe_out = NULL;
+
+static apr_thread_t *wsgi_signal_dispatcher = NULL;
+
 static void wsgi_signal_handler(int signum)
 {
     apr_size_t nbytes = 1;
@@ -909,6 +926,22 @@ static void wsgi_signal_handler(int signum)
         apr_file_write(wsgi_signal_pipe_out, "C", &nbytes);
         apr_file_flush(wsgi_signal_pipe_out);
     }
+    else if (signum == SIGHUP)
+    {
+        if (wsgi_signal_event_pipe_out)
+        {
+            apr_file_write(wsgi_signal_event_pipe_out, "H", &nbytes);
+            apr_file_flush(wsgi_signal_event_pipe_out);
+        }
+    }
+    else if (signum == SIGUSR2)
+    {
+        if (wsgi_signal_event_pipe_out)
+        {
+            apr_file_write(wsgi_signal_event_pipe_out, "U", &nbytes);
+            apr_file_flush(wsgi_signal_event_pipe_out);
+        }
+    }
     else
     {
         wsgi_daemon_shutdown++;
@@ -918,6 +951,69 @@ static void wsgi_signal_handler(int signum)
     }
 }
 
+static void *wsgi_signal_dispatcher_thread(apr_thread_t *thd, void *data)
+{
+    WSGIDaemonProcess *daemon = data;
+
+    apr_pollfd_t poll_fd;
+    apr_int32_t poll_count = 0;
+    apr_status_t rv;
+
+    poll_fd.desc_type = APR_POLL_FILE;
+    poll_fd.reqevents = APR_POLLIN;
+    poll_fd.desc.f = wsgi_signal_event_pipe_in;
+
+    while (1)
+    {
+        char buf[1];
+        apr_size_t nbytes = 1;
+        int signum;
+        const char *signame;
+
+        rv = apr_poll(&poll_fd, 1, &poll_count, -1);
+        if (APR_STATUS_IS_EINTR(rv))
+            continue;
+        if (rv != APR_SUCCESS)
+            break;
+
+        rv = apr_file_read(wsgi_signal_event_pipe_in, buf, &nbytes);
+
+        if (APR_STATUS_IS_EOF(rv))
+            break;
+
+        if (rv != APR_SUCCESS || nbytes != 1)
+        {
+            if (!wsgi_daemon_shutdown)
+            {
+                wsgi_log_error(APLOG_ALERT, 0, wsgi_server, WSGI_APLOGNO(0208) "Read failed on signal event pipe in "
+                                                                                "daemon process '%s'; signal dispatcher "
+                                                                                "exiting.",
+                               daemon->group->name);
+            }
+            break;
+        }
+
+        switch (buf[0])
+        {
+            case 'H':
+                signum = SIGHUP;
+                signame = "SIGHUP";
+                break;
+            case 'U':
+                signum = SIGUSR2;
+                signame = "SIGUSR2";
+                break;
+            default:
+                /* Unknown tag byte; defensive skip. */
+                continue;
+        }
+
+        wsgi_publish_process_signal(signum, signame);
+    }
+
+    return NULL;
+}
+
 static void wsgi_exit_daemon_process(int status)
 {
     if (wsgi_server && wsgi_daemon_group)
@@ -2991,6 +3087,25 @@ static void wsgi_daemon_main(apr_pool_t *p, WSGIDaemonProcess *daemon)
         }
     }
 
+    /*
+     * Spawn the signal dispatcher thread that drains the signal
+     * event pipe and publishes process_signal events to registered
+     * Python subscribers. Created unconditionally since subscribers
+     * can register at any point during the daemon's lifetime.
+     */
+
+    rv = apr_thread_create(&wsgi_signal_dispatcher, thread_attr,
+                           wsgi_signal_dispatcher_thread, daemon, p);
+
+    if (rv != APR_SUCCESS)
+    {
+        wsgi_log_error(APLOG_ERR, rv, wsgi_server, WSGI_APLOGNO(0207) "Unable to create signal dispatcher thread in "
+                                                                       "daemon process '%s'; SIGHUP and SIGUSR2 signals "
+                                                                       "will not be delivered to mod_wsgi.subscribe_signals "
+                                                                       "subscribers.",
+                       daemon->group->name);
+    }
+
     /*
      * Start telemetry reporter if configured. Skip for service-script
      * daemons (threads=0): they handle no requests, so there is
@@ -3254,6 +3369,40 @@ static void wsgi_daemon_main(apr_pool_t *p, WSGIDaemonProcess *daemon)
         }
     }
 
+    /*
+     * Stop the signal dispatcher before publishing process_stopping
+     * so the dispatcher is not still inside a sub-interpreter GIL
+     * acquire when the shutdown publish walks the same interpreter
+     * table. Ignoring SIGHUP/SIGUSR2 first means no new bytes can
+     * appear in the pipe; closing the write end then makes the
+     * dispatcher's pending read return EOF and exit cleanly. The
+     * join is best-effort: if a subscriber callback is wedged the
+     * shutdown-timeout reaper still bounds the total wait via
+     * exit().
+     */
+
+    apr_signal(SIGHUP, SIG_IGN);
+    apr_signal(SIGUSR2, SIG_IGN);
+
+    if (wsgi_signal_event_pipe_out)
+    {
+        apr_file_close(wsgi_signal_event_pipe_out);
+        wsgi_signal_event_pipe_out = NULL;
+    }
+
+    if (wsgi_signal_dispatcher)
+    {
+        rv = apr_thread_join(&thread_rv, wsgi_signal_dispatcher);
+        if (rv != APR_SUCCESS)
+        {
+            wsgi_log_error(APLOG_WARNING, rv, wsgi_server,
+                           "Unable to join with signal dispatcher thread "
+                           "in daemon process '%s' during shutdown.",
+                           daemon->group->name);
+        }
+        wsgi_signal_dispatcher = NULL;
+    }
+
     /*
      * If shutting down process due to reaching request time
      * limit, then try and dump out stack traces of any threads
@@ -3546,6 +3695,31 @@ static int wsgi_start_process(apr_pool_t *p, WSGIDaemonProcess *daemon)
             wsgi_daemon_init_failure_exit();
         }
 
+        /*
+         * Dedicated pipe for the application-facing signal events
+         * (SIGHUP, SIGUSR2). Separate from the shutdown signal pipe
+         * so that the daemon main thread reading shutdown bytes is
+         * never delayed by subscriber callback work. Write end is
+         * set non-blocking so the in-signal-handler write cannot
+         * deadlock if subscribers are slow enough to fill the
+         * kernel pipe buffer.
+         */
+
+        status = apr_file_pipe_create(&wsgi_signal_event_pipe_in,
+                                      &wsgi_signal_event_pipe_out, p);
+
+        if (status != APR_SUCCESS)
+        {
+            wsgi_log_error(APLOG_ALERT, status, wsgi_server, WSGI_APLOGNO(0206) "Unable to initialise signal event pipe in "
+                                                                                "daemon process '%s'. Daemon process will "
+                                                                                "exit and be restarted after a delay.",
+                           daemon->group->name);
+
+            wsgi_daemon_init_failure_exit();
+        }
+
+        apr_file_pipe_timeout_set(wsgi_signal_event_pipe_out, 0);
+
         wsgi_daemon_shutdown = 0;
 
         wsgi_daemon_pid = getpid();
@@ -3559,6 +3733,19 @@ static int wsgi_start_process(apr_pool_t *p, WSGIDaemonProcess *daemon)
         apr_signal(SIGXCPU, wsgi_signal_handler);
 #endif
 
+        /*
+         * Application-facing signal handlers. SIGHUP and SIGUSR2
+         * are not used by Apache for child process management
+         * (Apache uses SIGHUP at the parent only, and translates
+         * parent shutdown to SIGTERM/SIGUSR1 for the daemon); they
+         * are routed through the signal event pipe to the
+         * dispatcher thread which calls registered Python
+         * subscribers via mod_wsgi.subscribe_signals.
+         */
+
+        apr_signal(SIGHUP, wsgi_signal_handler);
+        apr_signal(SIGUSR2, wsgi_signal_handler);
+
         /* Set limits on amount of CPU time that can be used. */
 
         if (daemon->group->cpu_time_limit > 0)

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/src/server/wsgi_interp.c

@@ -1687,8 +1687,6 @@ failure:
 static void wsgi_destroy_interpreter(InterpreterObject *self)
 {
     PyThreadState *tstate = NULL;
-    PyObject *module = NULL;
-    PyObject *exitfunc = NULL;
 
     PyThreadState *tstate_enter = NULL;
 
@@ -1769,87 +1767,6 @@ static void wsgi_destroy_interpreter(InterpreterObject *self)
                                   wsgi_server->process->pool));
     }
 
-#if 0
-    /*
-     * Disabled: Py_EndInterpreter on Python 3.7+ runs the
-     * threading._shutdown atexit hook itself during sub-interpreter
-     * teardown, so the destroy thread no longer needs to be
-     * pre-registered in threading._active for that hook to find a
-     * Thread handle. Left in #if 0 so the original rationale and
-     * call shape are recoverable if a regression turns up.
-     */
-
-    module = PyImport_ImportModule("threading");
-
-    if (!module)
-        PyErr_Clear();
-
-    if (module)
-    {
-        PyObject *dict = NULL;
-        PyObject *func = NULL;
-
-        dict = PyModule_GetDict(module);
-        func = PyDict_GetItemString(dict, "current_thread");
-        if (func)
-        {
-            PyObject *res = NULL;
-            Py_INCREF(func);
-            res = PyObject_CallObject(func, (PyObject *)NULL);
-            if (!res)
-            {
-                PyErr_Clear();
-            }
-            Py_XDECREF(res);
-            Py_DECREF(func);
-        }
-    }
-
-    Py_XDECREF(module);
-#endif
-
-#if 0
-    /*
-     * Disabled: Py_EndInterpreter on Python 3.7+ calls
-     * _PyAtExit_Call on the sub-interpreter itself, so driving
-     * atexit._run_exitfuncs here just runs every callback twice
-     * (atexit does not deregister as it calls). Left in #if 0 so
-     * the original call shape is recoverable.
-     */
-
-    module = NULL;
-
-    if (is_sub)
-    {
-        module = PyImport_ImportModule("atexit");
-
-        if (module)
-        {
-            PyObject *dict = NULL;
-
-            dict = PyModule_GetDict(module);
-            exitfunc = PyDict_GetItemString(dict, "_run_exitfuncs");
-        }
-        else
-            PyErr_Clear();
-    }
-
-    if (exitfunc)
-    {
-        PyObject *res = NULL;
-        Py_INCREF(exitfunc);
-        res = PyObject_CallObject(exitfunc, (PyObject *)NULL);
-
-        if (res == NULL)
-            wsgi_log_python_interp_atexit_error(self->name);
-
-        Py_XDECREF(res);
-        Py_DECREF(exitfunc);
-    }
-
-    Py_XDECREF(module);
-#endif
-
     if (is_sub)
     {
         /*
@@ -2883,6 +2800,91 @@ void wsgi_publish_process_stopping(char *reason)
     }
 }
 
+void wsgi_publish_process_signal(int signum, const char *signame)
+{
+    apr_pool_t *pool = NULL;
+    apr_array_header_t *names = NULL;
+    apr_hash_index_t *hi;
+    apr_status_t rv;
+    int i;
+
+    /*
+     * Snapshot the interpreter name table under wsgi_interp_lock.
+     * Worker threads may grow the table concurrently via
+     * wsgi_acquire_interpreter, so iterating it directly is unsafe;
+     * a snapshot lets us release the lock before acquiring any
+     * sub-interpreter GIL (acquire then takes wsgi_interp_lock again
+     * internally, which would deadlock if we still held it here).
+     */
+
+    rv = apr_pool_create(&pool, NULL);
+    if (rv != APR_SUCCESS)
+        return;
+
+    apr_thread_mutex_lock(wsgi_interp_lock);
+
+    names = apr_array_make(pool, apr_hash_count(wsgi_interpreters),
+                           sizeof(const char *));
+
+    for (hi = apr_hash_first(pool, wsgi_interpreters); hi;
+         hi = apr_hash_next(hi))
+    {
+        const void *key;
+        apr_hash_this(hi, &key, NULL, NULL);
+        APR_ARRAY_PUSH(names, const char *) = apr_pstrdup(pool,
+                                                          (const char *)key);
+    }
+
+    apr_thread_mutex_unlock(wsgi_interp_lock);
+
+    for (i = 0; i < names->nelts; i++)
+    {
+        const char *name = APR_ARRAY_IDX(names, i, const char *);
+        InterpreterObject *interp = NULL;
+        PyObject *event = NULL;
+        PyObject *signame_obj = NULL;
+        PyObject *signum_obj = NULL;
+        int ok = 0;
+
+        interp = wsgi_acquire_interpreter((char *)name);
+
+        if (!interp)
+            continue;
+
+        event = PyDict_New();
+        signame_obj = PyUnicode_FromString(signame);
+        signum_obj = PyLong_FromLong(signum);
+
+        if (event && signame_obj && signum_obj &&
+            PyDict_SetItemString(event, "signame", signame_obj) == 0 &&
+            PyDict_SetItemString(event, "signum", signum_obj) == 0)
+        {
+            wsgi_publish_event("process_signal", event);
+            ok = 1;
+        }
+
+        Py_XDECREF(signum_obj);
+        Py_XDECREF(signame_obj);
+        Py_XDECREF(event);
+
+        if (!ok)
+        {
+            wsgi_log_error_locked(APLOG_ERR, 0, wsgi_server,
+                                  WSGI_APLOGNO(0209) "Unable to publish "
+                                                     "'process_signal' event "
+                                                     "for %s.",
+                                  wsgi_format_interp_context(
+                                      wsgi_server->process->pool, NULL,
+                                      name));
+            PyErr_Clear();
+        }
+
+        wsgi_release_interpreter(interp);
+    }
+
+    apr_pool_destroy(pool);
+}
+
 /* ------------------------------------------------------------------------- */
 
 /*

{mod_wsgi_standalone-6.0.0.dev4 → mod_wsgi_standalone-6.0.0.dev5}/src/server/wsgi_interp.h

@@ -119,6 +119,19 @@ extern int wsgi_interpreter_exists(const char *name);
 
 extern void wsgi_publish_process_stopping(char *reason);
 
+/*
+ * Publish a "process_signal" event into every existing sub-interpreter
+ * in this process. Snapshots the interpreter name table under
+ * wsgi_interp_lock so the walk is safe against concurrent creation by
+ * worker threads, then for each name acquires the interpreter (which
+ * takes the GIL for that interpreter), constructs an event dict with
+ * signame (canonical str like "SIGHUP") and signum (int) payload keys,
+ * and dispatches via wsgi_publish_event. Intended to be called only
+ * from the signal dispatcher thread in daemon mode.
+ */
+
+extern void wsgi_publish_process_signal(int signum, const char *signame);
+
 extern apr_status_t wsgi_python_child_init(apr_pool_t *p);
 
 /* ------------------------------------------------------------------------- */