mod-wsgi 6.0.1__tar.gz → 6.0.3.dev1__tar.gz

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mod_wsgi
-Version: 6.0.1
+Version: 6.0.3.dev1
 Summary: Installer for Apache/mod_wsgi.
 Home-page: https://www.modwsgi.org/
 Author: Graham Dumpleton

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/mod_wsgi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mod_wsgi
-Version: 6.0.1
+Version: 6.0.3.dev1
 Summary: Installer for Apache/mod_wsgi.
 Home-page: https://www.modwsgi.org/
 Author: Graham Dumpleton

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/setup.py

@@ -456,6 +456,6 @@ setup(name = package_name,
     entry_points = { 'console_scripts':
         ['mod_wsgi-express = mod_wsgi.express.cli:main'],},
     zip_safe = False,
-    install_requires = standalone and ['mod_wsgi-httpd==2.4.67.1'] or [],
+    install_requires = standalone and ['mod_wsgi-httpd==2.4.68.1'] or [],
     python_requires='>=3.10',
 )

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/express/apache.py

@@ -243,6 +243,7 @@ WSGIDaemonProcess %(process_group)s \\
    header-buffer-size=%(header_buffer_size)s \\
    response-buffer-size=%(response_buffer_size)s \\
    response-socket-timeout=%(response_socket_timeout)s \\
+   response-flush-delay=%(response_flush_delay)s \\
    server-metrics=%(server_metrics_flag)s%(daemon_switch_interval_option)s
 </IfDefine>
 <IfDefine !MOD_WSGI_MULTIPROCESS>
@@ -273,6 +274,7 @@ WSGIDaemonProcess %(process_group)s \\
    receive-buffer-size=%(receive_buffer_size)s \\
    response-buffer-size=%(response_buffer_size)s \\
    response-socket-timeout=%(response_socket_timeout)s \\
+   response-flush-delay=%(response_flush_delay)s \\
    server-metrics=%(server_metrics_flag)s%(daemon_switch_interval_option)s
 </IfDefine>
 </IfDefine>

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/express/cli.py

@@ -67,11 +67,33 @@ def cmd_start_server(params):
         httpd_arguments.extend(['-f', config['httpd_conf']])
         httpd_arguments.extend(['-DONE_PROCESS'])
 
-        os.environ['MOD_WSGI_MODULES_DIRECTORY'] = config['modules_directory']
-
-        subprocess.call([executable]+httpd_arguments)
-
-        sys.exit(0)
+        # On Windows httpd shares our console, so a Ctrl-C delivers a
+        # CTRL_C_EVENT to the whole console process group and httpd runs
+        # its own graceful shutdown. We must not let the same Ctrl-C kill
+        # this launcher first, or it returns to the shell while httpd is
+        # still tearing down (and dumps a KeyboardInterrupt traceback). So
+        # absorb our own interrupt and keep waiting until httpd exits.
+        #
+        # A first Ctrl-C is treated as "you should have received the
+        # console event, shutting down gracefully, I will wait". If httpd
+        # did not actually receive the event (for example a git-bash pty
+        # bridge that does not forward it to the child), a second Ctrl-C
+        # escalates to terminating it so we cannot hang indefinitely.
+
+        process = subprocess.Popen([executable]+httpd_arguments, env=environ)
+
+        interrupts = 0
+
+        while True:
+            try:
+                process.wait()
+                break
+            except KeyboardInterrupt:
+                interrupts += 1
+                if interrupts >= 2:
+                    process.terminate()
+
+        sys.exit(process.returncode)
 
     else:
         executable = posixpath.join(config['server_root'], 'apachectl')

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/express/options.py

