summaryrefslogtreecommitdiff
path: root/indra/llmessage/llassetstorage.h
blob: 88fa572092361cc9e357ffa68883093368a41b7c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
/**
 * @file llassetstorage.h
 * @brief definition of LLAssetStorage class which allows simple
 * up/downloads of uuid,type asets
 *
 * $LicenseInfo:firstyear=2001&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$
 */

#ifndef LL_LLASSETSTORAGE_H
#define LL_LLASSETSTORAGE_H
#include <string>
#include <functional>

#include "lluuid.h"
#include "lltimer.h"
#include "llnamevalue.h"
#include "llhost.h"
#include "lltransfermanager.h" // For LLTSCode enum
#include "llassettype.h"
#include "llstring.h"
#include "llextendedstatus.h"
#include "llxfer.h"

// Forward declarations
class LLMessageSystem;
class LLXferManager;
class LLAssetStorage;
class LLSD;

// anything that takes longer than this to download will abort.
// HTTP Uploads also timeout if they take longer than this.
const F32Minutes LL_ASSET_STORAGE_TIMEOUT(5);


// Specific error codes
const int LL_ERR_ASSET_REQUEST_FAILED = -1;
//const int LL_ERR_ASSET_REQUEST_INVALID = -2;
const int LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE = -3;
const int LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE = -4;
const int LL_ERR_INSUFFICIENT_PERMISSIONS = -5;
const int LL_ERR_PRICE_MISMATCH = -23018;

// *TODO: these typedefs are passed into the cache via a legacy C function pointer
// future project would be to convert these to C++ callables (std::function<>) so that
// we can use bind and remove the userData parameter.
//
typedef std::function<void(const LLUUID &asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)> LLGetAssetCallback;
typedef std::function<void(const LLUUID &asset_id, void *user_data, S32 status, LLExtStat ext_status)> LLStoreAssetCallback;


class LLAssetInfo
{
protected:
    std::string     mDescription;
    std::string     mName;

public:
    LLUUID          mUuid;
    LLTransactionID mTransactionID;
    LLUUID          mCreatorID;
    LLAssetType::EType  mType;

    LLAssetInfo( void );
    LLAssetInfo( const LLUUID& object_id, const LLUUID& creator_id,
                 LLAssetType::EType type, const char* name, const char* desc );
    LLAssetInfo( const LLNameValue& nv );

    const std::string& getName( void ) const { return mName; }
    const std::string& getDescription( void ) const { return mDescription; }
    void setName( const std::string& name );
    void setDescription( const std::string& desc );

    // Assets (aka potential inventory items) can be applied to an
    // object in the world. We'll store that as a string name value
    // pair where the name encodes part of asset info, and the value
    // the rest.  LLAssetInfo objects will be responsible for parsing
    // the meaning out froman LLNameValue object. See the inventory
    // design docs for details.
    void setFromNameValue( const LLNameValue& nv );
};


class LLBaseDownloadRequest
{
public:
    LLBaseDownloadRequest(const LLUUID &uuid, const LLAssetType::EType at);
    virtual ~LLBaseDownloadRequest();

    LLUUID getUUID() const                  { return mUUID; }
    LLAssetType::EType getType() const      { return mType; }

    void setUUID(const LLUUID& id) { mUUID = id; }
    void setType(LLAssetType::EType type) { mType = type; }

    virtual LLBaseDownloadRequest* getCopy();

protected:
    LLUUID  mUUID;
    LLAssetType::EType mType;

public:
    LLGetAssetCallback mDownCallback;

    void    *mUserData;
    LLHost  mHost;
    bool    mIsTemp;
    F64Seconds      mTime;              // Message system time
    bool    mIsPriority;
    bool    mDataSentInFirstPacket;
    bool    mDataIsInCache;
};

class LLAssetRequest : public LLBaseDownloadRequest
{
public:
    LLAssetRequest(const LLUUID &uuid, const LLAssetType::EType at);
    virtual ~LLAssetRequest();

    void setTimeout(F64Seconds timeout) { mTimeout = timeout; }

    virtual LLBaseDownloadRequest* getCopy();

    LLStoreAssetCallback mUpCallback;
//  void    (*mUpCallback)(const LLUUID&, void *, S32, LLExtStat);
    void    (*mInfoCallback)(LLAssetInfo *, void *, S32);

    bool    mIsLocal;
    bool    mIsUserWaiting;     // We don't want to try forever if a user is waiting for a result.
    F64Seconds      mTimeout;           // Amount of time before timing out.
    LLUUID  mRequestingAgentID; // Only valid for uploads from an agent
    F64 mBytesFetched;

    virtual LLSD getTerseDetails() const;
    virtual LLSD getFullDetails() const;
};

template <class T>
struct ll_asset_request_equal : public std::equal_to<T>
{
    bool operator()(const T& x, const T& y) const
    {
        return (    x->getType() == y->getType()
                &&  x->getUUID() == y->getUUID() );
    }
};


