path: root/indra/newview/llviewerassetstorage.cpp

/** 
 * @file llviewerassetstorage.cpp
 * @brief Subclass capable of loading asset data to/from an external source.
 *
 * $LicenseInfo:firstyear=2003&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "llviewerassetstorage.h"

#include "llvfile.h"
#include "llvfs.h"
#include "message.h"

#include "llagent.h"
#include "llviewerregion.h"

#include "lltransfersourceasset.h"
#include "lltransfertargetvfile.h"
#include "llviewerassetstats.h"
#include "llcoros.h"
#include "lleventcoro.h"
#include "llsdutil.h"

///----------------------------------------------------------------------------
/// LLViewerAssetRequest
///----------------------------------------------------------------------------

/**
 * @brief Local class to encapsulate asset fetch requests with a timestamp.
 *
 * Derived from the common LLAssetRequest class, this is currently used
 * only for fetch/get operations and its only function is to wrap remote
 * asset fetch requests so that they can be timed.
 */
class LLViewerAssetRequest : public LLAssetRequest
{
public:
    LLViewerAssetRequest(const LLUUID &uuid, const LLAssetType::EType type)
        : LLAssetRequest(uuid, type),
          mMetricsStartTime(0)
    {
    }
    
    LLViewerAssetRequest & operator=(const LLViewerAssetRequest &); // Not defined
    // Default assignment operator valid
    
    // virtual
    ~LLViewerAssetRequest()
    {
        recordMetrics();
    }

protected:
    void recordMetrics()
    {
        if (mMetricsStartTime.value())
        {
            // Okay, it appears this request was used for useful things.  Record
            // the expected dequeue and duration of request processing.
            LLViewerAssetStatsFF::record_dequeue(mType, false, false);
            LLViewerAssetStatsFF::record_response(mType, false, false,
                                                  (LLViewerAssetStatsFF::get_timestamp()
                                                   - mMetricsStartTime));
            mMetricsStartTime = (U32Seconds)0;
        }
    }
    
public:
    LLViewerAssetStats::duration_t      mMetricsStartTime;
};

///----------------------------------------------------------------------------
/// LLViewerAssetStorage
///----------------------------------------------------------------------------

LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
                                           LLVFS *vfs, LLVFS *static_vfs, 
                                           const LLHost &upstream_host)
    : LLAssetStorage(msg, xfer, vfs, static_vfs, upstream_host)
{
}


LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
                                           LLVFS *vfs, LLVFS *static_vfs)
    : LLAssetStorage(msg, xfer, vfs, static_vfs)
{
}

