mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-06-21 08:49:13 +02:00
772 lines
26 KiB
C++
772 lines
26 KiB
C++
//
|
|
// AssetClient.cpp
|
|
// libraries/networking/src
|
|
//
|
|
// Created by Ryan Huffman on 2015/07/21
|
|
// Copyright 2015 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include "AssetClient.h"
|
|
|
|
#include <cstdint>
|
|
|
|
#include <QtCore/QBuffer>
|
|
#include <QtCore/QStandardPaths>
|
|
#include <QtCore/QThread>
|
|
#include <QtScript/QScriptEngine>
|
|
#include <QtNetwork/QNetworkDiskCache>
|
|
|
|
#include "AssetRequest.h"
|
|
#include "AssetUpload.h"
|
|
#include "AssetUtils.h"
|
|
#include "MappingRequest.h"
|
|
#include "NetworkAccessManager.h"
|
|
#include "NetworkLogging.h"
|
|
#include "NodeList.h"
|
|
#include "PacketReceiver.h"
|
|
#include "ResourceCache.h"
|
|
|
|
MessageID AssetClient::_currentID = 0;
|
|
|
|
AssetClient::AssetClient() {
|
|
setCustomDeleter([](Dependency* dependency){
|
|
static_cast<AssetClient*>(dependency)->deleteLater();
|
|
});
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
auto& packetReceiver = nodeList->getPacketReceiver();
|
|
|
|
packetReceiver.registerListener(PacketType::AssetMappingOperationReply, this, "handleAssetMappingOperationReply");
|
|
packetReceiver.registerListener(PacketType::AssetGetInfoReply, this, "handleAssetGetInfoReply");
|
|
packetReceiver.registerListener(PacketType::AssetGetReply, this, "handleAssetGetReply", true);
|
|
packetReceiver.registerListener(PacketType::AssetUploadReply, this, "handleAssetUploadReply");
|
|
|
|
connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &AssetClient::handleNodeKilled);
|
|
connect(nodeList.data(), &LimitedNodeList::clientConnectionToNodeReset,
|
|
this, &AssetClient::handleNodeClientConnectionReset);
|
|
}
|
|
|
|
void AssetClient::init() {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
// Setup disk cache if not already
|
|
auto& networkAccessManager = NetworkAccessManager::getInstance();
|
|
if (!networkAccessManager.cache()) {
|
|
QString cachePath = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
|
|
cachePath = !cachePath.isEmpty() ? cachePath : "interfaceCache";
|
|
|
|
QNetworkDiskCache* cache = new QNetworkDiskCache();
|
|
cache->setMaximumCacheSize(MAXIMUM_CACHE_SIZE);
|
|
cache->setCacheDirectory(cachePath);
|
|
networkAccessManager.setCache(cache);
|
|
qInfo() << "ResourceManager disk cache setup at" << cachePath
|
|
<< "(size:" << MAXIMUM_CACHE_SIZE / BYTES_PER_GIGABYTES << "GB)";
|
|
}
|
|
}
|
|
|
|
void AssetClient::cacheInfoRequest(QObject* reciever, QString slot) {
|
|
if (QThread::currentThread() != thread()) {
|
|
QMetaObject::invokeMethod(this, "cacheInfoRequest", Qt::QueuedConnection,
|
|
Q_ARG(QObject*, reciever), Q_ARG(QString, slot));
|
|
return;
|
|
}
|
|
|
|
|
|
if (auto* cache = qobject_cast<QNetworkDiskCache*>(NetworkAccessManager::getInstance().cache())) {
|
|
QMetaObject::invokeMethod(reciever, slot.toStdString().data(), Qt::QueuedConnection,
|
|
Q_ARG(QString, cache->cacheDirectory()),
|
|
Q_ARG(qint64, cache->cacheSize()),
|
|
Q_ARG(qint64, cache->maximumCacheSize()));
|
|
} else {
|
|
qCWarning(asset_client) << "No disk cache to get info from.";
|
|
}
|
|
}
|
|
|
|
void AssetClient::clearCache() {
|
|
if (QThread::currentThread() != thread()) {
|
|
QMetaObject::invokeMethod(this, "clearCache", Qt::QueuedConnection);
|
|
return;
|
|
}
|
|
|
|
if (auto cache = NetworkAccessManager::getInstance().cache()) {
|
|
qInfo() << "AssetClient::clearCache(): Clearing disk cache.";
|
|
cache->clear();
|
|
} else {
|
|
qCWarning(asset_client) << "No disk cache to clear.";
|
|
}
|
|
}
|
|
|
|
void AssetClient::handleAssetMappingOperationReply(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
MessageID messageID;
|
|
message->readPrimitive(&messageID);
|
|
|
|
AssetServerError error;
|
|
message->readPrimitive(&error);
|
|
|
|
// Check if we have any pending requests for this node
|
|
auto messageMapIt = _pendingMappingRequests.find(senderNode);
|
|
if (messageMapIt != _pendingMappingRequests.end()) {
|
|
|
|
// Found the node, get the MessageID -> Callback map
|
|
auto& messageCallbackMap = messageMapIt->second;
|
|
|
|
// Check if we have this pending request
|
|
auto requestIt = messageCallbackMap.find(messageID);
|
|
if (requestIt != messageCallbackMap.end()) {
|
|
auto callback = requestIt->second;
|
|
callback(true, error, message);
|
|
messageCallbackMap.erase(requestIt);
|
|
}
|
|
|
|
// Although the messageCallbackMap may now be empty, we won't delete the node until we have disconnected from
|
|
// it to avoid constantly creating/deleting the map on subsequent requests.
|
|
}
|
|
}
|
|
|
|
bool haveAssetServer() {
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (!assetServer) {
|
|
qCWarning(asset_client) << "Could not complete AssetClient operation "
|
|
<< "since you are not currently connected to an asset-server.";
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
GetMappingRequest* AssetClient::createGetMappingRequest(const AssetPath& path) {
|
|
auto request = new GetMappingRequest(path);
|
|
|
|
request->moveToThread(thread());
|
|
|
|
return request;
|
|
}
|
|
|
|
GetAllMappingsRequest* AssetClient::createGetAllMappingsRequest() {
|
|
auto request = new GetAllMappingsRequest();
|
|
|
|
request->moveToThread(thread());
|
|
|
|
return request;
|
|
}
|
|
|
|
DeleteMappingsRequest* AssetClient::createDeleteMappingsRequest(const AssetPathList& paths) {
|
|
auto request = new DeleteMappingsRequest(paths);
|
|
|
|
request->moveToThread(thread());
|
|
|
|
return request;
|
|
}
|
|
|
|
SetMappingRequest* AssetClient::createSetMappingRequest(const AssetPath& path, const AssetHash& hash) {
|
|
auto request = new SetMappingRequest(path, hash);
|
|
|
|
request->moveToThread(thread());
|
|
|
|
return request;
|
|
}
|
|
|
|
RenameMappingRequest* AssetClient::createRenameMappingRequest(const AssetPath& oldPath, const AssetPath& newPath) {
|
|
auto request = new RenameMappingRequest(oldPath, newPath);
|
|
|
|
request->moveToThread(thread());
|
|
|
|
return request;
|
|
}
|
|
|
|
AssetRequest* AssetClient::createRequest(const AssetHash& hash, const ByteRange& byteRange) {
|
|
auto request = new AssetRequest(hash, byteRange);
|
|
|
|
// Move to the AssetClient thread in case we are not currently on that thread (which will usually be the case)
|
|
request->moveToThread(thread());
|
|
|
|
return request;
|
|
}
|
|
|
|
AssetUpload* AssetClient::createUpload(const QString& filename) {
|
|
auto upload = new AssetUpload(filename);
|
|
|
|
upload->moveToThread(thread());
|
|
|
|
return upload;
|
|
}
|
|
|
|
AssetUpload* AssetClient::createUpload(const QByteArray& data) {
|
|
auto upload = new AssetUpload(data);
|
|
|
|
upload->moveToThread(thread());
|
|
|
|
return upload;
|
|
}
|
|
|
|
MessageID AssetClient::getAsset(const QString& hash, DataOffset start, DataOffset end,
|
|
ReceivedAssetCallback callback, ProgressCallback progressCallback) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
if (hash.length() != SHA256_HASH_HEX_LENGTH) {
|
|
qCWarning(asset_client) << "Invalid hash size";
|
|
return false;
|
|
}
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
|
|
auto messageID = ++_currentID;
|
|
|
|
auto payloadSize = sizeof(messageID) + SHA256_HASH_LENGTH + sizeof(start) + sizeof(end);
|
|
auto packet = NLPacket::create(PacketType::AssetGet, payloadSize, true);
|
|
|
|
qCDebug(asset_client) << "Requesting data from" << start << "to" << end << "of" << hash << "from asset-server.";
|
|
|
|
packet->writePrimitive(messageID);
|
|
|
|
packet->write(QByteArray::fromHex(hash.toLatin1()));
|
|
|
|
packet->writePrimitive(start);
|
|
packet->writePrimitive(end);
|
|
|
|
if (nodeList->sendPacket(std::move(packet), *assetServer) != -1) {
|
|
_pendingRequests[assetServer][messageID] = { QSharedPointer<ReceivedMessage>(), callback, progressCallback };
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QByteArray());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
MessageID AssetClient::getAssetInfo(const QString& hash, GetInfoCallback callback) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto messageID = ++_currentID;
|
|
|
|
auto payloadSize = sizeof(messageID) + SHA256_HASH_LENGTH;
|
|
auto packet = NLPacket::create(PacketType::AssetGetInfo, payloadSize, true);
|
|
|
|
packet->writePrimitive(messageID);
|
|
packet->write(QByteArray::fromHex(hash.toLatin1()));
|
|
|
|
if (nodeList->sendPacket(std::move(packet), *assetServer) != -1) {
|
|
_pendingInfoRequests[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, { "", 0 });
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
void AssetClient::handleAssetGetInfoReply(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
MessageID messageID;
|
|
message->readPrimitive(&messageID);
|
|
auto assetHash = message->read(SHA256_HASH_LENGTH);
|
|
|
|
AssetServerError error;
|
|
message->readPrimitive(&error);
|
|
|
|
AssetInfo info { assetHash.toHex(), 0 };
|
|
|
|
if (error == AssetServerError::NoError) {
|
|
message->readPrimitive(&info.size);
|
|
}
|
|
|
|
// Check if we have any pending requests for this node
|
|
auto messageMapIt = _pendingInfoRequests.find(senderNode);
|
|
if (messageMapIt != _pendingInfoRequests.end()) {
|
|
|
|
// Found the node, get the MessageID -> Callback map
|
|
auto& messageCallbackMap = messageMapIt->second;
|
|
|
|
// Check if we have this pending request
|
|
auto requestIt = messageCallbackMap.find(messageID);
|
|
if (requestIt != messageCallbackMap.end()) {
|
|
auto callback = requestIt->second;
|
|
callback(true, error, info);
|
|
messageCallbackMap.erase(requestIt);
|
|
}
|
|
|
|
// Although the messageCallbackMap may now be empty, we won't delete the node until we have disconnected from
|
|
// it to avoid constantly creating/deleting the map on subsequent requests.
|
|
}
|
|
}
|
|
|
|
void AssetClient::handleAssetGetReply(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
auto assetHash = message->readHead(SHA256_HASH_LENGTH);
|
|
qCDebug(asset_client) << "Got reply for asset: " << assetHash.toHex();
|
|
|
|
MessageID messageID;
|
|
message->readHeadPrimitive(&messageID);
|
|
|
|
AssetServerError error;
|
|
message->readHeadPrimitive(&error);
|
|
|
|
DataOffset length = 0;
|
|
if (!error) {
|
|
message->readHeadPrimitive(&length);
|
|
} else {
|
|
qCWarning(asset_client) << "Failure getting asset: " << error;
|
|
}
|
|
|
|
// Check if we have any pending requests for this node
|
|
auto messageMapIt = _pendingRequests.find(senderNode);
|
|
if (messageMapIt == _pendingRequests.end()) {
|
|
return;
|
|
}
|
|
|
|
// Found the node, get the MessageID -> Callback map
|
|
auto& messageCallbackMap = messageMapIt->second;
|
|
|
|
// Check if we have this pending request
|
|
auto requestIt = messageCallbackMap.find(messageID);
|
|
if (requestIt == messageCallbackMap.end()) {
|
|
// Although the messageCallbackMap may now be empty, we won't delete the node until we have disconnected from
|
|
// it to avoid constantly creating/deleting the map on subsequent requests.
|
|
return;
|
|
}
|
|
|
|
auto& callbacks = requestIt->second;
|
|
|
|
// Store message in case we need to disconnect from it later.
|
|
callbacks.message = message;
|
|
|
|
if (message->isComplete()) {
|
|
callbacks.completeCallback(true, error, message->readAll());
|
|
messageCallbackMap.erase(requestIt);
|
|
} else {
|
|
auto weakNode = senderNode.toWeakRef();
|
|
|
|
connect(message.data(), &ReceivedMessage::progress, this, [this, weakNode, messageID, length](qint64 size) {
|
|
handleProgressCallback(weakNode, messageID, size, length);
|
|
});
|
|
connect(message.data(), &ReceivedMessage::completed, this, [this, weakNode, messageID]() {
|
|
handleCompleteCallback(weakNode, messageID);
|
|
});
|
|
}
|
|
}
|
|
|
|
void AssetClient::handleProgressCallback(const QWeakPointer<Node>& node, MessageID messageID,
|
|
qint64 size, DataOffset length) {
|
|
auto senderNode = node.toStrongRef();
|
|
|
|
if (!senderNode) {
|
|
return;
|
|
}
|
|
|
|
// Check if we have any pending requests for this node
|
|
auto messageMapIt = _pendingRequests.find(senderNode);
|
|
if (messageMapIt == _pendingRequests.end()) {
|
|
return;
|
|
}
|
|
|
|
// Found the node, get the MessageID -> Callback map
|
|
auto& messageCallbackMap = messageMapIt->second;
|
|
|
|
// Check if we have this pending request
|
|
auto requestIt = messageCallbackMap.find(messageID);
|
|
if (requestIt == messageCallbackMap.end()) {
|
|
return;
|
|
}
|
|
|
|
auto& callbacks = requestIt->second;
|
|
callbacks.progressCallback(size, length);
|
|
}
|
|
|
|
void AssetClient::handleCompleteCallback(const QWeakPointer<Node>& node, MessageID messageID) {
|
|
auto senderNode = node.toStrongRef();
|
|
|
|
if (!senderNode) {
|
|
qCWarning(asset_client) << "Got completed asset for node that no longer exists";
|
|
return;
|
|
}
|
|
|
|
// Check if we have any pending requests for this node
|
|
auto messageMapIt = _pendingRequests.find(senderNode);
|
|
if (messageMapIt == _pendingRequests.end()) {
|
|
qCWarning(asset_client) << "Got completed asset for a node that doesn't have any pending requests";
|
|
return;
|
|
}
|
|
|
|
// Found the node, get the MessageID -> Callback map
|
|
auto& messageCallbackMap = messageMapIt->second;
|
|
|
|
// Check if we have this pending request
|
|
auto requestIt = messageCallbackMap.find(messageID);
|
|
if (requestIt == messageCallbackMap.end()) {
|
|
qCWarning(asset_client) << "Got completed asset for a request that doesn't exist";
|
|
return;
|
|
}
|
|
|
|
auto& callbacks = requestIt->second;
|
|
auto& message = callbacks.message;
|
|
|
|
if (!message) {
|
|
qCWarning(asset_client) << "Got completed asset for a message that doesn't exist";
|
|
return;
|
|
}
|
|
|
|
|
|
if (message->failed()) {
|
|
callbacks.completeCallback(false, AssetServerError::NoError, QByteArray());
|
|
} else {
|
|
callbacks.completeCallback(true, AssetServerError::NoError, message->readAll());
|
|
}
|
|
|
|
// We should never get to this point without the associated senderNode and messageID
|
|
// in our list of pending requests. If the senderNode had disconnected or the message
|
|
// had been canceled, we should have been disconnected from the ReceivedMessage
|
|
// signals and thus never had this lambda called.
|
|
messageCallbackMap.erase(messageID);
|
|
}
|
|
|
|
|
|
MessageID AssetClient::getAssetMapping(const AssetPath& path, MappingOperationCallback callback) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto packetList = NLPacketList::create(PacketType::AssetMappingOperation, QByteArray(), true, true);
|
|
|
|
auto messageID = ++_currentID;
|
|
packetList->writePrimitive(messageID);
|
|
|
|
packetList->writePrimitive(AssetMappingOperationType::Get);
|
|
|
|
packetList->writeString(path);
|
|
|
|
if (nodeList->sendPacketList(std::move(packetList), *assetServer) != -1) {
|
|
_pendingMappingRequests[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QSharedPointer<ReceivedMessage>());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
MessageID AssetClient::getAllAssetMappings(MappingOperationCallback callback) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto packetList = NLPacketList::create(PacketType::AssetMappingOperation, QByteArray(), true, true);
|
|
|
|
auto messageID = ++_currentID;
|
|
packetList->writePrimitive(messageID);
|
|
|
|
packetList->writePrimitive(AssetMappingOperationType::GetAll);
|
|
|
|
if (nodeList->sendPacketList(std::move(packetList), *assetServer) != -1) {
|
|
_pendingMappingRequests[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QSharedPointer<ReceivedMessage>());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
MessageID AssetClient::deleteAssetMappings(const AssetPathList& paths, MappingOperationCallback callback) {
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto packetList = NLPacketList::create(PacketType::AssetMappingOperation, QByteArray(), true, true);
|
|
|
|
auto messageID = ++_currentID;
|
|
packetList->writePrimitive(messageID);
|
|
|
|
packetList->writePrimitive(AssetMappingOperationType::Delete);
|
|
|
|
packetList->writePrimitive(int(paths.size()));
|
|
|
|
for (auto& path: paths) {
|
|
packetList->writeString(path);
|
|
}
|
|
|
|
if (nodeList->sendPacketList(std::move(packetList), *assetServer) != -1) {
|
|
_pendingMappingRequests[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QSharedPointer<ReceivedMessage>());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
MessageID AssetClient::setAssetMapping(const QString& path, const AssetHash& hash, MappingOperationCallback callback) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto packetList = NLPacketList::create(PacketType::AssetMappingOperation, QByteArray(), true, true);
|
|
|
|
auto messageID = ++_currentID;
|
|
packetList->writePrimitive(messageID);
|
|
|
|
packetList->writePrimitive(AssetMappingOperationType::Set);
|
|
|
|
packetList->writeString(path);
|
|
packetList->write(QByteArray::fromHex(hash.toUtf8()));
|
|
|
|
if (nodeList->sendPacketList(std::move(packetList), *assetServer) != -1) {
|
|
_pendingMappingRequests[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QSharedPointer<ReceivedMessage>());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
MessageID AssetClient::renameAssetMapping(const AssetPath& oldPath, const AssetPath& newPath, MappingOperationCallback callback) {
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto packetList = NLPacketList::create(PacketType::AssetMappingOperation, QByteArray(), true, true);
|
|
|
|
auto messageID = ++_currentID;
|
|
packetList->writePrimitive(messageID);
|
|
|
|
packetList->writePrimitive(AssetMappingOperationType::Rename);
|
|
|
|
packetList->writeString(oldPath);
|
|
packetList->writeString(newPath);
|
|
|
|
if (nodeList->sendPacketList(std::move(packetList), *assetServer) != -1) {
|
|
_pendingMappingRequests[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QSharedPointer<ReceivedMessage>());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
bool AssetClient::cancelMappingRequest(MessageID id) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
for (auto& kv : _pendingMappingRequests) {
|
|
if (kv.second.erase(id)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AssetClient::cancelGetAssetInfoRequest(MessageID id) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
for (auto& kv : _pendingInfoRequests) {
|
|
if (kv.second.erase(id)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AssetClient::cancelGetAssetRequest(MessageID id) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
// Search through each pending mapping request for id `id`
|
|
for (auto& kv : _pendingRequests) {
|
|
auto& messageCallbackMap = kv.second;
|
|
auto requestIt = messageCallbackMap.find(id);
|
|
if (requestIt != messageCallbackMap.end()) {
|
|
|
|
auto& message = requestIt->second.message;
|
|
if (message) {
|
|
// disconnect from all signals emitting from the pending message
|
|
disconnect(message.data(), nullptr, this, nullptr);
|
|
}
|
|
|
|
messageCallbackMap.erase(requestIt);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AssetClient::cancelUploadAssetRequest(MessageID id) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
// Search through each pending mapping request for id `id`
|
|
for (auto& kv : _pendingUploads) {
|
|
if (kv.second.erase(id)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
MessageID AssetClient::uploadAsset(const QByteArray& data, UploadResultCallback callback) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
auto nodeList = DependencyManager::get<NodeList>();
|
|
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
|
|
|
|
if (assetServer) {
|
|
auto packetList = NLPacketList::create(PacketType::AssetUpload, QByteArray(), true, true);
|
|
|
|
auto messageID = ++_currentID;
|
|
packetList->writePrimitive(messageID);
|
|
|
|
uint64_t size = data.length();
|
|
packetList->writePrimitive(size);
|
|
packetList->write(data.constData(), size);
|
|
|
|
if (nodeList->sendPacketList(std::move(packetList), *assetServer) != -1) {
|
|
_pendingUploads[assetServer][messageID] = callback;
|
|
|
|
return messageID;
|
|
}
|
|
}
|
|
|
|
callback(false, AssetServerError::NoError, QString());
|
|
return INVALID_MESSAGE_ID;
|
|
}
|
|
|
|
void AssetClient::handleAssetUploadReply(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
MessageID messageID;
|
|
message->readPrimitive(&messageID);
|
|
|
|
AssetServerError error;
|
|
message->readPrimitive(&error);
|
|
|
|
QString hashString;
|
|
|
|
if (error) {
|
|
qCWarning(asset_client) << "Error uploading file to asset server";
|
|
} else {
|
|
auto hash = message->read(SHA256_HASH_LENGTH);
|
|
hashString = hash.toHex();
|
|
|
|
qCDebug(asset_client) << "Successfully uploaded asset to asset-server - SHA256 hash is " << hashString;
|
|
}
|
|
|
|
// Check if we have any pending requests for this node
|
|
auto messageMapIt = _pendingUploads.find(senderNode);
|
|
if (messageMapIt != _pendingUploads.end()) {
|
|
|
|
// Found the node, get the MessageID -> Callback map
|
|
auto& messageCallbackMap = messageMapIt->second;
|
|
|
|
// Check if we have this pending request
|
|
auto requestIt = messageCallbackMap.find(messageID);
|
|
if (requestIt != messageCallbackMap.end()) {
|
|
auto callback = requestIt->second;
|
|
callback(true, error, hashString);
|
|
messageCallbackMap.erase(requestIt);
|
|
}
|
|
|
|
// Although the messageCallbackMap may now be empty, we won't delete the node until we have disconnected from
|
|
// it to avoid constantly creating/deleting the map on subsequent requests.
|
|
}
|
|
}
|
|
|
|
void AssetClient::handleNodeKilled(SharedNodePointer node) {
|
|
Q_ASSERT(QThread::currentThread() == thread());
|
|
|
|
if (node->getType() != NodeType::AssetServer) {
|
|
return;
|
|
}
|
|
|
|
forceFailureOfPendingRequests(node);
|
|
|
|
{
|
|
auto messageMapIt = _pendingUploads.find(node);
|
|
if (messageMapIt != _pendingUploads.end()) {
|
|
for (const auto& value : messageMapIt->second) {
|
|
value.second(false, AssetServerError::NoError, "");
|
|
}
|
|
messageMapIt->second.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
void AssetClient::handleNodeClientConnectionReset(SharedNodePointer node) {
|
|
// a client connection to a Node was reset
|
|
// if it was an AssetServer we need to cause anything pending to fail so it is re-attempted
|
|
|
|
if (node->getType() != NodeType::AssetServer) {
|
|
return;
|
|
}
|
|
|
|
qCDebug(asset_client) << "AssetClient detected client connection reset handshake with Asset Server - failing any pending requests";
|
|
|
|
forceFailureOfPendingRequests(node);
|
|
}
|
|
|
|
void AssetClient::forceFailureOfPendingRequests(SharedNodePointer node) {
|
|
|
|
{
|
|
auto messageMapIt = _pendingRequests.find(node);
|
|
if (messageMapIt != _pendingRequests.end()) {
|
|
for (const auto& value : messageMapIt->second) {
|
|
auto& message = value.second.message;
|
|
if (message) {
|
|
// Disconnect from all signals emitting from the pending message
|
|
disconnect(message.data(), nullptr, this, nullptr);
|
|
}
|
|
|
|
value.second.completeCallback(false, AssetServerError::NoError, QByteArray());
|
|
}
|
|
messageMapIt->second.clear();
|
|
}
|
|
}
|
|
|
|
{
|
|
auto messageMapIt = _pendingInfoRequests.find(node);
|
|
if (messageMapIt != _pendingInfoRequests.end()) {
|
|
AssetInfo info { "", 0 };
|
|
for (const auto& value : messageMapIt->second) {
|
|
value.second(false, AssetServerError::NoError, info);
|
|
}
|
|
messageMapIt->second.clear();
|
|
}
|
|
}
|
|
|
|
{
|
|
auto messageMapIt = _pendingMappingRequests.find(node);
|
|
if (messageMapIt != _pendingMappingRequests.end()) {
|
|
for (const auto& value : messageMapIt->second) {
|
|
value.second(false, AssetServerError::NoError, QSharedPointer<ReceivedMessage>());
|
|
}
|
|
messageMapIt->second.clear();
|
|
}
|
|
}
|
|
}
|