Fix SocketTimeoutException in Vaadin Large File Downloads

// The timeout variable from getWriteTimeout() is larger than 30 seconds (default is 60)
// But the actual timeout occurs before this value is reached

# These settings might need additional configuration
proxy_buffering off;  # Disable buffering for large files
proxy_request_buffering off;
chunked_transfer_encoding on;

location /download/ {
    proxy_buffering off;
    proxy_request_buffering off;
    proxy_set_header Transfer-Encoding chunked;
    proxy_set_header Connection "keep-alive";
    
    # Keep your existing timeout settings
    send_timeout 300;
    proxy_connect_timeout 600;
    proxy_send_timeout 600;
    proxy_read_timeout 600;
}

StreamResource resource = new StreamResource(() -> {
    try {
        return new FileInputStream(file);
    } catch (FileNotFoundException e) {
        throw new RuntimeException("File not found", e);
    }
}, filename);

resource.setMIMEType(contentType);
resource.setCacheTime(0); // No caching for downloads

StreamRegistration registration = ui.getSession().getResourceRegistry().registerResource(resource);
String resourceUrl = registration.getResourceUri().toString();

DownloadHandler downloadHandler = DownloadHandler.fromInputStream(downloadEvent -> {
    try (InputStream inputStream = new FileInputStream(file);
         OutputStream outputStream = downloadEvent.getOutputStream()) {
        
        byte[] buffer = new byte[8192]; // 8KB buffer
        int bytesRead;
        long totalBytesRead = 0;
        
        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
            totalBytesRead += bytesRead;
            
            // Periodically flush to maintain connection
            if (totalBytesRead % (1024 * 1024) == 0) { // Flush every 1MB
                outputStream.flush();
            }
        }
        
        return new DownloadResponse(outputStream, filename, contentType, file.length());
    } catch (IOException e) {
        throw new RuntimeException("Download failed", e);
    }
});

// In your download handler
VaadinResponse response = downloadEvent.getResponse();
response.setHeader("X-Content-Transfer-Idle-Timeout", "300");

// Check if browser supports range requests
String rangeHeader = downloadEvent.getRequest().getHeader("Range");
if (rangeHeader != null) {
    // Parse range header and send partial content
    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
}

@WebServlet("/download/*")
public class LargeFileDownloadServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        
        String fileName = request.getPathInfo().substring(1);
        File file = new File("/path/to/files", fileName);
        
        if (file.exists()) {
            response.setContentType(getServletContext().getMimeType(fileName));
            response.setHeader("Content-Disposition", 
                "attachment; filename=\"" + fileName + "\"");
            response.setContentLength((int) file.length());
            
            Files.copy(file.toPath(), response.getOutputStream());
        } else {
            response.sendError(HttpServletResponse.SC_NOT_FOUND);
        }
    }
}

@Async
public CompletableFuture<Void> downloadLargeFile(File file, String filename, 
        String contentType, HttpServletResponse response) {
    try (InputStream inputStream = new FileInputStream(file);
         OutputStream outputStream = response.getOutputStream()) {
        
        byte[] buffer = new byte[16384]; // 16KB buffer
        int bytesRead;
        
        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
            outputStream.flush();
        }
        
        return CompletableFuture.completedFuture(null);
    } catch (IOException e) {
        throw new CompletionException(e);
    }
}

server:
  tomcat:
    threads:
      max: 200
      min-spare: 10
    connection-timeout: 900000
    max-connections: 8192
    accept-count: 100
    max-http-post-size: 0 # Unlimited POST size
    max-swallow-size: 0 # Unlimited request body size

response.setHeader("Connection", "keep-alive");
response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
response.setHeader("Pragma", "no-cache");
response.setHeader("Expires", "0");
response.setHeader("X-Content-Type-Options", "nosniff");

// Check for Range header
String rangeHeader = request.getHeader("Range");
if (rangeHeader != null && rangeHeader.startsWith("bytes=")) {
    String[] ranges = rangeHeader.substring(6).split("-");
    long start = Long.parseLong(ranges[0]);
    long end = ranges.length > 1 ? Long.parseLong(ranges[1]) : file.length() - 1;
    
    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
    response.setHeader("Content-Range", 
        "bytes " + start + "-" + end + "/" + file.length());
    response.setContentLength((int) (end - start + 1));
    
    // Skip to the start position
    try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
        raf.seek(start);
        byte[] buffer = new byte[8192];
        long remaining = end - start + 1;
        
        while (remaining > 0) {
            int read = raf.read(buffer, 0, 
                (int) Math.min(buffer.length, remaining));
            outputStream.write(buffer, 0, read);
            remaining -= read;
        }
    }
}