Changeset 229471 in webkit


Ignore:
Timestamp:
Mar 9, 2018 10:51:27 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

[Curl] Implement connection limit.
​https://bugs.webkit.org/show_bug.cgi?id=183016

Implement both connection limit per host and total
connection limit on curl network layer.

Patch by Basuke Suzuki <Basuke Suzuki> on 2018-03-09
Reviewed by Youenn Fablet.

No new tests because there's no behavior change.

  • platform/network/curl/CurlContext.cpp:

(WebCore::EnvironmentVariableReader::sscanTemplate<signed>):
(WebCore::CurlContext::CurlContext):
(WebCore::CurlMultiHandle::setMaxConnects):
(WebCore::CurlMultiHandle::setMaxTotalConnections):
(WebCore::CurlMultiHandle::setMaxHostConnections):

  • platform/network/curl/CurlContext.h:

(WebCore::CurlContext::scheduler):

  • platform/network/curl/CurlRequest.cpp:

(WebCore::CurlRequest::startWithJobManager):
(WebCore::CurlRequest::cancel):
(WebCore::CurlRequest::invokeDidReceiveResponseForFile):
(WebCore::CurlRequest::completeDidReceiveResponse):
(WebCore::CurlRequest::pausedStatusChanged):

  • platform/network/curl/CurlRequestScheduler.cpp:

