core/router/router_stack.h

/* router_stack.h                                                  -*- C++ -*-
   Jeremy Barnes, 21 November 2012
   Copyright (c) 2012 Datacratic Inc.  All rights reserved.

   The core router stack.
*/

#pragma once


#include "router.h"
#include "rtbkit/core/monitor/monitor_endpoint.h"
#include "rtbkit/core/banker/master_banker.h"
#include "rtbkit/core/banker/slave_banker.h"
#include "rtbkit/core/post_auction/post_auction_loop.h"
#include "rtbkit/core/agent_configuration/agent_configuration_service.h"
#include "soa/service/testing/redis_temporary_server.h"

namespace RTBKIT {


/*****************************************************************************/
/* ROUTER STACK                                                              */
/*****************************************************************************/

struct RouterStack: public ServiceBase {
    
    RouterStack(std::shared_ptr<ServiceProxies> services,
                const std::string & serviceName = "routerStack",
                double secondsUntilLossAssumed = 2.0);

    void init();
    
    virtual void
    start(boost::function<void ()> onStop = boost::function<void ()>());

    virtual void sleepUntilIdle();
    
    virtual void shutdown();

    virtual size_t numNonIdle() const;

    void submitAuction(const std::shared_ptr<Auction> & auction,
                       const Id & adSpotId,
                       const Auction::Response & response);

    void notifyFinishedAuction(const Id & auctionId)
    {
        router.notifyFinishedAuction(auctionId);
    }

    int numAuctionsInProgress()
    {
        return router.numAuctionsInProgress();
    }

    Json::Value getStats() const
    {
        return router.getStats();
    }

    void injectWin(const Id & auctionId,
                   const Id & adSpotId,
                   Amount winPrice,
                   Date timestamp,
                   const JsonHolder & winMeta,
                   const UserIds & uids,
                   const AccountKey & account,
                   Date bidTimestamp)
    {
        postAuctionLoop.injectWin(auctionId, adSpotId, winPrice,
                                  timestamp, winMeta, uids,
                                  account, bidTimestamp);
    }

    void injectLoss(const Id & auctionId,
                    const Id & adSpotId,
                    Date timestamp,
                    const JsonHolder & lossMeta,
                    const AccountKey & account,
                    Date bidTimestamp)
    {
        postAuctionLoop.injectLoss(auctionId, adSpotId, timestamp,
                                   lossMeta, account, bidTimestamp);
    }

    void injectCampaignEvent(const std::string & label,
                             const Id & auctionId,
                             const Id & spotId,
                             Date timestamp,
                             const JsonHolder & eventMeta,
                             const UserIds & uids)
    {
        postAuctionLoop.injectCampaignEvent(label, auctionId, spotId,
                                            timestamp, eventMeta, uids);
    }

    void notifyFinishedSpot(const Id & auctionId, const Id & adSpotId)
    {
        postAuctionLoop.notifyFinishedSpot(auctionId, adSpotId);
    }

    void initStatePersistence(const std::string & path)
    {
        postAuctionLoop.initStatePersistence(path);
    }

    void addBudget(const AccountKey & account, CurrencyPool amount);
    
    void setBudget(const AccountKey & account, CurrencyPool amount);
    
    void topupTransfer(const AccountKey & account, CurrencyPool amount);

    Router router;

    Redis::RedisTemporaryServer redis;
    MasterBanker masterBanker;
    SlaveBudgetController budgetController;

    PostAuctionLoop postAuctionLoop;
    AgentConfigurationService config;

    MonitorEndpoint monitor;

    bool initialized;
};



} // namespace RTBKIT