feat: Add Poweroff action

- Moves ServerChangeListener to use a Switch
- Moves action sending + tracking logic to a shared method
- Adds powerOff method on Server

Author: CubitsDev

src/main/java/dev/tomr/hcloud/listener/ServerChangeListener.java

@@ -19,16 +19,36 @@ public class ServerChangeListener implements PropertyChangeListener {
     @Override
     public void propertyChange(PropertyChangeEvent evt) {
         Server server = (Server) evt.getSource();
-        if (evt.getPropertyName().equals("delete")) {
-            logger.warn("Server delete has been called. Instructing Hetzner to delete");
-            HetznerCloud.getInstance().getServiceManager().getServerService().deleteServerFromHetzner(server);
-        } else if (evt.getPropertyName().equals("shutdown")) {
-            logger.info("Server shutdown has been called. Instructing Hetzner to shut the server down");
-            HetznerCloud.getInstance().getServiceManager().getServerService().shutdownServer(server);
-        } else {
-            logger.info("Server changed: " + evt.getPropertyName());
-            logger.info("Server: " + evt.getOldValue() + " -> " + evt.getNewValue());
-            HetznerCloud.getInstance().getServiceManager().getServerService().serverNameOrLabelUpdate(evt.getPropertyName(), evt.getNewValue(), server);
+        String propertyName = evt.getPropertyName();
+
+        switch (propertyName) {
+            case "delete" -> {
+                logger.warn("Server delete has been called. Instructing Hetzner to delete");
+                HetznerCloud.getInstance().getServiceManager().getServerService().deleteServerFromHetzner(server);
+            }
+            case "shutdown" -> {
+                logger.info("Server shutdown has been called. Instructing Hetzner to shut the server down");
+                HetznerCloud.getInstance().getServiceManager().getServerService().shutdownServer(server);
+            }
+            case "poweroff" -> {
+                logger.info("Server poweroff has been called. Instructing Hetzner to power down the server");
+                logger.warn("This is a potentially destructive action!");
+                HetznerCloud.getInstance().getServiceManager().getServerService().powerOffServer(server);
+            }
+            default -> {
+                logger.info("Server changed: {}", evt.getPropertyName());
+                logger.info("Server: {} -> {}", evt.getOldValue(), evt.getNewValue());
+                HetznerCloud.getInstance().getServiceManager().getServerService().serverNameOrLabelUpdate(evt.getPropertyName(), evt.getNewValue(), server);
+            }
         }
+//        if (evt.getPropertyName().equals("delete")) {
+//
+//        } else if (evt.getPropertyName().equals("shutdown")) {
+//
+//        } else if (evt.getPropertyName().equals("poweroff")) {
+//
+//        } else {
+//
+//        }
     }
 }

src/main/java/dev/tomr/hcloud/resources/server/Server.java

@@ -107,12 +107,19 @@ public void delete() {
     }
 
     /**
-     * Sends a Shutdown signal to the server, which will instruct the OS to shut it down. Note that if you **must** ensure the server is completely offline, you should also call .powerOff() to ensure the 'plug is pulled'
+     * Sends a Shutdown signal to the server, which will instruct the OS to shut it down. Note that if you <b>must</b>> ensure the server is completely offline, you should also call .powerOff() to ensure the 'plug is pulled'
      */
     public void shutdown() {
         propertyChangeSupport.firePropertyChange("shutdown", null, null);
     }
 
+    /**
+     * Sends a command to Power off the server. This is essentially <b>'pulling the plug'</b> and could be destructive if programs are still running on the server. <b>Only use if absolutely necessary</b>
+     */
+    public void powerOff() {
+        propertyChangeSupport.firePropertyChange("poweroff", null, null);
+    }
+
 
     // These are the current setters that will send an API request (PUT /servers) when actions begin to be added, they will also likely be triggered by setters
 

src/main/java/dev/tomr/hcloud/service/action/Action.java

@@ -0,0 +1,12 @@
+package dev.tomr.hcloud.service.action;
+
+public enum Action {
+    SHUTDOWN("shutdown"),
+    POWEROFF("poweroff");
+
+    public final String path;
+
+    Action(String path) {
+        this.path = path;
+    }
+}

src/main/java/dev/tomr/hcloud/service/server/ServerService.java

@@ -25,6 +25,8 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import static dev.tomr.hcloud.http.RequestVerb.*;
+import static dev.tomr.hcloud.service.action.Action.POWEROFF;
+import static dev.tomr.hcloud.service.action.Action.SHUTDOWN;
 
 public class ServerService {
     protected static final Logger logger = LogManager.getLogger();
@@ -127,19 +129,27 @@ public void deleteServerFromHetzner(Server server) {
     }
 
     public void shutdownServer(Server server) {
+        sendServerAction(server, SHUTDOWN);
+    }
+
+    public void powerOffServer(Server server) {
+        sendServerAction(server, POWEROFF);
+    }
+
+    private void sendServerAction(Server server, dev.tomr.hcloud.service.action.Action givenAction) {
         List<String> hostAndKey = HetznerCloud.getInstance().getHttpDetails();
-        String httpUrl = String.format("%sservers/%d/actions/poweroff", hostAndKey.get(0), server.getId());
+        String httpUrl = String.format("%sservers/%d/actions/%s", hostAndKey.get(0), server.getId(), givenAction.path);
         AtomicReference<String> exceptionMsg = new AtomicReference<>();
         try {
             Action action = client.sendHttpRequest(ActionWrapper.class, httpUrl, POST, hostAndKey.get(1), "").getAction();
             CompletableFuture<Action> completedActionFuture = serviceManager.getActionService().waitForActionToComplete(action).thenApplyAsync((completedAction) -> {
                 if (completedAction == null) {
                     throw new NullPointerException();
                 }
-                logger.info("Server shutdown at {}", completedAction.getFinished());
+                logger.info("Server {} at {}", givenAction.toString(), completedAction.getFinished());
                 return completedAction;
             }).exceptionally((e) -> {
-                logger.error("Server shutdown failed");
+                logger.error("Server {} failed", givenAction.toString());
                 logger.error(e.getMessage());
                 exceptionMsg.set(e.getMessage());
                 return null;
@@ -148,7 +158,7 @@ public void shutdownServer(Server server) {
                 throw new RuntimeException(exceptionMsg.get());
             }
         } catch (Exception e) {
-            logger.error("Failed to shutdown the Server");
+            logger.error("Failed to {} the Server", givenAction.toString());
             throw new RuntimeException(e);
         }
     }

src/test/java/dev/tomr/hcloud/resources/server/ServerTest.java

@@ -248,5 +248,31 @@ void callingShutdownSendsAnEventToTheServerChangeListener() {
 
     }
 
+    @Test
+    @DisplayName("calling poweroff sends an event to the ServerChangeListener")
+    void callingPoweroffSendsAnEventToTheServerChangeListener() {
+        try (MockedStatic<HetznerCloud> hetznerCloud = mockStatic(HetznerCloud.class)) {
+            HetznerCloud hetznerCloudMock = mock(HetznerCloud.class);
+            ServerChangeListener scl = new ServerChangeListener();
+            ServerChangeListener serverChangeListener = spy(scl);
+            ListenerManager listenerManager = mock(ListenerManager.class);
+            ServiceManager serviceManager = mock(ServiceManager.class);
+            ServerService serverService = mock(ServerService.class);
+            ArgumentCaptor<PropertyChangeEvent> captor = ArgumentCaptor.forClass(PropertyChangeEvent.class);
+
+            hetznerCloud.when(HetznerCloud::getInstance).thenReturn(hetznerCloudMock);
+            when(hetznerCloudMock.getListenerManager()).thenReturn(listenerManager);
+            when(hetznerCloudMock.getServiceManager()).thenReturn(serviceManager);
+            when(listenerManager.getServerChangeListener()).thenReturn(serverChangeListener);
+            when(serviceManager.getServerService()).thenReturn(serverService);
+
+            Server server = new Server();
+            server.powerOff();
+            verify(serverChangeListener, times(1)).propertyChange(captor.capture());
+            assertEquals("poweroff", captor.getValue().getPropertyName());
+        }
+
+    }
+
 
 }

src/test/java/dev/tomr/hcloud/service/action/ActionEnumTest.java

@@ -0,0 +1,21 @@
+package dev.tomr.hcloud.service.action;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ActionEnumTest {
+
+    @Test
+    @DisplayName("SHUTDOWN enum returns 'shutdown' for the path")
+    void shutdown() {
+        assertEquals("shutdown", Action.SHUTDOWN.path);
+    }
+
+    @Test
+    @DisplayName("POWEROFF enum returns 'poweroff' for the path")
+    void poweroff() {
+        assertEquals("poweroff", Action.POWEROFF.path);
+    }
+}

src/test/java/dev/tomr/hcloud/service/server/ServerServiceTest.java

@@ -12,10 +12,7 @@
 import dev.tomr.hcloud.resources.server.Server;
 import dev.tomr.hcloud.service.ServiceManager;
 import dev.tomr.hcloud.service.action.ActionService;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.*;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
@@ -761,4 +758,36 @@ void whenShutdownActionReturnedFromHetznerIsNullServerServiceThrowsANullPointer(
         }
     }
 
+    @Test
+    @DisplayName("Poweroff Server calls Hetzner and tracks the action")
+    void powerOffServerCallsHetznerAndTracksTheAction() throws IOException, InterruptedException, IllegalAccessException {
+        HetznerCloud hetznerCloud = mock(HetznerCloud.class);
+        HetznerCloudHttpClient hetznerCloudHttpClient = mock(HetznerCloudHttpClient.class);
+        ListenerManager listenerManager = mock(ListenerManager.class);
+        ServiceManager serviceManager = mock(ServiceManager.class);
+        ActionService actionService = mock(ActionService.class);
+
+        try (MockedStatic<HetznerCloud> hetznerCloudMockedStatic = mockStatic(HetznerCloud.class);
+             MockedStatic<HetznerCloudHttpClient> hetznerCloudHttpClientMockedStatic = mockStatic(HetznerCloudHttpClient.class)) {
+
+            Action action = new Action();
+            action.setFinished(Date.from(Instant.now()).toString());
+
+            hetznerCloudHttpClientMockedStatic.when(HetznerCloudHttpClient::getInstance).thenReturn(hetznerCloudHttpClient);
+            hetznerCloudMockedStatic.when(HetznerCloud::getInstance).thenReturn(hetznerCloud);
+            when(hetznerCloud.getListenerManager()).thenReturn(listenerManager);
+            when(hetznerCloud.getHttpDetails()).thenReturn(List.of("http://host/", "key1234"));
+            when(serviceManager.getActionService()).thenReturn(actionService);
+            when(actionService.waitForActionToComplete(any(Action.class))).thenReturn(CompletableFuture.completedFuture(action));
+
+            when(hetznerCloudHttpClient.sendHttpRequest(any(), anyString(), any(RequestVerb.class), anyString(), anyString())).thenReturn(new ActionWrapper(action));
+
+            ServerService serverService = new ServerService(serviceManager);
+            serverService.powerOffServer(new Server());
+
+            verify(hetznerCloudHttpClient, times(1)).sendHttpRequest(any(), anyString(), eq(RequestVerb.POST), eq("key1234"), eq(""));
+            verify(actionService, times(1)).waitForActionToComplete(any(Action.class));
+        }
+    }
+
 }