@@ -395,18 +395,32 @@ add_option('unix', '--header-buffer-size', type='int', default=0,
         'indicating internal default of 32768 bytes is used.')
 
 add_option('unix', '--response-buffer-size', type='int', default=0,
-        metavar='NUMBER', help='Maximum amount of response content '
-        'that will be allowed to be buffered in the Apache child '
-        'worker process when proxying the response from a daemon '
-        'process. Defaults to 0, indicating internal default of '
-        '65536 bytes is used.')
+        metavar='NUMBER', help='Coarse upper bound, in bytes, on how '
+        'much response content is passed down the output filter chain '
+        'without a flush when proxying the response from a daemon '
+        'process. Only bounds a downstream filter that buffers without '
+        'draining; the Apache core output filter handles normal memory '
+        'bounding. Defaults to 0, indicating the internal default of '
+        '8388608 bytes (8 MB) is used. Setting it low can interfere with '
+        'a downstream pacing filter such as mod_ratelimit.')
 
 add_option('unix', '--response-socket-timeout', type='int', default=0,
         metavar='SECONDS', help='Maximum number of seconds allowed '
         'to pass before timing out on a write operation back to the '
-        'HTTP client when the response buffer has filled and data is '
-        'being forcibly flushed. Defaults to 0 seconds indicating that '
-        'it will default to the value of the \'socket-timeout\' option.')
+        'HTTP client when transferring the response body. Defaults to 0 '
+        'seconds indicating that it will default to the value of the '
+        '\'socket-timeout\' option.')
+
+add_option('unix', '--response-flush-delay', type='int', default=5,
+        metavar='MILLISECONDS', help='Number of milliseconds mod_wsgi '
+        'will wait for further response data from a daemon process before '
+        'flushing what it has to the HTTP client. Waiting briefly lets a '
+        'downstream output filter such as mod_ratelimit pace or batch the '
+        'response correctly instead of being forced to emit a short write '
+        'on every momentary stall. Defaults to 5 milliseconds. Setting it '
+        'to 0 flushes on any stall and is not recommended when a pacing '
+        'filter such as mod_ratelimit is in use, as it can throttle '
+        'responses far below the configured rate.')
 
 add_option('all', '--enable-sendfile', action='store_true',
         default=False, help='Flag indicating whether sendfile() support '

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/express/platform.py

@@ -82,7 +82,7 @@ def default_run_group():
 
 def find_program(names, default=None, paths=[]):
     for name in names:
-        for path in os.environ['PATH'].split(':') + paths:
+        for path in os.environ['PATH'].split(os.pathsep) + paths:
             program = posixpath.join(path, name)
             if os.path.exists(program):
                 return program

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/express/reloader.py

@@ -97,6 +97,17 @@ def track_changes(path):
         _files.append(path)
 
 def start_reloader(interval=1.0):
+    # The reloader triggers a restart by sending SIGINT to this process. On
+    # Windows os.kill() cannot deliver SIGINT to ourselves: any signal other
+    # than CTRL_C_EVENT/CTRL_BREAK_EVENT is implemented as an unconditional
+    # TerminateProcess, so the reloader would hard kill the server rather than
+    # trigger a graceful restart. Disable it on Windows.
+    if os.name == 'nt':
+        prefix = 'monitor (pid=%d):' % os.getpid()
+        print('%s Source code reloading is not supported on Windows.' % prefix,
+                file=sys.stderr)
+        return
+
     global _interval
     if interval < _interval:
         _interval = interval

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/express/server.py

@@ -255,14 +255,17 @@ def setup_server(command, args, options):
         options['access_log_file'] = posixpath.join(
                 options['log_directory'], options['access_log_name'])
     else:
-        try:
-            with open('/dev/stdout', 'w'):
-                pass
-        except IOError:
-            options['access_log_file'] = '|%s' % find_program(
-                    ['tee'], default='tee')
+        if os.name == 'nt':
+            options['access_log_file'] = 'CON'
         else:
-            options['access_log_file'] = '/dev/stdout'
+            try:
+                with open('/dev/stdout', 'w'):
+                    pass
+            except IOError:
+                options['access_log_file'] = '|%s' % find_program(
+                        ['tee'], default='tee')
+            else:
+                options['access_log_file'] = '/dev/stdout'
 
     if options['access_log_format']:
         if options['access_log_format'] in ('common', 'combined'):

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/server/mod_wsgi.c

@@ -793,6 +793,20 @@ static int wsgi_hook_handler(request_rec *r)
         return HTTP_INTERNAL_SERVER_ERROR;
     }
 
