path: root/indra/newview/llavatarrenderinfoaccountant.cpp

/**
 * @file   llavatarrenderinfoaccountant.cpp
 * @author Dave Simmons
 * @date   2013-02-28
 * @brief  
 * 
 * $LicenseInfo:firstyear=2013&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2013, 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$
 */

// Precompiled header
#include "llviewerprecompiledheaders.h"
// STL headers
// std headers
// external library headers
// other Linden headers
#include "llcharacter.h"
#include "httprequest.h"
#include "httphandler.h"
#include "httpresponse.h"
#include "llcorehttputil.h"
#include "llappcorehttp.h"
#include "llavatarrendernotifier.h"
#include "lltimer.h"
#include "llviewercontrol.h"
#include "llviewermenu.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llvoavatar.h"
#include "llworld.h"
// associated header
#include "llavatarrenderinfoaccountant.h"


static	const std::string KEY_AGENTS = "agents";			// map
static 	const std::string KEY_WEIGHT = "weight";			// integer
static 	const std::string KEY_TOO_COMPLEX  = "tooComplex";  // bool
static  const std::string KEY_OVER_COMPLEXITY_LIMIT = "overlimit";  // integer
static  const std::string KEY_REPORTING_COMPLEXITY_LIMIT = "reportinglimit";  // integer

static	const std::string KEY_IDENTIFIER = "identifier";
static	const std::string KEY_MESSAGE = "message";
static	const std::string KEY_ERROR = "error";


static const F32 SECS_BETWEEN_REGION_SCANS   =  5.f;		// Scan the region list every 5 seconds
static const F32 SECS_BETWEEN_REGION_REQUEST = 15.0;		// Look for new avs every 15 seconds
static const F32 SECS_BETWEEN_REGION_REPORTS = 60.0;		// Update each region every 60 seconds
	

// The policy class for HTTP traffic; this is the right value for all capability requests.
static LLCore::HttpRequest::policy_t http_policy(LLAppCoreHttp::AP_REPORTING);

// Priority for HTTP requests.  Use 0U.
static LLCore::HttpRequest::priority_t http_priority(0U);

LLAvatarRenderInfoAccountant::LLAvatarRenderInfoAccountant()
	: mHttpRequest(new LLCore::HttpRequest)
	, mHttpHeaders(new LLCore::HttpHeaders)
	, mHttpOptions(new LLCore::HttpOptions)
{
	mHttpOptions->setTransferTimeout(SECS_BETWEEN_REGION_SCANS);

	mHttpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
	mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_LLSD_XML);
}

LLAvatarRenderInfoAccountant::~LLAvatarRenderInfoAccountant()
{
	mHttpOptions->release();
	mHttpHeaders->release();
	// delete mHttpRequest; ???
}

// HTTP responder class for GET request for avatar render weight information
class LLAvatarRenderInfoGetHandler : public LLCore::HttpHandler
{
private:
	LOG_CLASS(LLAvatarRenderInfoGetHandler);
	
public:
	LLAvatarRenderInfoGetHandler() : LLCore::HttpHandler()
	{
	}

