/indra/newview/llmediadataclient.cpp
https://bitbucket.org/lindenlab/viewer-beta/ · C++ · 1070 lines · 722 code · 176 blank · 172 comment · 107 complexity · fab296ae8ceaefb9a25fa3d64843bf43 MD5 · raw file
- /**
- * @file llmediadataclient.cpp
- * @brief class for queueing up requests for media data
- *
- * $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$
- */
- #include "llviewerprecompiledheaders.h"
- #include "llmediadataclient.h"
- #if LL_MSVC
- // disable boost::lexical_cast warning
- #pragma warning (disable:4702)
- #endif
- #include <boost/lexical_cast.hpp>
- #include "llhttpstatuscodes.h"
- #include "llsdutil.h"
- #include "llmediaentry.h"
- #include "lltextureentry.h"
- #include "llviewerregion.h"
- //
- // When making a request
- // - obtain the "overall interest score" of the object.
- // This would be the sum of the impls' interest scores.
- // - put the request onto a queue sorted by this score
- // (highest score at the front of the queue)
- // - On a timer, once a second, pull off the head of the queue and send
- // the request.
- // - Any request that gets a 503 still goes through the retry logic
- //
- /***************************************************************************************************************
- What's up with this queueing code?
- First, a bit of background:
- Media on a prim was added into the system in the Viewer 2.0 timeframe. In order to avoid changing the
- network format of objects, an unused field in the object (the "MediaURL" string) was repurposed to
- indicate that the object had media data, and also hold a sequence number and the UUID of the agent
- who last updated the data. The actual media data for objects is accessed via the "ObjectMedia" capability.
- Due to concerns about sim performance, requests to this capability are rate-limited to 5 requests every
- 5 seconds per agent.
- The initial implementation of LLMediaDataClient used a single queue to manage requests to the "ObjectMedia" cap.
- Requests to the cap were queued so that objects closer to the avatar were loaded in first, since they were most
- likely to be the ones the media performance manager would load.
- This worked in some cases, but we found that it was possible for a scripted object that constantly updated its
- media data to starve other objects, since the same queue contained both requests to load previously unseen media
- data and requests to fetch media data in response to object updates.
- The solution for this we came up with was to have two queues. The sorted queue contains requests to fetch media
- data for objects that don't have it yet, and the round-robin queue contains requests to update media data for
- objects that have already completed their initial load. When both queues are non-empty, the code ping-pongs
- between them so that updates can't completely block initial load-in.
- **************************************************************************************************************/
- //
- // Forward decls
- //
- const F32 LLMediaDataClient::QUEUE_TIMER_DELAY = 1.0; // seconds(s)
- const F32 LLMediaDataClient::UNAVAILABLE_RETRY_TIMER_DELAY = 5.0; // secs
- const U32 LLMediaDataClient::MAX_RETRIES = 4;
- const U32 LLMediaDataClient::MAX_SORTED_QUEUE_SIZE = 10000;
- const U32 LLMediaDataClient::MAX_ROUND_ROBIN_QUEUE_SIZE = 10000;
- // << operators
- std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::request_queue_t &q);
- std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &q);
- template <typename T>
- static typename T::iterator find_matching_request(T &c, const LLMediaDataClient::Request *request, LLMediaDataClient::Request::Type match_type)
- {
- for(typename T::iterator iter = c.begin(); iter != c.end(); ++iter)
- {
- if(request->isMatch(*iter, match_type))
- {
- return iter;
- }
- }
-
- return c.end();
- }
- template <typename T>
- static typename T::iterator find_matching_request(T &c, const LLUUID &id, LLMediaDataClient::Request::Type match_type)
- {
- for(typename T::iterator iter = c.begin(); iter != c.end(); ++iter)
- {
- if(((*iter)->getID() == id) && ((match_type == LLMediaDataClient::Request::ANY) || (match_type == (*iter)->getType())))
- {
- return iter;
- }
- }
-
- return c.end();
- }
- // NOTE: remove_matching_requests will not work correctly for containers where deleting an element may invalidate iterators
- // to other elements in the container (such as std::vector).
- // If the implementation is changed to use a container with this property, this will need to be revisited.
- template <typename T>
- static void remove_matching_requests(T &c, const LLUUID &id, LLMediaDataClient::Request::Type match_type)
- {
- for(typename T::iterator iter = c.begin(); iter != c.end();)
- {
- typename T::value_type i = *iter;
- typename T::iterator next = iter;
- next++;
- if((i->getID() == id) && ((match_type == LLMediaDataClient::Request::ANY) || (match_type == i->getType())))
- {
- i->markDead();
- c.erase(iter);
- }
- iter = next;
- }
- }
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLMediaDataClient
- //
- //////////////////////////////////////////////////////////////////////////////////////
- LLMediaDataClient::LLMediaDataClient(F32 queue_timer_delay,
- F32 retry_timer_delay,
- U32 max_retries,
- U32 max_sorted_queue_size,
- U32 max_round_robin_queue_size)
- : mQueueTimerDelay(queue_timer_delay),
- mRetryTimerDelay(retry_timer_delay),
- mMaxNumRetries(max_retries),
- mMaxSortedQueueSize(max_sorted_queue_size),
- mMaxRoundRobinQueueSize(max_round_robin_queue_size),
- mQueueTimerIsRunning(false)
- {
- }
- LLMediaDataClient::~LLMediaDataClient()
- {
- stopQueueTimer();
- }
- bool LLMediaDataClient::isEmpty() const
- {
- return mQueue.empty();
- }
- bool LLMediaDataClient::isInQueue(const LLMediaDataClientObject::ptr_t &object)
- {
- if(find_matching_request(mQueue, object->getID()) != mQueue.end())
- return true;
-
- if(find_matching_request(mUnQueuedRequests, object->getID()) != mUnQueuedRequests.end())
- return true;
-
- return false;
- }
- void LLMediaDataClient::removeFromQueue(const LLMediaDataClientObject::ptr_t &object)
- {
- LL_DEBUGS("LLMediaDataClient") << "removing requests matching ID " << object->getID() << LL_ENDL;
- remove_matching_requests(mQueue, object->getID());
- remove_matching_requests(mUnQueuedRequests, object->getID());
- }
- void LLMediaDataClient::startQueueTimer()
- {
- if (! mQueueTimerIsRunning)
- {
- LL_DEBUGS("LLMediaDataClient") << "starting queue timer (delay=" << mQueueTimerDelay << " seconds)" << LL_ENDL;
- // LLEventTimer automagically takes care of the lifetime of this object
- new QueueTimer(mQueueTimerDelay, this);
- }
- else {
- LL_DEBUGS("LLMediaDataClient") << "queue timer is already running" << LL_ENDL;
- }
- }
- void LLMediaDataClient::stopQueueTimer()
- {
- mQueueTimerIsRunning = false;
- }
- bool LLMediaDataClient::processQueueTimer()
- {
- if(isEmpty())
- return true;
- LL_DEBUGS("LLMediaDataClient") << "QueueTimer::tick() started, queue size is: " << mQueue.size() << LL_ENDL;
- LL_DEBUGS("LLMediaDataClientQueue") << "QueueTimer::tick() started, SORTED queue is: " << mQueue << LL_ENDL;
-
- serviceQueue();
-
- LL_DEBUGS("LLMediaDataClient") << "QueueTimer::tick() finished, queue size is: " << mQueue.size() << LL_ENDL;
- LL_DEBUGS("LLMediaDataClientQueue") << "QueueTimer::tick() finished, SORTED queue is: " << mQueue << LL_ENDL;
-
- return isEmpty();
- }
- LLMediaDataClient::request_ptr_t LLMediaDataClient::dequeue()
- {
- request_ptr_t request;
- request_queue_t *queue_p = getQueue();
-
- if (queue_p->empty())
- {
- LL_DEBUGS("LLMediaDataClient") << "queue empty: " << (*queue_p) << LL_ENDL;
- }
- else
- {
- request = queue_p->front();
-
- if(canServiceRequest(request))
- {
- // We will be returning this request, so remove it from the queue.
- queue_p->pop_front();
- }
- else
- {
- // Don't return this request -- it's not ready to be serviced.
- request = NULL;
- }
- }
- return request;
- }
- void LLMediaDataClient::pushBack(request_ptr_t request)
- {
- request_queue_t *queue_p = getQueue();
- queue_p->push_front(request);
- }
- void LLMediaDataClient::trackRequest(request_ptr_t request)
- {
- request_set_t::iterator iter = mUnQueuedRequests.find(request);
-
- if(iter != mUnQueuedRequests.end())
- {
- LL_WARNS("LLMediaDataClient") << "Tracking already tracked request: " << *request << LL_ENDL;
- }
- else
- {
- mUnQueuedRequests.insert(request);
- }
- }
- void LLMediaDataClient::stopTrackingRequest(request_ptr_t request)
- {
- request_set_t::iterator iter = mUnQueuedRequests.find(request);
-
- if (iter != mUnQueuedRequests.end())
- {
- mUnQueuedRequests.erase(iter);
- }
- else
- {
- LL_WARNS("LLMediaDataClient") << "Removing an untracked request: " << *request << LL_ENDL;
- }
- }
- void LLMediaDataClient::serviceQueue()
- {
- // Peel one off of the items from the queue and execute it
- request_ptr_t request;
-
- do
- {
- request = dequeue();
- if(request.isNull())
- {
- // Queue is empty.
- return;
- }
- if(request->isDead())
- {
- LL_INFOS("LLMediaDataClient") << "Skipping dead request " << *request << LL_ENDL;
- continue;
- }
- } while(false);
-
- // try to send the HTTP message to the cap url
- std::string url = request->getCapability();
- if (!url.empty())
- {
- const LLSD &sd_payload = request->getPayload();
- LL_INFOS("LLMediaDataClient") << "Sending request for " << *request << LL_ENDL;
-
- // Add this request to the non-queued tracking list
- trackRequest(request);
-
- // and make the post
- LLHTTPClient::post(url, sd_payload, request->createResponder());
- }
- else
- {
- // Cap url doesn't exist.
-
- if(request->getRetryCount() < mMaxNumRetries)
- {
- LL_WARNS("LLMediaDataClient") << "Could not send request " << *request << " (empty cap url), will retry." << LL_ENDL;
- // Put this request back at the head of its queue, and retry next time the queue timer fires.
- request->incRetryCount();
- pushBack(request);
- }
- else
- {
- // This request has exceeded its maxumim retry count. It will be dropped.
- LL_WARNS("LLMediaDataClient") << "Could not send request " << *request << " for " << mMaxNumRetries << " tries, dropping request." << LL_ENDL;
- }
- }
- }
- // dump the queue
- std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::request_queue_t &q)
- {
- int i = 0;
- LLMediaDataClient::request_queue_t::const_iterator iter = q.begin();
- LLMediaDataClient::request_queue_t::const_iterator end = q.end();
- while (iter != end)
- {
- s << "\t" << i << "]: " << (*iter)->getID().asString() << "(" << (*iter)->getObject()->getMediaInterest() << ")";
- iter++;
- i++;
- }
- return s;
- }
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLMediaDataClient::QueueTimer
- // Queue of LLMediaDataClientObject smart pointers to request media for.
- //
- //////////////////////////////////////////////////////////////////////////////////////
- LLMediaDataClient::QueueTimer::QueueTimer(F32 time, LLMediaDataClient *mdc)
- : LLEventTimer(time), mMDC(mdc)
- {
- mMDC->setIsRunning(true);
- }
- // virtual
- BOOL LLMediaDataClient::QueueTimer::tick()
- {
- BOOL result = TRUE;
-
- if (!mMDC.isNull())
- {
- result = mMDC->processQueueTimer();
-
- if(result)
- {
- // This timer won't fire again.
- mMDC->setIsRunning(false);
- mMDC = NULL;
- }
- }
- return result;
- }
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLMediaDataClient::Responder::RetryTimer
- //
- //////////////////////////////////////////////////////////////////////////////////////
- LLMediaDataClient::RetryTimer::RetryTimer(F32 time, request_ptr_t request)
- : LLEventTimer(time), mRequest(request)
- {
- mRequest->startTracking();
- }
- // virtual
- BOOL LLMediaDataClient::RetryTimer::tick()
- {
- mRequest->stopTracking();
- if(mRequest->isDead())
- {
- LL_INFOS("LLMediaDataClient") << "RetryTimer fired for dead request: " << *mRequest << ", aborting." << LL_ENDL;
- }
- else
- {
- LL_INFOS("LLMediaDataClient") << "RetryTimer fired for: " << *mRequest << ", retrying." << LL_ENDL;
- mRequest->reEnqueue();
- }
-
- // Release the ref to the request.
- mRequest = NULL;
- // Don't fire again
- return TRUE;
- }
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLMediaDataClient::Request
- //
- //////////////////////////////////////////////////////////////////////////////////////
- /*static*/U32 LLMediaDataClient::Request::sNum = 0;
- LLMediaDataClient::Request::Request(Type in_type,
- LLMediaDataClientObject *obj,
- LLMediaDataClient *mdc,
- S32 face)
- : mType(in_type),
- mObject(obj),
- mNum(++sNum),
- mRetryCount(0),
- mMDC(mdc),
- mScore((F64)0.0),
- mFace(face)
- {
- mObjectID = mObject->getID();
- }
- const char *LLMediaDataClient::Request::getCapName() const
- {
- if(mMDC)
- return mMDC->getCapabilityName();
-
- return "";
- }
- std::string LLMediaDataClient::Request::getCapability() const
- {
- if(mMDC)
- {
- return getObject()->getCapabilityUrl(getCapName());
- }
-
- return "";
- }
- const char *LLMediaDataClient::Request::getTypeAsString() const
- {
- Type t = getType();
- switch (t)
- {
- case GET:
- return "GET";
- break;
- case UPDATE:
- return "UPDATE";
- break;
- case NAVIGATE:
- return "NAVIGATE";
- break;
- case ANY:
- return "ANY";
- break;
- }
- return "";
- }
- void LLMediaDataClient::Request::reEnqueue()
- {
- if(mMDC)
- {
- mMDC->enqueue(this);
- }
- }
- F32 LLMediaDataClient::Request::getRetryTimerDelay() const
- {
- if(mMDC)
- return mMDC->mRetryTimerDelay;
-
- return 0.0f;
- }
- U32 LLMediaDataClient::Request::getMaxNumRetries() const
- {
- if(mMDC)
- return mMDC->mMaxNumRetries;
-
- return 0;
- }
- void LLMediaDataClient::Request::updateScore()
- {
- F64 tmp = mObject->getMediaInterest();
- if (tmp != mScore)
- {
- LL_DEBUGS("LLMediaDataClient") << "Score for " << mObject->getID() << " changed from " << mScore << " to " << tmp << LL_ENDL;
- mScore = tmp;
- }
- }
-
- void LLMediaDataClient::Request::markDead()
- {
- mMDC = NULL;
- }
- bool LLMediaDataClient::Request::isDead()
- {
- return ((mMDC == NULL) || mObject->isDead());
- }
- void LLMediaDataClient::Request::startTracking()
- {
- if(mMDC)
- mMDC->trackRequest(this);
- }
- void LLMediaDataClient::Request::stopTracking()
- {
- if(mMDC)
- mMDC->stopTrackingRequest(this);
- }
- std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &r)
- {
- s << "request: num=" << r.getNum()
- << " type=" << r.getTypeAsString()
- << " ID=" << r.getID()
- << " face=" << r.getFace()
- << " #retries=" << r.getRetryCount();
- return s;
- }
-
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLMediaDataClient::Responder
- //
- //////////////////////////////////////////////////////////////////////////////////////
- LLMediaDataClient::Responder::Responder(const request_ptr_t &request)
- : mRequest(request)
- {
- }
- /*virtual*/
- void LLMediaDataClient::Responder::error(U32 status, const std::string& reason)
- {
- mRequest->stopTracking();
- if(mRequest->isDead())
- {
- LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
- return;
- }
-
- if (status == HTTP_SERVICE_UNAVAILABLE)
- {
- F32 retry_timeout = mRequest->getRetryTimerDelay();
-
- mRequest->incRetryCount();
-
- if (mRequest->getRetryCount() < mRequest->getMaxNumRetries())
- {
- LL_INFOS("LLMediaDataClient") << *mRequest << " got SERVICE_UNAVAILABLE...retrying in " << retry_timeout << " seconds" << LL_ENDL;
-
- // Start timer (instances are automagically tracked by
- // InstanceTracker<> and LLEventTimer)
- new RetryTimer(F32(retry_timeout/*secs*/), mRequest);
- }
- else
- {
- LL_INFOS("LLMediaDataClient") << *mRequest << " got SERVICE_UNAVAILABLE...retry count "
- << mRequest->getRetryCount() << " exceeds " << mRequest->getMaxNumRetries() << ", not retrying" << LL_ENDL;
- }
- }
- else
- {
- std::string msg = boost::lexical_cast<std::string>(status) + ": " + reason;
- LL_WARNS("LLMediaDataClient") << *mRequest << " http error(" << msg << ")" << LL_ENDL;
- }
- }
- /*virtual*/
- void LLMediaDataClient::Responder::result(const LLSD& content)
- {
- mRequest->stopTracking();
- if(mRequest->isDead())
- {
- LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
- return;
- }
- LL_DEBUGS("LLMediaDataClientResponse") << *mRequest << " result : " << ll_print_sd(content) << LL_ENDL;
- }
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLObjectMediaDataClient
- // Subclass of LLMediaDataClient for the ObjectMedia cap
- //
- //////////////////////////////////////////////////////////////////////////////////////
- void LLObjectMediaDataClient::fetchMedia(LLMediaDataClientObject *object)
- {
- // Create a get request and put it in the queue.
- enqueue(new RequestGet(object, this));
- }
- const char *LLObjectMediaDataClient::getCapabilityName() const
- {
- return "ObjectMedia";
- }
- LLObjectMediaDataClient::request_queue_t *LLObjectMediaDataClient::getQueue()
- {
- return (mCurrentQueueIsTheSortedQueue) ? &mQueue : &mRoundRobinQueue;
- }
- void LLObjectMediaDataClient::sortQueue()
- {
- if(!mQueue.empty())
- {
- // score all elements in the sorted queue.
- for(request_queue_t::iterator iter = mQueue.begin(); iter != mQueue.end(); iter++)
- {
- (*iter)->updateScore();
- }
-
- // Re-sort the list...
- mQueue.sort(compareRequestScores);
-
- // ...then cull items over the max
- U32 size = mQueue.size();
- if (size > mMaxSortedQueueSize)
- {
- U32 num_to_cull = (size - mMaxSortedQueueSize);
- LL_INFOS_ONCE("LLMediaDataClient") << "sorted queue MAXED OUT! Culling "
- << num_to_cull << " items" << LL_ENDL;
- while (num_to_cull-- > 0)
- {
- mQueue.back()->markDead();
- mQueue.pop_back();
- }
- }
- }
-
- }
- // static
- bool LLObjectMediaDataClient::compareRequestScores(const request_ptr_t &o1, const request_ptr_t &o2)
- {
- if (o2.isNull()) return true;
- if (o1.isNull()) return false;
- return ( o1->getScore() > o2->getScore() );
- }
- void LLObjectMediaDataClient::enqueue(Request *request)
- {
- if(request->isDead())
- {
- LL_DEBUGS("LLMediaDataClient") << "not queueing dead request " << *request << LL_ENDL;
- return;
- }
- // Invariants:
- // new requests always go into the sorted queue.
- //
-
- bool is_new = request->isNew();
-
- if(!is_new && (request->getType() == Request::GET))
- {
- // For GET requests that are not new, if a matching request is already in the round robin queue,
- // in flight, or being retried, leave it at its current position.
- request_queue_t::iterator iter = find_matching_request(mRoundRobinQueue, request->getID(), Request::GET);
- request_set_t::iterator iter2 = find_matching_request(mUnQueuedRequests, request->getID(), Request::GET);
-
- if( (iter != mRoundRobinQueue.end()) || (iter2 != mUnQueuedRequests.end()) )
- {
- LL_DEBUGS("LLMediaDataClient") << "ALREADY THERE: NOT Queuing request for " << *request << LL_ENDL;
- return;
- }
- }
-
- // TODO: should an UPDATE cause pending GET requests for the same object to be removed from the queue?
- // IF the update will cause an object update message to be sent out at some point in the future, it probably should.
-
- // Remove any existing requests of this type for this object
- remove_matching_requests(mQueue, request->getID(), request->getType());
- remove_matching_requests(mRoundRobinQueue, request->getID(), request->getType());
- remove_matching_requests(mUnQueuedRequests, request->getID(), request->getType());
- if (is_new)
- {
- LL_DEBUGS("LLMediaDataClient") << "Queuing SORTED request for " << *request << LL_ENDL;
-
- mQueue.push_back(request);
-
- LL_DEBUGS("LLMediaDataClientQueue") << "SORTED queue:" << mQueue << LL_ENDL;
- }
- else
- {
- if (mRoundRobinQueue.size() > mMaxRoundRobinQueueSize)
- {
- LL_INFOS_ONCE("LLMediaDataClient") << "RR QUEUE MAXED OUT!!!" << LL_ENDL;
- LL_DEBUGS("LLMediaDataClient") << "Not queuing " << *request << LL_ENDL;
- return;
- }
-
- LL_DEBUGS("LLMediaDataClient") << "Queuing RR request for " << *request << LL_ENDL;
- // Push the request on the pending queue
- mRoundRobinQueue.push_back(request);
-
- LL_DEBUGS("LLMediaDataClientQueue") << "RR queue:" << mRoundRobinQueue << LL_ENDL;
- }
- // Start the timer if not already running
- startQueueTimer();
- }
- bool LLObjectMediaDataClient::canServiceRequest(request_ptr_t request)
- {
- if(mCurrentQueueIsTheSortedQueue)
- {
- if(!request->getObject()->isInterestingEnough())
- {
- LL_DEBUGS("LLMediaDataClient") << "Not fetching " << *request << ": not interesting enough" << LL_ENDL;
- return false;
- }
- }
-
- return true;
- };
- void LLObjectMediaDataClient::swapCurrentQueue()
- {
- // Swap
- mCurrentQueueIsTheSortedQueue = !mCurrentQueueIsTheSortedQueue;
- // If its empty, swap back
- if (getQueue()->empty())
- {
- mCurrentQueueIsTheSortedQueue = !mCurrentQueueIsTheSortedQueue;
- }
- }
- bool LLObjectMediaDataClient::isEmpty() const
- {
- return mQueue.empty() && mRoundRobinQueue.empty();
- }
- bool LLObjectMediaDataClient::isInQueue(const LLMediaDataClientObject::ptr_t &object)
- {
- // First, call parent impl.
- if(LLMediaDataClient::isInQueue(object))
- return true;
- if(find_matching_request(mRoundRobinQueue, object->getID()) != mRoundRobinQueue.end())
- return true;
-
- return false;
- }
- void LLObjectMediaDataClient::removeFromQueue(const LLMediaDataClientObject::ptr_t &object)
- {
- // First, call parent impl.
- LLMediaDataClient::removeFromQueue(object);
-
- remove_matching_requests(mRoundRobinQueue, object->getID());
- }
- bool LLObjectMediaDataClient::processQueueTimer()
- {
- if(isEmpty())
- return true;
-
- LL_DEBUGS("LLMediaDataClient") << "started, SORTED queue size is: " << mQueue.size()
- << ", RR queue size is: " << mRoundRobinQueue.size() << LL_ENDL;
- LL_DEBUGS("LLMediaDataClientQueue") << " SORTED queue is: " << mQueue << LL_ENDL;
- LL_DEBUGS("LLMediaDataClientQueue") << " RR queue is: " << mRoundRobinQueue << LL_ENDL;
- // purgeDeadRequests();
- sortQueue();
- LL_DEBUGS("LLMediaDataClientQueue") << "after sort, SORTED queue is: " << mQueue << LL_ENDL;
-
- serviceQueue();
- swapCurrentQueue();
-
- LL_DEBUGS("LLMediaDataClient") << "finished, SORTED queue size is: " << mQueue.size()
- << ", RR queue size is: " << mRoundRobinQueue.size() << LL_ENDL;
- LL_DEBUGS("LLMediaDataClientQueue") << " SORTED queue is: " << mQueue << LL_ENDL;
- LL_DEBUGS("LLMediaDataClientQueue") << " RR queue is: " << mRoundRobinQueue << LL_ENDL;
-
- return isEmpty();
- }
- LLObjectMediaDataClient::RequestGet::RequestGet(LLMediaDataClientObject *obj, LLMediaDataClient *mdc):
- LLMediaDataClient::Request(LLMediaDataClient::Request::GET, obj, mdc)
- {
- }
- LLSD LLObjectMediaDataClient::RequestGet::getPayload() const
- {
- LLSD result;
- result["verb"] = "GET";
- result[LLTextureEntry::OBJECT_ID_KEY] = mObject->getID();
-
- return result;
- }
- LLMediaDataClient::Responder *LLObjectMediaDataClient::RequestGet::createResponder()
- {
- return new LLObjectMediaDataClient::Responder(this);
- }
- void LLObjectMediaDataClient::updateMedia(LLMediaDataClientObject *object)
- {
- // Create an update request and put it in the queue.
- enqueue(new RequestUpdate(object, this));
- }
- LLObjectMediaDataClient::RequestUpdate::RequestUpdate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc):
- LLMediaDataClient::Request(LLMediaDataClient::Request::UPDATE, obj, mdc)
- {
- }
- LLSD LLObjectMediaDataClient::RequestUpdate::getPayload() const
- {
- LLSD result;
- result["verb"] = "UPDATE";
- result[LLTextureEntry::OBJECT_ID_KEY] = mObject->getID();
- LLSD object_media_data;
- int i = 0;
- int end = mObject->getMediaDataCount();
- for ( ; i < end ; ++i)
- {
- object_media_data.append(mObject->getMediaDataLLSD(i));
- }
-
- result[LLTextureEntry::OBJECT_MEDIA_DATA_KEY] = object_media_data;
-
- return result;
- }
- LLMediaDataClient::Responder *LLObjectMediaDataClient::RequestUpdate::createResponder()
- {
- // This just uses the base class's responder.
- return new LLMediaDataClient::Responder(this);
- }
- /*virtual*/
- void LLObjectMediaDataClient::Responder::result(const LLSD& content)
- {
- getRequest()->stopTracking();
- if(getRequest()->isDead())
- {
- LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
- return;
- }
- // This responder is only used for GET requests, not UPDATE.
- LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " GET returned: " << ll_print_sd(content) << LL_ENDL;
-
- // Look for an error
- if (content.has("error"))
- {
- const LLSD &error = content["error"];
- LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error getting media data for object: code=" <<
- error["code"].asString() << ": " << error["message"].asString() << LL_ENDL;
-
- // XXX Warn user?
- }
- else
- {
- // Check the data
- const LLUUID &object_id = content[LLTextureEntry::OBJECT_ID_KEY];
- if (object_id != getRequest()->getObject()->getID())
- {
- // NOT good, wrong object id!!
- LL_WARNS("LLMediaDataClient") << *(getRequest()) << " DROPPING response with wrong object id (" << object_id << ")" << LL_ENDL;
- return;
- }
-
- // Otherwise, update with object media data
- getRequest()->getObject()->updateObjectMediaData(content[LLTextureEntry::OBJECT_MEDIA_DATA_KEY],
- content[LLTextureEntry::MEDIA_VERSION_KEY]);
- }
- }
- //////////////////////////////////////////////////////////////////////////////////////
- //
- // LLObjectMediaNavigateClient
- // Subclass of LLMediaDataClient for the ObjectMediaNavigate cap
- //
- //////////////////////////////////////////////////////////////////////////////////////
- const char *LLObjectMediaNavigateClient::getCapabilityName() const
- {
- return "ObjectMediaNavigate";
- }
- void LLObjectMediaNavigateClient::enqueue(Request *request)
- {
- if(request->isDead())
- {
- LL_DEBUGS("LLMediaDataClient") << "not queueing dead request " << *request << LL_ENDL;
- return;
- }
-
- // If there's already a matching request in the queue, remove it.
- request_queue_t::iterator iter = find_matching_request(mQueue, request);
- if(iter != mQueue.end())
- {
- LL_DEBUGS("LLMediaDataClient") << "removing matching queued request " << (**iter) << LL_ENDL;
- mQueue.erase(iter);
- }
- else
- {
- request_set_t::iterator set_iter = find_matching_request(mUnQueuedRequests, request);
- if(set_iter != mUnQueuedRequests.end())
- {
- LL_DEBUGS("LLMediaDataClient") << "removing matching unqueued request " << (**set_iter) << LL_ENDL;
- mUnQueuedRequests.erase(set_iter);
- }
- }
- #if 0
- // Sadly, this doesn't work. It ends up creating a race condition when the user navigates and then hits the "back" button
- // where the navigate-back appears to be spurious and doesn't get broadcast.
- if(request->getObject()->isCurrentMediaUrl(request->getFace(), request->getURL()))
- {
- // This navigate request is trying to send the face to the current URL. Drop it.
- LL_DEBUGS("LLMediaDataClient") << "dropping spurious request " << (*request) << LL_ENDL;
- }
- else
- #endif
- {
- LL_DEBUGS("LLMediaDataClient") << "queueing new request " << (*request) << LL_ENDL;
- mQueue.push_back(request);
-
- // Start the timer if not already running
- startQueueTimer();
- }
- }
- void LLObjectMediaNavigateClient::navigate(LLMediaDataClientObject *object, U8 texture_index, const std::string &url)
- {
- // LL_INFOS("LLMediaDataClient") << "navigate() initiated: " << ll_print_sd(sd_payload) << LL_ENDL;
-
- // Create a get request and put it in the queue.
- enqueue(new RequestNavigate(object, this, texture_index, url));
- }
- LLObjectMediaNavigateClient::RequestNavigate::RequestNavigate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc, U8 texture_index, const std::string &url):
- LLMediaDataClient::Request(LLMediaDataClient::Request::NAVIGATE, obj, mdc, (S32)texture_index),
- mURL(url)
- {
- }
- LLSD LLObjectMediaNavigateClient::RequestNavigate::getPayload() const
- {
- LLSD result;
- result[LLTextureEntry::OBJECT_ID_KEY] = getID();
- result[LLMediaEntry::CURRENT_URL_KEY] = mURL;
- result[LLTextureEntry::TEXTURE_INDEX_KEY] = (LLSD::Integer)getFace();
-
- return result;
- }
- LLMediaDataClient::Responder *LLObjectMediaNavigateClient::RequestNavigate::createResponder()
- {
- return new LLObjectMediaNavigateClient::Responder(this);
- }
- /*virtual*/
- void LLObjectMediaNavigateClient::Responder::error(U32 status, const std::string& reason)
- {
- getRequest()->stopTracking();
- if(getRequest()->isDead())
- {
- LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
- return;
- }
- // Bounce back (unless HTTP_SERVICE_UNAVAILABLE, in which case call base
- // class
- if (status == HTTP_SERVICE_UNAVAILABLE)
- {
- LLMediaDataClient::Responder::error(status, reason);
- }
- else
- {
- // bounce the face back
- LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating: http code=" << status << LL_ENDL;
- const LLSD &payload = getRequest()->getPayload();
- // bounce the face back
- getRequest()->getObject()->mediaNavigateBounceBack((LLSD::Integer)payload[LLTextureEntry::TEXTURE_INDEX_KEY]);
- }
- }
- /*virtual*/
- void LLObjectMediaNavigateClient::Responder::result(const LLSD& content)
- {
- getRequest()->stopTracking();
- if(getRequest()->isDead())
- {
- LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
- return;
- }
- LL_INFOS("LLMediaDataClient") << *(getRequest()) << " NAVIGATE returned " << ll_print_sd(content) << LL_ENDL;
-
- if (content.has("error"))
- {
- const LLSD &error = content["error"];
- int error_code = error["code"];
-
- if (ERROR_PERMISSION_DENIED_CODE == error_code)
- {
- LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Navigation denied: bounce back" << LL_ENDL;
- const LLSD &payload = getRequest()->getPayload();
- // bounce the face back
- getRequest()->getObject()->mediaNavigateBounceBack((LLSD::Integer)payload[LLTextureEntry::TEXTURE_INDEX_KEY]);
- }
- else
- {
- LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating: code=" <<
- error["code"].asString() << ": " << error["message"].asString() << LL_ENDL;
- }
- // XXX Warn user?
- }
- else
- {
- // No action required.
- LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " result : " << ll_print_sd(content) << LL_ENDL;
- }
- }