class LLInvItemRequest : public LLBaseDownloadRequest
{
public:
    LLInvItemRequest(const LLUUID &uuid, const LLAssetType::EType at);
    virtual ~LLInvItemRequest();

    virtual LLBaseDownloadRequest* getCopy();
};

class LLEstateAssetRequest : public LLBaseDownloadRequest
{
public:
    LLEstateAssetRequest(const LLUUID &uuid, const LLAssetType::EType at, EstateAssetType et);
    virtual ~LLEstateAssetRequest();

    LLAssetType::EType getAType() const     { return mType; }

    virtual LLBaseDownloadRequest* getCopy();

protected:
    EstateAssetType mEstateAssetType;
};


// Map of known bad assets
typedef std::map<LLUUID,U64,lluuid_less> toxic_asset_map_t;



class LLAssetStorage
{
public:
    typedef ::LLStoreAssetCallback LLStoreAssetCallback;
    typedef ::LLGetAssetCallback LLGetAssetCallback;

    enum ERequestType
    {
        RT_INVALID = -1,
        RT_DOWNLOAD = 0,
        RT_UPLOAD = 1,
        RT_LOCALUPLOAD = 2,
        RT_COUNT = 3
    };

protected:
    bool mShutDown;
    LLHost mUpstreamHost;

    LLMessageSystem *mMessageSys;
    LLXferManager   *mXferManager;


    typedef std::list<LLAssetRequest*> request_list_t;
    request_list_t mPendingDownloads;
    request_list_t mPendingUploads;
    request_list_t mPendingLocalUploads;

    // Map of toxic assets - these caused problems when recently rezzed, so avoid them
    toxic_asset_map_t   mToxicAssetMap;     // Objects in this list are known to cause problems and are not loaded

public:
    LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host);

    LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer);
    virtual ~LLAssetStorage();

    void setUpstream(const LLHost &upstream_host);

    bool hasLocalAsset(const LLUUID &uuid, LLAssetType::EType type);

    // public interface methods
    // note that your callback may get called BEFORE the function returns
    void getAssetData(const LLUUID uuid, LLAssetType::EType atype, LLGetAssetCallback cb, void *user_data, bool is_priority = false);

    /*
     * TransactionID version
     * Viewer needs the store_local
     */
    virtual void storeAssetData(
        const LLTransactionID& tid,
        LLAssetType::EType atype,
        LLStoreAssetCallback callback,
        void* user_data,
        bool temp_file = false,
        bool is_priority = false,
        bool store_local = false,
        bool user_waiting= false,
        F64Seconds timeout=LL_ASSET_STORAGE_TIMEOUT) = 0;

    virtual void logAssetStorageInfo() = 0;

    virtual void checkForTimeouts();

    void getEstateAsset(const LLHost &object_sim, const LLUUID &agent_id, const LLUUID &session_id,
                                    const LLUUID &asset_id, LLAssetType::EType atype, EstateAssetType etype,
                                     LLGetAssetCallback callback, void *user_data, bool is_priority);

    void getInvItemAsset(const LLHost &object_sim,
                         const LLUUID &agent_id, const LLUUID &session_id,
                         const LLUUID &owner_id, const LLUUID &task_id, const LLUUID &item_id,
                         const LLUUID &asset_id, LLAssetType::EType atype,
                         LLGetAssetCallback cb, void *user_data, bool is_priority = false); // Get a particular inventory item.

    // Check if an asset is in the toxic map.  If it is, the entry is updated
    bool        isAssetToxic( const LLUUID& uuid );

    // Clean the toxic asset list, remove old entries
    void        flushOldToxicAssets( bool force_it );

    // Add an item to the toxic asset map
    void        markAssetToxic( const LLUUID& uuid );

protected:
    bool findInCacheAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
                                          LLGetAssetCallback callback, void *user_data);

    LLSD getPendingDetailsImpl(const request_list_t* requests,
                               LLAssetType::EType asset_type,
                               const std::string& detail_prefix) const;

    LLSD getPendingRequestImpl(const request_list_t* requests,
                               LLAssetType::EType asset_type,
                               const LLUUID& asset_id) const;

    bool deletePendingRequestImpl(request_list_t* requests,
                                  LLAssetType::EType asset_type,
                                  const LLUUID& asset_id);

