command-line utility for fetching an asset from a remote asset-server

tools/CMakeLists.txt

@@ -17,3 +17,5 @@ set_target_properties(ac-client PROPERTIES FOLDER "Tools")
 add_subdirectory(skeleton-dump)
 set_target_properties(skeleton-dump PROPERTIES FOLDER "Tools")
 
+add_subdirectory(atp-get)
+set_target_properties(skeleton-dump PROPERTIES FOLDER "Tools")

tools/atp-get/CMakeLists.txt

@@ -0,0 +1,3 @@
+set(TARGET_NAME atp-get)
+setup_hifi_project(Core Widgets)
+link_hifi_libraries(shared networking)

tools/atp-get/src/ATPGetApp.cpp

@@ -0,0 +1,269 @@
+//
+//  ATPGetApp.cpp
+//  tools/atp-get/src
+//
+//  Created by Seth Alves on 2017-3-15
+//  Copyright 2017 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 <QDataStream>
+#include <QTextStream>
+#include <QThread>
+#include <QFile>
+#include <QLoggingCategory>
+#include <QCommandLineParser>
+#include <NetworkLogging.h>
+#include <SharedLogging.h>
+#include <AddressManager.h>
+#include <DependencyManager.h>
+#include <SettingHandle.h>
+
+#include "ATPGetApp.h"
+
+ATPGetApp::ATPGetApp(int argc, char* argv[]) :
+    QCoreApplication(argc, argv)
+{
+    // parse command-line
+    QCommandLineParser parser;
+    parser.setApplicationDescription("High Fidelity ATP-Get");
+
+    const QCommandLineOption helpOption = parser.addHelpOption();
+
+    const QCommandLineOption verboseOutput("v", "verbose output");
+    parser.addOption(verboseOutput);
+
+    const QCommandLineOption domainAddressOption("d", "domain-server address", "127.0.0.1");
+    parser.addOption(domainAddressOption);
+
+    const QCommandLineOption cacheSTUNOption("s", "cache stun-server response");
+    parser.addOption(cacheSTUNOption);
+
+    const QCommandLineOption listenPortOption("listenPort", "listen port", QString::number(INVALID_PORT));
+    parser.addOption(listenPortOption);
+
+
+    if (!parser.parse(QCoreApplication::arguments())) {
+        qCritical() << parser.errorText() << endl;
+        parser.showHelp();
+        Q_UNREACHABLE();
+    }
+
+    if (parser.isSet(helpOption)) {
+        parser.showHelp();
+        Q_UNREACHABLE();
+    }
+
+    _verbose = parser.isSet(verboseOutput);
+    if (!_verbose) {
+        QLoggingCategory::setFilterRules("qt.network.ssl.warning=false");
+
+        const_cast<QLoggingCategory*>(&networking())->setEnabled(QtDebugMsg, false);
+        const_cast<QLoggingCategory*>(&networking())->setEnabled(QtInfoMsg, false);
+        const_cast<QLoggingCategory*>(&networking())->setEnabled(QtWarningMsg, false);
+
+        const_cast<QLoggingCategory*>(&shared())->setEnabled(QtDebugMsg, false);
+        const_cast<QLoggingCategory*>(&shared())->setEnabled(QtInfoMsg, false);
+        const_cast<QLoggingCategory*>(&shared())->setEnabled(QtWarningMsg, false);
+    }
+
+
+    QStringList filenames = parser.positionalArguments();
+    if (filenames.empty() || filenames.size() > 2) {
+        qDebug() << "give remote url and optional local filename as arguments";
+        parser.showHelp();
+        Q_UNREACHABLE();
+    }
+
+    _url = QUrl(filenames[0]);
+    if (_url.scheme() != "atp") {
+        qDebug() << "url should start with atp:";
+        parser.showHelp();
+        Q_UNREACHABLE();
+    }
+
+    if (filenames.size() == 2) {
+        _localOutputFile = filenames[1];
+    }
+
+    QString domainServerAddress = "127.0.0.1:40103";
+    if (parser.isSet(domainAddressOption)) {
+        domainServerAddress = parser.value(domainAddressOption);
+    }
+
+    if (_verbose) {
+        qDebug() << "domain-server address is" << domainServerAddress;
+    }
+
+    int listenPort = INVALID_PORT;
+    if (parser.isSet(listenPortOption)) {
+        listenPort = parser.value(listenPortOption).toInt();
+    }
+
+    Setting::init();
+    DependencyManager::registerInheritance<LimitedNodeList, NodeList>();
+
+    DependencyManager::set<AccountManager>([&]{ return QString("Mozilla/5.0 (HighFidelityATPGet)"); });
+    DependencyManager::set<AddressManager>();
+    DependencyManager::set<NodeList>(NodeType::Agent, listenPort);
+
+
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    // start the nodeThread so its event loop is running
+    QThread* nodeThread = new QThread(this);
+    nodeThread->setObjectName("NodeList Thread");
+    nodeThread->start();
+
+    // make sure the node thread is given highest priority
+    nodeThread->setPriority(QThread::TimeCriticalPriority);
+
+    // setup a timer for domain-server check ins
+    QTimer* domainCheckInTimer = new QTimer(nodeList.data());
+    connect(domainCheckInTimer, &QTimer::timeout, nodeList.data(), &NodeList::sendDomainServerCheckIn);
+    domainCheckInTimer->start(DOMAIN_SERVER_CHECK_IN_MSECS);
+
+    // put the NodeList and datagram processing on the node thread
+    nodeList->moveToThread(nodeThread);
+
+    const DomainHandler& domainHandler = nodeList->getDomainHandler();
+
+    connect(&domainHandler, SIGNAL(hostnameChanged(const QString&)), SLOT(domainChanged(const QString&)));
+    // connect(&domainHandler, SIGNAL(resetting()), SLOT(resettingDomain()));
+    // connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(clearDomainOctreeDetails()));
+    connect(&domainHandler, &DomainHandler::domainConnectionRefused, this, &ATPGetApp::domainConnectionRefused);
+
+    connect(nodeList.data(), &NodeList::nodeAdded, this, &ATPGetApp::nodeAdded);
+    connect(nodeList.data(), &NodeList::nodeKilled, this, &ATPGetApp::nodeKilled);
+    connect(nodeList.data(), &NodeList::nodeActivated, this, &ATPGetApp::nodeActivated);
+    // connect(nodeList.data(), &NodeList::uuidChanged, getMyAvatar(), &MyAvatar::setSessionUUID);
+    // connect(nodeList.data(), &NodeList::uuidChanged, this, &ATPGetApp::setSessionUUID);
+    connect(nodeList.data(), &NodeList::packetVersionMismatch, this, &ATPGetApp::notifyPacketVersionMismatch);
+
+    nodeList->addSetOfNodeTypesToNodeInterestSet(NodeSet() << NodeType::AudioMixer << NodeType::AvatarMixer
+                                                 << NodeType::EntityServer << NodeType::AssetServer << NodeType::MessagesMixer);
+
+    DependencyManager::get<AddressManager>()->handleLookupString(domainServerAddress, false);
+
+    auto assetClient = DependencyManager::set<AssetClient>();
+    assetClient->init();
+
+    QTimer* doTimer = new QTimer(this);
+    doTimer->setSingleShot(true);
+    connect(doTimer, &QTimer::timeout, this, &ATPGetApp::timedOut);
+    doTimer->start(4000);
+}
+
+ATPGetApp::~ATPGetApp() {
+}
+
+
+void ATPGetApp::domainConnectionRefused(const QString& reasonMessage, int reasonCodeInt, const QString& extraInfo) {
+    qDebug() << "domainConnectionRefused";
+}
+
+void ATPGetApp::domainChanged(const QString& domainHostname) {
+    if (_verbose) {
+        qDebug() << "domainChanged";
+    }
+}
+
+void ATPGetApp::nodeAdded(SharedNodePointer node) {
+    if (_verbose) {
+        qDebug() << "node added: " << node->getType();
+    }
+}
+
+void ATPGetApp::nodeActivated(SharedNodePointer node) {
+    if (node->getType() == NodeType::AssetServer) {
+        lookup();
+    }
+}
+
+void ATPGetApp::nodeKilled(SharedNodePointer node) {
+    qDebug() << "nodeKilled";
+}
+
+void ATPGetApp::timedOut() {
+    finish(1);
+}
+
+void ATPGetApp::notifyPacketVersionMismatch() {
+    if (_verbose) {
+        qDebug() << "packet version mismatch";
+    }
+    finish(1);
+}
+
+void ATPGetApp::lookup() {
+
+    auto path = _url.path();
+    qDebug() << "path is " << path;
+
+    auto request = DependencyManager::get<AssetClient>()->createGetMappingRequest(path);
+    QObject::connect(request, &GetMappingRequest::finished, this, [=](GetMappingRequest* request) mutable {
+        auto result = request->getError();
+        if (result == GetMappingRequest::NotFound) {
+            qDebug() << "not found";
+        } else if (result == GetMappingRequest::NoError) {
+            qDebug() << "found, hash is " << request->getHash();
+            download(request->getHash());
+        } else {
+            qDebug() << "error -- " << request->getError() << " -- " << request->getErrorString();
+        }
+        request->deleteLater();
+    });
+    request->start();
+}
+
+void ATPGetApp::download(AssetHash hash) {
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto assetRequest = new AssetRequest(hash);
+
+    connect(assetRequest, &AssetRequest::finished, this, [this](AssetRequest* request) mutable {
+        Q_ASSERT(request->getState() == AssetRequest::Finished);
+
+        if (request->getError() == AssetRequest::Error::NoError) {
+            QString data = QString::fromUtf8(request->getData());
+            if (_localOutputFile == "") {
+                QTextStream cout(stdout);
+                cout << data;
+            } else {
+                QFile outputHandle(_localOutputFile);
+                if (outputHandle.open(QIODevice::ReadWrite)) {
+                    QTextStream stream( &outputHandle );
+                    stream << data;
+                } else {
+                    qDebug() << "couldn't open output file:" << _localOutputFile;
+                }
+            }
+        }
+
+        request->deleteLater();
+        finish(0);
+    });
+
+    assetRequest->start();
+}
+
+void ATPGetApp::finish(int exitCode) {
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    // send the domain a disconnect packet, force stoppage of domain-server check-ins
+    nodeList->getDomainHandler().disconnect();
+    nodeList->setIsShuttingDown(true);
+
+    // tell the packet receiver we're shutting down, so it can drop packets
+    nodeList->getPacketReceiver().setShouldDropPackets(true);
+
+    QThread* nodeThread = DependencyManager::get<NodeList>()->thread();
+    // remove the NodeList from the DependencyManager
+    DependencyManager::destroy<NodeList>();
+    // ask the node thread to quit and wait until it is done
+    nodeThread->quit();
+    nodeThread->wait();
+
+    QCoreApplication::exit(exitCode);
+}