+    /*
+     * Embedded execution needs a Python interpreter in this child. If
+     * one was never initialised (or initialisation failed), the
+     * per-thread state used by wsgi_execute_script() does not exist and
+     * running it would crash the process, so refuse the request.
+     */
+
+    if (!wsgi_python_initialized)
+    {
+        wsgi_log_rerror(APLOG_ERR, 0, r, WSGI_APLOGNO(0210) "Embedded mode of mod_wsgi cannot be used as Python "
+                                                            "was not initialised in this process.");
+        return HTTP_INTERNAL_SERVER_ERROR;
+    }
+
     return wsgi_execute_script(r);
 }
 
@@ -1262,27 +1276,4 @@ module AP_MODULE_DECLARE_DATA wsgi_module = {
 
 /* ------------------------------------------------------------------------- */
 
-#if defined(_WIN32)
-PyMODINIT_FUNC PyInit_mod_wsgi(void)
-{
-    /* The 'mod_wsgi' Python module is created at runtime by the Apache
-     * module when it sets up each interpreter; it is not a regular
-     * Python extension and cannot be imported from a standalone Python
-     * process. This stub exists only to satisfy the Windows linker and
-     * is not expected to be reached. Set an explicit ImportError so the
-     * importer reports the actual situation instead of the generic
-     * "initialization of mod_wsgi failed without raising an exception"
-     * SystemError. */
-
-    PyErr_SetString(PyExc_ImportError,
-                    "mod_wsgi cannot be imported as a regular Python "
-                    "module; it is provided by the Apache mod_wsgi "
-                    "module and is only available inside an Apache "
-                    "process running mod_wsgi.");
-    return NULL;
-}
-#endif
-
-/* ------------------------------------------------------------------------- */
-
 /* vi: set sw=4 expandtab : */

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/server/wsgi_config.c

@@ -778,6 +778,12 @@ const char *wsgi_set_restrict_embedded(cmd_parms *cmd, void *mconfig,
         if (wsgi_python_required == -1)
             wsgi_python_required = 0;
     }
+    else
+    {
+        /* Embedded mode enabled, so Python is needed in the child. */
+
+        wsgi_python_required = 1;
+    }
 
     return NULL;
 }

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/server/wsgi_daemon.c