public:
    static const LLAssetRequest* findRequest(const request_list_t* requests,
                                        LLAssetType::EType asset_type,
                                        const LLUUID& asset_id);
    static LLAssetRequest* findRequest(request_list_t* requests,
                                        LLAssetType::EType asset_type,
                                        const LLUUID& asset_id);

    request_list_t* getRequestList(ERequestType rt);
    const request_list_t* getRequestList(ERequestType rt) const;
    static std::string getRequestName(ERequestType rt);

    S32 getNumPendingDownloads() const;
    S32 getNumPendingUploads() const;
    S32 getNumPendingLocalUploads();
    S32 getNumPending(ERequestType rt) const;

    LLSD getPendingDetails(ERequestType rt,
                           LLAssetType::EType asset_type,
                           const std::string& detail_prefix) const;

    LLSD getPendingRequest(ERequestType rt,
                           LLAssetType::EType asset_type,
                           const LLUUID& asset_id) const;

    bool deletePendingRequest(ERequestType rt,
                              LLAssetType::EType asset_type,
                              const LLUUID& asset_id);


    static void removeAndCallbackPendingDownloads(const LLUUID& file_id, LLAssetType::EType file_type,
                                                  const LLUUID& callback_id, LLAssetType::EType callback_type,
                                                  S32 result_code, LLExtStat ext_status);

    // download process callbacks
    static void downloadCompleteCallback(
        S32 result,
        const LLUUID& file_id,
        LLAssetType::EType file_type,
        LLBaseDownloadRequest* user_data, LLExtStat ext_status);
    static void downloadEstateAssetCompleteCallback(
        S32 result,
        const LLUUID& file_id,
        LLAssetType::EType file_type,
        LLBaseDownloadRequest* user_data, LLExtStat ext_status);
    static void downloadInvItemCompleteCallback(
        S32 result,
        const LLUUID& file_id,
        LLAssetType::EType file_type,
        LLBaseDownloadRequest* user_data, LLExtStat ext_status);

    // upload process callbacks
    static void uploadCompleteCallback(const LLUUID&, void *user_data, S32 result, LLExtStat ext_status);
    static void processUploadComplete(LLMessageSystem *msg, void **this_handle);

    // debugging
    static const char* getErrorString( S32 status );

    // deprecated file-based methods
    // Not overriden
    void getAssetData(const LLUUID uuid, LLAssetType::EType type, void (*callback)(const char*, const LLUUID&, void *, S32, LLExtStat), void *user_data, bool is_priority = false);

    /*
     * TransactionID version
     */
    virtual void storeAssetData(
        const std::string& filename,
        const LLTransactionID &transaction_id,
        LLAssetType::EType type,
        LLStoreAssetCallback callback,
        void *user_data,
        bool temp_file = false,
        bool is_priority = false,
        bool user_waiting = false,
        F64Seconds timeout  = LL_ASSET_STORAGE_TIMEOUT) = 0;

    static void legacyGetDataCallback(const LLUUID &uuid, LLAssetType::EType, void *user_data, S32 status, LLExtStat ext_status);
    static void legacyStoreDataCallback(const LLUUID &uuid, void *user_data, S32 status, LLExtStat ext_status);

    // add extra methods to handle metadata

protected:
    void _cleanupRequests(bool all, S32 error);
    void _callUploadCallbacks(const LLUUID &uuid, const LLAssetType::EType asset_type, bool success, LLExtStat ext_status);

    virtual void _queueDataRequest(const LLUUID& uuid, LLAssetType::EType type, LLGetAssetCallback callback,
                                   void *user_data, bool duplicate,
                                   bool is_priority) = 0;

private:
    void _init(LLMessageSystem *msg,
               LLXferManager *xfer,
               const LLHost &upstream_host);

protected:
    enum EMetricResult
    {
        // Static valued enums for #dw readability - please copy this
        // declaration to them on updates -- source in llassetstorage.h
        MR_INVALID          = -1,   // Makes no sense
        MR_OKAY             = 0,    // Success - no metric normally
        MR_ZERO_SIZE        = 1,    // Zero size asset
        MR_BAD_FUNCTION     = 2,    // Tried to use a virtual base (PROGRAMMER ERROR)
        MR_FILE_NONEXIST    = 3,    // Old format store call - source file does not exist
        MR_NO_FILENAME      = 4,    // Old format store call - source filename is NULL/0-length
        MR_NO_UPSTREAM      = 5,    // Upstream provider is missing
        MR_CACHE_CORRUPTION = 6     // cache is corrupt - too-large or mismatched stated/returned sizes
    };

    static class LLMetrics *metric_recipient;

    static void reportMetric( const LLUUID& asset_id, const LLAssetType::EType asset_type, const std::string& filename,
                              const LLUUID& agent_id, S32 asset_size, EMetricResult result,
                              const char* file, const S32 line, const std::string& message );
public:
    static void setMetricRecipient( LLMetrics *recip )
    {
        metric_recipient = recip;
    }
};

////////////////////////////////////////////////////////////////////////
// Wrappers to replicate deprecated API
////////////////////////////////////////////////////////////////////////

class LLLegacyAssetRequest
{
public:
    void    (*mDownCallback)(const char *, const LLUUID&, void *, S32, LLExtStat);
    LLStoreAssetCallback mUpCallback;

    void    *mUserData;
};

extern LLAssetStorage *gAssetStorage;
extern const LLUUID CATEGORIZE_LOST_AND_FOUND_ID;
#endif