Merge branch 'develop'

15 files changed, 1421 insertions, 255 deletions

diff --git a/logic/net/ByteArrayDownload.cpp b/logic/net/ByteArrayDownload.cpp
new file mode 100644
index 00000000..ba771eef
--- /dev/null
+++ b/logic/net/ByteArrayDownload.cpp
@@ -0,0 +1,65 @@
+#include "ByteArrayDownload.h"
+#include "MultiMC.h"
+#include <logger/QsLog.h>
+
+ByteArrayDownload::ByteArrayDownload(QUrl url) : Download()
+{
+	m_url = url;
+	m_status = Job_NotStarted;
+}
+
+void ByteArrayDownload::start()
+{
+	QLOG_INFO() << "Downloading " << m_url.toString();
+	QNetworkRequest request(m_url);
+	request.setHeader(QNetworkRequest::UserAgentHeader, "MultiMC/5.0 (Uncached)");
+	auto worker = MMC->qnam();
+	QNetworkReply *rep = worker->get(request);
+
+	m_reply = std::shared_ptr<QNetworkReply>(rep);
+	connect(rep, SIGNAL(downloadProgress(qint64, qint64)),
+			SLOT(downloadProgress(qint64, qint64)));
+	connect(rep, SIGNAL(finished()), SLOT(downloadFinished()));
+	connect(rep, SIGNAL(error(QNetworkReply::NetworkError)),
+			SLOT(downloadError(QNetworkReply::NetworkError)));
+	connect(rep, SIGNAL(readyRead()), SLOT(downloadReadyRead()));
+}
+
+void ByteArrayDownload::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
+{
+	emit progress(index_within_job, bytesReceived, bytesTotal);
+}
+
+void ByteArrayDownload::downloadError(QNetworkReply::NetworkError error)
+{
+	// error happened during download.
+	QLOG_ERROR() << "Error getting URL:" << m_url.toString().toLocal8Bit()
+				 << "Network error: " << error;
+	m_status = Job_Failed;
+}
+
+void ByteArrayDownload::downloadFinished()
+{
+	// if the download succeeded
+	if (m_status != Job_Failed)
+	{
+		// nothing went wrong...
+		m_status = Job_Finished;
+		m_data = m_reply->readAll();
+		m_reply.reset();
+		emit succeeded(index_within_job);
+		return;
+	}
+	// else the download failed
+	else
+	{
+		m_reply.reset();
+		emit failed(index_within_job);
+		return;
+	}
+}
+
+void ByteArrayDownload::downloadReadyRead()
+{
+	// ~_~
+}
diff --git a/logic/net/ByteArrayDownload.h b/logic/net/ByteArrayDownload.h
new file mode 100644
index 00000000..cfc6a8d0
--- /dev/null
+++ b/logic/net/ByteArrayDownload.h
@@ -0,0 +1,24 @@
+#pragma once
+#include "Download.h"
+
+class ByteArrayDownload: public Download
+{
+	Q_OBJECT
+public:
+	ByteArrayDownload(QUrl url);
+	
+public:
+	/// if not saving to file, downloaded data is placed here
+	QByteArray m_data;
+	
+public slots:
+	virtual void start();
+	
+protected slots:
+	void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+	void downloadError(QNetworkReply::NetworkError error);
+	void downloadFinished();
+	void downloadReadyRead();
+};
+
+typedef std::shared_ptr<ByteArrayDownload> ByteArrayDownloadPtr;
diff --git a/logic/net/CacheDownload.cpp b/logic/net/CacheDownload.cpp
new file mode 100644
index 00000000..309eb345
--- /dev/null
+++ b/logic/net/CacheDownload.cpp
@@ -0,0 +1,136 @@
+#include "MultiMC.h"
+#include "CacheDownload.h"
+#include <pathutils.h>
+
+#include <QCryptographicHash>
+#include <QFileInfo>
+#include <QDateTime>
+#include <logger/QsLog.h>
+
+CacheDownload::CacheDownload(QUrl url, MetaEntryPtr entry)
+	: Download(), md5sum(QCryptographicHash::Md5)
+{
+	m_url = url;
+	m_entry = entry;
+	m_target_path = entry->getFullPath();
+	m_status = Job_NotStarted;
+	m_opened_for_saving = false;
+}
+
+void CacheDownload::start()
+{
+	if (!m_entry->stale)
+	{
+		emit succeeded(index_within_job);
+		return;
+	}
+	m_output_file.setFileName(m_target_path);
+	// if there already is a file and md5 checking is in effect and it can be opened
+	if (!ensureFilePathExists(m_target_path))
+	{
+		emit failed(index_within_job);
+		return;
+	}
+	QLOG_INFO() << "Downloading " << m_url.toString();
+	QNetworkRequest request(m_url);
+	if(m_entry->remote_changed_timestamp.size())
+		request.setRawHeader(QString("If-Modified-Since").toLatin1(), m_entry->remote_changed_timestamp.toLatin1());
+	if(m_entry->etag.size())
+		request.setRawHeader(QString("If-None-Match").toLatin1(), m_entry->etag.toLatin1());
+
+	request.setHeader(QNetworkRequest::UserAgentHeader,"MultiMC/5.0 (Cached)");
+
+	auto worker = MMC->qnam();
+	QNetworkReply *rep = worker->get(request);
+
+	m_reply = std::shared_ptr<QNetworkReply>(rep);
+	connect(rep, SIGNAL(downloadProgress(qint64, qint64)),
+			SLOT(downloadProgress(qint64, qint64)));
+	connect(rep, SIGNAL(finished()), SLOT(downloadFinished()));
+	connect(rep, SIGNAL(error(QNetworkReply::NetworkError)),
+			SLOT(downloadError(QNetworkReply::NetworkError)));
+	connect(rep, SIGNAL(readyRead()), SLOT(downloadReadyRead()));
+}
+
+void CacheDownload::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
+{
+	emit progress(index_within_job, bytesReceived, bytesTotal);
+}
+
+void CacheDownload::downloadError(QNetworkReply::NetworkError error)
+{
+	// error happened during download.
+	QLOG_ERROR() << "Failed" << m_url.toString() << "with reason" << error;
+	m_status = Job_Failed;
+}
+void CacheDownload::downloadFinished()
+{
+	// if the download succeeded
+	if (m_status != Job_Failed)
+	{
+
+		// nothing went wrong...
+		m_status = Job_Finished;
+		if (m_opened_for_saving)
+		{
+			// save the data to the downloadable if we aren't saving to file
+			m_output_file.close();
+			m_entry->md5sum = md5sum.result().toHex().constData();
+		}
+		else
+		{
+			if (m_output_file.open(QIODevice::ReadOnly))
+			{
+				m_entry->md5sum =
+					QCryptographicHash::hash(m_output_file.readAll(), QCryptographicHash::Md5)
+						.toHex()
+						.constData();
+				m_output_file.close();
+			}
+		}
+		QFileInfo output_file_info(m_target_path);
+
+		m_entry->etag = m_reply->rawHeader("ETag").constData();
+		if(m_reply->hasRawHeader("Last-Modified"))
+		{
+			m_entry->remote_changed_timestamp = m_reply->rawHeader("Last-Modified").constData();
+		}
+		m_entry->local_changed_timestamp =
+			output_file_info.lastModified().toUTC().toMSecsSinceEpoch();
+		m_entry->stale = false;
+		MMC->metacache()->updateEntry(m_entry);
+
+		m_reply.reset();
+		emit succeeded(index_within_job);
+		return;
+	}
+	// else the download failed
+	else
+	{
+		m_output_file.close();
+		m_output_file.remove();
+		m_reply.reset();
+		emit failed(index_within_job);
+		return;
+	}
+}
+
+void CacheDownload::downloadReadyRead()
+{
+	if (!m_opened_for_saving)
+	{
+		if (!m_output_file.open(QIODevice::WriteOnly))
+		{
+			/*
+			* Can't open the file... the job failed
+			*/
+			m_reply->abort();
+			emit failed(index_within_job);
+			return;
+		}
+		m_opened_for_saving = true;
+	}
+	QByteArray ba = m_reply->readAll();
+	md5sum.addData(ba);
+	m_output_file.write(ba);
+}
diff --git a/logic/net/CacheDownload.h b/logic/net/CacheDownload.h
new file mode 100644
index 00000000..295391b1
--- /dev/null
+++ b/logic/net/CacheDownload.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Download.h"
+#include "HttpMetaCache.h"
+#include <QFile>
+#include <qcryptographichash.h>
+
+class CacheDownload : public Download
+{
+	Q_OBJECT
+public:
+	MetaEntryPtr m_entry;
+	/// is the saving file already open?
+	bool m_opened_for_saving;
+	/// if saving to file, use the one specified in this string
+	QString m_target_path;
+	/// this is the output file, if any
+	QFile m_output_file;
+	/// the hash-as-you-download
+	QCryptographicHash md5sum;
+public:
+	explicit CacheDownload(QUrl url, MetaEntryPtr entry);
+	
+protected slots:
+	virtual void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+	virtual void downloadError(QNetworkReply::NetworkError error);
+	virtual void downloadFinished();
+	virtual void downloadReadyRead();
+	
+public slots:
+	virtual void start();
+};
+
+typedef std::shared_ptr<CacheDownload> CacheDownloadPtr;
diff --git a/logic/net/Download.h b/logic/net/Download.h
new file mode 100644
index 00000000..ca4bee9f
--- /dev/null
+++ b/logic/net/Download.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <QObject>
+#include <QUrl>
+#include <memory>
+#include <QNetworkReply>
+
+enum JobStatus
+{
+	Job_NotStarted,
+	Job_InProgress,
+	Job_Finished,
+	Job_Failed
+};
+
+class Download : public QObject
+{
+	Q_OBJECT
+protected:
+	explicit Download() : QObject(0) {};
+
+public:
+	virtual ~Download() {};
+
+public:
+	/// the network reply
+	std::shared_ptr<QNetworkReply> m_reply;
+
+	/// source URL
+	QUrl m_url;
+
+	/// The file's status
+	JobStatus m_status;
+
+	/// index within the parent job
+	int index_within_job = 0;
+
+signals:
+	void started(int index);
+	void progress(int index, qint64 current, qint64 total);
+	void succeeded(int index);
+	void failed(int index);
+
+protected slots:
+	virtual void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) = 0;
+	virtual void downloadError(QNetworkReply::NetworkError error) = 0;
+	virtual void downloadFinished() = 0;
+	virtual void downloadReadyRead() = 0;
+
+public slots:
+	virtual void start() = 0;
+};
+
+typedef std::shared_ptr<Download> DownloadPtr;
diff --git a/logic/net/DownloadJob.cpp b/logic/net/DownloadJob.cpp
index cad9ae72..fa3e655e 100644
--- a/logic/net/DownloadJob.cpp
+++ b/logic/net/DownloadJob.cpp
@@ -1,181 +1,135 @@
 #include "DownloadJob.h"
 #include "pathutils.h"
 #include "MultiMC.h"
