Merge pull request #617 from nevingeorgesunny/generate-support-bundle-async

Generate support bundle Async

Author: jglick

src/main/java/com/cloudbees/jenkins/support/SupportAction.java

@@ -29,6 +29,7 @@
 import com.cloudbees.jenkins.support.api.Component;
 import com.cloudbees.jenkins.support.api.SupportProvider;
 import com.cloudbees.jenkins.support.filter.ContentFilters;
+import edu.umd.cs.findbugs.annotations.NonNull;
 import hudson.Extension;
 import hudson.model.Api;
 import hudson.model.Failure;
@@ -38,10 +39,14 @@
 import hudson.security.Permission;
 import jakarta.servlet.ServletException;
 import jakarta.servlet.ServletOutputStream;
+import jakarta.servlet.http.HttpServletResponse;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -52,18 +57,25 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
 import jenkins.model.Jenkins;
+import jenkins.util.ProgressiveRendering;
+import jenkins.util.Timer;
+import net.sf.json.JSON;
 import net.sf.json.JSONObject;
 import org.apache.commons.io.FileUtils;
 import org.jvnet.localizer.Localizable;
 import org.kohsuke.accmod.Restricted;
 import org.kohsuke.accmod.restrictions.NoExternalUse;
 import org.kohsuke.stapler.DataBoundConstructor;
+import org.kohsuke.stapler.HttpRedirect;
 import org.kohsuke.stapler.HttpResponse;
 import org.kohsuke.stapler.HttpResponses;
 import org.kohsuke.stapler.QueryParameter;
