Port ee9 BlockingTest to ee10/11

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/Blocker.java

@@ -80,6 +80,12 @@ public Throwable fillInStackTrace()
         {
             return this;
         }
+
+        @Override
+        public String toString()
+        {
+            return "ACQUIRED";
+        }
     };
     private static final Throwable SUCCEEDED = new Throwable()
     {
@@ -88,6 +94,12 @@ public Throwable fillInStackTrace()
         {
             return this;
         }
+
+        @Override
+        public String toString()
+        {
+            return "SUCCEEDED";
+        }
     };
 
     public interface Runnable extends java.lang.Runnable, AutoCloseable, Invocable
@@ -434,5 +446,11 @@ public Runnable runnable() throws IOException
                 _lock.unlock();
             }
         }
+
+        @Override
+        public String toString()
+        {
+            return "%s@%x[c=%s]".formatted(getClass().getSimpleName(), hashCode(), _completed);
+        }
     }
 }

jetty-core/jetty-util/src/main/java/org/eclipse/jetty/util/ExceptionUtil.java

@@ -13,6 +13,8 @@
 
 package org.eclipse.jetty.util;
 
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.lang.reflect.Constructor;
 import java.util.Arrays;
 import java.util.List;
@@ -466,6 +468,20 @@ public static <T> T get(CompletableFuture<T> completableFuture)
         }
     }
 
+    /**
+     * <p>Convert a {@link Throwable} to a string equivalent to what {@link Throwable#printStackTrace()} prints.</p>
+     * @param throwable The {@link Throwable} or null
+     * @return a string containing the throwable's full stack trace
+     */
+    public static String toString(Throwable throwable)
+    {
+        if (throwable == null)
+            return "null";
+        StringWriter sw = new StringWriter();
+        throwable.printStackTrace(new PrintWriter(sw));
+        return sw.toString();
+    }
+
     private ExceptionUtil()
     {
     }

jetty-ee10/jetty-ee10-servlet/src/main/java/org/eclipse/jetty/ee10/servlet/AsyncContentProducer.java

@@ -371,30 +371,58 @@ private LockedSemaphore()
             this._condition = _lock.newCondition();
         }
 
-        void assertLocked()
+        /**
+         * Checks that the {@link HttpInput} lock scope is correct.
+         * @throws IllegalStateException if the {@link HttpInput} lock is not held
+         */
+        void assertLocked() throws IllegalStateException
         {
             if (!_lock.isHeldByCurrentThread())
                 throw new IllegalStateException("LockedSemaphore must be called within lock scope");
         }
 
+        /**
+         * Resets the semaphore's permit count to 0.
+         */
         void drainPermits()
         {
             _permits = 0;
         }
 
+        /**
+         * Acquires a permit from the semaphore by decreasing the permit count by 1 without ever going negative.
+         * This method returns immediately when the permit count is >= 1 or it blocks until {@link #release} or {@link #fail()}
+         * is called to increase the permit count.
+         * @throws InterruptedException if this call was blocked waiting for the permit count to go above 0 and the thread
+         * got interrupted.
+         */
         void acquire() throws InterruptedException
         {
             while (_permits == 0)
                 _condition.await();
             _permits--;
         }
 
+        /**
+         * Releases a permit to the semaphore by increasing the permit count by 1, potentially unblocking one thread
+         * blocked in {@link #acquire()}.
+         */
         void release()
         {
             _permits++;
             _condition.signal();
         }
 
+        /**
+         * Unblock all threads blocked in {@link #acquire()} and prevent all further calls to {@link #acquire()}
+         * from blocking until {@link #drainPermits()} is called.
+         */
+        void fail()
+        {
+            _permits = Integer.MAX_VALUE;
+            _condition.signalAll();
+        }
+
         @Override
         public String toString()
         {

jetty-ee10/jetty-ee10-servlet/src/main/java/org/eclipse/jetty/ee10/servlet/BlockingContentProducer.java

@@ -153,8 +153,9 @@ public boolean onContentProducible()
         // Calling _asyncContentProducer.onContentProducible() changes the channel state from WAITING to WOKEN which
         // would prevent the async error thread from noticing that a redispatching is needed.
         boolean unready = _asyncContentProducer.isUnready();
+        boolean error = _asyncContentProducer.isError();
         if (LOG.isDebugEnabled())
-            LOG.debug("onContentProducible releasing semaphore {} unready={}", _semaphore, unready);
+            LOG.debug("onContentProducible releasing semaphore {} unready={} error={}", _semaphore, unready, error);
         // Do not release the semaphore if we are not unready, as certain protocols may call this method
         // just after having received the request, not only when they have read all the available content.
         if (unready)
@@ -163,6 +164,8 @@ public boolean onContentProducible()
             _asyncContentProducer.getServletChannel().getServletRequestState().onReadIdle();
             _semaphore.release();
         }
+        if (error)
+            _semaphore.fail();
         return false;
     }
 }