+#include "FileDownload.h"
+#include "ByteArrayDownload.h"
+#include "CacheDownload.h"
 
-Download::Download (QUrl url, QString target_path, QString expected_md5 )
-	:Job()
-{
-	m_url = url;
-	m_target_path = target_path;
-	m_expected_md5 = expected_md5;
-
-	m_check_md5 = m_expected_md5.size();
-	m_save_to_file = m_target_path.size();
-	m_status = Job_NotStarted;
-	m_opened_for_saving = false;
-}
-
-void Download::start()
-{
-	if ( m_save_to_file )
-	{
-		QString filename = m_target_path;
-		m_output_file.setFileName ( filename );
-		// if there already is a file and md5 checking is in effect and it can be opened
-		if ( m_output_file.exists() && m_output_file.open ( QIODevice::ReadOnly ) )
-		{
-			// check the md5 against the expected one
-			QString hash = QCryptographicHash::hash ( m_output_file.readAll(), QCryptographicHash::Md5 ).toHex().constData();
-			m_output_file.close();
-			// skip this file if they match
-			if ( m_check_md5 && hash == m_expected_md5 )
-			{
-				qDebug() << "Skipping " << m_url.toString() << ": md5 match.";
-				emit succeeded(index_within_job);
-				return;
-			}
-			else
-			{
-				m_expected_md5 = hash;
-			}
-		}
-		if(!ensureFilePathExists(filename))
-		{
-			emit failed(index_within_job);
-			return;
-		}
-	}
-	qDebug() << "Downloading " << m_url.toString();
-	QNetworkRequest request ( m_url );
-	request.setRawHeader(QString("If-None-Match").toLatin1(), m_expected_md5.toLatin1()); 
-	
-	auto worker = MMC->qnam();
-	QNetworkReply * rep = worker->get ( request );
-	
-	m_reply = QSharedPointer<QNetworkReply> ( rep, &QObject::deleteLater );
-	connect ( rep, SIGNAL ( downloadProgress ( qint64,qint64 ) ), SLOT ( downloadProgress ( qint64,qint64 ) ) );
-	connect ( rep, SIGNAL ( finished() ), SLOT ( downloadFinished() ) );
-	connect ( rep, SIGNAL ( error ( QNetworkReply::NetworkError ) ), SLOT ( downloadError ( QNetworkReply::NetworkError ) ) );
-	connect ( rep, SIGNAL ( readyRead() ), SLOT ( downloadReadyRead() ) );
-}
-
-void Download::downloadProgress ( qint64 bytesReceived, qint64 bytesTotal )
-{
-	emit progress (index_within_job, bytesReceived, bytesTotal );
-}
+#include <logger/QsLog.h>
 
