feat: Add supporting action service

- Checks and monitors an action completing
- Needs an accompanying notification service, to let a program be told it has happened (not just logs)
- Also needs tests

Author: CubitsDev

src/main/java/dev/tomr/hcloud/HetznerCloud.java

@@ -1,6 +1,8 @@
 package dev.tomr.hcloud;
 
+import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.json.JsonMapper;
 import dev.tomr.hcloud.listener.ListenerManager;
 import dev.tomr.hcloud.resources.server.Server;
 import dev.tomr.hcloud.service.ServiceManager;
@@ -15,7 +17,7 @@
 public class HetznerCloud {
     protected static final Logger logger = LogManager.getLogger();
 
-    private static final ObjectMapper objectMapper = new ObjectMapper();
+    private static final ObjectMapper objectMapper = JsonMapper.builder().configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS, true).build();
     private static final String HETZNER_CLOUD_HOST = "https://api.hetzner.cloud/v1/";
 
     private static HetznerCloud instance;

src/main/java/dev/tomr/hcloud/http/model/ActionWrapper.java

@@ -0,0 +1,24 @@
+package dev.tomr.hcloud.http.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import dev.tomr.hcloud.http.HetznerJsonObject;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ActionWrapper extends HetznerJsonObject {
+    private Action action;
+
+    public ActionWrapper() {
+    }
+
+    public ActionWrapper(Action action) {
+        this.action = action;
+    }
+
+    public Action getAction() {
+        return action;
+    }
+
+    public void setAction(Action action) {
+        this.action = action;
+    }
+}

src/main/java/dev/tomr/hcloud/service/ServiceManager.java

@@ -1,5 +1,6 @@
 package dev.tomr.hcloud.service;
 
+import dev.tomr.hcloud.service.action.ActionService;
 import dev.tomr.hcloud.service.server.ServerService;
 
 import java.util.concurrent.ExecutorService;
