Add Downloader abstract class

Author: Gamebuster19901

src/main/java/com/wildermods/thrixlvault/Downloader.java

@@ -0,0 +1,84 @@
+package com.wildermods.thrixlvault;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+import com.wildermods.thrixlvault.steam.IDownload;
+import com.wildermods.thrixlvault.steam.IDownloadable;
+
+/**
+ * Base class representing a generic downloader for a set of {@link IDownloadable} items.
+ * 
+ * <p>This class provides a framework for performing downloads and tracking their progress.
+ * Subclasses must implement the actual download logic in {@link #runImpl()} and optionally
+ * provide support for accessing downloads while they are in progress through
+ * {@link #getDownloadsInProgress()}.</p>
+ * 
+ * <p>The class distinguishes between downloads that are still in progress and those
+ * that are fully completed:</p>
+ * <ul>
+ *     <li>{@link #getDownloads()} returns the set of downloads either in progress or completed.
+ *         By default, it delegates to {@link #getDownloadsInProgress()} if the downloads are not
+ *         finished yet, and to {@link #getFinishedDownloads()} once complete.</li>
+ *     <li>{@link #getFinishedDownloads()} returns the completed downloads only and throws an
+ *         {@link IllegalStateException} if called before completion.</li>
+ * </ul>
+ * 
+ * <p>The {@link #run()} method executes the download synchronously and blocks until all downloads
+ * are finished. After completion, the results are cached as an immutable set. If asynchronous or
+ * incremental download reporting is desired, subclasses may override {@link #getDownloadsInProgress()}.</p>
+ * 
+ * @param <Downloadable> The type of items to download, must implement {@link IDownloadable}.
+ * @param <Download> The type representing a completed download, must implement {@link IDownload}.
+ */
+public abstract class Downloader<Downloadable extends IDownloadable, Download extends IDownload> {
+	
+	private final Object runLock = new Object();
+	
+	protected final Set<Downloadable> downloadables;
+	private volatile Set<Download> finishedDownloads;
+	private volatile boolean finished = false;
+	
+	public Downloader(Collection<Downloadable> downloadables) {
+		this.downloadables = ImmutableSet.copyOf(downloadables);
+	}
+	
+    /**
+     * Runs the downloader synchronously and blocks until all downloads are complete.
+     * 
+     * @return an immutable set of completed downloads.
+     * @throws IOException 
+     */
+	public final Set<Download> run() throws IOException {
+		synchronized(runLock) {
+			finishedDownloads = ImmutableSet.copyOf(runImpl());
+			finished = true;
+			return finishedDownloads;
+		}
+	}
+	
+	protected abstract Set<Download> runImpl() throws IOException;
+	
+	public final boolean isFinished() {
+		return finished;
+	}
+	
+	public final Set<Download> getFinishedDownloads() {
+		if(finished) {
+			return finishedDownloads;
+		}
+		throw new IllegalStateException("Download in progress");
+	}
+	
+	public final Set<Download> getDownloads() throws UnsupportedOperationException {
+		if(finished) {
+			return getFinishedDownloads();
+		}
+		return getDownloadsInProgress();
+	}
+	
+	protected abstract ImmutableSet<Download> getDownloadsInProgress() throws UnsupportedOperationException;
+	
+}

src/main/java/com/wildermods/thrixlvault/MassDownloadWeaver.java

@@ -7,32 +7,34 @@
 import java.util.LinkedHashSet;
 import java.util.Set;
 
+import com.google.common.collect.ImmutableSet;
 import com.wildermods.masshash.exception.IntegrityException;
 import com.wildermods.thrixlvault.steam.CompletedDownload;
 import com.wildermods.thrixlvault.steam.FailedDownload;
 import com.wildermods.thrixlvault.steam.ISteamDownload;
 import com.wildermods.thrixlvault.steam.ISteamDownloadable;
 import com.wildermods.thrixlvault.utils.FileUtil;
 
