feat: allow forcing Hotswapper to reload the page (#21157)

By default, on class change, Hotswapper determines the best strategy to
refresh the browser page. However, in some situations, a full page reload
may be a better option.
This change allows forcing Hotswapper to always trigger a full page reload
if the `vaadin.hotswap.forcePageReload` system property is set to `true`.
In addition, the `Hotswapper.forcePageReload()` method can be called to
change the behavior at runtime instead of setting the system property.

Fixes #20844

Author: mcollovati

flow-server/src/main/java/com/vaadin/flow/hotswap/Hotswapper.java

@@ -16,6 +16,7 @@
 
 package com.vaadin.flow.hotswap;
 
+import java.io.Serializable;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -29,6 +30,7 @@
 import java.util.ResourceBundle;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
@@ -84,6 +86,13 @@
  * {@link VaadinHotswapper} interface.
  * <p>
  * </p>
+ * By default, Hotswapper determines the best browser page refresh strategy, but
+ * a full page reload can be forced by setting the
+ * {@code vaadin.hotswap.forcePageReload} system property. Hotswap tools can
+ * alter the behavior at runtime by calling
+ * {@link #forcePageReload(VaadinService, boolean)}
+ * <p>
+ * </p>
  * For internal use only. May be renamed or removed in a future release.
  *
  * @author Vaadin Ltd
@@ -92,6 +101,14 @@
  */
 public class Hotswapper implements ServiceDestroyListener, SessionInitListener,
         SessionDestroyListener, UIInitListener {
+
+    /**
+     * Configuration name for the system parameter that determines whether
+     * Hotswapper should always trigger a full page reload instead of computing
+     * an appropriate UI refresh strategy.
+     */
+    public static final String FORCE_RELOAD_PROPERTY = "vaadin.hotswap.forcePageReload";
+
     private static final Logger LOGGER = LoggerFactory
             .getLogger(Hotswapper.class);
     private final Set<VaadinSession> sessions = ConcurrentHashMap.newKeySet();
@@ -259,9 +276,18 @@ private void onHotswapInternal(HashSet<Class<?>> classes,
                 vaadinSession.getLockInstance().unlock();
             }
         }
-        EnumMap<UIRefreshStrategy, List<UI>> refreshActions = computeRefreshStrategies(
-                classes, redefined);
-        boolean uiTreeNeedsRefresh = !refreshActions.isEmpty();
+        forceBrowserReload = forceBrowserReload
+                || getForceReloadHolder(vaadinService).shouldReloadPage();
+
+        boolean uiTreeNeedsRefresh = false;
+        EnumMap<UIRefreshStrategy, List<UI>> refreshActions = null;
+
+        // When a full page reload is requested it does not make sense to
+        // compute refresh strategy
+        if (!forceBrowserReload) {
+            refreshActions = computeRefreshStrategies(classes, redefined);
+            uiTreeNeedsRefresh = !refreshActions.isEmpty();
+        }
         if (forceBrowserReload || uiTreeNeedsRefresh) {
             triggerClientUpdate(refreshActions, forceBrowserReload);
         }
@@ -447,8 +473,8 @@ private void triggerClientUpdate(
             EnumMap<UIRefreshStrategy, List<UI>> uisToRefresh,
             boolean forceReload) {
 
-        boolean refreshRequested = uisToRefresh
-                .containsKey(UIRefreshStrategy.REFRESH);
+        boolean refreshRequested = !forceReload
+                && uisToRefresh.containsKey(UIRefreshStrategy.REFRESH);
 
         // If some UI has push not enabled, BrowserLiveReload should be used to
         // trigger a client update. However, BrowserLiveReload broadcasts the
@@ -548,4 +574,57 @@ public static Optional<Hotswapper> register(VaadinService vaadinService) {
         return Optional.empty();
     }
 
+    /**
+     * Instructs the {@link Hotswapper} if a full page reload should always be
+     * triggered instead of detecting the best UI refresh strategy.
+     *
+     * @param vaadinService
+     *            the {@link VaadinService} instance.
+     * @param forceReload
+     *            {@literal true} to always force a page reload,
+     *            {@literal false} to let the {@link Hotswapper} decide the
+     *            refresh strategy.
+     */
+    public static void forcePageReload(VaadinService vaadinService,
+            boolean forceReload) {
+        Objects.requireNonNull(vaadinService, "VaadinService cannot be null");
+        getForceReloadHolder(vaadinService).activate(forceReload);
+    }
+
+    /**
+     * Gets whether a forced full page reload is triggered on class changes.
+     *
+     * @param vaadinService
+     *            the {@link VaadinService} instance.
+     * @return {@literal true} if full page reload if forced, otherwise
+     *         {@literal false}.
+     */
+    public static boolean isForcedPageReload(VaadinService vaadinService) {
+        return getForceReloadHolder(vaadinService).isActive();
+    }
+
+    private static ForcePageReloadHolder getForceReloadHolder(
+            VaadinService vaadinService) {
+        return vaadinService.getContext().getAttribute(
+                ForcePageReloadHolder.class, ForcePageReloadHolder::new);
+    }
+
+    private static class ForcePageReloadHolder implements Serializable {
+
+        private final AtomicBoolean forceReload = new AtomicBoolean(false);
+
+        void activate(boolean active) {
+            forceReload.set(active);
+        }
+
+        boolean isActive() {
+            return forceReload.get();
+        }
+
+        boolean shouldReloadPage() {
+            return forceReload.get()
+                    || Boolean.getBoolean(FORCE_RELOAD_PROPERTY);
+        }
+    }
+
 }

flow-server/src/test/java/com/vaadin/flow/hotswap/HotswapperTest.java

@@ -943,6 +943,92 @@ public void onHotswap_mixedPushState_classInUITreeChanged_liveReloadTriggered()
         Mockito.verify(liveReload).refresh(anyBoolean());
     }
 
+    @Test
+    public void onHotswap_pushDisabled_forcePageReload_fullReloadTriggered()
+            throws ServiceException {
+        VaadinSession session = createMockVaadinSession();
+        hotswapper.sessionInit(new SessionInitEvent(service, session, null));
+
+        RefreshTestingUI ui = initUIAndNavigateTo(session, MyRoute.class);
+
+        Hotswapper.forcePageReload(service, true);
+        hotswapper.onHotswap(new String[] { MyRoute.class.getName() }, true);
+
+        ui.assertNotRefreshed();
+        Mockito.verify(liveReload, never()).refresh(anyBoolean());
+        Mockito.verify(liveReload).reload();
+    }
+
+    @Test
+    public void onHotswap_pushDisabled_forcePageReloadWithSystemProperty_fullReloadTriggered()
+            throws ServiceException {
+        VaadinSession session = createMockVaadinSession();
+        hotswapper.sessionInit(new SessionInitEvent(service, session, null));
+
+        RefreshTestingUI ui = initUIAndNavigateTo(session, MyRoute.class);
+
+        String reload = System.getProperty(Hotswapper.FORCE_RELOAD_PROPERTY);
+        System.setProperty(Hotswapper.FORCE_RELOAD_PROPERTY, "true");
+        try {
+            hotswapper.onHotswap(new String[] { MyRoute.class.getName() },
+                    true);
+        } finally {
+            if (reload != null) {
+                System.setProperty(Hotswapper.FORCE_RELOAD_PROPERTY, reload);
+            } else {
+                System.clearProperty(Hotswapper.FORCE_RELOAD_PROPERTY);
+            }
+        }
+
+        ui.assertNotRefreshed();
+        Mockito.verify(liveReload, never()).refresh(anyBoolean());
+        Mockito.verify(liveReload).reload();
+    }
+
+    @Test
+    public void onHotswap_pushEnabled_forcePageReload_fullReloadTriggered()
+            throws ServiceException {
+        VaadinSession session = createMockVaadinSession();
+        hotswapper.sessionInit(new SessionInitEvent(service, session, null));
+
+        RefreshTestingUI ui = initUIAndNavigateTo(session, MyRoute.class);
+        ui.enablePush();
+
+        Hotswapper.forcePageReload(service, true);
+        hotswapper.onHotswap(new String[] { MyRoute.class.getName() }, true);
+
+        ui.assertNotRefreshed();
+        Mockito.verify(liveReload, never()).refresh(anyBoolean());
+        Mockito.verify(liveReload).reload();
+    }
+
+    @Test
+    public void onHotswap_pushEnabled_forcePageReloadWithSystemProperty_fullReloadTriggered()
+            throws ServiceException {
+        VaadinSession session = createMockVaadinSession();
+        hotswapper.sessionInit(new SessionInitEvent(service, session, null));
+
+        RefreshTestingUI ui = initUIAndNavigateTo(session, MyRoute.class);
+        ui.enablePush();
+
+        String reload = System.getProperty(Hotswapper.FORCE_RELOAD_PROPERTY);
+        System.setProperty(Hotswapper.FORCE_RELOAD_PROPERTY, "true");
+        try {
+            hotswapper.onHotswap(new String[] { MyRoute.class.getName() },
+                    true);
+        } finally {
+            if (reload != null) {
+                System.setProperty(Hotswapper.FORCE_RELOAD_PROPERTY, reload);
+            } else {
+                System.clearProperty(Hotswapper.FORCE_RELOAD_PROPERTY);
+            }
+        }
+
+        ui.assertNotRefreshed();
+        Mockito.verify(liveReload, never()).refresh(anyBoolean());
+        Mockito.verify(liveReload).reload();
+    }
+
     @Test
     public void register_developmentMode_trackingListenerInstalled() {
         AtomicBoolean sessionInitInstalled = new AtomicBoolean();