@@ -9,12 +10,14 @@ public class ServiceManager {
     private static ServiceManager instance;
 
     private final ServerService serverService;
+    private final ActionService actionService;
 
     private ExecutorService executor;
 
     private ServiceManager() {
         instance = this;
         this.serverService = new ServerService(this);
+        this.actionService = new ActionService();
     }
 
     /**
@@ -36,6 +39,14 @@ public ServerService getServerService() {
         return serverService;
     }
 
+    /**
+     * Get ActionService Instance
+     * @return the {@code ActionService} instance
+     */
+    public ActionService getActionService() {
+        return actionService;
+    }
+
     /**
      * Get an Executor for threaded tasks
      * @return The Existing or a new {@code ExecutorService}

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

@@ -0,0 +1,74 @@
+package dev.tomr.hcloud.service.action;
+
+import dev.tomr.hcloud.HetznerCloud;
+import dev.tomr.hcloud.http.HetznerCloudHttpClient;
+import dev.tomr.hcloud.http.RequestVerb;
+import dev.tomr.hcloud.http.model.Action;
+import dev.tomr.hcloud.http.model.ActionWrapper;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class ActionService {
+    protected static final Logger logger = LogManager.getLogger();
+
+    private final HetznerCloudHttpClient client = HetznerCloudHttpClient.getInstance();
+
+    public ActionService() {
+    }
+
+    public CompletableFuture<Action> waitForActionToComplete(Action action) {
+        return CompletableFuture.supplyAsync(() -> {
+            ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+            List<String> hostAndKey = HetznerCloud.getInstance().getHttpDetails();
+            List<Future<Action>> futures = new ArrayList<>();
+            AtomicReference<Action> completedAction = new AtomicReference<>();
+            futures.add(scheduler.schedule(createCheckCallable(action, hostAndKey), 0, TimeUnit.MILLISECONDS));
+
+            try {
+                for (int i = 0; i < futures.size(); i++) {
+                    Future<Action> future = futures.get(i);
+                    if (future.isDone()) {
+                        if (future.get() != null) {
+                            completedAction.set(future.get());
+                        } else {
+                            futures.add(scheduler.schedule(createCheckCallable(action, hostAndKey), 1000L * (i + 1), TimeUnit.MILLISECONDS));
+                        }
+                    } else {
+                        i--;
+                    }
+                }
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+            futures.forEach((f) -> {
+                f.cancel(true);
+            });
+            return completedAction.get();
+        });
+    }
+
+    private Callable<Action> createCheckCallable(Action action, List<String> hostAndKey) {
+        String url = String.format("%sactions/%d", hostAndKey.get(0), action.getId());
+
+        return () -> {
+            try {
+                Action newAction = client.sendHttpRequest(ActionWrapper.class, url, RequestVerb.GET, hostAndKey.get(1)).getAction();
+                if (newAction.getError() != null) {
+                    throw new Exception(String.format("Error from Hetzner: %s, %s", newAction.getError().getMessage(), newAction.getError().getCode()));
+                }else if (newAction.getProgress() == 100 && newAction.getFinished() != null) {
+                    return newAction;
+                } else {
+                    return null;
+                }
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        };
+    }
+}

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

@@ -4,6 +4,7 @@
 import dev.tomr.hcloud.http.HetznerCloudHttpClient;
 import dev.tomr.hcloud.http.converter.ServerConverterUtil;
 import dev.tomr.hcloud.http.model.Action;
+import dev.tomr.hcloud.http.model.ActionWrapper;
 import dev.tomr.hcloud.http.model.ServerDTO;
 import dev.tomr.hcloud.http.model.ServerDTOList;
 import dev.tomr.hcloud.resources.server.Server;
@@ -22,6 +23,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 
 import static dev.tomr.hcloud.http.RequestVerb.*;
 
@@ -101,10 +103,25 @@ public void cancelServerNameOrLabelUpdate() {
     public void deleteServerFromHetzner(Server server) {
         List<String> hostAndKey = HetznerCloud.getInstance().getHttpDetails();
         String httpUrl = String.format("%sservers/%d", hostAndKey.get(0), server.getId());
+        AtomicReference<String> exceptionMsg = new AtomicReference<>();
         try {
-            Action action = client.sendHttpRequest(Action.class, httpUrl, DELETE, hostAndKey.get(1));
-
-        } catch (IOException | IllegalAccessException | InterruptedException e) {
+            Action action = client.sendHttpRequest(ActionWrapper.class, httpUrl, DELETE, hostAndKey.get(1)).getAction();
+            CompletableFuture<Action> completedActionFuture = serviceManager.getActionService().waitForActionToComplete(action).thenApplyAsync((completedAction) -> {
+                if (action == null) {
+                    throw new NullPointerException();
+                }
+                logger.info("Server confirmed deleted at {}", completedAction.getFinished());
+                return completedAction;
+            }).exceptionally((e) -> {
+                logger.error("Server delete failed");
+                logger.error(e.getMessage());
+                exceptionMsg.set(e.getMessage());
+                return null;
+            });
+            if (completedActionFuture.get() == null) {
+                throw new RuntimeException(exceptionMsg.get());
+            }
+        } catch (Exception e) {
             logger.error("Failed to delete the Server");
             throw new RuntimeException(e);
         }

src/test/java/dev/tomr/hcloud/service/ServiceManagerTest.java

@@ -1,5 +1,6 @@
 package dev.tomr.hcloud.service;
 
+import dev.tomr.hcloud.service.action.ActionService;
 import dev.tomr.hcloud.service.server.ServerService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -76,4 +77,12 @@ void callingCloseExecutorDoesNothingIfExecutorIsNull() {
         assertDoesNotThrow(serviceManager::closeExecutor);
     }
 
+    @Test
+    @DisplayName("Calling getActionService returns the ActionService instance")
+    void callingGetActionServiceReturnsTheActionServiceInstance() {
+        ServiceManager serviceManager = ServiceManager.getInstance();
+        assertInstanceOf(ActionService.class, serviceManager.getActionService());
+        assertNotNull(serviceManager.getActionService());
+    }
+
 }

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

@@ -0,0 +1,4 @@
+package dev.tomr.hcloud.service.action;
+
+public class ActionServiceTest {
+}

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

@@ -10,6 +10,7 @@
 import dev.tomr.hcloud.resources.common.*;
 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;
@@ -25,6 +26,8 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeoutException;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;
@@ -549,21 +552,62 @@ void deleteServerFromHetznerAndTracksTheAction() throws IOException, Interrupted
         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())).thenReturn(new Action());
 
-            ServerService serverService = new ServerService();
+            ServerService serverService = new ServerService(serviceManager);
             serverService.deleteServerFromHetzner(new Server());
 
             verify(hetznerCloudHttpClient, times(1)).sendHttpRequest(any(), anyString(), eq(RequestVerb.DELETE), eq("key1234"));
+            verify(actionService, times(1)).waitForActionToComplete(any(Action.class));
+        }
+    }
+
+    @Test
+    @DisplayName("When actionService throws, then delete Server from Hetzner also throws a Runtime exception")
+    void whenActionServiceThrowsDeleteServerAlsoThrows() 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)) {
+
+            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.failedFuture(new RuntimeException(new TimeoutException())));
+
+            when(hetznerCloudHttpClient.sendHttpRequest(any(), anyString(), any(RequestVerb.class), anyString())).thenReturn(new Action());
+
+            ServerService serverService = new ServerService(serviceManager);
+
+            RuntimeException runtimeException = assertThrows(RuntimeException.class, () -> serverService.deleteServerFromHetzner(new Server()));
+
+            verify(hetznerCloudHttpClient, times(1)).sendHttpRequest(any(), anyString(), eq(RequestVerb.DELETE), eq("key1234"));
+            verify(actionService, times(1)).waitForActionToComplete(any(Action.class));
+
+            assertTrue(runtimeException.getMessage().contains("TimeoutException"));
         }
     }