-void Download::downloadError ( QNetworkReply::NetworkError error )
+ByteArrayDownloadPtr DownloadJob::addByteArrayDownload(QUrl url)
 {
-	// error happened during download.
-	// TODO: log the reason why
-	m_status = Job_Failed;
+	ByteArrayDownloadPtr ptr(new ByteArrayDownload(url));
+	ptr->index_within_job = downloads.size();
+	downloads.append(ptr);
+	parts_progress.append(part_info());
+	total_progress++;
+	return ptr;
 }
 
-void Download::downloadFinished()
+FileDownloadPtr DownloadJob::addFileDownload(QUrl url, QString rel_target_path)
 {
-	// if the download succeeded
-	if ( m_status != Job_Failed )
-	{
-		// nothing went wrong...
-		m_status = Job_Finished;
-		// save the data to the downloadable if we aren't saving to file
-		if ( !m_save_to_file )
-		{
-			m_data = m_reply->readAll();
-		}
-		else
-		{
-			m_output_file.close();
-		}
-
-		//TODO: check md5 here!
-		m_reply.clear();
-		emit succeeded(index_within_job);
-		return;
-	}
-	// else the download failed
-	else
-	{
-		if ( m_save_to_file )
-		{
-			m_output_file.close();
-			m_output_file.remove();
-		}
-		m_reply.clear();
-		emit failed(index_within_job);
-		return;
-	}
+	FileDownloadPtr ptr(new FileDownload(url, rel_target_path));
+	ptr->index_within_job = downloads.size();
+	downloads.append(ptr);
+	parts_progress.append(part_info());
+	total_progress++;
+	return ptr;
 }
 
