refactor: extract common logic in a separate class

Extract common semaphore logic into ConcurrentOperationBase for reuse in concurrent handlers.

Author: mlopezFC

src/main/java/com/flowingcode/vaadin/addons/gridexporter/ConcurrentDownloadHandler.java

@@ -19,18 +19,12 @@
  */
 package com.flowingcode.vaadin.addons.gridexporter;
 
-import com.vaadin.flow.component.UI;
 import com.vaadin.flow.server.streams.DownloadHandler;
 import com.vaadin.flow.server.streams.DownloadEvent;
 import com.vaadin.flow.server.VaadinSession;
 import java.io.IOException;
 import java.io.InterruptedIOException;
-import java.io.OutputStream;
 import java.nio.channels.InterruptedByTimeoutException;
-import java.util.Optional;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.TimeUnit;
-import java.util.function.IntFunction;
 
 /**
  * An implementation of {@link DownloadHandler} that controls access to the
@@ -41,112 +35,10 @@
  * @author Javier Godoy
  */
 @SuppressWarnings("serial")
-abstract class ConcurrentDownloadHandler implements DownloadHandler {
-
-    public static final float MAX_COST = 0x7FFF;
-
-    public static final float MIN_COST = 1.0f / 0x10000;
-
-    public static final float DEFAULT_COST = 1.0f;
-
-    private static final ConfigurableSemaphore semaphore = new ConfigurableSemaphore();
-
-    private static volatile boolean enabled;
-
-    private static volatile boolean failOnUiChange;
+abstract class ConcurrentDownloadHandler extends ConcurrentOperationBase implements DownloadHandler {
 
     private final DownloadHandler delegate;
 
-    private static final class ConfigurableSemaphore extends Semaphore {
-
-        private int maxPermits;
-
-        ConfigurableSemaphore() {
-            super(0);
-        }
-
-        synchronized void setPermits(int permits) {
-            if (permits < 0) {
-                throw new IllegalArgumentException();
-            }
-            int delta = permits - maxPermits;
-            if (delta > 0) {
-                super.release(delta);
-            } else if (delta < 0) {
-                super.reducePermits(-delta);
-            }
-            maxPermits = permits;
-        }
-
-        @Override
-        public String toString() {
-            IntFunction<String> str = permits -> {
-                float f = permits / (float) 0x10000;
-                return f == Math.floor(f) ? String.format("%.0f", f) : Float.toString(f);
-            };
-            return "Semaphore[" + str.apply(availablePermits()) + "/" + str.apply(maxPermits) + "]";
-        }
-
-    }
-
-    /**
-     * Sets the limit for the cost of concurrent downloads.
-     * <p>
-     * Finite limits are capped to {@link #MAX_COST} (32767). If the limit is
-     * {@link Float#POSITIVE_INFINITY POSITIVE_INFINITY}, the semaphore will not be
-     * used for
-     * controlling concurrent downloads.
-     *
-     * @param limit the maximum cost of concurrent downloads allowed
-     * @throws IllegalArgumentException if the limit is zero or negative.
-     */
-    public static void setLimit(float limit) {
-        if (limit <= 0) {
-            throw new IllegalArgumentException();
-        }
-        if (Float.isInfinite(limit)) {
-            enabled = false;
-            return;
-        }
-
-        synchronized (semaphore) {
-            enabled = true;
-            semaphore.setPermits(costToPermits(limit, Integer.MAX_VALUE));
-        }
-    }
-
-    static void setFailOnUiChange(boolean failOnUiChange) {
-        ConcurrentDownloadHandler.failOnUiChange = failOnUiChange;
-    }
-
-    /**
-     * Returns the limit for the number of concurrent downloads.
-     *
-     * @return the limit for the number of concurrent downloads, or
-     *         {@link Float#POSITIVE_INFINITY} if
-     *         the semaphore is disabled.
-     */
-    public static float getLimit() {
-        if (enabled) {
-            synchronized (semaphore) {
-                return (float) semaphore.maxPermits / 0x10000;
-            }
-        } else {
-            return Float.POSITIVE_INFINITY;
-        }
-    }
-
-    private static int costToPermits(float cost, int maxPermits) {
-        // restrict limit to 0x7fff to ensure the cost can be represented
-        // using fixed-point arithmetic with 16 fractional digits and 15 integral digits
-        cost = Math.min(cost, MAX_COST);
-        // Determine the number of permits required based on the cost, capping at
-        // maxPermits.
-        // If the cost is zero or negative, no permits are needed.
-        // Any positive cost, no matter how small, will require at least one permit.
-        return cost <= 0 ? 0 : Math.max(Math.min((int) (cost * 0x10000), maxPermits), 1);
-    }
-
     /**
      * Constructs a {@code ConcurrentDownloadHandler} with the specified delegate.
      * The delegate is a
@@ -158,101 +50,6 @@ private static int costToPermits(float cost, int maxPermits) {
         this.delegate = delegate;
     }
 
-    /**
-     * Sets the timeout for acquiring a permit to start a download when there are
-     * not enough permits
-     * available in the semaphore.
-     *
-     * @see GridExporter#setConcurrentDownloadTimeout(long, TimeUnit)
-     * @return the timeout in nanoseconds.
-     */
-    public abstract long getTimeout();
-
-    /**
-     * Returns the cost of this download.
-     *
-     * Note that the method is not called under the session lock. It means that if
-     * implementation
-     * requires access to the application/session data then the session has to be
-     * locked explicitly.
-     *
-     * @param session vaadin session
-     * @see GridExporter#setConcurrentDownloadCost(float)
-     */
-    public float getCost(VaadinSession session) {
-        return DEFAULT_COST;
-    }
-
-    /**
-     * Returns the UI associated with the current download.
-     * <p>
-     * This method is used to ensure that the UI is still attached to the current
-     * session when a
-     * download is initiated. Implementations should return the appropriate UI
-     * instance.
-     * </p>
-     *
-     * @return the {@link UI} instance associated with the current download, or
-     *         {@code null} if no UI
-     *         is available.
-     */
-    protected abstract UI getUI();
-
-    private UI getAttachedUI() {
-        return Optional.ofNullable(getUI()).filter(UI::isAttached).orElse(null);
-    }
-
-    /**
-     * Callback method that is invoked when a timeout occurs while trying to acquire
-     * a permit for
-     * starting a download.
-     * <p>
-     * Implementations can use this method to perform any necessary actions in
-     * response to the
-     * timeout, such as logging a warning or notifying the user.
-     * </p>
-     */
-    protected abstract void onTimeout();
-
-    /**
-     * Callback method that is invoked when a download is accepted.
-     * <p>
-     * This method is called at the start of the download process, right after the
-     * {@link #handleDownloadRequest(DownloadEvent) handleDownloadRequest} method is
-     * invoked and it
-     * has been determined that the download can proceed. Subclasses should
-     * implement this method to
-     * perform any necessary actions before the download begins, such as
-     * initializing resources,
-     * logging, or updating the UI to reflect the start of the download.
-     * <p>
-     * Note that this method is called before any semaphore permits are acquired, so
-     * it is executed
-     * regardless of whether the semaphore is enabled or not.
-     * </p>
-     */
-    protected abstract void onAccept();
-
-    /**
-     * Callback method that is invoked when a download finishes.
-     * <p>
-     * This method is called at the end of the download process, right before the
-     * {@link #handleDownloadRequest(DownloadEvent) handleDownloadRequest} method
-     * returns, regardless
-     * of whether the download was successful, timed out, or encountered an error.
-     * Subclasses should
-     * implement this method to perform any necessary actions after the download
-     * completes, such as
-     * releasing resources, logging, or updating the UI to reflect the completion of
-     * the download.
-     * <p>
-     * Note that this method is always called, even if an exception is thrown during
-     * the download
-     * process, ensuring that any necessary cleanup can be performed.
-     * </p>
-     */
-    protected abstract void onFinish();
-
     /**
      * Handles the download request using the provided {@link DownloadEvent}.
      * <p>
@@ -275,43 +72,7 @@ private UI getAttachedUI() {
      */
     @Override
     public final void handleDownloadRequest(DownloadEvent event) throws IOException {
-        onAccept();
-        try {
-            if (!enabled) {
-                delegate.handleDownloadRequest(event);
-            } else {
-
-                try {
-                    int permits;
-                    float cost = getCost(event.getSession());
-                    synchronized (semaphore) {
-                        permits = costToPermits(cost, semaphore.maxPermits);
-                    }
-
-                    UI ui = failOnUiChange ? getAttachedUI() : null;
-
-                    if (semaphore.tryAcquire(permits, getTimeout(), TimeUnit.NANOSECONDS)) {
-                        try {
-                            if (ui != null && getAttachedUI() != ui) {
-                                // The UI has changed or was detached after acquiring the semaphore
-                                throw new IOException("Detached UI");
-                            }
-                            delegate.handleDownloadRequest(event);
-                        } finally {
-                            semaphore.release(permits);
-                        }
-                    } else {
-                        onTimeout();
-                        throw new InterruptedByTimeoutException();
-                    }
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    throw (IOException) new InterruptedIOException().initCause(e);
-                }
-            }
-        } finally {
-            onFinish();
-        }
+        runWithSemaphore(event.getSession(), () -> delegate.handleDownloadRequest(event));
     }
 
 }