package com.cloudbackup.manager; import com.cloudbackup.CloudAutoBackup; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.nio.file.Files; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.zip.Deflater; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; public class ZipManager { private final CloudAutoBackup plugin; private final File tempDirectory; public ZipManager(CloudAutoBackup plugin) { this.plugin = plugin; String tempDirName = this.plugin.getConfigManager().getTempDirectory(); this.tempDirectory = new File(this.plugin.getDataFolder(), tempDirName); if (!this.tempDirectory.exists()) { this.tempDirectory.mkdirs(); } } public CompletableFuture> createBackupZip() { return CompletableFuture.supplyAsync(() -> { try { this.plugin.getNotificationManager().send("backup-zipping"); MySQLDumper mysqlDumper = new MySQLDumper(this.plugin); File sqlDump = mysqlDumper.createDump(); String backupName = generateBackupFileName(); File zipFile = new File(this.tempDirectory, backupName); File serverRoot = this.plugin.getServer().getWorldContainer().getAbsoluteFile(); this.plugin.getNotificationManager().debug("Server root: " + serverRoot.getAbsolutePath()); this.plugin.getNotificationManager().debug("Creating zip (ULTRA-LOW IMPACT): " + zipFile.getAbsolutePath()); int compressionLevel = this.plugin.getConfigManager().getCompressionLevel(); int bufferSize = this.plugin.getConfigManager().getBufferSizeKB() * 1024; int chunkDelayMs = this.plugin.getConfigManager().getChunkDelayMs(); int chunksPerYield = this.plugin.getConfigManager().getChunksPerYield(); List backupFolders = this.plugin.getConfigManager().getBackupFolders(); List excludeFolders = this.plugin.getConfigManager().getExcludeFolders(); List excludeExtensions = this.plugin.getConfigManager().getExcludeExtensions(); if (backupFolders.isEmpty()) { this.plugin.getNotificationManager().debug("No backup folders specified, defaulting to critical folders only"); backupFolders = new ArrayList<>(); backupFolders.add("world"); backupFolders.add("world_nether"); backupFolders.add("world_the_end"); backupFolders.add("plugins"); } this.plugin.getNotificationManager().debug("Backup folders: " + String.join(", ", backupFolders)); this.plugin.getNotificationManager().debug("Compression level: " + compressionLevel + " (0=NO_COMPRESSION, 1=BEST_SPEED)"); this.plugin.getNotificationManager().debug("Buffer size: " + bufferSize + " bytes"); this.plugin.getNotificationManager().debug("Chunk delay: " + chunkDelayMs + "ms every " + chunksPerYield + " chunks"); try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) { zos.setLevel(compressionLevel); UltraLowImpactZipContext context = new UltraLowImpactZipContext( bufferSize, chunkDelayMs, chunksPerYield ); for (String folderName : backupFolders) { File folder = new File(serverRoot, folderName); if (folder.exists() && folder.isDirectory()) { this.plugin.getNotificationManager().debug("Backing up folder: " + folderName); addDirectoryToZipLowImpact( serverRoot, folder, zos, context, excludeFolders, excludeExtensions ); } else { this.plugin.getNotificationManager().debug("Skipping non-existent folder: " + folderName); } } if (sqlDump != null && sqlDump.exists()) { this.plugin.getNotificationManager().debug("Adding MySQL dump"); addFileToZipLowImpact(sqlDump, "database/" + sqlDump.getName(), zos, context); sqlDump.delete(); } this.plugin.getNotificationManager().debug("Total chunks processed: " + context.getTotalChunks()); this.plugin.getNotificationManager().debug("Total yield operations: " + context.getTotalYields()); } long fileSize = zipFile.length(); String formattedSize = formatFileSize(fileSize); this.plugin.getNotificationManager().send("backup-zip-complete", java.util.Map.of("file", zipFile.getName(), "size", formattedSize)); if (this.plugin.getConfigManager().isSplitZipEnabled()) { long maxSizeMB = this.plugin.getConfigManager().getSplitZipSizeMB(); long maxSizeBytes = maxSizeMB * 1024 * 1024; if (fileSize > maxSizeBytes) { this.plugin.getNotificationManager().debug("File exceeds " + maxSizeMB + "MB, splitting..."); return splitZipFileLowImpact(zipFile, maxSizeBytes); } } List files = new ArrayList<>(); files.add(zipFile); return files; } catch (Exception e) { this.plugin.getLogger().severe("Failed to create backup zip: " + e.getMessage()); e.printStackTrace(); throw new RuntimeException("Zip creation failed", e); } }); } private List splitZipFileLowImpact(File originalZip, long maxSizeBytes) throws IOException { List parts = new ArrayList<>(); int chunkDelayMs = this.plugin.getConfigManager().getChunkDelayMs(); int chunksPerYield = this.plugin.getConfigManager().getChunksPerYield(); int chunkCount = 0; try (FileInputStream fis = new FileInputStream(originalZip)) { int partNumber = 1; byte[] buffer = new byte[8192]; while (true) { String partName = originalZip.getName().replace(".zip", ".part" + partNumber + ".zip"); File partFile = new File(originalZip.getParent(), partName); try (FileOutputStream fos = new FileOutputStream(partFile)) { long written = 0; int bytesRead; while (written < maxSizeBytes && (bytesRead = fis.read(buffer)) != -1) { int toWrite = (int) Math.min(bytesRead, maxSizeBytes - written); fos.write(buffer, 0, toWrite); written += toWrite; chunkCount++; if (chunkCount % chunksPerYield == 0) { try { Thread.sleep(chunkDelayMs); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IOException("Split operation interrupted", e); } } if (toWrite < bytesRead) { break; } } if (written == 0) { partFile.delete(); break; } parts.add(partFile); partNumber++; } } } originalZip.delete(); this.plugin.getNotificationManager().debug("Split into " + parts.size() + " parts"); return parts; } private void addFileToZipLowImpact(File file, String entryName, ZipOutputStream zos, UltraLowImpactZipContext context) throws IOException { byte[] buffer = new byte[context.getBufferSize()]; try (FileInputStream fis = new FileInputStream(file)) { ZipEntry zipEntry = new ZipEntry(entryName); zipEntry.setTime(file.lastModified()); zos.putNextEntry(zipEntry); int length; while ((length = fis.read(buffer)) > 0) { zos.write(buffer, 0, length); context.incrementChunkCount(); if (context.shouldYield()) { try { Thread.sleep(context.getChunkDelayMs()); context.incrementYieldCount(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IOException("Zip operation interrupted", e); } } } zos.closeEntry(); } } private void addDirectoryToZipLowImpact(File rootDir, File currentDir, ZipOutputStream zos, UltraLowImpactZipContext context, List excludeFolders, List excludeExtensions) throws IOException { File[] files = currentDir.listFiles(); if (files == null) { return; } byte[] buffer = new byte[context.getBufferSize()]; for (File file : files) { String relativePath = rootDir.toPath().relativize(file.toPath()).toString(); if (shouldExclude(relativePath, file, excludeFolders, excludeExtensions)) { this.plugin.getNotificationManager().debug("Excluding: " + relativePath); continue; } if (file.isDirectory()) { addDirectoryToZipLowImpact(rootDir, file, zos, context, excludeFolders, excludeExtensions); } else { try (FileInputStream fis = new FileInputStream(file)) { ZipEntry zipEntry = new ZipEntry(relativePath.replace("\\", "/")); zipEntry.setTime(file.lastModified()); zos.putNextEntry(zipEntry); int length; while ((length = fis.read(buffer)) > 0) { zos.write(buffer, 0, length); context.incrementChunkCount(); if (context.shouldYield()) { try { Thread.sleep(context.getChunkDelayMs()); context.incrementYieldCount(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IOException("Zip operation interrupted", e); } } } zos.closeEntry(); } } } } private boolean shouldExclude(String relativePath, File file, List excludeFolders, List excludeExtensions) { for (String excludeFolder : excludeFolders) { if (relativePath.startsWith(excludeFolder) || relativePath.contains("/" + excludeFolder) || relativePath.contains("\\" + excludeFolder)) { return true; } } if (file.isFile()) { String fileName = file.getName(); for (String extension : excludeExtensions) { if (fileName.endsWith(extension)) { return true; } } } return false; } private String generateBackupFileName() { String format = this.plugin.getConfigManager().getBackupNameFormat(); SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat timeFormat = new SimpleDateFormat("HH-mm-ss"); Date now = new Date(); String fileName = format .replace("%date%", dateFormat.format(now)) .replace("%time%", timeFormat.format(now)); return fileName + ".zip"; } public void deleteZipFile(File zipFile) { if (zipFile != null && zipFile.exists()) { try { Files.delete(zipFile.toPath()); this.plugin.getNotificationManager().debug("Deleted temporary zip: " + zipFile.getName()); } catch (IOException e) { this.plugin.getLogger().warning("Failed to delete temporary zip: " + e.getMessage()); } } } public void cleanupOldBackups() { if (!this.tempDirectory.exists()) { return; } File[] files = this.tempDirectory.listFiles((dir, name) -> name.endsWith(".zip")); if (files == null || files.length == 0) { return; } for (File file : files) { try { Files.delete(file.toPath()); this.plugin.getNotificationManager().debug("Cleaned up old backup: " + file.getName()); } catch (IOException e) { this.plugin.getLogger().warning("Failed to cleanup old backup: " + e.getMessage()); } } } public String formatFileSize(long bytes) { if (bytes < 1024) { return bytes + " B"; } else if (bytes < 1024 * 1024) { return String.format("%.2f KB", bytes / 1024.0); } else if (bytes < 1024 * 1024 * 1024) { return String.format("%.2f MB", bytes / (1024.0 * 1024.0)); } else { return String.format("%.2f GB", bytes / (1024.0 * 1024.0 * 1024.0)); } } private static class UltraLowImpactZipContext { private final int bufferSize; private final int chunkDelayMs; private final int chunksPerYield; private int chunkCount = 0; private int yieldCount = 0; public UltraLowImpactZipContext(int bufferSize, int chunkDelayMs, int chunksPerYield) { this.bufferSize = bufferSize; this.chunkDelayMs = chunkDelayMs; this.chunksPerYield = chunksPerYield; } public int getBufferSize() { return bufferSize; } public int getChunkDelayMs() { return chunkDelayMs; } public void incrementChunkCount() { chunkCount++; } public void incrementYieldCount() { yieldCount++; } public boolean shouldYield() { return chunkCount % chunksPerYield == 0; } public int getTotalChunks() { return chunkCount; } public int getTotalYields() { return yieldCount; } } }