tools/atp-get/src/ATPGetApp.h

@@ -0,0 +1,52 @@
+//
+//  ATPGetApp.h
+//  tools/atp-get/src
+//
+//  Created by Seth Alves on 2017-3-15
+//  Copyright 2017 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
+//
+
+
+#ifndef hifi_ATPGetApp_h
+#define hifi_ATPGetApp_h
+
+#include <QApplication>
+#include <udt/Constants.h>
+#include <udt/Socket.h>
+#include <ReceivedMessage.h>
+#include <NetworkPeer.h>
+#include <NodeList.h>
+#include <AssetRequest.h>
+#include <MappingRequest.h>
+
+
+class ATPGetApp : public QCoreApplication {
+    Q_OBJECT
+public:
+    ATPGetApp(int argc, char* argv[]);
+    ~ATPGetApp();
+
+private slots:
+    void domainConnectionRefused(const QString& reasonMessage, int reasonCodeInt, const QString& extraInfo);
+    void domainChanged(const QString& domainHostname);
+    void nodeAdded(SharedNodePointer node);
+    void nodeActivated(SharedNodePointer node);
+    void nodeKilled(SharedNodePointer node);
+    void notifyPacketVersionMismatch();
+
+private:
+    NodeList* _nodeList;
+    void timedOut();
+    void lookup();
+    void download(AssetHash hash);
+    void finish(int exitCode);
+    bool _verbose;
+
+    QUrl _url;
+    QString _localOutputFile;
+};
+
+#endif // hifi_ATPGetApp_h

tools/atp-get/src/main.cpp

@@ -0,0 +1,31 @@
+//
+//  main.cpp
+//  tools/atp-get/src
+//
+//  Created by Seth Alves on 2017-3-15
+//  Copyright 2017 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 <iostream>
+#include <iomanip>
+#include <string>
+#include <vector>
+
+#include <BuildInfo.h>
+
+#include "ATPGetApp.h"
+
+using namespace std;
+
+int main(int argc, char * argv[]) {
+    QCoreApplication::setApplicationName(BuildInfo::AC_CLIENT_SERVER_NAME);
+    QCoreApplication::setOrganizationName(BuildInfo::MODIFIED_ORGANIZATION);
+    QCoreApplication::setOrganizationDomain(BuildInfo::ORGANIZATION_DOMAIN);
+    QCoreApplication::setApplicationVersion(BuildInfo::VERSION);
+
+    ATPGetApp app(argc, argv);
+
+    return app.exec();
+}