path: root/api/logic/net/HttpMetaCache.cpp

/* Copyright 2013-2018 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 (const Exception &e)
	{
		qWarning() << e.what();
	}
}