244 lines
8.1 KiB
C++
244 lines
8.1 KiB
C++
/**
|
|
* @file aiperhost.cpp
|
|
* @brief Implementation of AIPerHostRequestQueue
|
|
*
|
|
* Copyright (c) 2012, 2013, Aleric Inglewood.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* 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.
|
|
*
|
|
* CHANGELOG
|
|
* and additional copyright holders.
|
|
*
|
|
* 04/11/2012
|
|
* Initial version, written by Aleric Inglewood @ SL
|
|
*
|
|
* 06/04/2013
|
|
* Renamed AICurlPrivate::PerHostRequestQueue[Ptr] to AIPerHostRequestQueue[Ptr]
|
|
* to allow public access.
|
|
*/
|
|
|
|
#include "sys.h"
|
|
#include "aicurlperhost.h"
|
|
#include "aicurlthread.h"
|
|
|
|
AIPerHostRequestQueue::threadsafe_instance_map_type AIPerHostRequestQueue::sInstanceMap;
|
|
LLAtomicS32 AIPerHostRequestQueue::sTotalQueued;
|
|
|
|
#undef AICurlPrivate
|
|
|
|
namespace AICurlPrivate {
|
|
|
|
U32 curl_concurrent_connections_per_host;
|
|
|
|
// Friend functions of RefCountedThreadSafePerHostRequestQueue
|
|
|
|
void intrusive_ptr_add_ref(RefCountedThreadSafePerHostRequestQueue* per_host)
|
|
{
|
|
per_host->mReferenceCount++;
|
|
}
|
|
|
|
void intrusive_ptr_release(RefCountedThreadSafePerHostRequestQueue* per_host)
|
|
{
|
|
if (--per_host->mReferenceCount == 0)
|
|
{
|
|
delete per_host;
|
|
}
|
|
}
|
|
|
|
} // namespace AICurlPrivate
|
|
|
|
using namespace AICurlPrivate;
|
|
|
|
// url must be of the form
|
|
// (see http://www.ietf.org/rfc/rfc3986.txt Appendix A for definitions not given here):
|
|
//
|
|
// url = sheme ":" hier-part [ "?" query ] [ "#" fragment ]
|
|
// hier-part = "//" authority path-abempty
|
|
// authority = [ userinfo "@" ] host [ ":" port ]
|
|
// path-abempty = *( "/" segment )
|
|
//
|
|
// That is, a hier-part of the form '/ path-absolute', '/ path-rootless' or
|
|
// '/ path-empty' is NOT allowed here. This should be safe because we only
|
|
// call this function for curl access, any file access would use APR.
|
|
//
|
|
// However, as a special exception, this function allows:
|
|
//
|
|
// url = authority path-abempty
|
|
//
|
|
// without the 'sheme ":" "//"' parts.
|
|
//
|
|
// As follows from the ABNF (see RFC, Appendix A):
|
|
// - authority is either terminated by a '/' or by the end of the string because
|
|
// neither userinfo, host nor port may contain a '/'.
|
|
// - userinfo does not contain a '@', and if it exists, is always terminated by a '@'.
|
|
// - port does not contain a ':', and if it exists is always prepended by a ':'.
|
|
//
|
|
//static
|
|
std::string AIPerHostRequestQueue::extract_canonical_hostname(std::string const& url)
|
|
{
|
|
std::string::size_type pos;
|
|
std::string::size_type authority = 0; // Default if there is no sheme.
|
|
if ((pos = url.find("://")) != url.npos && pos < url.find('/')) authority = pos + 3; // Skip the "sheme://" if any, the second find is to avoid finding a "://" as part of path-abempty.
|
|
std::string::size_type host = authority; // Default if there is no userinfo.
|
|
if ((pos = url.find('@', authority)) != url.npos) host = pos + 1; // Skip the "userinfo@" if any.
|
|
authority = url.length() - 1; // Default last character of host if there is no path-abempty.
|
|
if ((pos = url.find('/', host)) != url.npos) authority = pos - 1; // Point to last character of host.
|
|
std::string::size_type len = url.find_last_not_of(":0123456789", authority) - host + 1; // Skip trailing ":port", if any.
|
|
std::string hostname(url, host, len);
|
|
#if APR_CHARSET_EBCDIC
|
|
#error Not implemented
|
|
#else
|
|
// Convert hostname to lowercase in a way that we compare two hostnames equal iff libcurl does.
|
|
for (std::string::iterator iter = hostname.begin(); iter != hostname.end(); ++iter)
|
|
{
|
|
int c = *iter;
|
|
if (c >= 'A' && c <= 'Z')
|
|
*iter = c + ('a' - 'A');
|
|
}
|
|
#endif
|
|
return hostname;
|
|
}
|
|
|
|
//static
|
|
AIPerHostRequestQueuePtr AIPerHostRequestQueue::instance(std::string const& hostname)
|
|
{
|
|
llassert(!hostname.empty());
|
|
instance_map_wat instance_map_w(sInstanceMap);
|
|
AIPerHostRequestQueue::iterator iter = instance_map_w->find(hostname);
|
|
if (iter == instance_map_w->end())
|
|
{
|
|
iter = instance_map_w->insert(instance_map_type::value_type(hostname, new RefCountedThreadSafePerHostRequestQueue)).first;
|
|
}
|
|
// Note: the creation of AIPerHostRequestQueuePtr MUST be protected by the lock on sInstanceMap (see release()).
|
|
return iter->second;
|
|
}
|
|
|
|
//static
|
|
void AIPerHostRequestQueue::release(AIPerHostRequestQueuePtr& instance)
|
|
{
|
|
if (instance->exactly_two_left()) // Being 'instance' and the one in sInstanceMap.
|
|
{
|
|
// The viewer can be have left main() we can't access the global sInstanceMap anymore.
|
|
if (LLApp::isStopped())
|
|
{
|
|
return;
|
|
}
|
|
instance_map_wat instance_map_w(sInstanceMap);
|
|
// It is possible that 'exactly_two_left' is not up to date anymore.
|
|
// Therefore, recheck the condition now that we have locked sInstanceMap.
|
|
if (!instance->exactly_two_left())
|
|
{
|
|
// Some other thread added this host in the meantime.
|
|
return;
|
|
}
|
|
// The reference in the map is the last one; that means there can't be any curl easy requests queued for this host.
|
|
llassert(PerHostRequestQueue_rat(*instance)->mQueuedRequests.empty());
|
|
// Find the host and erase it from the map.
|
|
iterator const end = instance_map_w->end();
|
|
for(iterator iter = instance_map_w->begin(); iter != end; ++iter)
|
|
{
|
|
if (instance == iter->second)
|
|
{
|
|
instance_map_w->erase(iter);
|
|
instance.reset();
|
|
return;
|
|
}
|
|
}
|
|
// We should always find the host.
|
|
llassert(false);
|
|
}
|
|
instance.reset();
|
|
}
|
|
|
|
bool AIPerHostRequestQueue::throttled() const
|
|
{
|
|
llassert(mAdded <= int(curl_concurrent_connections_per_host));
|
|
return mAdded == int(curl_concurrent_connections_per_host);
|
|
}
|
|
|
|
void AIPerHostRequestQueue::added_to_multi_handle(void)
|
|
{
|
|
llassert(mAdded < int(curl_concurrent_connections_per_host));
|
|
++mAdded;
|
|
}
|
|
|
|
void AIPerHostRequestQueue::removed_from_multi_handle(void)
|
|
{
|
|
--mAdded;
|
|
llassert(mAdded >= 0);
|
|
}
|
|
|
|
void AIPerHostRequestQueue::queue(AICurlEasyRequest const& easy_request)
|
|
{
|
|
mQueuedRequests.push_back(easy_request.get_ptr());
|
|
sTotalQueued++;
|
|
}
|
|
|
|
bool AIPerHostRequestQueue::cancel(AICurlEasyRequest const& easy_request)
|
|
{
|
|
queued_request_type::iterator const end = mQueuedRequests.end();
|
|
queued_request_type::iterator cur = std::find(mQueuedRequests.begin(), end, easy_request.get_ptr());
|
|
|
|
if (cur == end)
|
|
return false; // Not found.
|
|
|
|
// We can't use erase because that uses assignment to move elements,
|
|
// because it isn't thread-safe. Therefore, move the element that we found to
|
|
// the back with swap (could just swap with the end immediately, but I don't
|
|
// want to break the order in which requests where added). Swap is also not
|
|
// thread-safe, but OK here because it only touches the objects in the deque,
|
|
// and the deque is protected by the lock on the AIPerHostRequestQueue object.
|
|
queued_request_type::iterator prev = cur;
|
|
while (++cur != end)
|
|
{
|
|
prev->swap(*cur); // This is safe,
|
|
prev = cur;
|
|
}
|
|
mQueuedRequests.pop_back(); // if this is safe.
|
|
--sTotalQueued;
|
|
llassert(sTotalQueued >= 0);
|
|
return true;
|
|
}
|
|
|
|
void AIPerHostRequestQueue::add_queued_to(curlthread::MultiHandle* multi_handle)
|
|
{
|
|
if (!mQueuedRequests.empty())
|
|
{
|
|
multi_handle->add_easy_request(mQueuedRequests.front());
|
|
mQueuedRequests.pop_front();
|
|
--sTotalQueued;
|
|
llassert(sTotalQueued >= 0);
|
|
}
|
|
}
|
|
|
|
//static
|
|
void AIPerHostRequestQueue::purge(void)
|
|
{
|
|
instance_map_wat instance_map_w(sInstanceMap);
|
|
for (iterator host = instance_map_w->begin(); host != instance_map_w->end(); ++host)
|
|
{
|
|
Dout(dc::curl, "Purging queue of host \"" << host->first << "\".");
|
|
PerHostRequestQueue_wat per_host_w(*host->second);
|
|
size_t s = per_host_w->mQueuedRequests.size();
|
|
per_host_w->mQueuedRequests.clear();
|
|
sTotalQueued -= s;
|
|
llassert(sTotalQueued >= 0);
|
|
}
|
|
}
|
|
|