Move all the things (YES. Move them.)

Also, implemented some basic modlist logic, to be wired up.

5 files changed, 401 insertions, 0 deletions

diff --git a/logic/net/DownloadJob.cpp b/logic/net/DownloadJob.cpp
new file mode 100644
index 00000000..ef842dfd
--- /dev/null
+++ b/logic/net/DownloadJob.cpp
@@ -0,0 +1,138 @@
+#include "DownloadJob.h"
+#include "pathutils.h"
+#include "NetWorker.h"
+
+DownloadJob::DownloadJob (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;
+}
+
+JobPtr DownloadJob::create (QUrl url,
+							QString target_path,
+							QString expected_md5 )
+{
+	return JobPtr ( new DownloadJob ( url, target_path, expected_md5 ) );
+}
+
+void DownloadJob::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 finish();
+				return;
+			}
+			else
+			{
+				m_expected_md5 = hash;
+			}
+		}
+		if(!ensurePathExists(filename))
+		{
+			emit fail();
+			return;
+		}
+	}
+	qDebug() << "Downloading " << m_url.toString();
+	QNetworkRequest request ( m_url );
+	request.setRawHeader(QString("If-None-Match").toLatin1(), m_expected_md5.toLatin1()); 
+	
+	auto &worker = NetWorker::spawn();
+	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 DownloadJob::downloadProgress ( qint64 bytesReceived, qint64 bytesTotal )
+{
+	emit progress ( bytesReceived, bytesTotal );
+}
+
+void DownloadJob::downloadError ( QNetworkReply::NetworkError error )
+{
+	// error happened during download.
+	// TODO: log the reason why
+	m_status = Job_Failed;
+}
+
+void DownloadJob::downloadFinished()
+{
+	// 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 finish();
+		return;
+	}
+	// else the download failed
+	else
+	{
+		if ( m_save_to_file )
+		{
+			m_output_file.close();
+			m_output_file.remove();
+		}
+		m_reply.clear();
+		emit fail();
+		return;
+	}
+}
+
+void DownloadJob::downloadReadyRead()
+{
+	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 fail();
+				return;
+			}
+			m_opened_for_saving = true;
+		}
+		m_output_file.write ( m_reply->readAll() );
+	}
+}
diff --git a/logic/net/DownloadJob.h b/logic/net/DownloadJob.h
new file mode 100644
index 00000000..cbde3852
--- /dev/null
+++ b/logic/net/DownloadJob.h
@@ -0,0 +1,51 @@
+#pragma once
+#include "JobQueue.h"
+#include <QtNetwork>
+
+/**
+ * A single file for the downloader/cache to process.
+ */
+class LIBUTIL_EXPORT DownloadJob : public Job
+{
+	Q_OBJECT
+public:
+	DownloadJob(QUrl url,
+				QString rel_target_path = QString(),
+				QString expected_md5 = QString()
+			   );
+	static JobPtr create(QUrl url, QString rel_target_path = QString(), QString expected_md5 = QString());
+public slots:
+	virtual void start();
+	
+private slots:
+	void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);;
+	void downloadError(QNetworkReply::NetworkError error);
+	void downloadFinished();
+	void downloadReadyRead();
+	
+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;
+	
+	/// The file's status
+	JobStatus m_status;
+};
diff --git a/logic/net/JobQueue.h b/logic/net/JobQueue.h
new file mode 100644
index 00000000..26f49307
--- /dev/null
+++ b/logic/net/JobQueue.h
@@ -0,0 +1,180 @@
+#pragma once
+#include <QtCore>
+#include "libutil_config.h"
+
+enum JobStatus
+{
+	Job_NotStarted,
+	Job_InProgress,
+	Job_Finished,
+	Job_Failed
+};
+
+class JobList;
+
+class LIBUTIL_EXPORT Job : public QObject
+{
+	Q_OBJECT
+protected:
+	explicit Job(): QObject(0){};
+public:
+	virtual ~Job() {};
+signals:
+	void finish();
+	void fail();
+	void progress(qint64 current, qint64 total);
+public slots:
+	virtual void start() = 0;
+};
+typedef QSharedPointer<Job> JobPtr;
+
+/**
+ * A list of jobs, to be processed one by one.
+ */
+class LIBUTIL_EXPORT JobList : public QObject
+{
+	friend class JobListQueue;
+	Q_OBJECT
+public:
+
+	JobList() : QObject(0)
+	{
+		m_status = Job_NotStarted;
+		current_job_idx = 0;
+	}
+	JobStatus getStatus()
+	{
+		return m_status;
+	}
+	void add(JobPtr dlable)
+	{
+		if(m_status == Job_NotStarted)
+			m_jobs.append(dlable);
+		//else there's a bug. TODO: catch the bugs
+	}
+	JobPtr getFirstJob()
+	{
+		if(m_jobs.size())
+			return m_jobs[0];
+		else
+			return JobPtr();
+	}
+	void start()
+	{
+		current_job_idx = 0;
+		auto job = m_jobs[current_job_idx];
+		
+		connect(job.data(), SIGNAL(progress(qint64,qint64)), SLOT(currentJobProgress(qint64,qint64)));
+		connect(job.data(), SIGNAL(finish()), SLOT(currentJobFinished()));
+		connect(job.data(), SIGNAL(fail()), SLOT(currentJobFailed()));
+		job->start();
+		emit started();
+	}
+private slots:
+	void currentJobFinished()
+	{
+		if(current_job_idx == m_jobs.size() - 1)
+		{
+			m_status = Job_Finished;
+			emit finished();
+		}
+		else
+		{
+			current_job_idx++;
+			auto job = m_jobs[current_job_idx];
+			connect(job.data(), SIGNAL(progress(qint64,qint64)), SLOT(currentJobProgress(qint64,qint64)));
+			connect(job.data(), SIGNAL(finish()), SLOT(currentJobFinished()));
+			connect(job.data(), SIGNAL(fail()), SLOT(currentJobFailed()));
+			job->start();
+		}
+	}
+	void currentJobFailed()
+	{
+		m_status = Job_Failed;
+		emit failed();
+	}
+	void currentJobProgress(qint64 current, qint64 total)
+	{
+		if(!total)
+			return;
+		
+		int total_jobs = m_jobs.size();
+		
+		if(!total_jobs)
+			return;
+		
+		float job_chunk = 1000.0 / float(total_jobs);
+		float cur = current;
+		float tot = total;
+		float last_chunk = (cur / tot) * job_chunk;
+		
+		float list_total = job_chunk * current_job_idx + last_chunk;
+		emit progress(qint64(list_total), 1000LL);
+	}
+private:
+	QVector<JobPtr> m_jobs;
+	/// The overall status of this job list
+	JobStatus m_status;
+	int current_job_idx;
+signals:
+	void progress(qint64 current, qint64 total);
+	void started();
+	void finished();
+	void failed();
+};
+typedef QSharedPointer<JobList> JobListPtr;
+
+
+/**
+ * A queue of job lists! The job lists fail or finish as units.
+ */
+class LIBUTIL_EXPORT JobListQueue : public QObject
+{
+	Q_OBJECT
+public:
+	JobListQueue(QObject *p = 0):
+		QObject(p),
+		currentIndex(0),
+		is_running(false){}
+	
+	void enqueue(JobListPtr job)
+	{
+		jobs.enqueue(job);
+		
+		// finish or fail, we should catch that and start the next one
+		connect(job.data(),SIGNAL(finished()), SLOT(startNextJob()));
+		connect(job.data(),SIGNAL(failed()), SLOT(startNextJob()));
+		
+		if(!is_running)
+		{
+			QTimer::singleShot(0, this, SLOT(startNextJob()));
+		}
+	}
+	
+private slots:
+	void startNextJob()
+	{
+		if (jobs.isEmpty())
+		{
+			currentJobList.clear();
+			currentIndex = 0;
+			is_running = false;
+			emit finishedAllJobs();
+			return;
+		}
+		
+		currentJobList = jobs.dequeue();
+		is_running = true;
+		currentIndex = 0;
+		currentJobList->start();
+	}
+	
+signals:
+	void finishedAllJobs();
+	
+private:
+	JobListPtr currentJobList;
+	QQueue<JobListPtr> jobs;
+	unsigned currentIndex;
+	bool is_running;
+};
diff --git a/logic/net/NetWorker.cpp b/logic/net/NetWorker.cpp
new file mode 100644
index 00000000..1eef13d9
--- /dev/null
+++ b/logic/net/NetWorker.cpp
@@ -0,0 +1,12 @@
+#include "NetWorker.h"
+#include <QThreadStorage>
+
+NetWorker& NetWorker::spawn()
+{
+	static QThreadStorage<NetWorker *> storage;
+	if (!storage.hasLocalData())
+	{
+		storage.setLocalData(new NetWorker());
+	}
+	return *storage.localData();
+}
diff --git a/logic/net/NetWorker.h b/logic/net/NetWorker.h
new file mode 100644
index 00000000..98374e3b
--- /dev/null
+++ b/logic/net/NetWorker.h
@@ -0,0 +1,20 @@
+/*
+        _.ooo-._
+      .OOOP   _ '. 
+     dOOOO   (_)  \
+    OOOOOb         |
+    OOOOOOb.       |
+    OOOOOOOOb      |
+     YOO(_)OOO    /
+      'OOOOOY  _.'
+        '""""''
+*/
+
+#pragma once
+#include <QNetworkAccessManager>
+class NetWorker : public QNetworkAccessManager
+{
+	Q_OBJECT
+public:
+	static NetWorker &spawn();
+};
\ No newline at end of file