Merge pull request #82 from birarda/atp-rename-mapping

add rename mapping operation for atomic rename

assignment-client/src/assets/AssetServer.cpp

@@ -21,11 +21,12 @@
 #include <QtCore/QJsonDocument>
 #include <QtCore/QString>
 
+#include <ServerPathUtils.h>
+
 #include "NetworkLogging.h"
 #include "NodeType.h"
 #include "SendAssetTask.h"
 #include "UploadAssetTask.h"
-#include <ServerPathUtils.h>
 
 const QString ASSET_SERVER_LOGGING_TARGET_NAME = "asset-server";
 
@@ -203,6 +204,10 @@ void AssetServer::handleAssetMappingOperation(QSharedPointer<ReceivedMessage> me
             handleDeleteMappingsOperation(*message, senderNode, *replyPacket);
             break;
         }
+        case AssetMappingOperationType::Rename: {
+            handleRenameMappingOperation(*message, senderNode, *replyPacket);
+            break;
+        }
     }
 
     auto nodeList = DependencyManager::get<NodeList>();
@@ -274,6 +279,21 @@ void AssetServer::handleDeleteMappingsOperation(ReceivedMessage& message, Shared
     }
 }
 
+void AssetServer::handleRenameMappingOperation(ReceivedMessage& message, SharedNodePointer senderNode, NLPacketList& replyPacket) {
+    if (senderNode->getCanRez()) {
+        QString oldPath = message.readString();
+        QString newPath = message.readString();
+
+        if (renameMapping(oldPath, newPath)) {
+            replyPacket.writePrimitive(AssetServerError::NoError);
+        } else {
+            replyPacket.writePrimitive(AssetServerError::MappingOperationFailed);
+        }
+    } else {
+        replyPacket.writePrimitive(AssetServerError::PermissionDenied);
+    }
+}
+
 void AssetServer::handleAssetGetInfo(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
     QByteArray assetHash;
     MessageID messageID;
@@ -468,7 +488,7 @@ bool AssetServer::writeMappingsToFile() {
     return false;
 }
 
-bool AssetServer::setMapping(AssetPath path, AssetHash hash) {
+bool AssetServer::setMapping(const AssetPath& path, const AssetHash& hash) {
     // remember what the old mapping was in case persistence fails
     auto oldMapping = _fileMappings.value(path).toString();
 
@@ -516,3 +536,25 @@ bool AssetServer::deleteMappings(const AssetPathList& paths) {
         return false;
     }
 }
+
+bool AssetServer::renameMapping(const AssetPath& oldPath, const AssetPath& newPath) {
+    // take the old hash to remove the old mapping
+    auto oldMapping = _fileMappings[oldPath].toString();
+
+    if (!oldMapping.isEmpty()) {
+        _fileMappings[newPath] = oldMapping;
+
+        if (writeMappingsToFile()) {
+            // persisted the renamed mapping, return success
+            return true;
+        } else {
+            // we couldn't persist the renamed mapping, rollback and return failure
+            _fileMappings[oldPath] = oldMapping;
+
+            return false;
+        }
+    } else {
+        // failed to find a mapping that was to be renamed, return failure
+        return false;
+    }
+}

assignment-client/src/assets/AssetServer.h

@@ -12,10 +12,10 @@
 #ifndef hifi_AssetServer_h
 #define hifi_AssetServer_h
 
-#include <QDir>
+#include <QtCore/QDir>
+#include <QtCore/QThreadPool>
 
 #include <ThreadedAssignment.h>
-#include <QThreadPool>
 
 #include "AssetUtils.h"
 #include "ReceivedMessage.h"
@@ -45,18 +45,20 @@ private:
     void handleGetAllMappingOperation(ReceivedMessage& message, SharedNodePointer senderNode, NLPacketList& replyPacket);
     void handleSetMappingOperation(ReceivedMessage& message, SharedNodePointer senderNode, NLPacketList& replyPacket);
     void handleDeleteMappingsOperation(ReceivedMessage& message, SharedNodePointer senderNode, NLPacketList& replyPacket);
+    void handleRenameMappingOperation(ReceivedMessage& message, SharedNodePointer senderNode, NLPacketList& replyPacket);
 
     // Mapping file operations must be called from main assignment thread only
     void loadMappingsFromFile();
     bool writeMappingsToFile();
 
     /// Set the mapping for path to hash
-    bool setMapping(AssetPath path, AssetHash hash);
+    bool setMapping(const AssetPath& path, const AssetHash& hash);
 
     /// Delete mapping `path`. Returns `true` if deletion of mappings succeeds, else `false`.
     bool deleteMappings(const AssetPathList& paths);
 
-    static void writeError(NLPacketList* packetList, AssetServerError error);
+    /// Rename mapping from `oldPath` to `newPath`. Returns true if successful
+    bool renameMapping(const AssetPath& oldPath, const AssetPath& newPath);
 
     void performMappingMigration();
 
@@ -67,8 +69,4 @@ private:
     QThreadPool _taskPool;
 };
 
-inline void writeError(NLPacketList* packetList, AssetServerError error) {
-    packetList->writePrimitive(error);
-}
-
 #endif

assignment-client/src/assets/SendAssetTask.cpp

@@ -56,7 +56,7 @@ void SendAssetTask::run() {
     replyPacketList->writePrimitive(messageID);
 
     if (end <= start) {
-        writeError(replyPacketList.get(), AssetServerError::InvalidByteRange);
+        replyPacketList->writePrimitive(AssetServerError::InvalidByteRange);
     } else {
         QString filePath = _resourcesDir.filePath(QString(hexHash));
         
@@ -64,7 +64,7 @@ void SendAssetTask::run() {
 
         if (file.open(QIODevice::ReadOnly)) {
             if (file.size() < end) {
-                writeError(replyPacketList.get(), AssetServerError::InvalidByteRange);
+                replyPacketList->writePrimitive(AssetServerError::InvalidByteRange);
                 qCDebug(networking) << "Bad byte range: " << hexHash << " " << start << ":" << end;
             } else {
                 auto size = end - start;
@@ -77,7 +77,7 @@ void SendAssetTask::run() {
             file.close();
         } else {
             qCDebug(networking) << "Asset not found: " << filePath << "(" << hexHash << ")";
-            writeError(replyPacketList.get(), AssetServerError::AssetNotFound);
+            replyPacketList->writePrimitive(AssetServerError::AssetNotFound);
         }
     }
 

libraries/networking/src/AssetClient.cpp

@@ -22,6 +22,7 @@
 #include "AssetRequest.h"
 #include "AssetUpload.h"
 #include "AssetUtils.h"
+#include "MappingRequest.h"
 #include "NetworkAccessManager.h"
 #include "NetworkLogging.h"
 #include "NodeList.h"
@@ -30,151 +31,6 @@
 
 MessageID AssetClient::_currentID = 0;
 
-void MappingRequest::start() {
-    if (QThread::currentThread() != thread()) {
-        QMetaObject::invokeMethod(this, "start", Qt::AutoConnection);
-        return;
-    }
-    doStart();
-};
-
-GetMappingRequest::GetMappingRequest(const AssetPath& path) : _path(path) {
-};
-
-void GetMappingRequest::doStart() {
-
-    auto assetClient = DependencyManager::get<AssetClient>();
-
-    // Check cache
-    auto it = assetClient->_mappingCache.constFind(_path);
-    if (it != assetClient->_mappingCache.constEnd()) {
-        _hash = it.value();
-        emit finished(this);
-        return;
-    }
-
-    assetClient->getAssetMapping(_path, [this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
-        if (!responseReceived) {
-            _error = NetworkError;
-        } else {
-            switch (error) {
-                case AssetServerError::NoError:
-                    _error = NoError;
-                    break;
-                case AssetServerError::AssetNotFound:
-                    _error = NotFound;
-                    break;
-                default:
-                    _error = UnknownError;
-                    break;
-            }
-        }
-
-        if (!_error) {
-            _hash = message->read(SHA256_HASH_LENGTH).toHex();
-            assetClient->_mappingCache[_path] = _hash;
-        }
-        emit finished(this);
-    });
-};
-
-GetAllMappingsRequest::GetAllMappingsRequest() {
-};
-
-void GetAllMappingsRequest::doStart() {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    assetClient->getAllAssetMappings([this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
-        if (!responseReceived) {
-            _error = NetworkError;
-        } else {
-            switch (error) {
-                case AssetServerError::NoError:
-                    _error = NoError;
-                    break;
-                default:
-                    _error = UnknownError;
-                    break;
-            }
-        }
-
-
-        if (!error) {
-            int numberOfMappings;
-            message->readPrimitive(&numberOfMappings);
-            assetClient->_mappingCache.clear();
-            for (auto i = 0; i < numberOfMappings; ++i) {
-                auto path = message->readString();
-                auto hash = message->readString();
-                _mappings[path] = hash;
-                assetClient->_mappingCache[path] = hash;
-            }
-        }
-        emit finished(this);
-    });
-};
-
-SetMappingRequest::SetMappingRequest(const AssetPath& path, const AssetHash& hash) : _path(path), _hash(hash) {
-};
-
-void SetMappingRequest::doStart() {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    assetClient->setAssetMapping(_path, _hash, [this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
-        if (!responseReceived) {
-            _error = NetworkError;
-        } else {
-            switch (error) {
-                case AssetServerError::NoError:
-                    _error = NoError;
-                    break;
-                case AssetServerError::PermissionDenied:
-                    _error = PermissionDenied;
-                    break;
-                default:
-                    _error = UnknownError;
-                    break;
-            }
-        }
-
-        if (!error) {
-            assetClient->_mappingCache[_path] = _hash;
-        }
-        emit finished(this);
-    });
-};
-
-DeleteMappingsRequest::DeleteMappingsRequest(const AssetPathList& paths) : _paths(paths) {
-};
-
-void DeleteMappingsRequest::doStart() {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    assetClient->deleteAssetMappings(_paths, [this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
-        if (!responseReceived) {
-            _error = NetworkError;
-        } else {
-            switch (error) {
-                case AssetServerError::NoError:
-                    _error = NoError;
-                    break;
-                case AssetServerError::PermissionDenied:
-                    _error = PermissionDenied;
-                    break;
-                default:
-                    _error = UnknownError;
-                    break;
-            }
-        }
-
-        if (!error) {
-            // enumerate the paths and remove them from the cache
-            for (auto& path : _paths) {
-                assetClient->_mappingCache.remove(path);
-            }
-        }
-        emit finished(this);
-    });
-};
-
-
 AssetClient::AssetClient() {
     
     setCustomDeleter([](Dependency* dependency){
@@ -300,6 +156,10 @@ SetMappingRequest* AssetClient::createSetMappingRequest(const AssetPath& path, c
     return new SetMappingRequest(path, hash);
 }
 
+RenameMappingRequest* AssetClient::createRenameMappingRequest(const AssetPath& oldPath, const AssetPath& newPath) {
+    return new RenameMappingRequest(oldPath, newPath);
+}
+
 AssetRequest* AssetClient::createRequest(const AssetHash& hash) {
     if (hash.length() != SHA256_HASH_HEX_LENGTH) {
         qCWarning(asset_client) << "Invalid hash size";
@@ -573,7 +433,7 @@ bool AssetClient::setAssetMapping(const QString& path, const AssetHash& hash, Ma
 
         packetList->writePrimitive(AssetMappingOperationType::Set);
 
-        packetList->writeString(path.toUtf8());
+        packetList->writeString(path);
         packetList->write(QByteArray::fromHex(hash.toUtf8()));
 
         nodeList->sendPacketList(std::move(packetList), *assetServer);
@@ -586,6 +446,32 @@ bool AssetClient::setAssetMapping(const QString& path, const AssetHash& hash, Ma
     return false;
 }
 
+bool 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);
+
+        nodeList->sendPacketList(std::move(packetList), *assetServer);
+
+        _pendingMappingRequests[assetServer][messageID] = callback;
+
+        return true;
+
+    }
+
+    return false;
+}
+
 bool AssetClient::uploadAsset(const QByteArray& data, UploadResultCallback callback) {
     auto nodeList = DependencyManager::get<NodeList>();
     SharedNodePointer assetServer = nodeList->soloNodeOfType(NodeType::AssetServer);
@@ -695,140 +581,3 @@ void AssetClient::handleNodeKilled(SharedNodePointer node) {
 
     _mappingCache.clear();
 }
-
-void AssetScriptingInterface::uploadData(QString data, QScriptValue callback) {
-    QByteArray dataByteArray = data.toUtf8();
-    auto upload = DependencyManager::get<AssetClient>()->createUpload(dataByteArray);
-    if (!upload) {
-        qCWarning(asset_client) << "Error uploading file to asset server";
-        return;
-    }
-
-    QObject::connect(upload, &AssetUpload::finished, this, [this, callback](AssetUpload* upload, const QString& hash) mutable {
-        if (callback.isFunction()) {
-            QString url = "atp://" + hash;
-            QScriptValueList args { url };
-            callback.call(_engine->currentContext()->thisObject(), args);
-        }
-    });
-    upload->start();
-}
-
-AssetScriptingInterface::AssetScriptingInterface(QScriptEngine* engine) :
-    _engine(engine)
-{
-}
-
-void AssetScriptingInterface::downloadData(QString urlString, QScriptValue callback) {
-    const QString ATP_SCHEME { "atp://" };
-
-    if (!urlString.startsWith(ATP_SCHEME)) {
-        return;
-    }
-
-    // Make request to atp
-    auto path = urlString.right(urlString.length() - ATP_SCHEME.length());
-    auto parts = path.split(".", QString::SkipEmptyParts);
-    auto hash = parts.length() > 0 ? parts[0] : "";
-
-    if (hash.length() != SHA256_HASH_HEX_LENGTH) {
-        return;
-    }
-
-    auto assetClient = DependencyManager::get<AssetClient>();
-    auto assetRequest = assetClient->createRequest(hash);
-
-    if (!assetRequest) {
-        return;
-    }
-
-    _pendingRequests << assetRequest;
-
-    connect(assetRequest, &AssetRequest::finished, this, [this, callback](AssetRequest* request) mutable {
-        Q_ASSERT(request->getState() == AssetRequest::Finished);
-
-        if (request->getError() == AssetRequest::Error::NoError) {
-            if (callback.isFunction()) {
-                QString data = QString::fromUtf8(request->getData());
-                QScriptValueList args { data };
-                callback.call(_engine->currentContext()->thisObject(), args);
-            }
-        }
-
-        request->deleteLater();
-        _pendingRequests.remove(request);
-    });
-
-    assetRequest->start();
-}
-
-void AssetScriptingInterface::setMapping(QString path, QString hash, QScriptValue callback) {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    auto request = assetClient->createSetMappingRequest(path, hash);
-
-    connect(request, &SetMappingRequest::finished, this, [this, callback](SetMappingRequest* request) mutable {
-        QScriptValueList args { uint8_t(request->getError()) };
-
-        callback.call(_engine->currentContext()->thisObject(), args);
-
-        request->deleteLater();
-         
-    });
-
-    request->start();
-}
-
-void AssetScriptingInterface::getMapping(QString path, QScriptValue callback) {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    auto request = assetClient->createGetMappingRequest(path);
-
-    connect(request, &GetMappingRequest::finished, this, [this, callback](GetMappingRequest* request) mutable {
-        QScriptValueList args { uint8_t(request->getError()), request->getHash() };
-
-        callback.call(_engine->currentContext()->thisObject(), args);
-
-        request->deleteLater();
-         
-    });
-
-    request->start();
-}
-
-void AssetScriptingInterface::deleteMappings(QStringList paths, QScriptValue callback) {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    auto request = assetClient->createDeleteMappingsRequest(paths);
-
-    connect(request, &DeleteMappingsRequest::finished, this, [this, callback](DeleteMappingsRequest* request) mutable {
-        QScriptValueList args { uint8_t(request->getError()) };
-
-        callback.call(_engine->currentContext()->thisObject(), args);
-
-        request->deleteLater();
-         
-    });
-
-    request->start();
-}
-
-void AssetScriptingInterface::getAllMappings(QScriptValue callback) {
-    auto assetClient = DependencyManager::get<AssetClient>();
-    auto request = assetClient->createGetAllMappingsRequest();
-
-    connect(request, &GetAllMappingsRequest::finished, this, [this, callback](GetAllMappingsRequest* request) mutable {
-        auto mappings = request->getMappings();
-        auto map = callback.engine()->newObject();
-
-        for (auto& kv : mappings ) {
-            map.setProperty(kv.first, kv.second);
-        }
-
-        QScriptValueList args { uint8_t(request->getError()), map };
-
-        callback.call(_engine->currentContext()->thisObject(), args);
-
-        request->deleteLater();
-         
-    });
-
-    request->start();
-}

libraries/networking/src/AssetClient.h

@@ -9,12 +9,10 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-
 #ifndef hifi_AssetClient_h
 #define hifi_AssetClient_h
 
 #include <QString>
-#include <QScriptValue>
 
 #include <map>
 
@@ -29,6 +27,9 @@
 
 class GetMappingRequest;
 class SetMappingRequest;
+class GetAllMappingsRequest;
+class DeleteMappingsRequest;
+class RenameMappingRequest;
 class AssetRequest;
 class AssetUpload;
 
@@ -43,92 +44,6 @@ using GetInfoCallback = std::function<void(bool responseReceived, AssetServerErr
 using UploadResultCallback = std::function<void(bool responseReceived, AssetServerError serverError, const QString& hash)>;
 using ProgressCallback = std::function<void(qint64 totalReceived, qint64 total)>;
 
-class MappingRequest : public QObject {
-    Q_OBJECT
-public:
-    enum Error {
-        NoError,
-        NotFound,
-        NetworkError,
-        PermissionDenied,
-        UnknownError
-    };
-
-    Q_INVOKABLE void start();
-    Error getError() const { return _error; }
-
-protected:
-    Error _error { NoError };
-
-private:
-    virtual void doStart() = 0;
-};
-
-
-class GetMappingRequest : public MappingRequest {
-    Q_OBJECT
-public:
-    GetMappingRequest(const AssetPath& path);
-
-    AssetHash getHash() const { return _hash;  }
-
-signals:
-    void finished(GetMappingRequest* thisRequest);
-
-private:
-    virtual void doStart() override;
-
-    AssetPath _path;
-    AssetHash _hash;
-};
-
-class SetMappingRequest : public MappingRequest {
-    Q_OBJECT
-public:
-    SetMappingRequest(const AssetPath& path, const AssetHash& hash);
-
-    AssetHash getHash() const { return _hash;  }
-
-signals:
-    void finished(SetMappingRequest* thisRequest);
-
-private:
-    virtual void doStart() override;
-
-    AssetPath _path;
-    AssetHash _hash;
-};
-
-class DeleteMappingsRequest : public MappingRequest {
-    Q_OBJECT
-public:
-    DeleteMappingsRequest(const AssetPathList& path);
-
-signals:
-    void finished(DeleteMappingsRequest* thisRequest);
-
-private:
-    virtual void doStart() override;
-
-    AssetPathList _paths;
-};
-
-class GetAllMappingsRequest : public MappingRequest {
-    Q_OBJECT
-public:
-    GetAllMappingsRequest();
-
-    AssetMapping getMappings() const { return _mappings;  }
-
-signals:
-    void finished(GetAllMappingsRequest* thisRequest);
-
-private:
-    virtual void doStart() override;
-
-    std::map<AssetPath, AssetHash> _mappings;
-};
-
 class AssetClient : public QObject, public Dependency {
     Q_OBJECT
 public:
@@ -138,6 +53,7 @@ public:
     Q_INVOKABLE GetAllMappingsRequest* createGetAllMappingsRequest();
     Q_INVOKABLE DeleteMappingsRequest* createDeleteMappingsRequest(const AssetPathList& paths);
     Q_INVOKABLE SetMappingRequest* createSetMappingRequest(const AssetPath& path, const AssetHash& hash);
+    Q_INVOKABLE RenameMappingRequest* createRenameMappingRequest(const AssetPath& oldPath, const AssetPath& newPath);
     Q_INVOKABLE AssetRequest* createRequest(const AssetHash& hash);
     Q_INVOKABLE AssetUpload* createUpload(const QString& filename);
     Q_INVOKABLE AssetUpload* createUpload(const QByteArray& data);
@@ -161,6 +77,7 @@ private:
     bool getAllAssetMappings(MappingOperationCallback callback);
     bool setAssetMapping(const QString& path, const AssetHash& hash, MappingOperationCallback callback);
     bool deleteAssetMappings(const AssetPathList& paths, MappingOperationCallback callback);
+    bool renameAssetMapping(const AssetPath& oldPath, const AssetPath& newPath, MappingOperationCallback callback);
 
     bool getAssetInfo(const QString& hash, GetInfoCallback callback);
     bool getAsset(const QString& hash, DataOffset start, DataOffset end,
@@ -186,24 +103,7 @@ private:
     friend class GetAllMappingsRequest;
     friend class SetMappingRequest;
     friend class DeleteMappingsRequest;
+    friend class RenameMappingRequest;
 };
 
-
-class AssetScriptingInterface : public QObject {
-    Q_OBJECT
-public:
-    AssetScriptingInterface(QScriptEngine* engine);
-
-    Q_INVOKABLE void uploadData(QString data, QScriptValue callback);
-    Q_INVOKABLE void downloadData(QString url, QScriptValue downloadComplete);
-    Q_INVOKABLE void setMapping(QString path, QString hash, QScriptValue callback);
-    Q_INVOKABLE void getMapping(QString path, QScriptValue callback);
-    Q_INVOKABLE void deleteMappings(QStringList paths, QScriptValue callback);
-    Q_INVOKABLE void getAllMappings(QScriptValue callback);
-protected:
-    QSet<AssetRequest*> _pendingRequests;
-    QScriptEngine* _engine;
-};
-
-
 #endif

libraries/networking/src/AssetResourceRequest.cpp

@@ -13,6 +13,7 @@
 
 #include "AssetClient.h"
 #include "AssetUtils.h"
+#include "MappingRequest.h"
 
 AssetResourceRequest::~AssetResourceRequest() {
     if (_assetMappingRequest) {

libraries/networking/src/AssetUtils.h

@@ -44,7 +44,8 @@ enum AssetMappingOperationType : uint8_t {
     Get = 0,
     GetAll,
     Set,
-    Delete
+    Delete,
+    Rename
 };
 
 QUrl getATPUrl(const QString& hash);

libraries/networking/src/MappingRequest.cpp

@@ -0,0 +1,202 @@
+//
+//  MappingRequest.cpp
+//  libraries/networking/src
+//
+//  Created by Stephen Birarda on 2016-03-08.
+//  Copyright 2016 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 "MappingRequest.h"
+
+#include <QtCore/QThread>
+
+#include <DependencyManager.h>
+
+#include "AssetClient.h"
+
+void MappingRequest::start() {
+    if (QThread::currentThread() != thread()) {
+        QMetaObject::invokeMethod(this, "start", Qt::AutoConnection);
+        return;
+    }
+    doStart();
+};
+
+GetMappingRequest::GetMappingRequest(const AssetPath& path) : _path(path) {
+};
+
+void GetMappingRequest::doStart() {
+
+    auto assetClient = DependencyManager::get<AssetClient>();
+
+    // Check cache
+    auto it = assetClient->_mappingCache.constFind(_path);
+    if (it != assetClient->_mappingCache.constEnd()) {
+        _hash = it.value();
+        emit finished(this);
+        return;
+    }
+
+    assetClient->getAssetMapping(_path, [this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
+        if (!responseReceived) {
+            _error = NetworkError;
+        } else {
+            switch (error) {
+                case AssetServerError::NoError:
+                    _error = NoError;
+                    break;
+                case AssetServerError::AssetNotFound:
+                    _error = NotFound;
+                    break;
+                default:
+                    _error = UnknownError;
+                    break;
+            }
+        }
+
+        if (!_error) {
+            _hash = message->read(SHA256_HASH_LENGTH).toHex();
+            assetClient->_mappingCache[_path] = _hash;
+        }
+        emit finished(this);
+    });
+};
+
+GetAllMappingsRequest::GetAllMappingsRequest() {
+};
+
+void GetAllMappingsRequest::doStart() {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    assetClient->getAllAssetMappings([this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
+        if (!responseReceived) {
+            _error = NetworkError;
+        } else {
+            switch (error) {
+                case AssetServerError::NoError:
+                    _error = NoError;
+                    break;
+                default:
+                    _error = UnknownError;
+                    break;
+            }
+        }
+
+
+        if (!error) {
+            int numberOfMappings;
+            message->readPrimitive(&numberOfMappings);
+            assetClient->_mappingCache.clear();
+            for (auto i = 0; i < numberOfMappings; ++i) {
+                auto path = message->readString();
+                auto hash = message->readString();
+                _mappings[path] = hash;
+                assetClient->_mappingCache[path] = hash;
+            }
+        }
+        emit finished(this);
+    });
+};
+
+SetMappingRequest::SetMappingRequest(const AssetPath& path, const AssetHash& hash) : _path(path), _hash(hash) {
+};
+
+void SetMappingRequest::doStart() {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    assetClient->setAssetMapping(_path, _hash, [this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
+        if (!responseReceived) {
+            _error = NetworkError;
+        } else {
+            switch (error) {
+                case AssetServerError::NoError:
+                    _error = NoError;
+                    break;
+                case AssetServerError::PermissionDenied:
+                    _error = PermissionDenied;
+                    break;
+                default:
+                    _error = UnknownError;
+                    break;
+            }
+        }
+
+        if (!error) {
+            assetClient->_mappingCache[_path] = _hash;
+        }
+        emit finished(this);
+    });
+};
+
+DeleteMappingsRequest::DeleteMappingsRequest(const AssetPathList& paths) : _paths(paths) {
+};
+
+void DeleteMappingsRequest::doStart() {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    assetClient->deleteAssetMappings(_paths, [this, assetClient](bool responseReceived, AssetServerError error, QSharedPointer<ReceivedMessage> message) {
+        if (!responseReceived) {
+            _error = NetworkError;
+        } else {
+            switch (error) {
+                case AssetServerError::NoError:
+                    _error = NoError;
+                    break;
+                case AssetServerError::PermissionDenied:
+                    _error = PermissionDenied;
+                    break;
+                default:
+                    _error = UnknownError;
+                    break;
+            }
+        }
+
+        if (!error) {
+            // enumerate the paths and remove them from the cache
+            for (auto& path : _paths) {
+                assetClient->_mappingCache.remove(path);
+            }
+        }
+        emit finished(this);
+    });
+};
+
+RenameMappingRequest::RenameMappingRequest(const AssetPath& oldPath, const AssetPath& newPath) :
+_oldPath(oldPath),
+_newPath(newPath)
+{
+
+}
+
+void RenameMappingRequest::doStart() {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    assetClient->renameAssetMapping(_oldPath, _newPath, [this, assetClient](bool responseReceived,
+                                                                            AssetServerError error,
+                                                                            QSharedPointer<ReceivedMessage> message) {
+        if (!responseReceived) {
+            _error = NetworkError;
+        } else {
+            switch (error) {
+                case AssetServerError::NoError:
+                    _error = NoError;
+                    break;
+                case AssetServerError::PermissionDenied:
+                    _error = PermissionDenied;
+                    break;
+                default:
+                    _error = UnknownError;
+                    break;
+            }
+        }
+
+        if (!error) {
+            // take the hash mapped for the old path from the cache
+            auto hash = assetClient->_mappingCache.take(_oldPath);
+            if (!hash.isEmpty()) {
+                // use the hash mapped for the old path for the new path
+                assetClient->_mappingCache[_newPath] = hash;
+            }
+        }
+        emit finished(this);
+    });
+}

libraries/networking/src/MappingRequest.h

@@ -0,0 +1,123 @@
+//
+//  MappingRequest.h
+//  libraries/networking/src
+//
+//  Created by Stephen Birarda on 2016-03-08.
+//  Copyright 2016 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
+//
+
+#pragma once
+
+#ifndef hifi_MappingRequest_h
+#define hifi_MappingRequest_h
+
+#include <QtCore/QObject>
+
+#include "AssetUtils.h"
+
+class MappingRequest : public QObject {
+    Q_OBJECT
+public:
+    enum Error {
+        NoError,
+        NotFound,
+        NetworkError,
+        PermissionDenied,
+        UnknownError
+    };
+
+    Q_INVOKABLE void start();
+    Error getError() const { return _error; }
+
+protected:
+    Error _error { NoError };
+
+private:
+    virtual void doStart() = 0;
+};
+
+
+class GetMappingRequest : public MappingRequest {
+    Q_OBJECT
+public:
+    GetMappingRequest(const AssetPath& path);
+
+    AssetHash getHash() const { return _hash;  }
+
+signals:
+    void finished(GetMappingRequest* thisRequest);
+
+private:
+    virtual void doStart() override;
+
+    AssetPath _path;
+    AssetHash _hash;
+};
+
+class SetMappingRequest : public MappingRequest {
+    Q_OBJECT
+public:
+    SetMappingRequest(const AssetPath& path, const AssetHash& hash);
+
+    AssetHash getHash() const { return _hash;  }
+
+signals:
+    void finished(SetMappingRequest* thisRequest);
+
+private:
+    virtual void doStart() override;
+
+    AssetPath _path;
+    AssetHash _hash;
+};
+
+class DeleteMappingsRequest : public MappingRequest {
+    Q_OBJECT
+public:
+    DeleteMappingsRequest(const AssetPathList& path);
+
+signals:
+    void finished(DeleteMappingsRequest* thisRequest);
+
+private:
+    virtual void doStart() override;
+
+    AssetPathList _paths;
+};
+
+class RenameMappingRequest : public MappingRequest {
+    Q_OBJECT
+public:
+    RenameMappingRequest(const AssetPath& oldPath, const AssetPath& newPath);
+
+signals:
+    void finished(RenameMappingRequest* thisRequest);
+
+private:
+    virtual void doStart() override;
+
+    AssetPath _oldPath;
+    AssetPath _newPath;
+};
+
+class GetAllMappingsRequest : public MappingRequest {
+    Q_OBJECT
+public:
+    GetAllMappingsRequest();
+
+    AssetMapping getMappings() const { return _mappings;  }
+
+signals:
+    void finished(GetAllMappingsRequest* thisRequest);
+
+private:
+    virtual void doStart() override;
+    
+    std::map<AssetPath, AssetHash> _mappings;
+};
+
+
+#endif // hifi_MappingRequest_h

libraries/script-engine/src/AssetScriptingInterface.cpp

@@ -0,0 +1,173 @@
+//
+//  AssetScriptingInterface.cpp
+//  libraries/script-engine/src
+//
+//  Created by Stephen Birarda on 2016-03-08.
+//  Copyright 2016 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 "AssetScriptingInterface.h"
+
+#include <QtScript/QScriptEngine>
+
+#include <AssetRequest.h>
+#include <AssetUpload.h>
+#include <MappingRequest.h>
+#include <NetworkLogging.h>
+
+AssetScriptingInterface::AssetScriptingInterface(QScriptEngine* engine) :
+    _engine(engine)
+{
+
+}
+
+void AssetScriptingInterface::uploadData(QString data, QScriptValue callback) {
+    QByteArray dataByteArray = data.toUtf8();
+    auto upload = DependencyManager::get<AssetClient>()->createUpload(dataByteArray);
+    if (!upload) {
+        qCWarning(asset_client) << "Error uploading file to asset server";
+        return;
+    }
+
+    QObject::connect(upload, &AssetUpload::finished, this, [this, callback](AssetUpload* upload, const QString& hash) mutable {
+        if (callback.isFunction()) {
+            QString url = "atp://" + hash;
+            QScriptValueList args { url };
+            callback.call(_engine->currentContext()->thisObject(), args);
+        }
+    });
+    upload->start();
+}
+
+void AssetScriptingInterface::downloadData(QString urlString, QScriptValue callback) {
+    const QString ATP_SCHEME { "atp://" };
+
+    if (!urlString.startsWith(ATP_SCHEME)) {
+        return;
+    }
+
+    // Make request to atp
+    auto path = urlString.right(urlString.length() - ATP_SCHEME.length());
+    auto parts = path.split(".", QString::SkipEmptyParts);
+    auto hash = parts.length() > 0 ? parts[0] : "";
+
+    if (hash.length() != SHA256_HASH_HEX_LENGTH) {
+        return;
+    }
+
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto assetRequest = assetClient->createRequest(hash);
+
+    if (!assetRequest) {
+        return;
+    }
+
+    _pendingRequests << assetRequest;
+
+    connect(assetRequest, &AssetRequest::finished, this, [this, callback](AssetRequest* request) mutable {
+        Q_ASSERT(request->getState() == AssetRequest::Finished);
+
+        if (request->getError() == AssetRequest::Error::NoError) {
+            if (callback.isFunction()) {
+                QString data = QString::fromUtf8(request->getData());
+                QScriptValueList args { data };
+                callback.call(_engine->currentContext()->thisObject(), args);
+            }
+        }
+
+        request->deleteLater();
+        _pendingRequests.remove(request);
+    });
+
+    assetRequest->start();
+}
+
+void AssetScriptingInterface::setMapping(QString path, QString hash, QScriptValue callback) {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto request = assetClient->createSetMappingRequest(path, hash);
+
+    connect(request, &SetMappingRequest::finished, this, [this, callback](SetMappingRequest* request) mutable {
+        QScriptValueList args { uint8_t(request->getError()) };
+
+        callback.call(_engine->currentContext()->thisObject(), args);
+
+        request->deleteLater();
+
+    });
+
+    request->start();
+}
+
+void AssetScriptingInterface::getMapping(QString path, QScriptValue callback) {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto request = assetClient->createGetMappingRequest(path);
+
+    connect(request, &GetMappingRequest::finished, this, [this, callback](GetMappingRequest* request) mutable {
+        QScriptValueList args { uint8_t(request->getError()), request->getHash() };
+
+        callback.call(_engine->currentContext()->thisObject(), args);
+
+        request->deleteLater();
+
+    });
+
+    request->start();
+}
+
+void AssetScriptingInterface::deleteMappings(QStringList paths, QScriptValue callback) {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto request = assetClient->createDeleteMappingsRequest(paths);
+
+    connect(request, &DeleteMappingsRequest::finished, this, [this, callback](DeleteMappingsRequest* request) mutable {
+        QScriptValueList args { uint8_t(request->getError()) };
+
+        callback.call(_engine->currentContext()->thisObject(), args);
+
+        request->deleteLater();
+
+    });
+
+    request->start();
+}
+
+void AssetScriptingInterface::getAllMappings(QScriptValue callback) {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto request = assetClient->createGetAllMappingsRequest();
+
+    connect(request, &GetAllMappingsRequest::finished, this, [this, callback](GetAllMappingsRequest* request) mutable {
+        auto mappings = request->getMappings();
+        auto map = callback.engine()->newObject();
+
+        for (auto& kv : mappings ) {
+            map.setProperty(kv.first, kv.second);
+        }
+
+        QScriptValueList args { uint8_t(request->getError()), map };
+
+        callback.call(_engine->currentContext()->thisObject(), args);
+
+        request->deleteLater();
+
+    });
+
+    request->start();
+}
+
+void AssetScriptingInterface::renameMapping(QString oldPath, QString newPath, QScriptValue callback) {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto request = assetClient->createRenameMappingRequest(oldPath, newPath);
+
+    connect(request, &RenameMappingRequest::finished, this, [this, callback](RenameMappingRequest* request) mutable {
+        QScriptValueList args { uint8_t(request->getError()) };
+        
+        callback.call(_engine->currentContext()->thisObject(), args);
+        
+        request->deleteLater();
+        
+    });
+    
+    request->start();
+}

libraries/script-engine/src/AssetScriptingInterface.h

@@ -0,0 +1,39 @@
+//
+//  AssetScriptingInterface.h
+//  libraries/script-engine/src
+//
+//  Created by Stephen Birarda on 2016-03-08.
+//  Copyright 2016 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
+//
+
+#pragma once
+
+#ifndef hifi_AssetScriptingInterface_h
+#define hifi_AssetScriptingInterface_h
+
+#include <QtCore/QObject>
+#include <QtScript/QScriptValue>
+
+#include <AssetClient.h>
+
+class AssetScriptingInterface : public QObject {
+    Q_OBJECT
+public:
+    AssetScriptingInterface(QScriptEngine* engine);
+
+    Q_INVOKABLE void uploadData(QString data, QScriptValue callback);
+    Q_INVOKABLE void downloadData(QString url, QScriptValue downloadComplete);
+    Q_INVOKABLE void setMapping(QString path, QString hash, QScriptValue callback);
+    Q_INVOKABLE void getMapping(QString path, QScriptValue callback);
+    Q_INVOKABLE void deleteMappings(QStringList paths, QScriptValue callback);
+    Q_INVOKABLE void getAllMappings(QScriptValue callback);
+    Q_INVOKABLE void renameMapping(QString oldPath, QString newPath, QScriptValue callback);
+protected:
+    QSet<AssetRequest*> _pendingRequests;
+    QScriptEngine* _engine;
+};
+
+#endif // hifi_AssetScriptingInterface_h

libraries/script-engine/src/ScriptEngine.h

@@ -23,7 +23,6 @@
 
 #include <AnimationCache.h>
 #include <AnimVariant.h>
-#include <AssetClient.h>
 #include <AvatarData.h>
 #include <AvatarHashMap.h>
 #include <LimitedNodeList.h>
@@ -32,6 +31,7 @@
 
 #include "MouseEvent.h"
 #include "ArrayBufferClass.h"
+#include "AssetScriptingInterface.h"
 #include "AudioScriptingInterface.h"
 #include "Quat.h"
 #include "ScriptCache.h"
@@ -219,4 +219,4 @@ protected:
     static std::atomic<bool> _stoppingAllScripts;
 };
 
-#endif // hifi_ScriptEngine_h
+#endif // hifi_ScriptEngine_h