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

{mod_wsgi_standalone-6.0.0.dev3 → 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.dev3
+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.dev3 → 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.dev3
+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.dev3 → 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.dev3 → mod_wsgi_standalone-6.0.0.dev5}/src/express/apache.py

@@ -317,6 +317,10 @@ WSGISlowRequests %(slow_requests)s
 WSGISwitchInterval %(switch_interval)s
 </IfDefine>
 
+<IfDefine MOD_WSGI_FREE_THREADING>
+WSGIFreeThreading On
+</IfDefine>
+
 <IfDefine MOD_WSGI_TELEMETRY_OPTIONS>
 %(telemetry_options)s
 </IfDefine>
@@ -812,6 +816,10 @@ APACHE_SETENV_CONFIG = """
 SetEnv '%(name)s' '%(value)s'
 """
 
+APACHE_PYTHON_WARNINGS_CONFIG = """
+WSGIPythonWarnings '%(spec)s'
+"""
+
 APACHE_PASSENV_CONFIG = """
 PassEnv '%(name)s'
 """
@@ -978,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.dev3 → mod_wsgi_standalone-6.0.0.dev5}/src/express/options.py

@@ -540,10 +540,25 @@ add_option('all', '--telemetry-service', metavar='TARGET',
         'ingester). Remote "udp:host:port" targets are not supported. '
         'Off by default.')
 