// virtual 
void LLViewerAssetStorage::storeAssetData(
    const LLTransactionID& tid,
    LLAssetType::EType asset_type,
    LLStoreAssetCallback callback,
    void* user_data,
    bool temp_file,
    bool is_priority,
    bool store_local,
    bool user_waiting,
    F64Seconds timeout)
{
    LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
    LL_DEBUGS("AssetStorage") << "LLViewerAssetStorage::storeAssetData (legacy) " << tid << ":" << LLAssetType::lookup(asset_type)
                              << " ASSET_ID: " << asset_id << LL_ENDL;
    
    if (mUpstreamHost.isOk())
    {
        if (mVFS->getExists(asset_id, asset_type))
        {
            // Pack data into this packet if we can fit it.
            U8 buffer[MTUBYTES];
            buffer[0] = 0;

            LLVFile vfile(mVFS, asset_id, asset_type, LLVFile::READ);
            S32 asset_size = vfile.getSize();

            LLAssetRequest *req = new LLAssetRequest(asset_id, asset_type);
            req->mUpCallback = callback;
            req->mUserData = user_data;

            if (asset_size < 1)
            {
                // This can happen if there's a bug in our code or if the VFS has been corrupted.
                LL_WARNS() << "LLViewerAssetStorage::storeAssetData()  Data _should_ already be in the VFS, but it's not! " << asset_id << LL_ENDL;
                // LLAssetStorage metric: Zero size VFS
                reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );

                delete req;
                if (callback)
                {
                    callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_FAILED, LL_EXSTAT_VFS_CORRUPT);
                }
                return;
            }
            else
            {
                // LLAssetStorage metric: Successful Request
                S32 size = mVFS->getSize(asset_id, asset_type);
                const char *message = "Added to upload queue";
                reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, size, MR_OKAY, __FILE__, __LINE__, message );

                if(is_priority)
                {
                    mPendingUploads.push_front(req);
                }
                else
                {
                    mPendingUploads.push_back(req);
                }
            }

            // Read the data from the VFS if it'll fit in this packet.
            if (asset_size + 100 < MTUBYTES)
            {
                BOOL res = vfile.read(buffer, asset_size);      /* Flawfinder: ignore */
                S32 bytes_read = res ? vfile.getLastBytesRead() : 0;
                
                if( bytes_read == asset_size )
                {
                    req->mDataSentInFirstPacket = TRUE;
                    //LL_INFOS() << "LLViewerAssetStorage::createAsset sending data in first packet" << LL_ENDL;
                }
                else
                {
                    LL_WARNS() << "Probable corruption in VFS file, aborting store asset data" << LL_ENDL;

                    // LLAssetStorage metric: VFS corrupt - bogus size
                    reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, asset_size, MR_VFS_CORRUPTION, __FILE__, __LINE__, "VFS corruption" );

                    if (callback)
                    {
                        callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LL_EXSTAT_VFS_CORRUPT);
                    }
                    return;
                }
            }
            else
            {
                // Too big, do an xfer
                buffer[0] = 0;
                asset_size = 0;
            }
            mMessageSys->newMessageFast(_PREHASH_AssetUploadRequest);
            mMessageSys->nextBlockFast(_PREHASH_AssetBlock);
            mMessageSys->addUUIDFast(_PREHASH_TransactionID, tid);
            mMessageSys->addS8Fast(_PREHASH_Type, (S8)asset_type);
            mMessageSys->addBOOLFast(_PREHASH_Tempfile, temp_file);
            mMessageSys->addBOOLFast(_PREHASH_StoreLocal, store_local);
            mMessageSys->addBinaryDataFast( _PREHASH_AssetData, buffer, asset_size );
            mMessageSys->sendReliable(mUpstreamHost);
        }
        else
        {
            LL_WARNS() << "AssetStorage: attempt to upload non-existent vfile " << asset_id << ":" << LLAssetType::lookup(asset_type) << LL_ENDL;
            // LLAssetStorage metric: Zero size VFS
            reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
            if (callback)
            {
                callback(asset_id, user_data,  LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LL_EXSTAT_NONEXISTENT_FILE);
            }
        }
    }
    else
    {
        LL_WARNS() << "Attempt to move asset store request upstream w/o valid upstream provider" << LL_ENDL;
        // LLAssetStorage metric: Upstream provider dead
        reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_NO_UPSTREAM, __FILE__, __LINE__, "No upstream provider" );
        if (callback)
        {
            callback(asset_id, user_data, LL_ERR_CIRCUIT_GONE, LL_EXSTAT_NO_UPSTREAM);
        }
    }
}

