path: root/indra/newview/llappcorehttp.h

/**
 * @file llappcorehttp.h
 * @brief Singleton initialization/shutdown class for llcorehttp library
 *
 * $LicenseInfo:firstyear=2012&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2012-2014, 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$
 */

#ifndef _LL_APP_COREHTTP_H_
#define _LL_APP_COREHTTP_H_


#include "httprequest.h"
#include "httphandler.h"
#include "httpresponse.h"


// This class manages the lifecyle of the core http library.
// Slightly different style than traditional code but reflects
// the use of handler classes and light-weight interface
// object instances of the new libraries.  To be used
// as a singleton and static construction is fine.
class LLAppCoreHttp : public LLCore::HttpHandler
{
public:
    static const long           PIPELINING_DEPTH;

    typedef LLCore::HttpRequest::policy_t policy_t;

    enum EAppPolicy
    {
        /// Catchall policy class.  Not used yet
        /// but will have a generous concurrency
        /// limit.  Deep queueing possible by having
        /// a chatty HTTP user.
        ///
        /// Destination:     anywhere
        /// Protocol:        http: or https:
        /// Transfer size:   KB-MB
        /// Long poll:       no
        /// Concurrency:     high
        /// Request rate:    unknown
        /// Pipelined:       no
        AP_DEFAULT,

        /// Texture fetching policy class.  Used to
        /// download textures via capability or SSA
        /// baking service.  Deep queueing of requests.
        /// Do not share.  GET requests only.
        ///
        /// Destination:     simhost:12046 & {bake-texture,cdn}:80
        /// Protocol:        http:
        /// Transfer size:   KB-MB
        /// Long poll:       no
        /// Concurrency:     high
        /// Request rate:    high
        /// Pipelined:       yes
        AP_TEXTURE,

        /// Legacy mesh fetching policy class.  Used to
        /// download textures via 'GetMesh' capability.
        /// To be deprecated.  Do not share.
        ///
        /// Destination:     simhost:12046
        /// Protocol:        http:
        /// Transfer size:   KB-MB
        /// Long poll:       no
        /// Concurrency:     dangerously high
        /// Request rate:    high
        /// Pipelined:       no
        AP_MESH1,

        /// New mesh fetching policy class.  Used to
        /// download textures via 'GetMesh2' capability.
        /// Used when fetch request (typically one LOD)
        /// is 'small', currently defined as 2MB.
        /// Very deeply queued.  Do not share.  GET
        /// requests only.
        ///
        /// Destination:     simhost:12046 & cdn:80
        /// Protocol:        http:
        /// Transfer size:   KB-MB
        /// Long poll:       no
        /// Concurrency:     high
        /// Request rate:    high
        /// Pipelined:       yes
        AP_MESH2,

        /// Large mesh fetching policy class.  Used to
        /// download textures via 'GetMesh' or 'GetMesh2'
        /// capability.  Used when fetch request
        /// is not small to avoid head-of-line problem
        /// when large requests block a sequence of small,
        /// fast requests.  Can be shared with similar
        /// traffic that can wait for longish stalls
        /// (default timeout 600S).
        ///
        /// Destination:     simhost:12046 & cdn:80
        /// Protocol:        http:
        /// Transfer size:   MB
        /// Long poll:       no
        /// Concurrency:     low
        /// Request rate:    low
        /// Pipelined:       no
        AP_LARGE_MESH,

        /// Asset upload policy class.  Used to store
        /// assets (mesh only at the moment) via
        /// changeable URL.  Responses may take some
        /// time (default timeout 240S).
        ///
        /// Destination:     simhost:12043
        /// Protocol:        https:
        /// Transfer size:   KB-MB
        /// Long poll:       no
        /// Concurrency:     low
        /// Request rate:    low
        /// Pipelined:       no
        AP_UPLOADS,

