/** * @file lleventpoll.cpp * @brief Implementation of the LLEventPoll class. * * $LicenseInfo:firstyear=2006&license=viewergpl$ * * Copyright (c) 2006-2009, Linden Research, Inc. * * Second Life Viewer Source Code * The source code in this file ("Source Code") is provided by Linden Lab * to you under the terms of the GNU General Public License, version 2.0 * ("GPL"), unless you have obtained a separate licensing agreement * ("Other License"), formally executed by you and Linden Lab. Terms of * the GPL can be found in doc/GPL-license.txt in this distribution, or * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 * * There are special exceptions to the terms and conditions of the GPL as * it is applied to this Source Code. View the full text of the exception * in the file doc/FLOSS-exception.txt in this software distribution, or * online at * http://secondlifegrid.net/programs/open_source/licensing/flossexception * * By copying, modifying or distributing this software, you acknowledge * that you have read and understood your obligations described above, * and agree to abide by those obligations. * * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, * COMPLETENESS OR PERFORMANCE. * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "lleventpoll.h" #include "llappviewer.h" #include "llagent.h" #include "llhttpclient.h" #include "llhttpstatuscodes.h" #include "llsdserialize.h" #include "lltimer.h" #include "llviewerregion.h" #include "message.h" #include "lltrans.h" namespace { // We will wait RETRY_SECONDS + (errorCount * RETRY_SECONDS_INC) before retrying after an error. // This means we attempt to recover relatively quickly but back off giving more time to recover // until we finally give up after MAX_EVENT_POLL_HTTP_ERRORS attempts. const F32 EVENT_POLL_ERROR_RETRY_SECONDS = 15.f; // ~ half of a normal timeout. const F32 EVENT_POLL_ERROR_RETRY_SECONDS_INC = 5.f; // ~ half of a normal timeout. const S32 MAX_EVENT_POLL_HTTP_ERRORS = 10; // ~5 minutes, by the above rules. class LLEventPollResponder : public LLHTTPClient::Responder { public: static LLHTTPClient::ResponderPtr start(const std::string& pollURL, const LLHost& sender); void stop(); void makeRequest(); private: LLEventPollResponder(const std::string& pollURL, const LLHost& sender); ~LLEventPollResponder(); void handleMessage(const LLSD& content); virtual void error(U32 status, const std::string& reason); virtual void result(const LLSD& content); virtual void completedRaw(U32 status, const std::string& reason, const LLChannelDescriptors& channels, const LLIOPipe::buffer_ptr_t& buffer); private: bool mDone; std::string mPollURL; std::string mSender; LLSD mAcknowledge; // these are only here for debugging so we can see which poller is which static int sCount; int mCount; S32 mErrorCount; }; class LLEventPollEventTimer : public LLEventTimer { typedef boost::intrusive_ptr<LLEventPollResponder> EventPollResponderPtr; public: LLEventPollEventTimer(F32 period, EventPollResponderPtr responder) : LLEventTimer(period), mResponder(responder) { } virtual BOOL tick() { mResponder->makeRequest(); return TRUE; // Causes this instance to be deleted. } private: EventPollResponderPtr mResponder; }; //static LLHTTPClient::ResponderPtr LLEventPollResponder::start( const std::string& pollURL, const LLHost& sender) { LLHTTPClient::ResponderPtr result = new LLEventPollResponder(pollURL, sender); llinfos << "LLEventPollResponder::start <" << sCount << "> " << pollURL << llendl; return result; } void LLEventPollResponder::stop() { llinfos << "LLEventPollResponder::stop <" << mCount << "> " << mPollURL << llendl; // there should be a way to stop a LLHTTPClient request in progress mDone = true; } int LLEventPollResponder::sCount = 0; LLEventPollResponder::LLEventPollResponder(const std::string& pollURL, const LLHost& sender) : mDone(false), mPollURL(pollURL), mCount(++sCount), mErrorCount(0) { //extract host and port of simulator to set as sender LLViewerRegion *regionp = gAgent.getRegion(); if (!regionp) { llerrs << "LLEventPoll initialized before region is added." << llendl; } mSender = sender.getIPandPort(); llinfos << "LLEventPoll initialized with sender " << mSender << llendl; makeRequest(); } LLEventPollResponder::~LLEventPollResponder() { stop(); lldebugs << "LLEventPollResponder::~Impl <" << mCount << "> " << mPollURL << llendl; } // virtual void LLEventPollResponder::completedRaw(U32 status, const std::string& reason, const LLChannelDescriptors& channels, const LLIOPipe::buffer_ptr_t& buffer) { if (status == HTTP_BAD_GATEWAY) { // These errors are not parsable as LLSD, // which LLHTTPClient::Responder::completedRaw will try to do. completed(status, reason, LLSD()); } else { LLHTTPClient::Responder::completedRaw(status,reason,channels,buffer); } } void LLEventPollResponder::makeRequest() { LLSD request; request["ack"] = mAcknowledge; request["done"] = mDone; lldebugs << "LLEventPollResponder::makeRequest <" << mCount << "> ack = " << LLSDXMLStreamer(mAcknowledge) << llendl; LLHTTPClient::post(mPollURL, request, this); } void LLEventPollResponder::handleMessage(const LLSD& content) { std::string msg_name = content["message"]; LLSD message; message["sender"] = mSender; message["body"] = content["body"]; LLMessageSystem::dispatch(msg_name, message); } //virtual void LLEventPollResponder::error(U32 status, const std::string& reason) { if (mDone) return; // A HTTP_BAD_GATEWAY (502) error is our standard timeout response // we get this when there are no events. if ( status == HTTP_BAD_GATEWAY ) { mErrorCount = 0; makeRequest(); } else if (mErrorCount < MAX_EVENT_POLL_HTTP_ERRORS) { ++mErrorCount; // The 'tick' will return TRUE causing the timer to delete this. new LLEventPollEventTimer(EVENT_POLL_ERROR_RETRY_SECONDS + mErrorCount * EVENT_POLL_ERROR_RETRY_SECONDS_INC , this); llwarns << "Unexpected HTTP error. status: " << status << ", reason: " << reason << llendl; } else { llwarns << "LLEventPollResponder::error: <" << mCount << "> got " << status << ": " << reason << (mDone ? " -- done" : "") << llendl; stop(); // At this point we have given up and the viewer will not receive HTTP messages from the simulator. // IMs, teleports, about land, selecing land, region crossing and more will all fail. // They are essentially disconnected from the region even though some things may still work. // Since things won't get better until they relog we force a disconnect now. // *NOTE:Mani - The following condition check to see if this failing event poll // is attached to the Agent's main region. If so we disconnect the viewer. // Else... its a child region and we just leave the dead event poll stopped and // continue running. if(gAgent.getRegion() && gAgent.getRegion()->getHost().getIPandPort() == mSender) { llwarns << "Forcing disconnect due to stalled main region event poll." << llendl; LLAppViewer::instance()->forceDisconnect(LLTrans::getString("AgentLostConnection")); } } } //virtual void LLEventPollResponder::result(const LLSD& content) { lldebugs << "LLEventPollResponder::result <" << mCount << ">" << (mDone ? " -- done" : "") << llendl; if (mDone) return; mErrorCount = 0; if (!content.get("events") || !content.get("id")) { llwarns << "received event poll with no events or id key" << llendl; makeRequest(); return; } mAcknowledge = content["id"]; LLSD events = content["events"]; if(mAcknowledge.isUndefined()) { llwarns << "LLEventPollResponder: id undefined" << llendl; } // was llinfos but now that CoarseRegionUpdate is TCP @ 1/second, it'd be too verbose for viewer logs. -MG lldebugs << "LLEventPollResponder::completed <" << mCount << "> " << events.size() << "events (id " << LLSDXMLStreamer(mAcknowledge) << ")" << llendl; LLSD::array_const_iterator i = events.beginArray(); LLSD::array_const_iterator end = events.endArray(); for (; i != end; ++i) { if (i->has("message")) { handleMessage(*i); } } makeRequest(); } } LLEventPoll::LLEventPoll(const std::string& poll_url, const LLHost& sender) : mImpl(LLEventPollResponder::start(poll_url, sender)) { } LLEventPoll::~LLEventPoll() { LLHTTPClient::Responder* responderp = mImpl.get(); LLEventPollResponder* event_poll_responder = dynamic_cast<LLEventPollResponder*>(responderp); if (event_poll_responder) event_poll_responder->stop(); }