-void Download::downloadReadyRead()
+CacheDownloadPtr DownloadJob::addCacheDownload(QUrl url, MetaEntryPtr entry)
 {
-	if( m_save_to_file )
-	{
-		if(!m_opened_for_saving)
-		{
-			if ( !m_output_file.open ( QIODevice::WriteOnly ) )
-			{
-				/*
-				* Can't open the file... the job failed
-				*/
-				m_reply->abort();
-				emit failed(index_within_job);
-				return;
-			}
-			m_opened_for_saving = true;
-		}
-		m_output_file.write ( m_reply->readAll() );
-	}
+	CacheDownloadPtr ptr(new CacheDownload(url, entry));
+	ptr->index_within_job = downloads.size();
+	downloads.append(ptr);
+	parts_progress.append(part_info());
+	total_progress++;
+	return ptr;
 }
 
-DownloadPtr DownloadJob::add ( QUrl url, QString rel_target_path, QString expected_md5 )
+ForgeXzDownloadPtr DownloadJob::addForgeXzDownload(QUrl url, MetaEntryPtr entry)
 {
-	DownloadPtr ptr (new Download(url, rel_target_path, expected_md5));
+	ForgeXzDownloadPtr ptr(new ForgeXzDownload(url, entry));
 	ptr->index_within_job = downloads.size();
 	downloads.append(ptr);
+	parts_progress.append(part_info());
+	total_progress++;
 	return ptr;
 }
 