-public class MassDownloadWeaver {
+public class MassDownloadWeaver extends Downloader<ISteamDownloadable, ISteamDownload>{
 
 	final String username;
 	final int totalDownloads;
-	final LinkedHashSet<ISteamDownloadable> downloadables;
 	final HashMap<ISteamDownloadable, Integer> failedDownloads = new HashMap<>();
-	final HashSet<ISteamDownload> finishedDownloads = new HashSet<ISteamDownload>();
 
-	public MassDownloadWeaver(String username, Collection<ISteamDownloadable> downloadable) throws IOException, InterruptedException {
+	public MassDownloadWeaver(String username, Collection<ISteamDownloadable> downloadables) throws IOException, InterruptedException {
+		super(downloadables);
 		this.username = username;
-		totalDownloads = downloadable.size();
-		downloadables = new LinkedHashSet<>(downloadable);
+		totalDownloads = downloadables.size();
 	}
 
-	public void run() throws IOException, InterruptedException {
+	public Set<ISteamDownload> runImpl() throws IOException {
+		final HashSet<ISteamDownloadable> downloadables = new LinkedHashSet<>(this.downloadables);
+		final HashSet<ISteamDownload> finishedDownloads = new HashSet<ISteamDownload>();
 		while(!downloadables.isEmpty()) {
 
 			SteamDownloader downloader = new SteamDownloader(username, downloadables);
-			Set<ISteamDownload> downloads = downloader.run((download) -> {
+			
+			downloader.setConsumer((download) -> {
 				if(download instanceof CompletedDownload) {
 					try {
 						Weaver weaver = new Weaver(Vault.DEFAULT, download);
@@ -46,6 +48,8 @@ public void run() throws IOException, InterruptedException {
 					throw new RuntimeException(e);
 				}
 			});
+			
+			Set<ISteamDownload> downloads = downloader.run();
 			for(ISteamDownload download : downloads) {
 				if(download instanceof FailedDownload) {
 					final int attempt;
@@ -94,6 +98,12 @@ else if(download instanceof FailedDownload) {
 		System.out.println("Remaining downloads:" + remaining + "/" + totalDownloads);
 		System.out.println("Other status downloads: " + other + "/" + totalDownloads);
 		System.out.println("Downloads unaccounted for: " + (totalDownloads - (failed + success + other + remaining)));
+		return finishedDownloads;
+	}
+
+	@Override
+	protected ImmutableSet<ISteamDownload> getDownloadsInProgress() throws UnsupportedOperationException {
+		throw new UnsupportedOperationException();
 	}
 
 }

src/main/java/com/wildermods/thrixlvault/SteamDownloader.java

@@ -21,6 +21,7 @@
 import javax.security.auth.login.CredentialException;
 import javax.security.sasl.AuthenticationException;
 
+import com.google.common.collect.ImmutableSet;
 import com.wildermods.thrixlvault.steam.CompletedDownload;
 import com.wildermods.thrixlvault.steam.FailedDownload;
 import com.wildermods.thrixlvault.steam.IManifest;
@@ -30,50 +31,61 @@
 
 import static com.wildermods.thrixlvault.SteamDownloader.SteamState.*;
 
-public class SteamDownloader {
+public class SteamDownloader extends Downloader<ISteamDownloadable, ISteamDownload> {
 
 	private static final Object GLOBAL_RUN_LOCK = new Object(); // So we only have one instance of steamcmd operating at a time.
 
 	public static final Path DEFAULT_APP_INSTALL_DIR = Path.of(System.getProperty("user.home")).resolve("thrixlvault").resolve("current_download");
 	private final Path installDir;
 	private final String username;
-	private final Collection<ISteamDownloadable> downloadables;
 	private final HashMap<IManifest, ISteamDownload> processedDownloads = new HashMap<IManifest, ISteamDownload>();
 
 	private volatile Process process;
 	private volatile SteamState prevState = SteamState.UNINITIALIZED;
 	private volatile SteamState steamState = SteamState.UNINITIALIZED;
 	private volatile boolean userInput = false;
 	private volatile Instant lastResponse = Instant.now();
+	private volatile Duration hangTimeout = Duration.ofSeconds(30);
+	private volatile Duration downloadTimeout = Duration.ofMinutes(7);
+	private volatile Consumer<ISteamDownload> onManifestDownload = (d) -> {};
 
 	private final Object interruptLock = new Object();
+	private final Object stateLock = new Object();
 	private volatile boolean interrupt = false;;
 
 	private volatile ISteamDownloadable currentDownload;
 
 	private static final Pattern ERROR_REGEX = Pattern.compile("ERROR \\((?<error>.*)\\)\\n");
 
 	public SteamDownloader(String username, Collection<ISteamDownloadable> downloads) {
+		super(downloads);
 		this.username = username;
-		this.downloadables = downloads;
 		this.installDir = DEFAULT_APP_INSTALL_DIR;
 	}
 
 	public SteamDownloader(String username, Collection<ISteamDownloadable> downloads, Path installDir) {
+		super(downloads);
 		this.username = username;
-		this.downloadables = downloads;
 		this.installDir = installDir;
 	}
 
-	public Set<ISteamDownload> run() throws Throwable {
-		return run((c) -> {});
+	public SteamDownloader setHangTimeout(Duration hangTimeout) {
+		this.hangTimeout = hangTimeout;
+		return this;
 	}
 
-	public Set<ISteamDownload> run(Consumer<ISteamDownload> onManifestDownload) throws IOException, InterruptedException {
-		return run(onManifestDownload, Duration.ofSeconds(30), Duration.ofMinutes(7));
+	public SteamDownloader setDownloadTimeout(Duration downloadTimeout) {
+		this.downloadTimeout = downloadTimeout;
+		return this;
 	}
-
-	public Set<ISteamDownload> run(Consumer<ISteamDownload> onManifestDownload, Duration hangTimeout, Duration downloadTimeout) throws IOException, InterruptedException {
+	
+	public SteamDownloader setConsumer(Consumer<ISteamDownload> onManifestDownload) {
+		this.onManifestDownload = onManifestDownload;
+		return this;
+	}
+	
+	@Override
+	public Set<ISteamDownload> runImpl() throws IOException {
 		synchronized (GLOBAL_RUN_LOCK) {
 			System.out.println("[DOWNLOADER] Acquired global run lock");
 			return this.runInternal(onManifestDownload, hangTimeout, downloadTimeout);
@@ -328,6 +340,11 @@ else if (state == DOWNLOADING) {
 		return Set.copyOf(processedDownloads.values());
 	}
 
+	@Override
+	protected ImmutableSet<ISteamDownload> getDownloadsInProgress() throws UnsupportedOperationException {
+		throw new UnsupportedOperationException();
+	}
+	
 	private void putDownload(Consumer<ISteamDownload> onManifestDownload, IManifest manifest, ISteamDownload download) {
 		this.processedDownloads.put(manifest, download);
 		onManifestDownload.accept(download);
@@ -382,14 +399,17 @@ public SteamState getState() {
 		return steamState;
 	}
 
-	private synchronized SteamState setState(SteamState newState) {
-		prevState = getState();
-		steamState = newState;
-		System.out.println("\n[DOWNLOADER/STATE]: Steam state changed from " + prevState + " to " + newState);
-		return prevState;
+	private SteamState setState(SteamState newState) {
+		synchronized(stateLock) {
+			prevState = getState();
+			steamState = newState;
+			System.out.println("\n[DOWNLOADER/STATE]: Steam state changed from " + prevState + " to " + newState);
+			return prevState;
+		}
 	}
 
 	public enum SteamState {
 		UNINITIALIZED, INITIALIZE, SETUP_DIR, LOGGING_IN, DOWNLOADING, FINISHED, FAILURE
 	}
+
 }