livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed dead code

meow-7.2.2
Rider Linden 2015-04-08 15:56:25 -07:00
parent 9965e13e83
commit 6aa2812fad
2 changed files with 0 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
indra/newview/lleventpoll.cpp
View File

@ -53,8 +53,6 @@ namespace Details
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.
#if 1
class LLEventPollImpl
{
public:
@ -253,249 +251,6 @@ namespace Details
}
#else
class LLEventPollResponder : public LLHTTPClient::Responder
{
LOG_CLASS(LLEventPollResponder);
public:
static LLHTTPClient::ResponderPtr start(const std::string& pollURL, const LLHost& sender);
void stop();
void makeRequest();
/* virtual */ void completedRaw(const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
private:
LLEventPollResponder(const std::string& pollURL, const LLHost& sender);
~LLEventPollResponder();
void handleMessage(const LLSD& content);
/* virtual */ void httpFailure();
/* virtual */ void httpSuccess();
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 LLPointer<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);
LL_INFOS() << "LLEventPollResponder::start <" << sCount << "> "
<< pollURL << LL_ENDL;
return result;
}
void LLEventPollResponder::stop()
{
LL_INFOS() << "LLEventPollResponder::stop <" << mCount << "> "
<< mPollURL << LL_ENDL;
// 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)
{
LL_ERRS() << "LLEventPoll initialized before region is added." << LL_ENDL;
}
mSender = sender.getIPandPort();
LL_INFOS() << "LLEventPoll initialized with sender " << mSender << LL_ENDL;
makeRequest();
}
LLEventPollResponder::~LLEventPollResponder()
{
stop();
LL_DEBUGS() << "LLEventPollResponder::~Impl <" << mCount << "> "
<< mPollURL << LL_ENDL;
}
// virtual
void LLEventPollResponder::completedRaw(const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
if (getStatus() == HTTP_BAD_GATEWAY)
{
// These errors are not parsable as LLSD,
// which LLHTTPClient::Responder::completedRaw will try to do.
httpCompleted();
}
else
{
LLHTTPClient::Responder::completedRaw(channels,buffer);
}
}
void LLEventPollResponder::makeRequest()
{
LLSD request;
request["ack"] = mAcknowledge;
request["done"] = mDone;
LL_DEBUGS() << "LLEventPollResponder::makeRequest <" << mCount << "> ack = "
<< LLSDXMLStreamer(mAcknowledge) << LL_ENDL;
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::httpFailure()
{
if (mDone) return;
// A HTTP_BAD_GATEWAY (502) error is our standard timeout response
// we get this when there are no events.
if ( getStatus() == 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);
LL_WARNS() << dumpResponse() << LL_ENDL;
}
else
{
LL_WARNS() << dumpResponse()
<< " [count:" << mCount << "] "
<< (mDone ? " -- done" : "") << LL_ENDL;
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)
{
LL_WARNS() << "Forcing disconnect due to stalled main region event poll." << LL_ENDL;
LLAppViewer::instance()->forceDisconnect(LLTrans::getString("AgentLostConnection"));
}
}
}
//virtual
void LLEventPollResponder::httpSuccess()
{
LL_DEBUGS() << "LLEventPollResponder::result <" << mCount << ">"
<< (mDone ? " -- done" : "") << LL_ENDL;
if (mDone) return;
mErrorCount = 0;
const LLSD& content = getContent();
if (!content.isMap() ||
!content.get("events") ||
!content.get("id"))
{
LL_WARNS() << "received event poll with no events or id key: " << dumpResponse() << LL_ENDL;
makeRequest();
return;
}
mAcknowledge = content["id"];
LLSD events = content["events"];
if(mAcknowledge.isUndefined())
{
LL_WARNS() << "LLEventPollResponder: id undefined" << LL_ENDL;
}
// was LL_INFOS() but now that CoarseRegionUpdate is TCP @ 1/second, it'd be too verbose for viewer logs. -MG
LL_DEBUGS() << "LLEventPollResponder::httpSuccess <" << mCount << "> " << events.size() << "events (id "
<< LLSDXMLStreamer(mAcknowledge) << ")" << LL_ENDL;
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();
}
#endif
}
}

5
indra/newview/lleventpoll.h
View File

@ -58,12 +58,7 @@ public:
private:
#if 1
boost::unique_ptr<LLEventPolling::Details::LLEventPollImpl> mImpl;
#else
LLHTTPClient::ResponderPtr mImpl;
#endif
};