-void DownloadJob::partSucceeded ( int index )
+void DownloadJob::partSucceeded(int index)
 {
+	// do progress. all slots are 1 in size at least
+	auto &slot = parts_progress[index];
+	partProgress(index, slot.total_progress, slot.total_progress);
+
 	num_succeeded++;
-	if(num_failed + num_succeeded == downloads.size())
+	QLOG_INFO() << m_job_name.toLocal8Bit() << "progress:" << num_succeeded << "/"
+			 << downloads.size();
+	if (num_failed + num_succeeded == downloads.size())
 	{
-		if(num_failed)
+		if (num_failed)
 		{
-			qDebug() << "Download JOB failed: " << this;
+			QLOG_ERROR() << m_job_name.toLocal8Bit() << "failed.";
 			emit failed();
 		}
 		else
 		{
-			qDebug() << "Download JOB succeeded: " << this;
+			QLOG_INFO() << m_job_name.toLocal8Bit() << "succeeded.";
 			emit succeeded();
 		}
 	}
 }
 
-void DownloadJob::partFailed ( int index )
+void DownloadJob::partFailed(int index)
 {
-	num_failed++;
-	if(num_failed + num_succeeded == downloads.size())
+	auto &slot = parts_progress[index];
+	if (slot.failures == 3)
 	{
-		qDebug() << "Download JOB failed: " << this;
-		emit failed();
+		QLOG_ERROR() << "Part" << index << "failed 3 times (" << downloads[index]->m_url << ")";
+		num_failed++;
+		if (num_failed + num_succeeded == downloads.size())
+		{
+			QLOG_ERROR() << m_job_name.toLocal8Bit() << "failed.";
+			emit failed();
+		}
+	}
+	else
+	{
+		QLOG_ERROR() << "Part" << index << "failed, restarting (" << downloads[index]->m_url
+				 << ")";
+		// restart the job
+		slot.failures++;
+		downloads[index]->start();
 	}
 }
 
-void DownloadJob::partProgress ( int index, qint64 bytesReceived, qint64 bytesTotal )
+void DownloadJob::partProgress(int index, qint64 bytesReceived, qint64 bytesTotal)
 {
-	// PROGRESS? DENIED!
-}
+	auto &slot = parts_progress[index];
+
+	current_progress -= slot.current_progress;
+	slot.current_progress = bytesReceived;
+	current_progress += slot.current_progress;
 
+	total_progress -= slot.total_progress;
+	slot.total_progress = bytesTotal;
+	total_progress += slot.total_progress;
+	emit progress(current_progress, total_progress);
+}
 
 void DownloadJob::start()
 {
-	qDebug() << "Download JOB started: " << this;
-	for(auto iter: downloads)
+	QLOG_INFO() << m_job_name.toLocal8Bit() << " started.";
+	for (auto iter : downloads)
 	{
-		connect(iter.data(), SIGNAL(succeeded(int)), SLOT(partSucceeded(int)));
+		connect(iter.get(), SIGNAL(succeeded(int)), SLOT(partSucceeded(int)));
+		connect(iter.get(), SIGNAL(failed(int)), SLOT(partFailed(int)));
+		connect(iter.get(), SIGNAL(progress(int, qint64, qint64)),
+				SLOT(partProgress(int, qint64, qint64)));
 		iter->start();
 	}
 }
+
+QStringList DownloadJob::getFailedFiles()
+{
+	QStringList failed;
+	for (auto download : downloads)
+	{
+		if (download->m_status == Job_Failed)
+		{
+			failed.push_back(download->m_url.toString());
+		}
+	}
+	return failed;
+}
diff --git a/logic/net/DownloadJob.h b/logic/net/DownloadJob.h
index adeef646..91b014ad 100644
--- a/logic/net/DownloadJob.h
+++ b/logic/net/DownloadJob.h
@@ -1,98 +1,31 @@
 #pragma once
 #include <QtNetwork>
+#include "Download.h"
+#include "ByteArrayDownload.h"
+#include "FileDownload.h"
+#include "CacheDownload.h"
+#include "HttpMetaCache.h"
+#include "ForgeXzDownload.h"
+#include "logic/tasks/ProgressProvider.h"
 
 class DownloadJob;