@@ -92,6 +104,12 @@ public class SupportAction implements RootAction, StaplerProxy {
      */
     private final Logger logger = Logger.getLogger(SupportAction.class.getName());
 
+    private static final Path SUPPORT_BUNDLE_CREATION_FOLDER =
+            Paths.get(System.getProperty("java.io.tmpdir")).resolve("support-bundle");
+    public static final String SYNC_SUPPORT_BUNDLE = "support-bundle.zip";
+
+    private final Map<UUID, SupportBundleAsyncGenerator> generatorByTaskId = new ConcurrentHashMap<>();
+
     @Override
     @Restricted(NoExternalUse.class)
     public Object getTarget() {
@@ -318,6 +336,63 @@ public void doGenerateAllBundles(StaplerRequest2 req, StaplerResponse2 rsp) thro
             rsp.sendError(SC_BAD_REQUEST);
             return;
         }
+        final List<Component> components = getComponents(req, json);
+        prepareBundle(rsp, components);
+    }
+
+    /**
+     * Generates a support bundle with selected components from the UI. in async
+     * @param req The stapler request
+     * @param rsp The stapler response
+     * @throws ServletException If an error occurred during form submission
+     * @throws IOException If an input or output exception occurs
+     */
+    @RequirePOST
+    public HttpRedirect doGenerateBundleAsync(StaplerRequest2 req, StaplerResponse2 rsp)
+            throws ServletException, IOException {
+        JSONObject json = req.getSubmittedForm();
+        if (!json.has("components")) {
+            rsp.sendError(SC_BAD_REQUEST);
+            return new HttpRedirect("support");
+        }
+        final List<Component> components = getComponents(req, json);
+        UUID taskId = UUID.randomUUID();
+
+        // There are some components that need the request components to be processed
+        // these components cannot be processed async
+        // so process them first and then process the other components async
+        List<Component> syncComponent =
+                components.stream().filter(c -> !c.canBeGeneratedAsync()).toList();
+        if (!syncComponent.isEmpty()) {
+            Path outputDir = SUPPORT_BUNDLE_CREATION_FOLDER.resolve(taskId.toString());
+            if (!Files.exists(outputDir)) {
+                try {
+                    Files.createDirectories(outputDir);
+                } catch (IOException e) {
+                    throw new IOException("Failed to create directory: " + outputDir.toAbsolutePath(), e);
+                }
+            }
+            try (FileOutputStream fileOutputStream =
+                    new FileOutputStream(new File(outputDir.toString(), SYNC_SUPPORT_BUNDLE))) {
+                SupportPlugin.setRequesterAuthentication(Jenkins.getAuthentication2());
+                try {
+                    SupportPlugin.writeBundleForSyncComponents(fileOutputStream, syncComponent);
+                } finally {
+                    SupportPlugin.clearRequesterAuthentication();
+                }
+            } finally {
+                logger.fine("Processing support bundle sunc completed");
+            }
+        }
+
+        // Process the remaining components that can be process async
+        SupportBundleAsyncGenerator supportBundleAsyncGenerator = new SupportBundleAsyncGenerator();
+        supportBundleAsyncGenerator.init(taskId, components);
+        generatorByTaskId.put(taskId, supportBundleAsyncGenerator);
+        return new HttpRedirect("progressPage?taskId=" + taskId);
+    }
+
+    private List<Component> getComponents(StaplerRequest2 req, JSONObject json) throws IOException {
         logger.fine("Parsing request...");
         Set<String> remove = new HashSet<>();
         for (Selection s : req.bindJSONToList(Selection.class, json.get("components"))) {
@@ -343,7 +418,7 @@ public void doGenerateAllBundles(StaplerRequest2 req, StaplerResponse2 rsp) thro
         if (supportPlugin != null) {
             supportPlugin.setExcludedComponents(remove);
         }
-        prepareBundle(rsp, components);
+        return components;
     }
 
     /**
@@ -439,4 +514,105 @@ public boolean isSelected() {
             return selected;
         }
     }
+
+    public ProgressiveRendering getGeneratorByTaskId(String taskId) throws Exception {
+        return generatorByTaskId.get(UUID.fromString(taskId));
+    }
+
+    public static class SupportBundleAsyncGenerator extends ProgressiveRendering {
+        private final Logger logger = Logger.getLogger(SupportAction.class.getName());
+        private UUID taskId;
+        private boolean isCompleted;
+        private List<Component> components;
+        private boolean supportBundleGenerationInProgress = false;
+        private String supportBundleName;
+
+        public SupportBundleAsyncGenerator init(UUID taskId, List<Component> components) {
+            this.taskId = taskId;
+            this.components = components;
+            return this;
+        }
+
+        @Override
+        protected void compute() throws Exception {
+            if (supportBundleGenerationInProgress) {
+                logger.fine("Support bundle generation already in progress, for task id " + taskId);
+                return;
+            }
+
+            this.supportBundleName = BundleFileName.generate();
+            this.supportBundleGenerationInProgress = true;
+            logger.fine("Generating support bundle... task id " + taskId);
+            Path outputDir = SUPPORT_BUNDLE_CREATION_FOLDER.resolve(taskId.toString());
+            if (!Files.exists(outputDir)) {
+                try {
+                    Files.createDirectories(outputDir);
+                } catch (IOException e) {
+                    throw new IOException("Failed to create directory: " + outputDir.toAbsolutePath(), e);
+                }
+            }
+
+            try (FileOutputStream fileOutputStream =
+                    new FileOutputStream(new File(outputDir.toString(), supportBundleName))) {
+                SupportPlugin.setRequesterAuthentication(Jenkins.getAuthentication2());
+                try {
+                    SupportPlugin.writeBundle(fileOutputStream, components, this::progress, outputDir);
+                } finally {
+                    SupportPlugin.clearRequesterAuthentication();
+                }
+            } finally {
+                logger.fine("Processing support bundle async completed");
+            }
+
+            isCompleted = true;
+        }
+
+        @NonNull
+        @Override
+        protected JSON data() {
+            JSONObject json = new JSONObject();
+            json.put("isCompleted", isCompleted);
+            json.put("taskId", String.valueOf(taskId));
+            return json;
+        }
+
+        public String getSupportBundleName() {
+            return supportBundleName;
+        }
+    }
+
+    public void doDownloadBundle(@QueryParameter("taskId") String taskId, StaplerResponse2 rsp) throws IOException {
+        String supportBundleName =
+                generatorByTaskId.get(UUID.fromString(taskId)).getSupportBundleName();
+
+        File bundleFile = new File(SUPPORT_BUNDLE_CREATION_FOLDER + "/" + taskId + "/" + supportBundleName);
+        if (!bundleFile.exists()) {
+            rsp.sendError(HttpServletResponse.SC_NOT_FOUND, "Support bundle file not found");
+            return;
+        }
+
+        rsp.setContentType("application/zip");
+        rsp.addHeader("Content-Disposition", "attachment; filename=" + supportBundleName);
+        try (ServletOutputStream outputStream = rsp.getOutputStream()) {
+            Files.copy(bundleFile.toPath(), outputStream);
+        }
+
+        // Clean up temporary files after assembling the full bundle
+        Timer.get()
+                .schedule(
+                        () -> {
+                            File outputDir = new File(SUPPORT_BUNDLE_CREATION_FOLDER + "/" + taskId);
+
+                            try {
+                                FileUtils.deleteDirectory(outputDir);
+                                generatorByTaskId.remove(taskId);
+                                logger.fine(() -> "Cleaned up temporary directory " + outputDir);
+
+                            } catch (IOException e) {
+                                logger.log(Level.WARNING, () -> "Unable to delete " + outputDir);
+                            }
+                        },
+                        15,
+                        TimeUnit.MINUTES);
+    }
 }