Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-13 10:53:22 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add GetInfo packets to AssetClient

Browse source
This commit is contained in:
Ryan Huffman 2015-08-03 16:30:22 -07:00
parent acff31ee2d
commit a6665612fc
2 changed files with 112 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

110
libraries/networking/src/AssetClient.cpp
View file

@ -10,20 +10,52 @@
#include "AssetClient.h"
#include <QThread>
#include "AssetRequest.h"
#include "NodeList.h"
#include "PacketReceiver.h"
const int HASH_HEX_LENGTH = 32;
MessageID AssetClient::_currentID = 0;
AssetClient::AssetClient() {
auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
packetReceiver.registerListener(PacketType::AssetGetInfoReply, this, "handleAssetGetInfoReply");
packetReceiver.registerListener(PacketType::AssetGetReply, this, "handleAssetGetReply");
packetReceiver.registerListener(PacketType::AssetUploadReply, this, "handleAssetUploadReply");
}
bool AssetClient::getAsset(QString hash, ReceivedAssetCallback callback) {
AssetRequest* AssetClient::create(QString hash) {
if (QThread::currentThread() != thread()) {
AssetRequest* req;
QMetaObject::invokeMethod(this, "create",
Qt::BlockingQueuedConnection,
Q_RETURN_ARG(AssetRequest*, req),
Q_ARG(QString, hash));
return req;
}
if (hash.length() != 32) {
qDebug() << "Invalid hash size";
return nullptr;
}
auto nodeList = DependencyManager::get<NodeList>();
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
if (assetServer) {
auto assetClient = DependencyManager::get<AssetClient>();
auto request = new AssetRequest(assetClient.data(), hash);
return request;
}
return nullptr;
}
bool AssetClient::getAsset(QString hash, DataOffset start, DataOffset end, ReceivedAssetCallback callback) {
if (hash.length() != HASH_HEX_LENGTH) {
qDebug() << "Invalid hash size";
return false;
}
@ -33,10 +65,16 @@ bool AssetClient::getAsset(QString hash, ReceivedAssetCallback callback) {
if (assetServer) {
auto packet = NLPacket::create(PacketType::AssetGet);
auto messageID = ++_currentID;
packet->writePrimitive(messageID);
packet->write(hash.toLatin1().constData(), 32);
packet->writePrimitive(start);
packet->writePrimitive(end);
nodeList->sendPacket(std::move(packet), *assetServer);
_pendingRequests[hash] = callback;
_pendingRequests[messageID] = callback;
return true;
}
@ -44,28 +82,70 @@ bool AssetClient::getAsset(QString hash, ReceivedAssetCallback callback) {
return false;
}
bool AssetClient::getAssetInfo(QString hash, GetInfoCallback callback) {
auto nodeList = DependencyManager::get<NodeList>();
SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
if (assetServer) {
auto packet = NLPacket::create(PacketType::AssetGetInfo);
auto messageID = ++_currentID;
packet->writePrimitive(messageID);
packet->write(hash.toLatin1().constData(), 32);
nodeList->sendPacket(std::move(packet), *assetServer);
_pendingInfoRequests[messageID] = callback;
return true;
}
return false;
}
void AssetClient::handleAssetGetInfoReply(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
MessageID messageID;
packet->readPrimitive(&messageID);
auto assetHash = QString(packet->read(HASH_HEX_LENGTH));
AssetServerError error;
packet->readPrimitive(&error);
AssetInfo info;
if (!error) {
packet->readPrimitive(&info.size);
}
if (_pendingInfoRequests.contains(messageID)) {
auto callback = _pendingInfoRequests.take(messageID);
callback(error != NO_ERROR, info);
}
}
void AssetClient::handleAssetGetReply(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
auto assetHash = packet->read(HASH_HEX_LENGTH);
qDebug() << "Got reply for asset: " << assetHash;
bool success;
packet->readPrimitive(&success);
MessageID messageID;
packet->readPrimitive(&messageID);
AssetServerError error;
packet->readPrimitive(&error);
QByteArray data;
if (success) {
int length;
if (!error) {
DataOffset length;
packet->readPrimitive(&length);
char assetData[length];
packet->read(assetData, length);
data = QByteArray(assetData, length);
data = packet->read(length);
qDebug() << "Got data: " << length << ", " << data.toHex();
} else {
qDebug() << "Failure getting asset";
qDebug() << "Failure getting asset: " << error;
}
if (_pendingRequests.contains(assetHash)) {
auto callback = _pendingRequests.take(assetHash);
callback(success, data);
if (_pendingRequests.contains(messageID)) {
auto callback = _pendingRequests.take(messageID);
callback(!error, data);
}
}

28
libraries/networking/src/AssetClient.h
View file

@ -13,39 +13,45 @@
#define hifi_AssetClient_h
#include <QString>
#include <QScriptValue>
#include <DependencyManager.h>
#include "AssetUtils.h"
#include "LimitedNodeList.h"
#include "NLPacket.h"
class AssetRequest;
struct AssetInfo {
QString hash;
int64_t size;
};
using ReceivedAssetCallback = std::function<void(bool result, QByteArray data)>;
using GetInfoCallback = std::function<void(bool result, AssetInfo info)>;
using UploadResultCallback = std::function<void(bool result, QString hash)>;
using MessageID = int;
class AssetClient : public QObject, public Dependency {
Q_OBJECT
public:
AssetClient();
enum RequestResult {
SUCCESS = 0,
FAILURE,
TIMEOUT
};
bool getAsset(QString hash, ReceivedAssetCallback callback);
Q_INVOKABLE AssetRequest* create(QString hash);
bool getAssetInfo(QString hash, GetInfoCallback callback);
bool getAsset(QString hash, DataOffset start, DataOffset end, ReceivedAssetCallback callback);
bool uploadAsset(QByteArray data, QString extension, UploadResultCallback callback);
bool abortDataRequest(MessageID messageID);
private slots:
void handleAssetGetInfoReply(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
void handleAssetGetReply(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
void handleAssetUploadReply(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
private:
static MessageID _currentID;
QMap<QString, ReceivedAssetCallback> _pendingRequests;
QMap<MessageID, UploadResultCallback> _pendingUploads;
QHash<MessageID, ReceivedAssetCallback> _pendingRequests;
QHash<MessageID, GetInfoCallback> _pendingInfoRequests;
QHash<MessageID, UploadResultCallback> _pendingUploads;
};
#endif