@@ -149,6 +149,8 @@ const char *wsgi_add_daemon_process(cmd_parms *cmd, void *mconfig,
 
     int response_socket_timeout = 0;
 
+    int response_flush_delay = -1;
+
     const char *script_user = NULL;
     const char *script_group = NULL;
 
@@ -510,6 +512,17 @@ const char *wsgi_add_daemon_process(cmd_parms *cmd, void *mconfig,
             if (response_socket_timeout < 0)
                 return "Invalid response socket timeout for WSGI daemon process.";
         }
+        else if (!strcmp(option, "response-flush-delay"))
+        {
+            if (!*value)
+                return "Invalid response flush delay for WSGI daemon process.";
+
+            /* Value is in milliseconds; 0 disables the delay. */
+
+            response_flush_delay = atoi(value);
+            if (response_flush_delay < 0)
+                return "Invalid response flush delay for WSGI daemon process.";
+        }
         else if (!strcmp(option, "socket-user"))
         {
             uid_t socket_uid;
@@ -741,6 +754,13 @@ const char *wsgi_add_daemon_process(cmd_parms *cmd, void *mconfig,
 
     entry->response_socket_timeout = apr_time_from_sec(response_socket_timeout);
 
+    /* Default the response flush delay to 5 milliseconds. */
+
+    if (response_flush_delay < 0)
+        response_flush_delay = 5;
+
+    entry->response_flush_delay = apr_time_from_msec(response_flush_delay);
+
     entry->script_user = script_user;
     entry->script_group = script_group;
 

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/server/wsgi_daemon.h

@@ -127,6 +127,7 @@ typedef struct
     int header_buffer_size;
     int response_buffer_size;
     apr_time_t response_socket_timeout;
+    apr_time_t response_flush_delay;
     const char *script_user;
     const char *script_group;
     int cpu_time_limit;

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/server/wsgi_remote.c

@@ -803,7 +803,9 @@ static int wsgi_scan_headers_brigade(request_rec *r, apr_bucket_brigade *bb,
 }
 
 static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
-                                  apr_size_t buffer_size, apr_time_t timeout)
+                                  apr_size_t buffer_size, apr_time_t timeout,
+                                  apr_socket_t *daemon_socket,
+                                  apr_time_t flush_delay)
 {
     apr_bucket *e;
     apr_read_type_e mode = APR_NONBLOCK_READ;
@@ -815,15 +817,24 @@ static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
 
     apr_size_t bytes_transfered = 0;
 
-    int bucket_count = 0;
-
     apr_status_t rv;
 
     apr_socket_t *sock;
     apr_interval_time_t existing_timeout = 0;
 
+    apr_interval_time_t daemon_timeout = 0;
+    int lingering = 0;
+
+    /*
+     * response-buffer-size bounds how many bytes of response content
+     * may be passed downstream without a flush, acting as a coarse
+     * runaway guard (see where it is applied below). Zero selects the
+     * default, which is high enough that the guard does not affect
+     * normal operation.
+     */
+
     if (buffer_size == 0)
-        buffer_size = 65536;
+        buffer_size = 8 * 1024 * 1024;
 
     /*
      * Override the socket timeout for writing back data to the
@@ -851,15 +862,22 @@ static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
     }
 
     /*
-     * Transfer any response content. We want to avoid the
-     * problem where the core output filter has no flow control
-     * to deal with slow HTTP clients and can actually buffer up
-     * excessive amounts of response content in memory. A fix
-     * for this was only introduced in Apache 2.3.3, with
-     * possible further tweaks in Apache 2.4.1. To avoid issue of
-     * what version it was implemented in, just employ a
-     * strategy of forcing a flush every time we pass through
-     * more than a certain amount of data.
+     * When a response flush delay is configured, remember the daemon
+     * socket's current read timeout. While lingering for more data we
+     * lower it to the flush delay and restore it afterwards. Guard
+     * against a NULL daemon socket by disabling the linger.
+     */
+
+    if (!daemon_socket)
+        flush_delay = 0;
+
+    if (flush_delay)
+        apr_socket_timeout_get(daemon_socket, &daemon_timeout);
+
+    /*
+     * Transfer the response content back to the client, reading it
+     * from the daemon a block at a time and passing each block down
+     * the output filter chain.
      */
 
     tmpbb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
@@ -923,13 +941,46 @@ static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
         rv = apr_bucket_read(e, &data, &length, mode);
 
         /*
-         * If we would have blocked if not in non blocking mode
-         * we send a flush bucket to ensure that all buffered
-         * data is sent out before we block waiting for more.
+         * A non-blocking read returned no data. Rather than flushing
+         * immediately, which would force any downstream pacing filter
+         * such as mod_ratelimit to emit a short write and so defeat
+         * its rate calculation, first wait a bounded flush delay for
+         * more data using a blocking read with a short timeout on the
+         * daemon socket. If data arrives within that window the
+         * transfer is still active and we keep accumulating without a
+         * flush. Only if the producer stays idle for the whole delay
+         * do we flush, so streaming responses still reach the client
+         * promptly. When the flush delay is zero this step is skipped
+         * and the data is flushed on any would-block.
+         */
+
+        if (rv == APR_EAGAIN && mode == APR_NONBLOCK_READ && flush_delay)
+        {
+            apr_socket_timeout_set(daemon_socket, flush_delay);
+
+            mode = APR_BLOCK_READ;
+            lingering = 1;
+
+            continue;
+        }
+
+        /*
+         * If we would have blocked, or the producer stayed idle for
+         * the whole flush delay, we send a flush bucket to ensure that
+         * all buffered data is sent out before we block waiting for
+         * more.
          */
 
-        if (rv == APR_EAGAIN && mode == APR_NONBLOCK_READ)
+        if ((rv == APR_EAGAIN && mode == APR_NONBLOCK_READ) ||
+            (rv == APR_TIMEUP && lingering))
         {
+            if (lingering)
+            {
+                apr_socket_timeout_set(daemon_socket, daemon_timeout);
+
+                lingering = 0;
+            }
+
             APR_BRIGADE_INSERT_TAIL(tmpbb, apr_bucket_flush_create(
                                                r->connection->bucket_alloc));
 
@@ -961,8 +1012,6 @@ static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
 
             bytes_transfered = 0;
 
-            bucket_count = 0;
-
             /*
              * Retry read from daemon using a blocking read. We do
              * not delete the bucket as we want to operate on the
@@ -991,9 +1040,18 @@ static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
 
         /*
          * We had some data to transfer. Next time round we need to
-         * always be try a non-blocking read first.
+         * always be try a non-blocking read first. If we got here from
+         * a lingering blocking read, restore the daemon socket timeout
+         * that we lowered to the flush delay.
          */
 
+        if (lingering)
+        {
+            apr_socket_timeout_set(daemon_socket, daemon_timeout);
+
+            lingering = 0;
+        }
+
         mode = APR_NONBLOCK_READ;
 
         /*
@@ -1010,41 +1068,38 @@ static int wsgi_transfer_response(request_rec *r, apr_bucket_brigade *bb,
         APR_BRIGADE_INSERT_TAIL(tmpbb, e);
 
         /*
-         * If we have reached the buffer size threshold, we want
-         * to flush the data so that we aren't buffering too much
-         * in memory and blowing out memory size. We also have a
-         * check on the number of buckets we have accumulated as
-         * a large number of buckets with very small amounts of
-         * data will also accumulate a lot of memory. Apache's
-         * own flow control doesn't cope with such a situation.
-         * Right now hard wire the max number of buckets at 16
-         * which equates to worst case number of separate data
-         * blocks can be written by a writev() call on systems
-         * such as Solaris.
+         * Each block is passed straight on without a forced flush. The
+         * Apache 2.4 core output filter bounds how much response data
+         * is buffered in the child process: it switches to blocking
+         * writes once its own threshold is reached, which backpressures
+         * through ap_pass_brigade and on to the daemon, and it batches
+         * its own writev() calls. Passing whole blocks on keeps writes
+         * large enough for a downstream pacing filter such as
+         * mod_ratelimit to pace correctly. Pending data is otherwise
+         * flushed when the producer goes idle (above) and at end of
+         * stream.
+         *
+         * As a coarse runaway guard, force a flush if more than
+         * buffer_size bytes have been passed downstream since the last
+         * flush. This bounds a downstream filter that buffers without
+         * draining to roughly buffer_size per request. It counts bytes
+         * transferred, not bytes currently buffered, so on a healthy
+         * connection it just emits an otherwise harmless flush every
+         * buffer_size bytes; buffer_size is high by default so it does
+         * not fire in normal operation.
          */
 
         bytes_transfered += length;
 
-        bucket_count += 1;
-
-        if (bytes_transfered > buffer_size || bucket_count >= 16)
+        if (bytes_transfered > buffer_size)
         {
             APR_BRIGADE_INSERT_TAIL(tmpbb, apr_bucket_flush_create(
                                                r->connection->bucket_alloc));
 
             bytes_transfered = 0;
-
-            bucket_count = 0;
-
-            /*
-             * Since we flushed the data out to the client, it is
-             * okay to go back and do a blocking read the next time.
-             */
-
-            mode = APR_BLOCK_READ;
         }
 
-        /* Pass the heap bucket and any flush bucket on. */
+        /* Pass the heap bucket and any runaway-guard flush on. */
 
         rv = ap_pass_brigade(r->output_filters, tmpbb);
 
@@ -1835,7 +1890,8 @@ int wsgi_execute_remote(request_rec *r)
     /* Transfer any response content. */
 
     return wsgi_transfer_response(r, bbin, group->response_buffer_size,
-                                  group->response_socket_timeout);
+                                  group->response_socket_timeout,
+                                  daemon->socket, group->response_flush_delay);
 }
 
 static apr_status_t wsgi_socket_read(apr_socket_t *sock, void *vbuf,

{mod_wsgi-6.0.1 → mod_wsgi-6.0.3.dev1}/src/server/wsgi_version.h

@@ -25,8 +25,8 @@
 
 #define MOD_WSGI_MAJORVERSION_NUMBER 6
 #define MOD_WSGI_MINORVERSION_NUMBER 0
-#define MOD_WSGI_MICROVERSION_NUMBER 1
-#define MOD_WSGI_VERSION_STRING "6.0.1"
+#define MOD_WSGI_MICROVERSION_NUMBER 3
+#define MOD_WSGI_VERSION_STRING "6.0.3.dev1"
 
 /* ------------------------------------------------------------------------- */