-class Download;
-typedef QSharedPointer<DownloadJob> DownloadJobPtr;
-typedef QSharedPointer<Download> DownloadPtr;
-
-enum JobStatus
-{
-	Job_NotStarted,
-	Job_InProgress,
-	Job_Finished,
-	Job_Failed
-};
-
-class Job : public QObject
-{
-	Q_OBJECT
-protected:
-	explicit Job(): QObject(0){};
-public:
-	virtual ~Job() {};
-
-public slots:
-	virtual void start() = 0;
-};
-
-class Download: public Job
-{
-	friend class DownloadJob;
-	Q_OBJECT
-protected:
-	Download(QUrl url, QString rel_target_path = QString(), QString expected_md5 = QString());
-public:
-	/// the network reply
-	QSharedPointer<QNetworkReply> m_reply;
-	/// source URL
-	QUrl m_url;
-	
-	/// if true, check the md5sum against a provided md5sum
-	/// also, if a file exists, perform an md5sum first and don't download only if they don't match
-	bool m_check_md5;
-	/// the expected md5 checksum
-	QString m_expected_md5;
-	
-	/// save to file?
-	bool m_save_to_file;
-	/// is the saving file already open?
-	bool m_opened_for_saving;
-	/// if saving to file, use the one specified in this string
-	QString m_target_path;
-	/// this is the output file, if any
-	QFile m_output_file;
-	/// if not saving to file, downloaded data is placed here
-	QByteArray m_data;
-	
-	int currentProgress = 0;
-	int totalProgress = 0;
-	
-	/// The file's status
-	JobStatus m_status;
-	
-	int index_within_job = 0;
-signals:
-	void started(int index);
-	void progress(int index, qint64 current, qint64 total);
-	void succeeded(int index);
-	void failed(int index);
-public slots:
-	virtual void start();
-	
-private slots:
-	void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);;
-	void downloadError(QNetworkReply::NetworkError error);
-	void downloadFinished();
-	void downloadReadyRead();
-};
+typedef std::shared_ptr<DownloadJob> DownloadJobPtr;
 
 /**
  * A single file for the downloader/cache to process.
  */
