Update reFetch result of order

baixinsui · baixinsui · commit 26efa6bdc1c9 · 2025-03-06T20:10:05.000+08:00
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/api/controllers/OpenTofuMakerTaskResultApi.java b/src/main/java/org/eclipse/xpanse/tofu/maker/api/controllers/OpenTofuMakerTaskResultApi.java
@@ -9,15 +9,20 @@
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.annotation.Resource;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
 import lombok.extern.slf4j.Slf4j;
-import org.eclipse.xpanse.tofu.maker.models.response.OpenTofuResult;
+import org.eclipse.xpanse.tofu.maker.models.response.ReFetchResult;
 import org.eclipse.xpanse.tofu.maker.opentofu.service.OpenTofuResultPersistenceManage;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.CrossOrigin;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
@@ -31,17 +36,51 @@ public class OpenTofuMakerTaskResultApi {
 
     @Resource private OpenTofuResultPersistenceManage openTofuResultPersistenceManage;
 
-    @Tag(name = "RetrieveOpenTofuResult", description = "APIs for manage the task form tofu-maker.")
+    /**
+     * Retrieve stored openTofu result.
+     *
+     * @param requestId id of the request
+     * @return response entity of the openTofu result
+     */
+    @Tag(
+            name = "RetrieveOpenTofuResult",
+            description = "APIs to manually fetching task results from tofu-maker.")
     @Operation(
             description =
                     "Method to retrieve stored openTofu result in case tofu-maker "
                             + "receives a failure while sending the openTofu result via callback.")
     @GetMapping(value = "/result/{requestId}", produces = MediaType.APPLICATION_JSON_VALUE)
     @ResponseStatus(HttpStatus.OK)
-    public ResponseEntity<OpenTofuResult> getStoredTaskResultByRequestId(
+    public ReFetchResult getStoredTaskResultByRequestId(
             @Parameter(name = "requestId", description = "id of the request")
                     @PathVariable("requestId")
-                    String requestId) {
+                    UUID requestId) {
         return openTofuResultPersistenceManage.retrieveOpenTofuResultByRequestId(requestId);
     }
+
+    /**
+     * Batch retrieve stored openTofu results.
+     *
+     * @param requestIds list of request ids
+     * @return list of re-fetch results
+     */
+    @Tag(
+            name = "RetrieveOpenTofuResult",
+            description = "APIs to manually fetching task results from tofu-maker.")
+    @Operation(description = "Method to batch retrieve stored openTofu results from tofu-maker.")
+    @PostMapping(value = "/results/batch", consumes = MediaType.APPLICATION_JSON_VALUE)
+    public List<ReFetchResult> getBatchTaskResults(
+            @Parameter(description = "List of request IDs") @RequestBody List<UUID> requestIds) {
+        if (CollectionUtils.isEmpty(requestIds)) {
+            throw new IllegalArgumentException("requestIds cannot be empty.");
+        }
+        List<ReFetchResult> reFetchResults = new ArrayList<>();
+        requestIds.forEach(
+                requestId -> {
+                    reFetchResults.add(
+                            openTofuResultPersistenceManage.retrieveOpenTofuResultByRequestId(
+                                    requestId));
+                });
+        return reFetchResults;
+    }
 }
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/models/exceptions/OpenTofuApiExceptionHandler.java b/src/main/java/org/eclipse/xpanse/tofu/maker/models/exceptions/OpenTofuApiExceptionHandler.java
@@ -29,12 +29,12 @@ public class OpenTofuApiExceptionHandler {
 
     /** Exception handler for IllegalArgumentException. */
     @ExceptionHandler({IllegalArgumentException.class})
-    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ResponseStatus(HttpStatus.UNPROCESSABLE_ENTITY)
     @ResponseBody
     public Response handleIllegalArgumentException(IllegalArgumentException ex) {
         log.error("handleIllegalArgumentException: ", ex);
         return Response.errorResponse(
-                ResultType.OPENTOFU_EXECUTION_FAILED, Collections.singletonList(ex.getMessage()));
+                ResultType.UNPROCESSABLE_ENTITY, Collections.singletonList(ex.getMessage()));
     }
 
     /** Exception handler for OpenTofuExecutorException. */
@@ -127,15 +127,4 @@ public Response handleInvalidOpenTofuScriptsException(InvalidOpenTofuScriptsExce
         return Response.errorResponse(
                 ResultType.INVALID_OPENTOFU_SCRIPTS, Collections.singletonList(ex.getMessage()));
     }
-
-    /** Exception handler for ResultAlreadyReturnedOrRequestIdInvalidException. */
-    @ExceptionHandler({ResultAlreadyReturnedOrRequestIdInvalidException.class})
-    @ResponseStatus(HttpStatus.BAD_REQUEST)
-    @ResponseBody
-    public Response handleResultAlreadyReturnedOrRequestIdInvalidException(
-            ResultAlreadyReturnedOrRequestIdInvalidException ex) {
-        return Response.errorResponse(
-                ResultType.RESULT_ALREADY_RETURNED_OR_REQUEST_ID_INVALID,
-                Collections.singletonList(ex.getMessage()));
-    }
 }
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/models/exceptions/ResultAlreadyReturnedOrRequestIdInvalidException.java b/src/main/java/org/eclipse/xpanse/tofu/maker/models/exceptions/ResultAlreadyReturnedOrRequestIdInvalidException.java
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/models/response/ReFetchResult.java b/src/main/java/org/eclipse/xpanse/tofu/maker/models/response/ReFetchResult.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Huawei Inc.
+ */
+
+package org.eclipse.xpanse.tofu.maker.models.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Data;
+
+/** Data model for re-fetching order result. */
+@Data
+@Builder
+public class ReFetchResult {
+
+    @NotNull
+    @Schema(description = "Id of the request order.")
+    private UUID requestId;
+
+    @NotNull
+    @Schema(description = "State of the re-fetching result of order.")
+    private ReFetchState state;
+
+    @Schema(description = "Result of the service order executed by open tofu.")
+    private OpenTofuResult openTofuResult;
+
+    @Schema(description = "Error message of the re-fetching result of order.")
+    private String errorMessage;
+}
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/models/response/ReFetchState.java b/src/main/java/org/eclipse/xpanse/tofu/maker/models/response/ReFetchState.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * SPDX-FileCopyrightText: Huawei Inc.
+ */
+
+package org.eclipse.xpanse.tofu.maker.models.response;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import org.apache.commons.lang3.StringUtils;
+
+/** ReFetch state for the REST API. */
+public enum ReFetchState {
+    OK("OK"),
+    ORDER_IN_PROGRESS("OrderInProgress"),
+    RESULT_NOT_FOUND("ResultNotFound"),
+    RESULT_PARSE_FAILED("ResultInvalid");
+    private final String state;
+
+    ReFetchState(String state) {
+        this.state = state;
+    }
+
+    /** For ReFetchState deserialize. */
+    @JsonValue
+    public String toValue() {
+        return this.state;
+    }
+
+    /** For ReFetchState serialize. */
+    @JsonCreator
+    public ReFetchState getByValue(String name) {
+        for (ReFetchState state : values()) {
+            if (StringUtils.equalsIgnoreCase(state.state, name)) {
+                return state;
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/opentofu/service/OpenTofuResultPersistenceManage.java b/src/main/java/org/eclipse/xpanse/tofu/maker/opentofu/service/OpenTofuResultPersistenceManage.java
@@ -12,11 +12,11 @@
 import java.io.IOException;
 import java.util.UUID;
 import lombok.extern.slf4j.Slf4j;
-import org.eclipse.xpanse.tofu.maker.models.exceptions.ResultAlreadyReturnedOrRequestIdInvalidException;
 import org.eclipse.xpanse.tofu.maker.models.response.OpenTofuResult;
+import org.eclipse.xpanse.tofu.maker.models.response.ReFetchResult;
+import org.eclipse.xpanse.tofu.maker.models.response.ReFetchState;
 import org.eclipse.xpanse.tofu.maker.utils.OpenTofuResultSerializer;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
 
 /** OpenTofu service classes are manage task result. */
@@ -42,19 +42,14 @@ public class OpenTofuResultPersistenceManage {
      * @param result OpenTofuResult.
      */
     public void persistOpenTofuResult(OpenTofuResult result) {
-        String filePath = getFilePath(result.getRequestId());
-        File file = new File(filePath);
-        if (!file.exists() && !file.mkdirs()) {
+        File filePath = getFilePath(result.getRequestId());
+        if (!filePath.exists() && !filePath.mkdirs()) {
             log.error("Failed to create directory {}", filePath);
             return;
         }
+        File file = new File(filePath, getFileName(result.getRequestId()));
         byte[] openTofuResultData = openTofuResultSerializer.serialize(result);
-        try (FileOutputStream fos =
-                new FileOutputStream(
-                        file.getPath()
-                                + File.separator
-                                + result.getRequestId()
-                                + TF_RESULT_FILE_SUFFIX)) {
+        try (FileOutputStream fos = new FileOutputStream(file)) {
             fos.write(openTofuResultData);
             log.info(
                     "openTofu result successfully stored to directoryName: {}",
@@ -74,49 +69,58 @@ public void persistOpenTofuResult(OpenTofuResult result) {
      * @param requestId requestId.
      * @return OpenTofuResult.
      */
-    public ResponseEntity<OpenTofuResult> retrieveOpenTofuResultByRequestId(String requestId) {
-        String filePath = getFilePath(UUID.fromString(requestId));
-        File resultFile = new File(filePath + File.separator + requestId + TF_RESULT_FILE_SUFFIX);
-        if (!resultFile.exists() && !resultFile.isFile()) {
+    public ReFetchResult retrieveOpenTofuResultByRequestId(UUID requestId) {
+        File resultFile = new File(getFilePath(requestId), getFileName(requestId));
+        if (!isValidResultFile(resultFile)) {
+            String errorMsg = String.format("Not found result file for requestId %s.", requestId);
             if (isDeployingInProgress(requestId)) {
-                return ResponseEntity.noContent().build();
+                errorMsg = errorMsg + " The order is still in progress.";
+                return buildErrorResponse(requestId, errorMsg, ReFetchState.ORDER_IN_PROGRESS);
             }
-            throw new ResultAlreadyReturnedOrRequestIdInvalidException(
-                    "Result file does not exist: " + resultFile.getAbsolutePath());
+            return buildErrorResponse(requestId, errorMsg, ReFetchState.RESULT_NOT_FOUND);
         }
         try (FileInputStream fis = new FileInputStream(resultFile)) {
-            byte[] openTofuResultData = fis.readAllBytes();
-            OpenTofuResult openTofuResult =
-                    openTofuResultSerializer.deserialize(openTofuResultData);
-            fis.close();
-            deleteResultFileAndDirectory(new File(filePath));
-            return ResponseEntity.ok(openTofuResult);
-        } catch (IOException e) {
-            log.error("Failed to retrieve OpenTofuResult for requestId: {}", requestId, e);
-            throw new ResultAlreadyReturnedOrRequestIdInvalidException(
-                    "Failed to retrieve OpenTofuResult for requestId: " + requestId);
+            OpenTofuResult terraformResult =
+                    openTofuResultSerializer.deserialize(fis.readAllBytes());
+            deleteResultFileAndDirectory(resultFile);
+            return ReFetchResult.builder()
+                    .requestId(requestId)
+                    .state(ReFetchState.OK)
+                    .openTofuResult(terraformResult)
+                    .build();
+        } catch (Exception e) {
+            String errorMsg =
+                    String.format("Failed to parse result file for requestId %s", requestId);
+            return buildErrorResponse(requestId, errorMsg, ReFetchState.RESULT_PARSE_FAILED);
         }
     }
 
-    private boolean isDeployingInProgress(String requestId) {
-        String workspace = scriptsHelper.buildTaskWorkspace(requestId);
-        File targetFile;
-        if (cleanWorkspaceAfterDeployment) {
-            targetFile = new File(workspace);
-            return targetFile.exists() && targetFile.isDirectory();
-        } else {
-            targetFile = new File(workspace, TF_LOCK_FILE_NAME);
-            return targetFile.exists() && targetFile.isFile();
-        }
+    private ReFetchResult buildErrorResponse(
+            UUID requestId, String errorMessage, ReFetchState state) {
+        log.error(errorMessage);
+        return ReFetchResult.builder()
+                .requestId(requestId)
+                .state(state)
+                .errorMessage(errorMessage)
+                .build();
+    }
+
+    private boolean isValidResultFile(File file) {
+        return file.exists() && file.isFile();
+    }
+
+    private boolean isDeployingInProgress(UUID requestId) {
+        String workspace = scriptsHelper.buildTaskWorkspace(requestId.toString());
+        File targetFile = new File(workspace, TF_LOCK_FILE_NAME);
+        return targetFile.exists() && targetFile.isFile();
     }
 
     private void deleteResultFileAndDirectory(File resultFile) {
         try {
             deleteRecursively(resultFile);
-            log.info("File folder deleted successfully: " + resultFile.getAbsolutePath());
+            log.info("File folder deleted successfully: {}", resultFile.getAbsolutePath());
         } catch (Exception e) {
-            log.error("An error occurred while deleting files: " + e.getMessage());
-            e.printStackTrace();
+            log.error("An error occurred while deleting files: {}", e.getMessage());
         }
     }
 
@@ -129,10 +133,16 @@ private void deleteRecursively(File file) {
                 }
             }
         }
-        file.delete();
+        if (file.delete()) {
+            log.info("File deleted successfully: {}", file.getAbsolutePath());
+        }
+    }
+
+    private File getFilePath(UUID requestId) {
+        return new File(failedCallbackStoreLocation + File.separator + requestId);
     }
 
-    private String getFilePath(UUID requestId) {
-        return failedCallbackStoreLocation + File.separator + requestId.toString();
+    private String getFileName(UUID requestId) {
+        return requestId + TF_RESULT_FILE_SUFFIX;
     }
 }
diff --git a/src/main/java/org/eclipse/xpanse/tofu/maker/utils/OpenTofuResultSerializer.java b/src/main/java/org/eclipse/xpanse/tofu/maker/utils/OpenTofuResultSerializer.java
@@ -14,29 +14,32 @@
 @Component
 public class OpenTofuResultSerializer {
 
+    private final Serializer<byte[]> serializer;
+
+    /** Constructor to initialize the Serializer with OpenTofuResult class registered. */
+    public OpenTofuResultSerializer() {
+        final SerializerFoundation<?> foundation =
+                SerializerFoundation.New().registerEntityTypes(OpenTofuResult.class);
+        this.serializer = Serializer.Bytes(foundation);
+    }
+
     /**
-     * serialize OpenTofuResult object.
+     * Serialize OpenTofuResult object.
      *
      * @param result OpenTofuResult.
      * @return byte[].
      */
     public byte[] serialize(OpenTofuResult result) {
-        final SerializerFoundation<?> foundation =
-                SerializerFoundation.New().registerEntityTypes(OpenTofuResult.class);
-        Serializer<byte[]> serializer = Serializer.Bytes(foundation);
         return serializer.serialize(result);
     }
 
     /**
-     * deserialize OpenTofuResult object.
+     * Deserialize OpenTofuResult object.
      *
      * @param data byte[].
      * @return OpenTofuResult.
      */
     public OpenTofuResult deserialize(byte[] data) {
-        final SerializerFoundation<?> foundation =
-                SerializerFoundation.New().registerEntityTypes(OpenTofuResult.class);
-        Serializer<byte[]> serializer = Serializer.Bytes(foundation);
         return serializer.deserialize(data);
     }
 }
diff --git a/src/main/resources/application-dev.properties b/src/main/resources/application-dev.properties
@@ -5,8 +5,8 @@
 tofu.maker.webhook.hmac.request.signing.key=1c30e4b1fad574f88572e25d0da03f34365f4ae92eda22bfd3a8c53cb5102f27
 authorization.server.endpoint=http://localhost:8088
 # set authorization client id for api
-authorization.api.client.id=302705713103306755
+authorization.api.client.id=306935357671276547
 # set authorization client secret for api
-authorization.api.client.secret=8cCu3PTpLPz3kBfB5aFCX32IdhIlmPZCic5aFNHCR6na8TW1ZIhFOR3v1s3GVBYx
+authorization.api.client.secret=AhOc8tsQv8nzk5diQx4EscdoEUKkVfTLM8R06mw7xZ5HIWViiOkfBK6VEWaRCXPR
 # set authorization client id for swagger-ui
-authorization.swagger.ui.client.id=302705713271078915
+authorization.swagger.ui.client.id=306935358862458883