+add_option('unix', '--enable-telemetry', action='store_true', default=False,
+        help='Bundle a telemetry ingester and web UI alongside the WSGI '
+        'application. Generates a service-script daemon that runs the '
+        'mod_wsgi-telemetry ingester on a UNIX socket inside the server '
+        'root and emits WSGITelemetryService pointing at that socket so '
+        'the WSGI processes report to it. Requires the mod_wsgi-telemetry '
+        'package to be installed. Mutually exclusive with '
+        '--telemetry-service.')
+
+add_option('unix', '--telemetry-ui-port', type='int', default=8888,
+        metavar='NUMBER', help='HTTP port the telemetry web UI binds to '
+        'on 127.0.0.1 when --enable-telemetry is set. Defaults to '
+        '%default. Two express instances on the same host need distinct '
+        'ports to avoid a bind collision.')
+
 add_option('all', '--telemetry-interval', type='float', default=1.0,
         metavar='SECONDS', help='Metrics reporter sampling interval '
-        'in seconds. Only applies when --telemetry-service is set. '
-        'Defaults to %default.')
+        'in seconds. Only applies when --telemetry-service or '
+        '--enable-telemetry is set. Defaults to %default.')
 
 add_option('all', '--slow-requests', type='float', default=None,
         metavar='SECONDS', help='Enable slow-request reporting and set '
@@ -558,6 +573,13 @@ add_option('all', '--switch-interval', type='float', default=None,
         'switch-interval option on WSGIDaemonProcess. Defaults to '
         'Python\'s built-in 0.005 (5 ms) when unset.')
 
+add_option('all', '--free-threading', action='store_true', default=False,
+        help='Emit WSGIFreeThreading On in the generated configuration to '
+        'run the Python interpreter without the GIL. Requires a Python '
+        'build with free-threading support (PEP 703, --disable-gil); '
+        'mod_wsgi-express will exit with an error if the running Python '
+        'does not support it.')
+
 add_option('all', '--telemetry-options', action='append', default=[],
         metavar='ARGS', help='Apache-Options-style metrics-capture '
         'toggle, passed verbatim to a WSGITelemetryOptions directive in '
@@ -729,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.dev3 → mod_wsgi_standalone-6.0.0.dev5}/src/express/scripts.py

@@ -166,6 +166,27 @@ def generate_wsgi_handler_script(options):
     with open(path, 'w') as fp:
         print(WSGI_DEFAULT_SCRIPT % options, file=fp)
 
+TELEMETRY_SERVICE_SCRIPT = '''
+# Auto-generated by mod_wsgi-express --enable-telemetry. Runs the
+# mod_wsgi-telemetry ingester and web UI inside a WSGIDaemonProcess
+# threads=0 service daemon. The WSGI processes report to the UNIX
+# socket below via the WSGITelemetryService directive in httpd.conf.
+
+from mod_wsgi.telemetry.server import main
+
+main([
+    "--listen",    "unix:%(telemetry_socket)s",
+    "--http-host", "127.0.0.1",
+    "--http-port", "%(telemetry_ui_port)s",
+    "--log-level", "INFO",
+])
+'''
+
+def generate_telemetry_service_script(options):
+    path = os.path.join(options['server_root'], 'telemetry-service.py')
+    with open(path, 'w') as fp:
+        print(TELEMETRY_SERVICE_SCRIPT % options, file=fp)
+
 WSGI_CONTROL_SCRIPT = """
 #!%(shell_executable)s
 

{mod_wsgi_standalone-6.0.0.dev3 → mod_wsgi_standalone-6.0.0.dev5}/src/express/server.py

@@ -5,12 +5,16 @@ import math
 import os
 import posixpath
 import sys
+import sysconfig
 import tempfile
 
 from . import apxs_config
 from .platform import find_program, MOD_WSGI_SO, PYTHON_DYLIB
 from .apache import generate_apache_config
-from .scripts import generate_wsgi_handler_script, generate_control_scripts
+from .scripts import (
+    generate_wsgi_handler_script, generate_control_scripts,
+    generate_telemetry_service_script,
+)
 
 def _mpm_module_defines(modules_directory, preferred=None):
     if os.name == 'nt':
@@ -367,6 +371,41 @@ def setup_server(command, args, options):
     else:
         options['server_metrics_flag'] = 'Off'
 
+    if options['enable_telemetry']:
+        if options['telemetry_service']:
+            raise ConfigurationError(
+                "--enable-telemetry and --telemetry-service are "
+                "mutually exclusive: --enable-telemetry generates an "
+                "ingester service and points the WSGI processes at "
+                "it, so an explicit telemetry target would conflict.")
+
+        try:
+            import mod_wsgi.telemetry.server  # noqa: F401
+        except ImportError:
+            raise ConfigurationError(
+                "--enable-telemetry requires the mod_wsgi-telemetry "
+                "package: install it with "
+                "'pip install mod_wsgi-telemetry'.")
+
+        for name, _ in options['service_scripts'] or []:
+            if name == 'telemetry':
+                raise ConfigurationError(
+                    "--enable-telemetry generates a service named "
+                    "'telemetry'; rename the conflicting "
+                    "--service-script entry or drop "
+                    "--enable-telemetry.")
+
+        socket_path = posixpath.join(options['server_root'],
+                                     'telemetry.sock')
+        options['telemetry_socket'] = socket_path
+        options['telemetry_service'] = 'unix:%s' % socket_path
+
+        script_path = posixpath.join(options['server_root'],
+                                     'telemetry-service.py')
+        options['service_scripts'] = list(
+            options['service_scripts'] or [])
+        options['service_scripts'].append(('telemetry', script_path))
+
     if options['telemetry_service']:
         target = options['telemetry_service']
         if not target.startswith('unix:'):
@@ -396,6 +435,13 @@ def setup_server(command, args, options):
         options['switch_interval'] = ''
         options['daemon_switch_interval_option'] = ''
 
+    if options['free_threading']:
+        if not sysconfig.get_config_var('Py_GIL_DISABLED'):
+            raise ConfigurationError(
+                "--free-threading requires a Python build with "
+                "free-threading support (PEP 703). Rebuild Python "
+                "with --disable-gil to use it.")
+
     if options['handler_scripts']:
         handler_scripts = []
         for extension, script in options['handler_scripts']:
@@ -781,6 +827,8 @@ def setup_server(command, args, options):
         options['httpd_arguments_list'].append('-DMOD_WSGI_SLOW_REQUESTS')
     if options['switch_interval'] != '':
         options['httpd_arguments_list'].append('-DMOD_WSGI_SWITCH_INTERVAL')
+    if options['free_threading']:
+        options['httpd_arguments_list'].append('-DMOD_WSGI_FREE_THREADING')
     if options['telemetry_options']:
         options['httpd_arguments_list'].append('-DMOD_WSGI_TELEMETRY_OPTIONS')
         options['telemetry_options'] = '\n'.join(
@@ -856,6 +904,9 @@ def setup_server(command, args, options):
 
     generate_wsgi_handler_script(options)
 
+    if options['enable_telemetry']:
+        generate_telemetry_service_script(options)
+
     print('Server URL         :', options['url'])
 
     if options['https_url']:

{mod_wsgi_standalone-6.0.0.dev3 → 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,9 +3087,34 @@ static void wsgi_daemon_main(apr_pool_t *p, WSGIDaemonProcess *daemon)
         }
     }
 
-    /* Start telemetry reporter if configured. */
+    /*
+     * 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
+     * nothing to accumulate, and an ingester-hosting service script
+     * would otherwise report telemetry datagrams to itself.
+     */
 
-    wsgi_telemetry_start_reporter(p);
+    if (daemon->group->threads != 0)
+        wsgi_telemetry_start_reporter(p);
 
     /* Initialise worker stack. */
 
@@ -3248,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
@@ -3540,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();
@@ -3553,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)