[194] Create a ServerManagerListener implementation which takes a snapshot of the server configuration after the server is started. Before the server is shutdown, the snapshot configuration is restored.

Signed-off-by: James R. Perkins <jperkins@ibm.com>

Author: jamezp

src/main/java/org/wildfly/plugin/tools/server/AbstractServerManager.java

@@ -365,7 +365,15 @@ public boolean isClosed() {
 
     @Override
     public void close() {
-        internalClose(configuration.shutdownOnClose(), true);
+        lock.lock();
+        try {
+            if (configuration.shutdownOnClose()) {
+                beforeShutdown();
+            }
+            internalClose(configuration.shutdownOnClose(), true);
+        } finally {
+            lock.unlock();
+        }
     }
 
     @Override

src/main/java/org/wildfly/plugin/tools/server/RestoreConfigListener.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright The WildFly Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.wildfly.plugin.tools.server;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import org.jboss.as.controller.client.helpers.Operations;
+import org.jboss.dmr.ModelNode;
+import org.jboss.logging.Logger;
+
+/**
+ * A listener which takes a {@linkplain ServerManager#takeSnapshot() snapshot} of the server configuration after the
+ * server has started and restores that configuration before the server is shutdown.
+ *
+ * @author <a href="mailto:jperkins@ibm.com">James R. Perkins</a>
+ */
+public class RestoreConfigListener implements ServerManagerListener {
+    private static final Logger LOGGER = Logger.getLogger(RestoreConfigListener.class);
+    private volatile String configPath;
+
+    @Override
+    public void afterStart(final ServerManager serverManager) {
+        try {
+            configPath = serverManager.takeSnapshot();
+        } catch (IOException e) {
+            throw new ServerManagerException(e, "Failed to take a snapshot of the servers configuration.");
+        }
+    }
+
+    @Override
+    public void beforeShutdown(final ServerManager serverManager) {
+        final String configPath = this.configPath;
+        if (configPath != null) {
+            try {
+                final String attributeName;
+                final ModelNode address;
+                if (serverManager instanceof DomainManager domainManager) {
+                    attributeName = "domain-config";
+                    address = domainManager.determineHostAddress();
+                } else {
+                    attributeName = "server-config";
+                    address = new ModelNode().setEmptyList();
+                }
+                final ModelNode op = Operations.createOperation("reload", address);
+                op.get(attributeName).set(configPath);
+                serverManager.executeReload(op);
+                // Wait until the server is running, then write the config
+                if (serverManager.waitFor(ServerManager.TIMEOUT, TimeUnit.SECONDS)) {
+                    final ModelNode writeOp = Operations.createOperation("write-config", address);
+                    final ModelNode result = serverManager.client().execute(writeOp);
+                    if (!Operations.isSuccessfulOutcome(result)) {
+                        LOGGER.warnf("Failed to write config after restoring from snapshot: %s",
+                                Operations.getFailureDescription(result).asString());
+                    }
+                } else {
+                    // The server has not reloaded within the timeout
+                    LOGGER.warnf(
+                            "The server failed to reload within %d seconds. The previous configuration at %s will not be restored.",
+                            ServerManager.TIMEOUT, configPath);
+                }
+            } catch (IOException e) {
+                LOGGER.warnf(e, "Failed to restore the previous configuration %s.", configPath);
+            } catch (InterruptedException e) {
+                LOGGER.warnf(e, "Interrupted while attempting to restore the configuration %s.", configPath);
+            }
+        } else {
+            LOGGER.warn("No configuration was restored. The snapshot configuration file was never created.");
+        }
+    }
+}

src/test/java/org/wildfly/plugin/tools/Environment.java

@@ -24,6 +24,7 @@
 import org.wildfly.plugin.tools.server.Configuration;
 import org.wildfly.plugin.tools.server.DomainConfiguration;
 import org.wildfly.plugin.tools.server.DomainManager;
+import org.wildfly.plugin.tools.server.RestoreConfigListener;
 import org.wildfly.plugin.tools.server.ServerManager;
 import org.wildfly.plugin.tools.server.StandaloneConfiguration;
 import org.wildfly.plugin.tools.server.StandaloneManager;
@@ -150,12 +151,15 @@ public static Collection<String> getJvmArgs() {
     }
 
     public static StandaloneManager launchStandalone() {
-        return launchStandalone(true);
+        return launchStandalone(true, false);
     }
 
-    public static StandaloneManager launchStandalone(final boolean shutdownOnClose) {
+    public static StandaloneManager launchStandalone(final boolean shutdownOnClose, final boolean addRestorerListener) {
         final StandaloneManager serverManager = ServerManager
                 .of(standaloneConfiguration().shutdownOnClose(shutdownOnClose));
+        if (addRestorerListener) {
+            serverManager.addServerManagerListener(new RestoreConfigListener());
+        }
         try {
             if (!serverManager.start(TIMEOUT, TimeUnit.SECONDS).isRunning()) {
                 serverManager.kill();
@@ -167,9 +171,12 @@ public static StandaloneManager launchStandalone(final boolean shutdownOnClose)
         return serverManager;
     }
 
-    public static DomainManager launchDomain() {
+    public static DomainManager launchDomain(final boolean addRestorerListener) {
         final DomainManager serverManager = ServerManager
                 .of(domainConfiguration());
+        if (addRestorerListener) {
+            serverManager.addServerManagerListener(new RestoreConfigListener());
+        }
         try {
             if (!serverManager.start(TIMEOUT, TimeUnit.SECONDS).isRunning()) {
                 serverManager.kill();

src/test/java/org/wildfly/plugin/tools/server/ServerManagerIT.java

@@ -53,7 +53,7 @@ public void checkStandaloneServerState() throws Exception {
 
     @Test
     public void checkStandaloneReloadIfRequired() throws Exception {
-        try (StandaloneManager serverManager = Environment.launchStandalone()) {
+        try (StandaloneManager serverManager = Environment.launchStandalone(true, true)) {
             // Execute a command which will put the server in a state of requiring a reload
             final ModelNode address = Operations.createAddress("subsystem", "remoting");
             ModelNode result = executeCommand(serverManager.client(),
@@ -71,7 +71,7 @@ public void checkStandaloneReloadIfRequired() throws Exception {
 
     @Test
     public void checkDomainReloadIfRequired() throws Exception {
-        try (DomainManager serverManager = Environment.launchDomain()) {
+        try (DomainManager serverManager = Environment.launchDomain(true)) {
             // Execute a command which will put the server in a state of requiring a reload
             final ModelNode address = Operations.createAddress("profile", "full", "subsystem", "remoting");
             ModelNode result = executeCommand(serverManager.client(),
@@ -93,7 +93,7 @@ public void checkDomainReloadIfRequired() throws Exception {
     public void checkStandaloneServerManagerClosed() throws Exception {
         ServerManager checker;
         ProcessHandle process;
-        try (StandaloneManager serverManager = Environment.launchStandalone(false)) {
+        try (StandaloneManager serverManager = Environment.launchStandalone(false, false)) {
             checker = serverManager;
             process = serverManager.process().orElseThrow(() -> new AssertionError("Server process is null"));
         }
@@ -170,7 +170,7 @@ public void checkManagedStandalone() {
 
     @Test
     public void checkManagedDomain() {
-        try (ServerManager serverManager = Environment.launchDomain()) {
+        try (ServerManager serverManager = Environment.launchDomain(false)) {
             final ServerManager managedServerManager = serverManager.asManaged();
             Assertions.assertThrows(UnsupportedOperationException.class, managedServerManager::kill);
             Assertions.assertThrows(UnsupportedOperationException.class, managedServerManager::shutdown);