        /// Long-poll-type HTTP requests.  Not
        /// bound by a connection limit.  Requests
        /// will typically hang around for a long
        /// time (~30S).  Only shareable with other
        /// long-poll requests.
        ///
        /// Destination:     simhost:12043
        /// Protocol:        https:
        /// Transfer size:   KB
        /// Long poll:       yes
        /// Concurrency:     unlimited but low in practice
        /// Request rate:    low
        /// Pipelined:       no
        AP_LONG_POLL,

        /// Inventory operations (really Capabilities-
        /// related operations).  Mix of high-priority
        /// and low-priority operations.
        ///
        /// Destination:     simhost:12043
        /// Protocol:        https:
        /// Transfer size:   KB-MB
        /// Long poll:       no
        /// Concurrency:     high
        /// Request rate:    high
        /// Pipelined:       no
        AP_INVENTORY,
        AP_REPORTING = AP_INVENTORY,    // Piggy-back on inventory

        /// Material resource requests and puts.
        ///
        /// Destination:     simhost:12043
        /// Protocol:        https:
        /// Transfer size:   KB
        /// Long poll:       no
        /// Concurrency:     low
        /// Request rate:    low
        /// Pipelined:       no
        AP_MATERIALS,

        /// Appearance resource requests and puts.
        ///
        /// Destination:     simhost:12043
        /// Protocol:        https:
        /// Transfer size:   KB
        /// Long poll:       no
        /// Concurrency:     mid
        /// Request rate:    low
        /// Pipelined:       yes
        AP_AGENT,

        AP_COUNT                        // Must be last
    };

public:
    LLAppCoreHttp();
    ~LLAppCoreHttp();

    // Initialize the LLCore::HTTP library creating service classes
    // and starting the servicing thread.  Caller is expected to do
    // other initializations (SSL mutex, thread hash function) appropriate
    // for the application.
    void init();

    // Request that the servicing thread stop servicing requests,
    // release resource references and stop.  Request is asynchronous
    // and @see cleanup() will perform a limited wait loop for this
    // request to stop the thread.
    void requestStop();

    // Terminate LLCore::HTTP library services.  Caller is expected
    // to have made a best-effort to shutdown the servicing thread
    // by issuing a requestThreadStop() and waiting for completion
    // notification that the stop has completed.
    void cleanup();

    // Notification when the stop request is complete.
    virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);

    // Retrieve a policy class identifier for desired
    // application function.
    policy_t getPolicy(EAppPolicy policy) const
        {
            return mHttpClasses[policy].mPolicy;
        }

    // Return whether a policy is using pipelined operations.
    bool isPipelined(EAppPolicy policy) const
        {
            return mHttpClasses[policy].mPipelined;
        }

    // Apply initial or new settings from the environment.
    void refreshSettings(bool initial);

private:
    static const F64            MAX_THREAD_WAIT_TIME;

private:

    // PODish container for per-class settings and state.
    struct HttpClass
    {
    public:
        HttpClass();

    public:
        policy_t                    mPolicy;            // Policy class id for the class
        U32                         mConnLimit;
        bool                        mPipelined;
        boost::signals2::connection mSettingsSignal;    // Signal to global setting that affect this class (if any)
    };

    LLCore::HttpRequest *       mRequest;               // Request queue to issue shutdowns
    LLCore::HttpHandle          mStopHandle;
    F64                         mStopRequested;
    bool                        mStopped;
    HttpClass                   mHttpClasses[AP_COUNT];
    bool                        mPipelined;             // Global setting
    boost::signals2::connection mPipelinedSignal;       // Signal for 'HttpPipelining' setting
    boost::signals2::connection mSSLNoVerifySignal;     // Signal for 'NoVerifySSLCert' setting

    static LLCore::HttpStatus   sslVerify(const std::string &uri, const LLCore::HttpHandler::ptr_t &handler, void *appdata);
};


#endif  // _LL_APP_COREHTTP_H_