	void onCompleted(LLCore::HttpHandle handle,
					 LLCore::HttpResponse* response)
	{
            LLCore::HttpStatus status = response->getStatus();
            if (status)
            {
                LL_DEBUGS("AvatarRenderInfo") << "response"<<LL_ENDL;
				LLSD avatar_render_info;
				if (LLCoreHttpUtil::responseToLLSD(response, false /* quiet logging */,
												   avatar_render_info))
				{
					if (avatar_render_info.isMap())
					{
						if (   avatar_render_info.has(KEY_REPORTING_COMPLEXITY_LIMIT)
                            && avatar_render_info.has(KEY_OVER_COMPLEXITY_LIMIT))
						{
                            U32 reporting = avatar_render_info[KEY_REPORTING_COMPLEXITY_LIMIT].asInteger();
                            U32 overlimit = avatar_render_info[KEY_OVER_COMPLEXITY_LIMIT].asInteger();

                            LL_DEBUGS("AvatarRenderInfo") << "complexity limit: "<<reporting<<" reporting, "<<overlimit<<" over limit"<<LL_ENDL;

							LLAvatarRenderNotifier::getInstance()->updateNotificationRegion(reporting, overlimit);
                        }
                        
						if (avatar_render_info.has(KEY_AGENTS))
						{
							const LLSD & agents = avatar_render_info[KEY_AGENTS];
							if (agents.isMap())
							{
								for (LLSD::map_const_iterator agent_iter = agents.beginMap();
									 agent_iter != agents.endMap();
									 agent_iter++
									 )
								{
									LLUUID target_agent_id = LLUUID(agent_iter->first);
									LLViewerObject* avatarp = gObjectList.findObject(target_agent_id);
									if (avatarp && avatarp->isAvatar())
									{
										const LLSD & agent_info_map = agent_iter->second;
										if (agent_info_map.isMap())
										{
											LL_DEBUGS("AvatarRenderInfo") << " Agent " << target_agent_id 
																		  << ": " << agent_info_map << LL_ENDL;

											if (agent_info_map.has(KEY_WEIGHT))
											{
												((LLVOAvatar *) avatarp)->setReportedVisualComplexity(agent_info_map[KEY_WEIGHT].asInteger());
											}
										}
										else
										{
											LL_WARNS("AvatarRenderInfo") << "agent entry invalid"
																		 << " agent " << target_agent_id
																		 << " map " << agent_info_map
																		 << LL_ENDL;
										}
									}
									else
									{
										LL_DEBUGS("AvatarRenderInfo") << "Unknown agent " << target_agent_id << LL_ENDL;
									}
								} // for agent_iter
							}
							else
							{
								LL_WARNS("AvatarRenderInfo") << "malformed get response agents avatar_render_info is not map" << LL_ENDL;
							}
						}	// has "agents"
						else if (avatar_render_info.has(KEY_ERROR))
						{
							const LLSD & error = avatar_render_info[KEY_ERROR];
							LL_WARNS("AvatarRenderInfo") << "Avatar render info GET error: "
														 << error[KEY_IDENTIFIER]
														 << ": " << error[KEY_MESSAGE] 
														 << LL_ENDL;
						}
						else
						{
							LL_WARNS("AvatarRenderInfo") << "no agent key in get response" << LL_ENDL;
						}
					}
					else
					{
						LL_WARNS("AvatarRenderInfo") << "malformed get response is not map" << LL_ENDL;
					}
                }
				else
				{
					LL_WARNS("AvatarRenderInfo") << "malformed get response parse failure" << LL_ENDL;
				}
            }
            else
            {
                // Something went wrong.  Translate the status to
                // a meaningful message.
                LL_WARNS("AvatarRenderInfo") << "GET failed Status:  "
											 << status.toTerseString()
											 << ", Reason:  " << status.toString()
											 << LL_ENDL;
            }           

			delete this;    // release the handler object
		}
};


// HTTP responder class for POST request for avatar render weight information
class LLAvatarRenderInfoPostHandler : public LLCore::HttpHandler
{
  private:
	LOG_CLASS(LLAvatarRenderInfoPostHandler);

  public:
	LLAvatarRenderInfoPostHandler() : LLCore::HttpHandler()
	{
	}

	void onCompleted(LLCore::HttpHandle handle,
					 LLCore::HttpResponse* response)
		{
			LLCore::HttpStatus status = response->getStatus();
			if (status)
			{
				LL_DEBUGS("AvatarRenderInfo") << "post succeeded" << LL_ENDL;
			}
			else
			{
				// Something went wrong.  Translate the status to
				// a meaningful message.
				LL_WARNS("AvatarRenderInfo") << "POST failed Status:  "
											 << status.toTerseString()
											 << ", Reason:  " << status.toString()
											 << LL_ENDL;
			}           

			delete this;    // release the handler object
		}
};


// Send request for avatar weights in one region
// called when the mRenderInfoScanTimer expires (forced when entering a new region)
void LLAvatarRenderInfoAccountant::sendRenderInfoToRegion(LLViewerRegion * regionp)
{
	if ( regionp->getRenderInfoReportTimer().hasExpired() ) // Time to make request
	{
		U32 num_avs = 0;
	
		std::string url = regionp->getCapability("AvatarRenderInfo");
		if (!url.empty())
		{
			// Build the render info to POST to the region
			LLSD agents = LLSD::emptyMap();
				
			std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
			while( iter != LLCharacter::sInstances.end() )
			{
				LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(*iter);
				if (avatar &&
					avatar->getRezzedStatus() >= 2 &&					// Mostly rezzed (maybe without baked textures downloaded)
					!avatar->isDead() &&								// Not dead yet
					avatar->getObjectHost() == regionp->getHost())		// Ensure it's on the same region
				{
					avatar->calculateUpdateRenderComplexity();			// Make sure the numbers are up-to-date

					LLSD info = LLSD::emptyMap();
                    U32 avatar_complexity = avatar->getVisualComplexity();
                    if (avatar_complexity > 0)
					{
                        // the weight/complexity is unsigned, but LLSD only stores signed integers,
                        // so if it's over that (which would be ridiculously high), just store the maximum signed int value
						info[KEY_WEIGHT] = (S32)(avatar_complexity < S32_MAX ? avatar_complexity : S32_MAX);
						info[KEY_TOO_COMPLEX]  = LLSD::Boolean(avatar->isTooComplex());
						agents[avatar->getID().asString()] = info;

						LL_DEBUGS("AvatarRenderInfo") << "Sending avatar render info for " << avatar->getID()
													  << ": " << info << LL_ENDL;
						num_avs++;
					}
				}
				iter++;
			}

			if (num_avs > 0)
			{
				LLSD report = LLSD::emptyMap();
				report[KEY_AGENTS] = agents;

				LLCore::HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
				LLAvatarRenderInfoPostHandler* handler = new LLAvatarRenderInfoPostHandler;
			
				handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest,
															 http_policy,
															 http_priority,
															 url,
															 report,
															 mHttpOptions,
															 mHttpHeaders,
															 handler);
				if (LLCORE_HTTP_HANDLE_INVALID == handle)
				{
					LLCore::HttpStatus status(mHttpRequest->getStatus());
					LL_WARNS("AvatarRenderInfo") << "HTTP POST request failed"
												 << " Status: " << status.toTerseString()
												 << " Reason: '" << status.toString() << "'"
												 << LL_ENDL;
					delete handler;
				}
				else
				{
					LL_DEBUGS("AvatarRenderInfo") << "Sent render costs for " << num_avs
												 << " avatars to region " << regionp->getName()
												 << LL_ENDL;


				}			
			}
			else
			{
				LL_DEBUGS("AvatarRenderInfo") << "no agent info to send" << LL_ENDL;
			}
		}
		else
		{
			LL_WARNS("AvatarRenderInfo") << "AvatarRenderInfo cap is empty" << LL_ENDL;
		}

		// Reset this regions timer, moving to longer intervals if there are lots of avatars around
		regionp->getRenderInfoReportTimer().resetWithExpiry(SECS_BETWEEN_REGION_REPORTS + (2.f * num_avs));
	}
}