void LLViewerAssetStorage::storeAssetData(
    const std::string& filename,
    const LLTransactionID& tid,
    LLAssetType::EType asset_type,
    LLStoreAssetCallback callback,
    void* user_data,
    bool temp_file,
    bool is_priority,
    bool user_waiting,
    F64Seconds timeout)
{
    if(filename.empty())
    {
        // LLAssetStorage metric: no filename
        reportMetric( LLUUID::null, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_VFS_CORRUPTION, __FILE__, __LINE__, "Filename missing" );
        LL_ERRS() << "No filename specified" << LL_ENDL;
        return;
    }
    
    LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
    LL_DEBUGS("AssetStorage") << "LLViewerAssetStorage::storeAssetData (legacy)" << asset_id << ":" << LLAssetType::lookup(asset_type) << LL_ENDL;

    LL_DEBUGS("AssetStorage") << "ASSET_ID: " << asset_id << LL_ENDL;

    S32 size = 0;
    LLFILE* fp = LLFile::fopen(filename, "rb");
    if (fp)
    {
        fseek(fp, 0, SEEK_END);
        size = ftell(fp);
        fseek(fp, 0, SEEK_SET);
    }
    if( size )
    {
        LLLegacyAssetRequest *legacy = new LLLegacyAssetRequest;
        
        legacy->mUpCallback = callback;
        legacy->mUserData = user_data;

        LLVFile file(mVFS, asset_id, asset_type, LLVFile::WRITE);

        file.setMaxSize(size);

        const S32 buf_size = 65536;
        U8 copy_buf[buf_size];
        while ((size = (S32)fread(copy_buf, 1, buf_size, fp)))
        {
            file.write(copy_buf, size);
        }
        fclose(fp);

        // if this upload fails, the caller needs to setup a new tempfile for us
        if (temp_file)
        {
            LLFile::remove(filename);
        }

        // LLAssetStorage metric: Success not needed; handled in the overloaded method here:

        LLViewerAssetStorage::storeAssetData(
            tid,
            asset_type,
            legacyStoreDataCallback,
            (void**)legacy,
            temp_file,
            is_priority);
    }
    else // size == 0 (but previous block changes size)
    {
        if( fp )
        {
            // LLAssetStorage metric: Zero size
            reportMetric( asset_id, asset_type, filename, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file was zero length" );
        }
        else
        {
            // LLAssetStorage metric: Missing File
            reportMetric( asset_id, asset_type, filename, LLUUID::null, 0, MR_FILE_NONEXIST, __FILE__, __LINE__, "The file didn't exist" );
        }
        if (callback)
        {
            callback(asset_id, user_data, LL_ERR_CANNOT_OPEN_FILE, LL_EXSTAT_BLOCKED_FILE);
        }
    }
}


/**
 * @brief Allocate and queue an asset fetch request for the viewer
 *
 * This is a nearly-verbatim copy of the base class's implementation
 * with the following changes:
 *  -  Use a locally-derived request class
 *  -  Start timing for metrics when request is queued
 *
 * This is an unfortunate implementation choice but it's forced by
 * current conditions.  A refactoring that might clean up the layers
 * of responsibility or introduce factories or more virtualization
 * of methods would enable a more attractive solution.
 *
 * If LLAssetStorage::_queueDataRequest changes, this must change
 * as well.
 */

// virtual
void LLViewerAssetStorage::_queueDataRequest(
    const LLUUID& uuid,
    LLAssetType::EType atype,
    LLGetAssetCallback callback,
    void *user_data,
    BOOL duplicate,
    BOOL is_priority)
{
    if (LLAssetType::lookupFetchWithVACap(atype))
    {
        queueRequestHttp(uuid, atype, callback, user_data, duplicate, is_priority);
    }
    else
    {
        queueRequestUDP(uuid, atype, callback, user_data, duplicate, is_priority);
    }
}

void LLViewerAssetStorage::queueRequestUDP(
    const LLUUID& uuid,
    LLAssetType::EType atype,
    LLGetAssetCallback callback,
    void *user_data,
    BOOL duplicate,
    BOOL is_priority)
{
    LL_DEBUGS("ViewerAsset") << "Request asset via UDP " << uuid << " type " << LLAssetType::lookup(atype) << LL_ENDL;

    if (mUpstreamHost.isOk())
    {
        // stash the callback info so we can find it after we get the response message
        LLViewerAssetRequest *req = new LLViewerAssetRequest(uuid, atype);
        req->mDownCallback = callback;
        req->mUserData = user_data;
        req->mIsPriority = is_priority;
        if (!duplicate)
        {
            // Only collect metrics for non-duplicate requests.  Others 
            // are piggy-backing and will artificially lower averages.
            req->mMetricsStartTime = LLViewerAssetStatsFF::get_timestamp();
        }
        
        mPendingDownloads.push_back(req);
    
        if (!duplicate)
        {
            // send request message to our upstream data provider
            // Create a new asset transfer.
            LLTransferSourceParamsAsset spa;
            spa.setAsset(uuid, atype);

            // Set our destination file, and the completion callback.
            LLTransferTargetParamsVFile tpvf;
            tpvf.setAsset(uuid, atype);
            tpvf.setCallback(downloadCompleteCallback, *req);

            LL_DEBUGS("AssetStorage") << "Starting transfer for " << uuid << LL_ENDL;
            LLTransferTargetChannel *ttcp = gTransferManager.getTargetChannel(mUpstreamHost, LLTCT_ASSET);
            ttcp->requestTransfer(spa, tpvf, 100.f + (is_priority ? 1.f : 0.f));

            LLViewerAssetStatsFF::record_enqueue(atype, false, false);
        }
    }
    else
    {
        // uh-oh, we shouldn't have gotten here
        LL_WARNS() << "Attempt to move asset data request upstream w/o valid upstream provider" << LL_ENDL;
        if (callback)
        {
            callback(mVFS, uuid, atype, user_data, LL_ERR_CIRCUIT_GONE, LL_EXSTAT_NO_UPSTREAM);
        }
    }
}

void LLViewerAssetStorage::queueRequestHttp(
    const LLUUID& uuid,
    LLAssetType::EType atype,
    LLGetAssetCallback callback,
    void *user_data,
    BOOL duplicate,
    BOOL is_priority)
{
    LL_DEBUGS("ViewerAsset") << "Request asset via HTTP " << uuid << " type " << LLAssetType::lookup(atype) << LL_ENDL;
    std::string cap_url = gAgent.getRegion()->getCapability("ViewerAsset");
    if (cap_url.empty())
    {
        LL_WARNS() << "No ViewerAsset cap found, fetch fails" << LL_ENDL;
        // TODO asset-http: handle waiting for caps? Other failure mechanism?
        return;
    }
    else
    {
        LL_DEBUGS("ViewerAsset") << "Will fetch via ViewerAsset cap " << cap_url << LL_ENDL;

        LLViewerAssetRequest *req = new LLViewerAssetRequest(uuid, atype);
        req->mDownCallback = callback;
        req->mUserData = user_data;
        req->mIsPriority = is_priority;
        if (!duplicate)
        {
            // Only collect metrics for non-duplicate requests.  Others 
            // are piggy-backing and will artificially lower averages.
            req->mMetricsStartTime = LLViewerAssetStatsFF::get_timestamp();
        }
        mPendingDownloads.push_back(req);

        // This is the same as the current UDP logic - don't re-request a duplicate.
        if (!duplicate)
        {
            LLViewerAssetStatsFF::record_enqueue(atype, false, false);

            LLCoros::instance().launch("LLViewerAssetStorage::assetRequestCoro",
                                       boost::bind(&LLViewerAssetStorage::assetRequestCoro, this, uuid, atype, callback, user_data));
        }
    }
}

void LLViewerAssetStorage::assetRequestCoro(
    const LLUUID& uuid,
    LLAssetType::EType atype,
    LLGetAssetCallback callback,
    void *user_data)
{
    std::string url = getAssetURL(uuid,atype);
    LL_DEBUGS("ViewerAsset") << "request url: " << url << LL_ENDL;
    
    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("assetRequestCoro", httpPolicy));
    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
    LLCore::HttpOptions::ptr_t httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);

    LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts);

    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
    if (!status)
    {
        // TODO asset-http: handle failures
        LL_DEBUGS("ViewerAsset") << "request failed, status " << status.toTerseString() << ", now what?" << LL_ENDL;
    }
    else
    {
        LL_DEBUGS("ViewerAsset") << "request succeeded" << LL_ENDL;

        LL_DEBUGS("ViewerAsset") << "result: " << ll_pretty_print_sd(httpResults) << LL_ENDL;

        const LLSD::Binary &raw = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_RAW].asBinary();

        S32 size = raw.size();
        if (size > 0)
        {
			// This create-then-rename flow is modeled on LLTransferTargetVFile, which is what's used in the UDP case.
            LLUUID temp_id;
            temp_id.generate();
            LLVFile vf(gAssetStorage->mVFS, temp_id, atype, LLVFile::WRITE);
            vf.setMaxSize(size);
            if (!vf.write(raw.data(),size))
            {
                // TODO asset-http: handle error
                LL_ERRS() << "Failure in vf.write()" << LL_ENDL;
            }
            if (!vf.rename(uuid, atype))
            {
                LL_ERRS() << "rename failed" << LL_ENDL;
            }
        }
        else
        {
            // TODO asset-http: handle invalid size case
        }

        // Clean up pending downloads and trigger callbacks
        // TODO asset-http: what are the result_code and ext_status?
        S32 result_code = LL_ERR_NOERR;
        LLExtStat ext_status = LL_EXSTAT_NONE;
        removeAndCallbackPendingDownloads(uuid, atype, uuid, atype, result_code, ext_status);
    }
}

std::string LLViewerAssetStorage::getAssetURL(const LLUUID& uuid, LLAssetType::EType atype)
{
    std::string cap_url = gAgent.getRegion()->getCapability("ViewerAsset");
    std::string type_name = LLAssetType::lookup(atype);
    std::string url = cap_url + "/?" + type_name + "_id=" + uuid.asString();
    return url;
}