fix destroy services with scripts from gitRepo always failed

Author: baixinsui

src/main/java/org/eclipse/xpanse/tofu/maker/models/request/git/OpenTofuDeployFromGitRepoRequest.java

@@ -6,6 +6,7 @@
 package org.eclipse.xpanse.tofu.maker.models.request.git;
 
 import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.eclipse.xpanse.tofu.maker.models.request.directory.OpenTofuDeployFromDirectoryRequest;
@@ -16,7 +17,8 @@
 @EqualsAndHashCode(callSuper = true)
 @Data
 public class OpenTofuDeployFromGitRepoRequest extends OpenTofuDeployFromDirectoryRequest {
-
+    
+	@NotNull
     @Schema(description = "GIT Repo details from where the scripts can be fetched.")
     OpenTofuScriptGitRepoDetails gitRepoDetails;
 }

src/main/java/org/eclipse/xpanse/tofu/maker/opentofu/service/OpenTofuDirectoryService.java

@@ -20,6 +20,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
+import java.util.stream.Stream;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.xpanse.tofu.maker.async.TaskConfiguration;
 import org.eclipse.xpanse.tofu.maker.models.OpenTofuMakerSystemStatus;
@@ -217,6 +218,7 @@ public void asyncDestroyWithScripts(OpenTofuAsyncDestroyFromDirectoryRequest req
             result = destroyFromDirectory(request, moduleDirectory);
         } catch (RuntimeException e) {
             result = OpenTofuResult.builder()
+                    .destroyScenario(request.getDestroyScenario())
                     .commandStdOutput(null)
                     .commandStdError(e.getMessage())
                     .isCommandSuccessful(false)
@@ -284,9 +286,8 @@ private Map<String, String> getImportantFilesContent(String workspace) {
 
     private void deleteWorkspace(String workspace) {
         Path path = Paths.get(workspace);
-        try {
-            Files.walk(path).sorted(Comparator.reverseOrder()).map(Path::toFile)
-                    .forEach(File::delete);
+        try (Stream<Path> pathStream = Files.walk(path)) {
+            pathStream.sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
         } catch (Exception e) {
             log.error(e.getMessage());
         }

src/main/java/org/eclipse/xpanse/tofu/maker/opentofu/service/OpenTofuGitRepoService.java

@@ -6,12 +6,20 @@
 package org.eclipse.xpanse.tofu.maker.opentofu.service;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.eclipse.jgit.api.CloneCommand;
 import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
 import org.eclipse.xpanse.tofu.maker.async.TaskConfiguration;
 import org.eclipse.xpanse.tofu.maker.models.exceptions.GitRepoCloneException;
 import org.eclipse.xpanse.tofu.maker.models.exceptions.OpenTofuExecutorException;
@@ -36,6 +44,7 @@
 @Component
 public class OpenTofuGitRepoService extends OpenTofuDirectoryService {
 
+    private static final int MAX_RETRY_COUNT = 5;
     private final RestTemplate restTemplate;
     private final OpenTofuExecutor executor;
     private final OpenTofuScriptsHelper openTofuScriptsHelper;
@@ -66,7 +75,8 @@ public OpenTofuValidationResult validateWithScripts(
      * Method to get openTofu plan.
      */
     public OpenTofuPlan getOpenTofuPlanFromGitRepo(OpenTofuPlanFromGitRepoRequest request,
-                                                    UUID uuid) {
+                                                   UUID uuid) {
+        uuid = getUuidToCreateEmptyWorkspace(uuid);
         buildDeployEnv(request.getGitRepoDetails(), uuid);
         return getOpenTofuPlanFromDirectory(request,
                 getScriptsLocationInRepo(request.getGitRepoDetails(), uuid));
@@ -76,6 +86,7 @@ public OpenTofuPlan getOpenTofuPlanFromGitRepo(OpenTofuPlanFromGitRepoRequest re
      * Method of deployment a service using a script.
      */
     public OpenTofuResult deployFromGitRepo(OpenTofuDeployFromGitRepoRequest request, UUID uuid) {
+        uuid = getUuidToCreateEmptyWorkspace(uuid);
         buildDeployEnv(request.getGitRepoDetails(), uuid);
         return deployFromDirectory(request, getScriptsLocationInRepo(
                 request.getGitRepoDetails(), uuid));
@@ -86,6 +97,7 @@ public OpenTofuResult deployFromGitRepo(OpenTofuDeployFromGitRepoRequest request
      */
     public OpenTofuResult destroyFromGitRepo(OpenTofuDestroyFromGitRepoRequest request,
                                              UUID uuid) {
+        uuid = getUuidToCreateEmptyWorkspace(uuid);
         buildDestroyEnv(request.getGitRepoDetails(), request.getTfState(), uuid);
         return destroyFromDirectory(request, getScriptsLocationInRepo(
                 request.getGitRepoDetails(), uuid));
@@ -125,6 +137,7 @@ public void asyncDestroyFromGitRepo(OpenTofuAsyncDestroyFromGitRepoRequest reque
             result = destroyFromGitRepo(request, uuid);
         } catch (RuntimeException e) {
             result = OpenTofuResult.builder()
+                    .destroyScenario(request.getDestroyScenario())
                     .commandStdOutput(null)
                     .commandStdError(e.getMessage())
                     .isCommandSuccessful(false)
@@ -145,6 +158,25 @@ private void buildDeployEnv(OpenTofuScriptGitRepoDetails openTofuScriptGitRepoDe
         extractScripts(workspace, openTofuScriptGitRepoDetails);
     }
 
+    private void buildDestroyEnv(OpenTofuScriptGitRepoDetails openTofuScriptGitRepoDetails,
+                                 String tfState, UUID uuid) {
+        buildDeployEnv(openTofuScriptGitRepoDetails, uuid);
+        openTofuScriptsHelper.createTfStateFile(tfState,
+                uuid + File.separator + openTofuScriptGitRepoDetails.getScriptPath());
+    }
+
+    private UUID getUuidToCreateEmptyWorkspace(UUID uuid) {
+        File ws = new File(executor.getModuleFullPath(uuid.toString()));
+        if (ws.exists()) {
+            if (!cleanWorkspace(uuid)) {
+                uuid = UUID.randomUUID();
+                log.info("Clean existed workspace failed. Create empty workspace with id:{}", uuid);
+                return UUID.randomUUID();
+            }
+        }
+        return uuid;
+    }
+
     private void buildWorkspace(String workspace) {
         log.info("start create workspace");
         File ws = new File(workspace);
@@ -156,36 +188,64 @@ private void buildWorkspace(String workspace) {
     }
 
     private void extractScripts(String workspace,
-                                OpenTofuScriptGitRepoDetails openTofuScriptGitRepoDetails) {
-        log.info("Cloning GIT repo");
-        try {
+                                OpenTofuScriptGitRepoDetails scriptsRepo) {
+        log.info("Cloning scripts from GIT repo:{} to workspace:{}", scriptsRepo.getRepoUrl(),
+                workspace);
+        File workspaceDirectory = new File(workspace);
+        FileRepositoryBuilder repositoryBuilder = new FileRepositoryBuilder();
+        repositoryBuilder.findGitDir(workspaceDirectory);
+        if (Objects.isNull(repositoryBuilder.getGitDir())) {
             CloneCommand cloneCommand = new CloneCommand();
-            cloneCommand.setURI(openTofuScriptGitRepoDetails.getRepoUrl());
+            cloneCommand.setURI(scriptsRepo.getRepoUrl());
             cloneCommand.setProgressMonitor(null);
-            cloneCommand.setDirectory(new File(workspace));
-            cloneCommand.setBranch(openTofuScriptGitRepoDetails.getBranch());
-            cloneCommand.call();
-        } catch (GitAPIException e) {
-            log.error(e.getMessage(), e);
-            throw new GitRepoCloneException(e.getMessage());
+            cloneCommand.setDirectory(workspaceDirectory);
+            cloneCommand.setBranch(scriptsRepo.getBranch());
+            boolean cloneSuccess = false;
+            int retryCount = 0;
+            String errMsg = "";
+            while (!cloneSuccess && retryCount < MAX_RETRY_COUNT) {
+                try {
+                    cloneCommand.call();
+                    cloneSuccess = true;
+                } catch (GitAPIException e) {
+                    retryCount++;
+                    errMsg =
+                            String.format("Cloning scripts form GIT repo error:%s", e.getMessage());
+                    log.error(errMsg);
+                }
+            }
+            if (!cloneSuccess) {
+                throw new GitRepoCloneException(errMsg);
+            }
         }
     }
 
-    private void buildDestroyEnv(OpenTofuScriptGitRepoDetails openTofuScriptGitRepoDetails,
-                                 String tfState, UUID uuid) {
-        buildDeployEnv(openTofuScriptGitRepoDetails, uuid);
-        openTofuScriptsHelper.createTfStateFile(tfState,
-                uuid + File.separator + openTofuScriptGitRepoDetails.getScriptPath());
-    }
-
     private String getScriptsLocationInRepo(
             OpenTofuScriptGitRepoDetails openTofuScriptGitRepoDetails,
             UUID uuid) {
-        if (Objects.nonNull(openTofuScriptGitRepoDetails.getScriptPath())) {
+        if (StringUtils.isNotBlank(openTofuScriptGitRepoDetails.getScriptPath())) {
             return uuid + File.separator + openTofuScriptGitRepoDetails.getScriptPath();
         }
         return uuid.toString();
     }
 
+    private boolean cleanWorkspace(UUID uuid) {
+        boolean cleanSuccess = true;
+        try {
+            String workspace = executor.getModuleFullPath(uuid.toString());
+            Path path = Paths.get(workspace).toAbsolutePath().normalize();
+            List<File> files =
+                    Files.walk(path).sorted(Comparator.reverseOrder()).map(Path::toFile).toList();
+            for (File file : files) {
+                if (!file.delete()) {
+                    cleanSuccess = false;
+                    log.info("Failed to delete file: {}", file.getAbsolutePath());
+                }
+            }
+        } catch (IOException e) {
+            return false;
+        }
+        return cleanSuccess;
+    }
 
 }

src/main/java/org/eclipse/xpanse/tofu/maker/opentofu/service/OpenTofuScriptsService.java

@@ -124,6 +124,7 @@ public void asyncDestroyWithScripts(OpenTofuAsyncDestroyFromScriptsRequest reque
             result = destroyWithScripts(request, uuid);
         } catch (RuntimeException e) {
             result = OpenTofuResult.builder()
+                    .destroyScenario(request.getDestroyScenario())
                     .commandStdOutput(null)
                     .commandStdError(e.getMessage())
                     .isCommandSuccessful(false)