core/banker/slave_banker.h

/* slave_banker.h                                                  -*- C++ -*-
   Jeremy Barens, 8 November 2012
   Copyright (c) 2012 Datacratic Inc.  All rights reserved.

   Slave "banker" object that authorizes spend.
*/

#ifndef __banker__slave_banker_h__
#define __banker__slave_banker_h__

#include "banker.h"
#include "soa/service/zmq_endpoint.h"
#include "soa/service/typed_message_channel.h"
#include "soa/service/rest_proxy.h"
#include <thread>

namespace RTBKIT {


/*****************************************************************************/
/* SLAVE BUDGET CONTROLLER                                                   */
/*****************************************************************************/

struct SlaveBudgetController
    : public BudgetController, public Accountant, public RestProxy  {

    SlaveBudgetController();

    ~SlaveBudgetController()
    {
        shutdown();
    }

    void init(std::shared_ptr<ConfigurationService> config,
              const std::string & serviceClass = "rtbBanker")
    {
        RestProxy::initServiceClass(config, serviceClass, "zeromq");
    }

    virtual void addAccount(const AccountKey & account,
                            const OnBudgetResult & onResult);

    virtual void topupTransfer(const AccountKey & account,
                               CurrencyPool amount,
                               const OnBudgetResult & onResult);

    virtual void setBudget(const std::string & topLevelAccount,
                           CurrencyPool amount,
                           const OnBudgetResult & onResult);
    
    virtual void addBudget(const std::string & topLevelAccount,
                           CurrencyPool amount,
                           const OnBudgetResult & onResult);

    virtual void
    getAccountList(const AccountKey & prefix,
                   int depth,
                   std::function<void (std::exception_ptr,
                                       std::vector<AccountKey> &&)> onResult);

    virtual void
    getAccountSummary(const AccountKey & account,
                     int depth,
                     std::function<void (std::exception_ptr,
                                         AccountSummary &&)> onResult);

    virtual void
    getAccount(const AccountKey & account,
               std::function<void (std::exception_ptr,
                                   Account &&)> onResult);

    static OnDone budgetResultCallback(const OnBudgetResult & onResult);
};


/*****************************************************************************/
/* SLAVE BANKER                                                              */
/*****************************************************************************/

struct SlaveBanker : public Banker, public RestProxy {

    SlaveBanker(std::shared_ptr<zmq::context_t> context);

    ~SlaveBanker()
    {
        shutdown();
    }

    SlaveBanker(std::shared_ptr<zmq::context_t> context,
                std::shared_ptr<ConfigurationService> config,
                const std::string & accountSuffix,
                const std::string & bankerServiceClass = "rtbBanker");

    void init(std::shared_ptr<ConfigurationService> config,
              const std::string & accountSuffix,
              const std::string & serviceClass = "rtbBanker");

    virtual void addSpendAccount(const AccountKey & account,
                                 CurrencyPool accountFloat,
                                 std::function<void (std::exception_ptr, ShadowAccount&&)> onDone);

    ShadowAccount getAccount(const AccountKey & account)
    {
        return accounts.activateAccount(account);
    }

    virtual bool authorizeBid(const AccountKey & account,
                              const std::string & item,
                              Amount amount)
    {
        return accounts.authorizeBid(account, item, amount);
    }

    virtual void commitBid(const AccountKey & account,
                           const std::string & item,
                           Amount amountPaid,
                           const LineItems & lineItems)
    {
        accounts.commitBid(account, item, amountPaid, lineItems);
    }

    virtual Amount detachBid(const AccountKey & account,
                             const std::string & item)
    {
        return accounts.detachBid(account, item);
    }

    virtual void attachBid(const AccountKey & account,
                           const std::string & item,
                           Amount amountAuthorized)
    {
        accounts.attachBid(account, item, amountAuthorized);
    }

    virtual void commitDetachedBid(const AccountKey & account,
                                   Amount amountAuthorized,
                                   Amount amountPaid,
                                   const LineItems & lineItems)
    {
        return accounts.commitDetachedBid(account,
                                          amountAuthorized, amountPaid,
                                          lineItems);
    }

    virtual void forceWinBid(const AccountKey & account,
                             Amount amountPaid,
                             const LineItems & lineItems)
    {
        return accounts.forceWinBid(account, amountPaid, lineItems);
    }

    ShadowAccount syncAccountSync(const AccountKey & account);

    void syncAccount(const AccountKey & account,
                     std::function<void (std::exception_ptr,
                                         ShadowAccount &&)> onDone);

    void syncAllSync();

    void syncAll(std::function<void (std::exception_ptr)> onDone
                 = std::function<void (std::exception_ptr)>());

    ShadowAccount getAccountStateDebug(AccountKey accountKey) const
    {
        return accounts.getAccount(accountKey);
    }

    /* Logging */
    virtual void logBidEvents(const Datacratic::EventRecorder & eventRecorder)
    {
        accounts.logBidEvents(eventRecorder);
    }

private:    
    ShadowAccounts accounts;

    TypedMessageSink<AccountKey> createdAccounts;
    std::string accountSuffix;
    
    void reportSpend(uint64_t numTimeoutsExpired);
    Date reportSpendSent;

    void reauthorizeBudget(uint64_t numTimeoutsExpired);
    Date reauthorizeBudgetSent;

    void onSyncResult(const AccountKey & accountKey,
                      std::function<void (std::exception_ptr,
                                          ShadowAccount &&)> onDone,
                      std::exception_ptr exc,
                      Account&& masterAccount);

    void onInitializeResult(const AccountKey & accountKey,
                            std::function<void (std::exception_ptr,
                                                ShadowAccount &&)> onDone,
                            std::exception_ptr exc,
                            Account&& masterAccount);
    
    void onReauthorizeBudgetMessage(const AccountKey & account,
                                    std::exception_ptr exc,
                                    int responseCode,
                                    const std::string & payload);

    std::string getShadowAccountStr(const AccountKey & account) const
    {
        return account.childKey(accountSuffix).toString();
    }
};

} // naemspace RTBKIT

#endif /* __banker__slave_banker_h__ */