(WebCore::CurlRequestScheduler::CurlRequestScheduler):
(WebCore::CurlRequestScheduler::workerThread):
(WebCore::CurlRequestScheduler::singleton): Deleted.

  • platform/network/curl/CurlRequestScheduler.h:
Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r229466 r229471  
     12018-03-09  Basuke Suzuki  <Basuke.Suzuki@sony.com>
     2
     3        [Curl] Implement connection limit.
     4        https://bugs.webkit.org/show_bug.cgi?id=183016
     5
     6        Implement both connection limit per host and total
     7        connection limit on curl network layer.
     8
     9        Reviewed by Youenn Fablet.
     10
     11        No new tests because there's no behavior change.
     12
     13        * platform/network/curl/CurlContext.cpp:
     14        (WebCore::EnvironmentVariableReader::sscanTemplate<signed>):
     15        (WebCore::CurlContext::CurlContext):
     16        (WebCore::CurlMultiHandle::setMaxConnects):
     17        (WebCore::CurlMultiHandle::setMaxTotalConnections):
     18        (WebCore::CurlMultiHandle::setMaxHostConnections):
     19        * platform/network/curl/CurlContext.h:
     20        (WebCore::CurlContext::scheduler):
     21        * platform/network/curl/CurlRequest.cpp:
     22        (WebCore::CurlRequest::startWithJobManager):
     23        (WebCore::CurlRequest::cancel):
     24        (WebCore::CurlRequest::invokeDidReceiveResponseForFile):
     25        (WebCore::CurlRequest::completeDidReceiveResponse):
     26        (WebCore::CurlRequest::pausedStatusChanged):
     27        * platform/network/curl/CurlRequestScheduler.cpp:
     28        (WebCore::CurlRequestScheduler::CurlRequestScheduler):
     29        (WebCore::CurlRequestScheduler::workerThread):
     30        (WebCore::CurlRequestScheduler::singleton): Deleted.
     31        * platform/network/curl/CurlRequestScheduler.h:
     32
    1332018-03-09  Jer Noble  <jer.noble@apple.com>
    234

  • trunk/Source/WebCore/platform/network/curl/CurlContext.cpp

    r229138 r229471  
    2929
    3030#if USE(CURL)
     31#include "CurlRequestScheduler.h"
    3132#include "HTTPHeaderMap.h"
    3233#include <NetworkLoadMetrics.h>
     34#include <mutex>
    3335#include <wtf/MainThread.h>
    3436#include <wtf/NeverDestroyed.h>
    … …  
    6769
    6870    // define specialized member function for specific type.
     71    template<> constexpr const char* sscanTemplate<signed>() { return "%d"; }
    6972    template<> constexpr const char* sscanTemplate<unsigned>() { return "%u"; }
    7073};
    … …  
    8992    if (auto value = envVar.readAs<unsigned>("WEBKIT_CURL_CONNECT_TIMEOUT"))
    9093        m_connectTimeout = Seconds(*value);
     94
     95    long maxConnects { CurlDefaultMaxConnects };
     96    long maxTotalConnections { CurlDefaultMaxTotalConnections };
     97    long maxHostConnections { CurlDefaultMaxHostConnections };
     98
     99    if (auto value = envVar.readAs<signed>("WEBKIT_CURL_MAXCONNECTS"))
     100        maxConnects = *value;
     101
     102    if (auto value = envVar.readAs<signed>("WEBKIT_CURL_MAX_TOTAL_CONNECTIONS"))
     103        maxTotalConnections = *value;
     104
     105    if (auto value = envVar.readAs<signed>("WEBKIT_CURL_MAX_HOST_CONNECTIONS"))
     106        maxHostConnections = *value;
     107
     108    m_scheduler = std::make_unique<CurlRequestScheduler>(maxConnects, maxTotalConnections, maxHostConnections);
    91109
    92110#ifndef NDEBUG
    … …  
    214232}
    215233
     234void CurlMultiHandle::setMaxConnects(long maxConnects)
     235{
     236    if (maxConnects < 0)
     237        return;
     238
     239    curl_multi_setopt(m_multiHandle, CURLMOPT_MAXCONNECTS, maxConnects);
     240}
     241
     242void CurlMultiHandle::setMaxTotalConnections(long maxTotalConnections)
     243{
     244    curl_multi_setopt(m_multiHandle, CURLMOPT_MAX_TOTAL_CONNECTIONS, maxTotalConnections);
     245}
     246
     247void CurlMultiHandle::setMaxHostConnections(long maxHostConnections)
     248{
     249    curl_multi_setopt(m_multiHandle, CURLMOPT_MAX_HOST_CONNECTIONS, maxHostConnections);
     250}
     251
    216252CURLMcode CurlMultiHandle::addHandle(CURL* handle)
    217253{

  • trunk/Source/WebCore/platform/network/curl/CurlContext.h

    r229138 r229471  
    5454};
    5555
     56// Values taken from http://www.browserscope.org/ following
     57// the rule "Do What Every Other Modern Browser Is Doing".
     58const long CurlDefaultMaxConnects { -1 }; // -1 : Does not set CURLMOPT_MAXCONNECTS
     59const long CurlDefaultMaxTotalConnections { 17 };
     60const long CurlDefaultMaxHostConnections { 6 };
     61
    5662// CurlGlobal --------------------------------------------
    5763// to make the initialization of libcurl happen before other initialization of CurlContext
    … …  
    9197// CurlContext --------------------------------------------
    9298
     99class CurlRequestScheduler;
     100
    93101class CurlContext : public CurlGlobal {
    94102    WTF_MAKE_NONCOPYABLE(CurlContext);
    … …  
    111119    const CurlShareHandle& shareHandle() { return m_shareHandle; }
    112120
     121    CurlRequestScheduler& scheduler() { return *m_scheduler; }
     122
    113123    // Proxy
    114124    const ProxyInfo& proxyInfo() const { return m_proxy; }
    … …  
    138148    CurlShareHandle m_shareHandle;
    139149    CurlSSLHandle m_sslHandle;
     150    std::unique_ptr<CurlRequestScheduler> m_scheduler;
    140151
    141152    Seconds m_dnsCacheTimeout { Seconds::fromMinutes(5) };
    … …  
    156167    CurlMultiHandle();
    157168    ~CurlMultiHandle();
     169
     170    void setMaxConnects(long);
     171    void setMaxTotalConnections(long);
     172    void setMaxHostConnections(long);
    158173
    159174    CURLMcode addHandle(CURL*);

  • trunk/Source/WebCore/platform/network/curl/CurlRequest.cpp

    r229138 r229471  
    9797    ASSERT(isMainThread());
    9898
    99     CurlRequestScheduler::singleton().add(this);
     99    CurlContext::singleton().scheduler().add(this);
    100100}
    101101
    … …  
    110110
    111111    if (!m_isSyncRequest) {
    112         auto& scheduler = CurlRequestScheduler::singleton();
     112        auto& scheduler = CurlContext::singleton().scheduler();
    113113
    114114        if (needToInvokeDidCancelTransfer()) {
    … …  
    518518    if (!m_isSyncRequest) {
    519519        // DidReceiveResponse must not be called immediately
    520         CurlRequestScheduler::singleton().callOnWorkerThread([protectedThis = makeRef(*this)]() {
     520        CurlContext::singleton().scheduler().callOnWorkerThread([protectedThis = makeRef(*this)]() {
    521521            protectedThis->invokeDidReceiveResponse(protectedThis->m_response, Action::StartTransfer);
    522522        });
    … …  
    561561    } else if (m_actionAfterInvoke == Action::FinishTransfer) {
    562562        if (!m_isSyncRequest) {
    563             CurlRequestScheduler::singleton().callOnWorkerThread([protectedThis = makeRef(*this), finishedResultCode = m_finishedResultCode]() {
     563            CurlContext::singleton().scheduler().callOnWorkerThread([protectedThis = makeRef(*this), finishedResultCode = m_finishedResultCode]() {
    564564                protectedThis->didCompleteTransfer(finishedResultCode);
    565565            });
    … …  
    603603
    604604    if (!m_isSyncRequest && isMainThread()) {
    605         CurlRequestScheduler::singleton().callOnWorkerThread([protectedThis = makeRef(*this), paused = isPaused()]() {
     605        CurlContext::singleton().scheduler().callOnWorkerThread([protectedThis = makeRef(*this), paused = isPaused()]() {
    606606            if (protectedThis->isCompletedOrCancelled())
    607607                return;

  • trunk/Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp

    r224322 r229471  
    3232
    3333#include "CurlRequestSchedulerClient.h"
    34 #include <wtf/NeverDestroyed.h>
    3534
    3635namespace WebCore {
    3736
    38 CurlRequestScheduler& CurlRequestScheduler::singleton()
    39 {
    40     static NeverDestroyed<CurlRequestScheduler> sharedInstance;
    41     return sharedInstance;
     37CurlRequestScheduler::CurlRequestScheduler(long maxConnects, long maxTotalConnections, long maxHostConnections)
     38    : m_maxConnects(maxConnects)
     39    , m_maxTotalConnections(maxTotalConnections)
     40    , m_maxHostConnections(maxHostConnections)
     41{
    4242}
    4343
    … …  
    136136
    137137    m_curlMultiHandle = std::make_unique<CurlMultiHandle>();
     138    m_curlMultiHandle->setMaxConnects(m_maxConnects);
     139    m_curlMultiHandle->setMaxTotalConnections(m_maxTotalConnections);
     140    m_curlMultiHandle->setMaxHostConnections(m_maxHostConnections);
    138141
    139142    while (m_runThread) {

  • trunk/Source/WebCore/platform/network/curl/CurlRequestScheduler.h

    r224322 r229471  
    4242    friend NeverDestroyed<CurlRequestScheduler>;
    4343public:
    44     static CurlRequestScheduler& singleton();
    45 
     44    CurlRequestScheduler(long maxConnects, long maxTotalConnections, long maxHostConnections);
    4645    ~CurlRequestScheduler() { stopThread(); }
    4746
    … …  
    5251
    5352private:
    54     CurlRequestScheduler() = default;
    55 
    5653    void startThreadIfNeeded();
    5754    void stopThreadIfNoMoreJobRunning();
    … …  
    7572
    7673    std::unique_ptr<CurlMultiHandle> m_curlMultiHandle;
     74
     75    long m_maxConnects;
     76    long m_maxTotalConnections;
     77    long m_maxHostConnections;
    7778};
    7879
Note: See TracChangeset for help on using the changeset viewer.