History

reuse same disk cache as AssetClient

humbletim committed 8 years ago

Commit 395cc661 parent 31cdd5c5 files · +128 −115Browse files

Showing the changes to libraries/networking/src/BaseAssetScriptingInterface.cpp (1 of 5 files). Show all

Unified · Split

libraries/networking/src/BaseAssetScriptingInterface.cpp+20−79
@@ -31,31 +31,23 @@ QSharedPointer<AssetClient> BaseAssetScriptingInterface::assetClient() { · 30 unmodified lines
3131 return DependencyManager::get<AssetClient>();
3232 }
3333
34−BaseAssetScriptingInterface::BaseAssetScriptingInterface(QObject* parent) : QObject(parent), _cache(this) {
35−}
36−
34+BaseAssetScriptingInterface::BaseAssetScriptingInterface(QObject* parent) : QObject(parent) {}
3735
3836 bool BaseAssetScriptingInterface::initializeCache() {
39− // NOTE: *instances* of QNetworkDiskCache are not thread-safe -- however, different threads can effectively
40− // use the same underlying cache if configured with identical settings. Once AssetClient's disk cache settings
41− // become available we configure our instance to match.
4237 auto assets = assetClient();
4338 if (!assets) {
4439 return false; // not yet possible to initialize the cache
4540 }
46− if (_cache.cacheDirectory().size()) {
41+ if (!_cacheDirectory.isEmpty()) {
4742 return true; // cache is ready
4843 }
4944
5045 // attempt to initialize the cache
51− QMetaObject::invokeMethod(assetClient().data(), "init");
46+ QMetaObject::invokeMethod(assets.data(), "init");
5247
5348 Promise deferred = makePromise("BaseAssetScriptingInterface--queryCacheStatus");
5449 deferred->then([&](QVariantMap result) {
55− auto cacheDirectory = result.value("cacheDirectory").toString();
56− auto maximumCacheSize = result.value("maximumCacheSize").toLongLong();
57− _cache.setCacheDirectory(cacheDirectory);
58− _cache.setMaximumCacheSize(maximumCacheSize);
50+ _cacheDirectory = result.value("cacheDirectory").toString();
5951 });
6052 deferred->fail([&](QString error) {
6153 qDebug() << "BaseAssetScriptingInterface::queryCacheStatus ERROR" << QThread::currentThread() << error;
@@ -64,79 +56,28 @@ bool BaseAssetScriptingInterface::initializeCache() { · 2 unmodified lines
6456 return false; // cache is not ready yet
6557 }
6658
67−QVariantMap BaseAssetScriptingInterface::getCacheStatus() {
68− return {
69− { "cacheDirectory", _cache.cacheDirectory() },
70− { "cacheSize", _cache.cacheSize() },
71− { "maximumCacheSize", _cache.maximumCacheSize() },
72− };
73−}
74−
75−QVariantMap BaseAssetScriptingInterface::queryCacheMeta(const QUrl& url) {
76− QNetworkCacheMetaData metaData = _cache.metaData(url);
77− QVariantMap attributes, rawHeaders;
78−
79− QHashIterator<QNetworkRequest::Attribute, QVariant> i(metaData.attributes());
80− while (i.hasNext()) {
81− i.next();
82− attributes[QString::number(i.key())] = i.value();
83− }
84− for (const auto& i : metaData.rawHeaders()) {
85− rawHeaders[i.first] = i.second;
86− }
87− return {
88− { "isValid", metaData.isValid() },
89− { "url", metaData.url() },
90− { "expirationDate", metaData.expirationDate() },
91− { "lastModified", metaData.lastModified().toString().isEmpty() ? QDateTime() : metaData.lastModified() },
92− { "saveToDisk", metaData.saveToDisk() },
93− { "attributes", attributes },
94− { "rawHeaders", rawHeaders },
95− };
59+Promise BaseAssetScriptingInterface::getCacheStatus() {
60+ Promise deferred = makePromise(__FUNCTION__);
61+ DependencyManager::get<AssetClient>()->cacheInfoRequest(deferred);
62+ return deferred;
9663 }
9764
98−QVariantMap BaseAssetScriptingInterface::loadFromCache(const QUrl& url) {
99− QVariantMap result = {
100− { "metadata", queryCacheMeta(url) },
101− { "data", QByteArray() },
102− };
103− // caller is responsible for the deletion of the ioDevice, hence the unique_ptr
104− if (auto ioDevice = std::unique_ptr<QIODevice>(_cache.data(url))) {
105− QByteArray data = ioDevice->readAll();
106− result["data"] = data;
107− }
108− return result;
65+Promise BaseAssetScriptingInterface::queryCacheMeta(const QUrl& url) {
66+ Promise deferred = makePromise(__FUNCTION__);
67+ DependencyManager::get<AssetClient>()->queryCacheMeta(deferred, url);
68+ return deferred;
10969 }
11070
111−namespace {
112− // parse RFC 1123 HTTP date format
113− QDateTime parseHttpDate(const QString& dateString) {
114− QDateTime dt = QDateTime::fromString(dateString.left(25), "ddd, dd MMM yyyy HH:mm:ss");
115− dt.setTimeSpec(Qt::UTC);
116− return dt;
117− }
71+Promise BaseAssetScriptingInterface::loadFromCache(const QUrl& url) {
72+ Promise deferred = makePromise(__FUNCTION__);
73+ DependencyManager::get<AssetClient>()->loadFromCache(deferred, url);
74+ return deferred;
11875 }
11976
120−bool BaseAssetScriptingInterface::saveToCache(const QUrl& url, const QByteArray& data, const QVariantMap& headers) {
121− QDateTime lastModified = headers.contains("last-modified") ?
122− parseHttpDate(headers["last-modified"].toString()) :
123− QDateTime::currentDateTimeUtc();
124− QDateTime expirationDate = headers.contains("expires") ?
125− parseHttpDate(headers["expires"].toString()) :
126− QDateTime(); // never expires
127− QNetworkCacheMetaData metaData;
128− metaData.setUrl(url);
129− metaData.setSaveToDisk(true);
130− metaData.setLastModified(lastModified);
131− metaData.setExpirationDate(expirationDate);
132− if (auto ioDevice = _cache.prepare(metaData)) {
133− ioDevice->write(data);
134− _cache.insert(ioDevice);
135− qCDebug(asset_client) << url.toDisplayString() << "saved to disk cache ("<< data.size()<<" bytes)";
136− return true;
137− }
138− qCWarning(asset_client) << "Could not save" << url.toDisplayString() << "to disk cache.";
139− return false;
77+Promise BaseAssetScriptingInterface::saveToCache(const QUrl& url, const QByteArray& data, const QVariantMap& headers) {
78+ Promise deferred = makePromise(__FUNCTION__);
79+ DependencyManager::get<AssetClient>()->saveToCache(deferred, url, data, headers);
80+ return deferred;
14081 }
14182
14283 Promise BaseAssetScriptingInterface::loadAsset(QString asset, bool decompress, QString responseType) {