1 files changed, 273 insertions, 0 deletions
diff --git a/api/logic/net/HttpMetaCache.cpp b/api/logic/net/HttpMetaCache.cpp
new file mode 100644
index 00000000..ea3e2834
--- /dev/null
+++ b/api/logic/net/HttpMetaCache.cpp
@@ -0,0 +1,273 @@
+/* Copyright 2013-2015 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Env.h"
+#include "HttpMetaCache.h"
+#include "FileSystem.h"
+
+#include <QFileInfo>
+#include <QFile>
+#include <QDateTime>
+#include <QCryptographicHash>
+
+#include <QDebug>
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QJsonObject>
+
+QString MetaEntry::getFullPath()
+{
+	// FIXME: make local?
+	return FS::PathCombine(basePath, relativePath);
+}
+
+HttpMetaCache::HttpMetaCache(QString path) : QObject()
+{
+	m_index_file = path;
+	saveBatchingTimer.setSingleShot(true);
+	saveBatchingTimer.setTimerType(Qt::VeryCoarseTimer);
+	connect(&saveBatchingTimer, SIGNAL(timeout()), SLOT(SaveNow()));
+}
+
+HttpMetaCache::~HttpMetaCache()
+{
+	saveBatchingTimer.stop();
+	SaveNow();
+}
+
+MetaEntryPtr HttpMetaCache::getEntry(QString base, QString resource_path)
+{
+	// no base. no base path. can't store
+	if (!m_entries.contains(base))
+	{
+		// TODO: log problem
+		return MetaEntryPtr();
+	}
+	EntryMap &map = m_entries[base];
+	if (map.entry_list.contains(resource_path))
+	{
+		return map.entry_list[resource_path];
+	}
+	return MetaEntryPtr();
+}
+
+MetaEntryPtr HttpMetaCache::resolveEntry(QString base, QString resource_path, QString expected_etag)
+{
+	auto entry = getEntry(base, resource_path);
+	// it's not present? generate a default stale entry
+	if (!entry)
+	{
+		return staleEntry(base, resource_path);
+	}
+
+	auto &selected_base = m_entries[base];
+	QString real_path = FS::PathCombine(selected_base.base_path, resource_path);
+	QFileInfo finfo(real_path);
+
+	// is the file really there? if not -> stale
+	if (!finfo.isFile() || !finfo.isReadable())
+	{
+		// if the file doesn't exist, we disown the entry
+		selected_base.entry_list.remove(resource_path);
+		return staleEntry(base, resource_path);
+	}
+
+	if (!expected_etag.isEmpty() && expected_etag != entry->etag)
+	{
+		// if the etag doesn't match expected, we disown the entry
+		selected_base.entry_list.remove(resource_path);
+		return staleEntry(base, resource_path);
+	}
+
+	// if the file changed, check md5sum
+	qint64 file_last_changed = finfo.lastModified().toUTC().toMSecsSinceEpoch();
+	if (file_last_changed != entry->local_changed_timestamp)
+	{
+		QFile input(real_path);
+		input.open(QIODevice::ReadOnly);
+		QString md5sum = QCryptographicHash::hash(input.readAll(), QCryptographicHash::Md5)
+							 .toHex()
+							 .constData();
+		if (entry->md5sum != md5sum)
+		{
+			selected_base.entry_list.remove(resource_path);
+			return staleEntry(base, resource_path);
+		}
+		// md5sums matched... keep entry and save the new state to file
+		entry->local_changed_timestamp = file_last_changed;
+		SaveEventually();
+	}
+
+	// entry passed all the checks we cared about.
+	entry->basePath = getBasePath(base);
+	return entry;
+}
+
+bool HttpMetaCache::updateEntry(MetaEntryPtr stale_entry)
+{
+	if (!m_entries.contains(stale_entry->baseId))
+	{
+		qCritical() << "Cannot add entry with unknown base: "
+					 << stale_entry->baseId.toLocal8Bit();
+		return false;
+	}
+	if (stale_entry->stale)
+	{
+		qCritical() << "Cannot add stale entry: " << stale_entry->getFullPath().toLocal8Bit();
+		return false;
+	}
+	m_entries[stale_entry->baseId].entry_list[stale_entry->relativePath] = stale_entry;
+	SaveEventually();
+	return true;
+}
+
+bool HttpMetaCache::evictEntry(MetaEntryPtr entry)
+{
+	if(entry)
+	{
+		entry->stale = true;
+		SaveEventually();
+		return true;
+	}
+	return false;
+}
+
+MetaEntryPtr HttpMetaCache::staleEntry(QString base, QString resource_path)
+{
+	auto foo = new MetaEntry();
+	foo->baseId = base;
+	foo->basePath = getBasePath(base);
+	foo->relativePath = resource_path;
+	foo->stale = true;
+	return MetaEntryPtr(foo);
+}
+
+void HttpMetaCache::addBase(QString base, QString base_root)
+{
+	// TODO: report error
+	if (m_entries.contains(base))
+		return;
+	// TODO: check if the base path is valid
+	EntryMap foo;
+	foo.base_path = base_root;
+	m_entries[base] = foo;
+}
+
+QString HttpMetaCache::getBasePath(QString base)
+{
+	if (m_entries.contains(base))
+	{
+		return m_entries[base].base_path;
+	}
+	return QString();
+}
+
+void HttpMetaCache::Load()
+{
+	if(m_index_file.isNull())
+		return;
+
+	QFile index(m_index_file);
+	if (!index.open(QIODevice::ReadOnly))
+		return;
+
+	QJsonDocument json = QJsonDocument::fromJson(index.readAll());
+	if (!json.isObject())
+		return;
+	auto root = json.object();
+	// check file version first
+	auto version_val = root.value("version");
+	if (!version_val.isString())
+		return;
+	if (version_val.toString() != "1")
+		return;
+
+	// read the entry array
+	auto entries_val = root.value("entries");
+	if (!entries_val.isArray())
+		return;
+	QJsonArray array = entries_val.toArray();
+	for (auto element : array)
+	{
+		if (!element.isObject())
+			return;
+		auto element_obj = element.toObject();
+		QString base = element_obj.value("base").toString();
+		if (!m_entries.contains(base))
+			continue;
+		auto &entrymap = m_entries[base];
+		auto foo = new MetaEntry();
+		foo->baseId = base;
+		QString path = foo->relativePath = element_obj.value("path").toString();
+		foo->md5sum = element_obj.value("md5sum").toString();
+		foo->etag = element_obj.value("etag").toString();
+		foo->local_changed_timestamp = element_obj.value("last_changed_timestamp").toDouble();
+		foo->remote_changed_timestamp =
+			element_obj.value("remote_changed_timestamp").toString();
+		// presumed innocent until closer examination
+		foo->stale = false;
+		entrymap.entry_list[path] = MetaEntryPtr(foo);
+	}
+}
+
+void HttpMetaCache::SaveEventually()
+{
+	// reset the save timer
+	saveBatchingTimer.stop();
+	saveBatchingTimer.start(30000);
+}
+
+void HttpMetaCache::SaveNow()
+{
+	if(m_index_file.isNull())
+		return;
+	QJsonObject toplevel;
+	toplevel.insert("version", QJsonValue(QString("1")));
+	QJsonArray entriesArr;
+	for (auto group : m_entries)
+	{
+		for (auto entry : group.entry_list)
+		{
+			// do not save stale entries. they are dead.
+			if(entry->stale)
+			{
+				continue;
+			}
+			QJsonObject entryObj;
+			entryObj.insert("base", QJsonValue(entry->baseId));
+			entryObj.insert("path", QJsonValue(entry->relativePath));
+			entryObj.insert("md5sum", QJsonValue(entry->md5sum));
+			entryObj.insert("etag", QJsonValue(entry->etag));
+			entryObj.insert("last_changed_timestamp",
+							QJsonValue(double(entry->local_changed_timestamp)));
+			if (!entry->remote_changed_timestamp.isEmpty())
+				entryObj.insert("remote_changed_timestamp",
+								QJsonValue(entry->remote_changed_timestamp));
+			entriesArr.append(entryObj);
+		}
+	}
+	toplevel.insert("entries", entriesArr);
+
+	QJsonDocument doc(toplevel);
+	try
+	{
+		FS::write(m_index_file, doc.toJson());
+	}
+	catch (Exception & e)
+	{
+		qWarning() << e.what();
+	}
+}