-class DownloadJob : public Job
+class DownloadJob : public ProgressProvider
 {
 	Q_OBJECT
 public:
-	explicit DownloadJob()
-		:Job(){};
-	explicit DownloadJob(QUrl url, QString rel_target_path = QString(), QString expected_md5 = QString())
-		:Job()
-	{
-		add(url, rel_target_path, expected_md5);
-	};
+	explicit DownloadJob(QString job_name)
+		:ProgressProvider(), m_job_name(job_name){};
+	
+	ByteArrayDownloadPtr addByteArrayDownload(QUrl url);
+	FileDownloadPtr      addFileDownload(QUrl url, QString rel_target_path);
+	CacheDownloadPtr     addCacheDownload(QUrl url, MetaEntryPtr entry);
+	ForgeXzDownloadPtr   addForgeXzDownload(QUrl url, MetaEntryPtr entry);
 	
-	DownloadPtr add(QUrl url, QString rel_target_path = QString(), QString expected_md5 = QString());
 	DownloadPtr operator[](int index)
 	{
 		return downloads[index];
@@ -107,6 +40,20 @@ public:
 	{
 		return downloads.size();
 	}
+	virtual void getProgress(qint64& current, qint64& total)
+	{
+		current = current_progress;
+		total = total_progress;
+	};
+	virtual QString getStatus() const
+	{
+		return m_job_name;
+	};
+	virtual bool isRunning() const
+	{
+		return m_running;
+	};
+	QStringList getFailedFiles();
 signals:
 	void started();
 	void progress(qint64 current, qint64 total);
@@ -119,8 +66,19 @@ private slots:
 	void partSucceeded(int index);
 	void partFailed(int index);
 private:
+	struct part_info
+	{
+		qint64 current_progress = 0;
+		qint64 total_progress = 1;
+		int failures = 0;
+	};
+	QString m_job_name;
 	QList<DownloadPtr> downloads;
+	QList<part_info> parts_progress;
+	qint64 current_progress = 0;
+	qint64 total_progress = 0;
 	int num_succeeded = 0;
 	int num_failed = 0;
+	bool m_running = false;
 };
 
diff --git a/logic/net/FileDownload.cpp b/logic/net/FileDownload.cpp
new file mode 100644
index 00000000..3f38b0fa
--- /dev/null
+++ b/logic/net/FileDownload.cpp
@@ -0,0 +1,112 @@
+#include "MultiMC.h"
+#include "FileDownload.h"
+#include <pathutils.h>
+#include <QCryptographicHash>
+#include <logger/QsLog.h>
+
+
+FileDownload::FileDownload ( QUrl url, QString target_path )
+	:Download()
+{
+	m_url = url;
+	m_target_path = target_path;
+	m_check_md5 = false;
+	m_status = Job_NotStarted;
+	m_opened_for_saving = false;
+}
+
+void FileDownload::start()
+{
+	QString filename = m_target_path;
+	m_output_file.setFileName ( filename );
+	// if there already is a file and md5 checking is in effect and it can be opened
+	if ( m_output_file.exists() && m_output_file.open ( QIODevice::ReadOnly ) )
+	{
+		// check the md5 against the expected one
+		QString hash = QCryptographicHash::hash ( m_output_file.readAll(), QCryptographicHash::Md5 ).toHex().constData();
+		m_output_file.close();
+		// skip this file if they match
+		if ( m_check_md5 && hash == m_expected_md5 )
+		{
+			QLOG_INFO() << "Skipping " << m_url.toString() << ": md5 match.";
+			emit succeeded(index_within_job);
+			return;
+		}
+		else
+		{
+			m_expected_md5 = hash;
+		}
+	}
+	if(!ensureFilePathExists(filename))
+	{
+		emit failed(index_within_job);
+		return;
+	}
+	
+	QLOG_INFO() << "Downloading " << m_url.toString();
+	QNetworkRequest request ( m_url );
+	request.setRawHeader(QString("If-None-Match").toLatin1(), m_expected_md5.toLatin1()); 
+	request.setHeader(QNetworkRequest::UserAgentHeader,"MultiMC/5.0 (Uncached)");
+	
+	auto worker = MMC->qnam();
+	QNetworkReply * rep = worker->get ( request );
+	
+	m_reply = std::shared_ptr<QNetworkReply> ( rep );
+	connect ( rep, SIGNAL ( downloadProgress ( qint64,qint64 ) ), SLOT ( downloadProgress ( qint64,qint64 ) ) );
+	connect ( rep, SIGNAL ( finished() ), SLOT ( downloadFinished() ) );
+	connect ( rep, SIGNAL ( error ( QNetworkReply::NetworkError ) ), SLOT ( downloadError ( QNetworkReply::NetworkError ) ) );
+	connect ( rep, SIGNAL ( readyRead() ), SLOT ( downloadReadyRead() ) );
+}
+
+void FileDownload::downloadProgress ( qint64 bytesReceived, qint64 bytesTotal )
+{
+	emit progress (index_within_job, bytesReceived, bytesTotal );
+}
+
+void FileDownload::downloadError ( QNetworkReply::NetworkError error )
+{
+	// error happened during download.
+	// TODO: log the reason why
+	m_status = Job_Failed;
+}
+
+void FileDownload::downloadFinished()
+{
+	// if the download succeeded
+	if ( m_status != Job_Failed )
+	{
+		// nothing went wrong...
+		m_status = Job_Finished;
+		m_output_file.close();
+
+		m_reply.reset();
+		emit succeeded(index_within_job);
+		return;
+	}
+	// else the download failed
+	else
+	{
+		m_output_file.close();
+		m_reply.reset();
+		emit failed(index_within_job);
+		return;
+	}
+}
+
+void FileDownload::downloadReadyRead()
+{
+	if(!m_opened_for_saving)
+	{
+		if ( !m_output_file.open ( QIODevice::WriteOnly ) )
+		{
+			/*
+			* Can't open the file... the job failed
+			*/
+			m_reply->abort();
+			emit failed(index_within_job);
+			return;
+		}
+		m_opened_for_saving = true;
+	}
+	m_output_file.write ( m_reply->readAll() );
+}
diff --git a/logic/net/FileDownload.h b/logic/net/FileDownload.h
new file mode 100644
index 00000000..9abb590d
--- /dev/null
+++ b/logic/net/FileDownload.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "Download.h"
+#include <QFile>
+
+class FileDownload : public Download
+{
+	Q_OBJECT
+public:
+	/// if true, check the md5sum against a provided md5sum
+	/// also, if a file exists, perform an md5sum first and don't download only if they don't match
+	bool m_check_md5;
+	/// the expected md5 checksum
+	QString m_expected_md5;
+	/// is the saving file already open?
+	bool m_opened_for_saving;
+	/// if saving to file, use the one specified in this string
+	QString m_target_path;
+	/// this is the output file, if any
+	QFile m_output_file;
+	
+public:
+	explicit FileDownload(QUrl url, QString target_path);
+	
+protected slots:
+	virtual void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+	virtual void downloadError(QNetworkReply::NetworkError error);
+	virtual void downloadFinished();
+	virtual void downloadReadyRead();
+	
+public slots:
+	virtual void start();
+};
+
+typedef std::shared_ptr<FileDownload> FileDownloadPtr;
diff --git a/logic/net/ForgeXzDownload.cpp b/logic/net/ForgeXzDownload.cpp
new file mode 100644
index 00000000..0e5287d8
--- /dev/null
+++ b/logic/net/ForgeXzDownload.cpp
@@ -0,0 +1,279 @@
+#include "MultiMC.h"
+#include "ForgeXzDownload.h"
+#include <pathutils.h>
+
+#include <QCryptographicHash>
+#include <QFileInfo>
+#include <QDateTime>
+#include <logger/QsLog.h>
+
+ForgeXzDownload::ForgeXzDownload(QUrl url, MetaEntryPtr entry)
+	: Download()
+{
+	QString urlstr = url.toString();
+	urlstr.append(".pack.xz");
+	m_url = QUrl(urlstr);
+	m_entry = entry;
+	m_target_path = entry->getFullPath();
+	m_status = Job_NotStarted;
+	m_opened_for_saving = false;
+}
+
+void ForgeXzDownload::start()
+{
+	if (!m_entry->stale)
+	{
+		emit succeeded(index_within_job);
+		return;
+	}
+	// can we actually create the real, final file?
+	if (!ensureFilePathExists(m_target_path))
+	{
+		emit failed(index_within_job);
+		return;
+	}
+	QLOG_INFO() << "Downloading " << m_url.toString();
+	QNetworkRequest request(m_url);
+	request.setRawHeader(QString("If-None-Match").toLatin1(), m_entry->etag.toLatin1());
+	request.setHeader(QNetworkRequest::UserAgentHeader,"MultiMC/5.0 (Cached)");
+
+	auto worker = MMC->qnam();
+	QNetworkReply *rep = worker->get(request);
+
+	m_reply = std::shared_ptr<QNetworkReply>(rep);
+	connect(rep, SIGNAL(downloadProgress(qint64, qint64)),
+			SLOT(downloadProgress(qint64, qint64)));
+	connect(rep, SIGNAL(finished()), SLOT(downloadFinished()));
+	connect(rep, SIGNAL(error(QNetworkReply::NetworkError)),
+			SLOT(downloadError(QNetworkReply::NetworkError)));
+	connect(rep, SIGNAL(readyRead()), SLOT(downloadReadyRead()));
+}
+
+void ForgeXzDownload::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
+{
+	emit progress(index_within_job, bytesReceived, bytesTotal);
+}
+
+void ForgeXzDownload::downloadError(QNetworkReply::NetworkError error)
+{
+	// error happened during download.
+	// TODO: log the reason why
+	m_status = Job_Failed;
+}
+
+void ForgeXzDownload::downloadFinished()
+{
+	// if the download succeeded
+	if (m_status != Job_Failed)
+	{
+		// nothing went wrong...
+		m_status = Job_Finished;
+		if (m_opened_for_saving)
+		{
+			// we actually downloaded something! process and isntall it
+			decompressAndInstall();
+			return;
+		}
+		else
+		{
+			// something bad happened
+			m_pack200_xz_file.remove();
+			m_reply.reset();
+			emit failed(index_within_job);
+			return;
+		}
+	}
+	// else the download failed
+	else
+	{
+		m_pack200_xz_file.close();
+		m_pack200_xz_file.remove();
+		m_reply.reset();
+		emit failed(index_within_job);
+		return;
+	}
+}
+
+void ForgeXzDownload::downloadReadyRead()
+{
+	
+	if (!m_opened_for_saving)
+	{
+		if (!m_pack200_xz_file.open())
+		{
+			/*