// static 
// Send request for one region, no timer checks
void LLAvatarRenderInfoAccountant::getRenderInfoFromRegion(LLViewerRegion * regionp)
{
	if (regionp->getRenderInfoRequestTimer().hasExpired())
	{
		std::string url = regionp->getCapability("AvatarRenderInfo");
		if (!url.empty())
		{
			
			LLAvatarRenderInfoGetHandler* handler = new LLAvatarRenderInfoGetHandler;
			// First send a request to get the latest data
			LLCore::HttpHandle handle = mHttpRequest->requestGet(http_policy,
																 http_priority,
																 url,
																 NULL,
																 NULL,
																 handler);
			if (LLCORE_HTTP_HANDLE_INVALID != handle)
			{
				LL_DEBUGS("AvatarRenderInfo") << "Requested avatar render info for region "
											 << regionp->getName() 
											 << LL_ENDL;
			}
			else
			{
				LL_WARNS("AvatarRenderInfo") << "Failed to launch HTTP GET request.  Try again."
											 << LL_ENDL;
				delete handler;
			}
		}
		else
		{
			LL_WARNS("AvatarRenderInfo") << "no AvatarRenderInfo cap for " << regionp->getName() << LL_ENDL;
		}

		regionp->getRenderInfoRequestTimer().resetWithExpiry(SECS_BETWEEN_REGION_REQUEST);
	}
}


// static
// Called every frame - send render weight requests to every region
void LLAvatarRenderInfoAccountant::idle()
{
	mHttpRequest->update(0); // give any pending http operations a chance to call completion methods
	
	if (mRenderInfoScanTimer.hasExpired())
	{
		LL_DEBUGS("AvatarRenderInfo") << "Scanning regions for render info updates"
									  << LL_ENDL;

		// Check all regions
		for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
			 iter != LLWorld::getInstance()->getRegionList().end();
			 ++iter)
		{
			LLViewerRegion* regionp = *iter;
			if (   regionp
				&& regionp->isAlive()
				&& regionp->capabilitiesReceived())
			{
				// each of these is further governed by and resets its own timer
				sendRenderInfoToRegion(regionp);
				getRenderInfoFromRegion(regionp);
			}
		}

		// We scanned all the regions, reset the request timer.
		mRenderInfoScanTimer.resetWithExpiry(SECS_BETWEEN_REGION_SCANS);
	}
}

void LLAvatarRenderInfoAccountant::resetRenderInfoScanTimer()
{
	// this will force the next frame to rescan
	mRenderInfoScanTimer.reset();
}

// static
// Called via LLViewerRegion::setCapabilitiesReceived() boost signals when the capabilities
// are returned for a new LLViewerRegion, and is the earliest time to get render info
void LLAvatarRenderInfoAccountant::scanNewRegion(const LLUUID& region_id)
{
	LL_INFOS("AvatarRenderInfo") << region_id << LL_ENDL;

	// Reset the global timer so it will scan regions on the next call to ::idle
	LLAvatarRenderInfoAccountant::getInstance()->resetRenderInfoScanTimer();
	
	LLViewerRegion* regionp = LLWorld::instance().getRegionFromID(region_id);
	if (regionp)
	{	// Reset the region's timers so we will:
		//  * request render info from it immediately
		//  * report on the following scan
		regionp->getRenderInfoRequestTimer().reset();
		regionp->getRenderInfoReportTimer().resetWithExpiry(SECS_BETWEEN_REGION_SCANS);
	}
	else
	{
		LL_WARNS("AvatarRenderInfo") << "unable to resolve region "<<region_id<<LL_ENDL;
	}
}