plugins/exchange/http_exchange_connector.h

/* http_exchange_connector.h                                       -*- C++ -*-
   Jeremy Barnes, 31 January 2011
   Copyright (c) 2011 Datacratic.  All rights reserved.

   Endpoint for bidding system.
*/

#pragma once

#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include "jml/arch/atomic_ops.h"
#include "soa/service/json_endpoint.h"
#include "soa/service/stats_events.h"
#include "rtbkit/common/auction.h"
#include <limits>
#include "rtbkit/common/exchange_connector.h"
#include <boost/algorithm/string.hpp>


namespace RTBKIT {

struct HttpExchangeConnector;
struct HttpAuctionHandler;


/*****************************************************************************/
/* HTTP EXCHANGE CONNECTOR                                                   */
/*****************************************************************************/

struct HttpExchangeConnector
    : public ExchangeConnector,
      public HttpEndpoint {

    HttpExchangeConnector(const std::string & name,
                          ServiceBase & parent);

    HttpExchangeConnector(const std::string & name,
                          std::shared_ptr<ServiceProxies> proxies);

    ~HttpExchangeConnector();

    int numServingRequest() const
    {
        return numServingRequest_;
    }
    
    virtual Json::Value getServiceStatus() const;


    /*************************************************************************/
    /* METHODS CALLED BY THE ROUTER TO CONTROL THE EXCHANGE CONNECTOR        */
    /*************************************************************************/

    virtual void configure(const Json::Value & parameters);

    void configureHttp(int numThreads,
                       const PortRange & listenPort,
                       const std::string & bindHost = "*",
                       bool performNameLookup = false,
                       int backlog = DEF_BACKLOG,
                       const std::string & auctionResource = "/auctions",
                       const std::string & auctionVerb = "POST");

    virtual void start();

    virtual void shutdown();

    virtual void enableUntil(Date date)
    {
        this->enabledUntil = date;
    }

    bool isEnabled(Date now = Date::now()) const
    {
        return now <= enabledUntil;
    }

    virtual void setAcceptBidRequestProbability(double prob)
    {
        if (prob < 0 || prob > 1)
            throw ML::Exception("invalid probability for "
                                "setBidRequestProbability: "
                                "%f is not between 0 and 1");
        this->acceptAuctionProbability = prob;
    }


    /*************************************************************************/
    /* METHODS TO OVERRIDE FOR A GIVEN EXCHANGE                              */
    /*************************************************************************/

    virtual std::string exchangeName() const = 0;

    virtual std::shared_ptr<BidRequest>
    parseBidRequest(HttpAuctionHandler & connection,
                    const HttpHeader & header,
                    const std::string & payload);

    virtual double
    getTimeAvailableMs(HttpAuctionHandler & connection,
                       const HttpHeader & header,
                       const std::string & payload);

    virtual double
    getRoundTripTimeMs(HttpAuctionHandler & connection,
                       const HttpHeader & header);

    virtual HttpResponse
    getResponse(const HttpAuctionHandler & connection,
                const HttpHeader & requestHeader,
                const Auction & auction) const;

    virtual HttpResponse
    getDroppedAuctionResponse(const HttpAuctionHandler & connection,
                              const Auction & auction,
                              const std::string & reason) const;

    virtual HttpResponse
    getErrorResponse(const HttpAuctionHandler & connection,
                     const Auction & auction,
                     const std::string & errorMessage) const;

    virtual void
    handleUnknownRequest(HttpAuctionHandler & connection,
                         const HttpHeader & header,
                         const std::string & payload) const;

    virtual ExchangeCompatibility
    getCampaignCompatibility(const AgentConfig & config,
                             bool includeReasons) const;
    
    virtual ExchangeCompatibility
    getCreativeCompatibility(const Creative & creative,
                             bool includeReasons) const;

protected:
    virtual std::shared_ptr<ConnectionHandler> makeNewHandler();
    virtual std::shared_ptr<HttpAuctionHandler> makeNewHandlerShared();

    double acceptAuctionProbability;

    Date enabledUntil;
    
    typedef boost::function<void (std::shared_ptr<Auction>, Date)> OnTimeout;
    OnTimeout onTimeout;

    typedef boost::function<HttpAuctionHandler * ()> HandlerFactory;
    HandlerFactory handlerFactory;

    int numServingRequest_;  

    int numThreads;         
    PortRange listenPort;
    std::string bindHost;
    bool performNameLookup;
    int backlog;
    std::string auctionResource;
    std::string auctionVerb;

    std::unordered_map<std::string, float> pingTimesByHostMs;

    float pingTimeUnknownHostsMs;
    
private:
    friend class HttpAuctionHandler;

    Lock handlersLock;
    std::set<std::shared_ptr<HttpAuctionHandler> > handlers;

    void finishedWithHandler(std::shared_ptr<HttpAuctionHandler> handler);

    void postConstructorInit();
};

} // namespace RTBKIT