core/banker/master_banker.h

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

   Master banker class to deal with all budgeting.
*/

#ifndef __banker__master_banker_h__
#define __banker__master_banker_h__

#include "banker.h"
#include "soa/service/named_endpoint.h"
#include "soa/service/message_loop.h"
#include "soa/service/redis.h"
#include "soa/service/rest_service_endpoint.h"
#include "soa/service/rest_request_router.h"
#include "jml/utils/vector_utils.h"
#include "jml/utils/positioned_types.h"
#include <type_traits>
#include "rtbkit/core/monitor/monitor_provider.h"

#include "null_banker.h"  // debug

namespace RTBKIT {

class Accounts;

inline AccountKey restDecode(const std::string & str, AccountKey *)
{
    return AccountKey(ML::split(str, ':'));
}

inline std::string restEncode(const AccountKey & val)
{
    return val.toString();
}


/*****************************************************************************/
/* REAL BANKER                                                               */
/*****************************************************************************/

/*****************************************************************************/
/* BANKER PERSISTENCE                                                        */
/*****************************************************************************/

struct BankerPersistence {
    enum PersistenceCallbackStatus {
        SUCCESS,             /* info = "" */
        BACKEND_ERROR,       /* info = error string */
        DATA_INCONSISTENCY   /* info = json array of account keys */
    };

    virtual ~BankerPersistence()
    {
    }

    /* callback types */
    typedef std::function<void (std::shared_ptr<Accounts>,
                                PersistenceCallbackStatus,
                                const std::string & info)>
        OnLoadedCallback;
    typedef std::function<void (PersistenceCallbackStatus,
                                const std::string & info)>
        OnSavedCallback;

    /* backend methods */
    virtual void loadAll(const std::string & topLevelKey,
                         OnLoadedCallback onLoaded) = 0;
    virtual void saveAll(const Accounts & toSave,
                         OnSavedCallback onDone) = 0;
};


/*****************************************************************************/
/* NO BANKER PERSISTENCE                                                     */
/*****************************************************************************/

struct NoBankerPersistence : public BankerPersistence {
    NoBankerPersistence()
    {
    }

    virtual ~NoBankerPersistence()
    {
    }

    virtual void
    loadAll(const std::string & topLevelKey, OnLoadedCallback onLoaded)
    {
        onLoaded(std::make_shared<Accounts>(), SUCCESS, "");
    }

    virtual void
    saveAll(const Accounts & toSave, OnSavedCallback onDone)
    {
        onDone(SUCCESS, "");
    }
};

/*****************************************************************************/
/* REDIS BANKER PERSISTENCE                                                  */
/*****************************************************************************/

struct RedisBankerPersistence : public BankerPersistence {
    RedisBankerPersistence(const Redis::Address & redis);
    RedisBankerPersistence(std::shared_ptr<Redis::AsyncConnection> redis);

    struct Itl;
    std::shared_ptr<Itl> itl;

    void loadAll(const std::string & topLevelKey, OnLoadedCallback onLoaded);
    void saveAll(const Accounts & toSave, OnSavedCallback onDone);
};

/*****************************************************************************/
/* OLD REDIS BANKER PERSISTENCE                                              */
/*****************************************************************************/

struct OldRedisBankerPersistence : public BankerPersistence {

    OldRedisBankerPersistence();

    struct Itl;
    std::shared_ptr<Itl> itl;

    void loadAll(const std::string & topLevelKey, OnLoadedCallback onLoaded);
    void saveAll(const Accounts & toSave, OnSavedCallback onDone);
};


/*****************************************************************************/
/* MASTER BANKER                                                             */
/*****************************************************************************/

struct MasterBanker
    : public ServiceBase,
      public RestServiceEndpoint,
      public MonitorProvider
{

    MasterBanker(std::shared_ptr<ServiceProxies> proxies,
                 const std::string & serviceName = "masterBanker");
    ~MasterBanker();

    std::shared_ptr<BankerPersistence> storage_;

    void init(const std::shared_ptr<BankerPersistence> & storage);
    void start();
    std::pair<std::string, std::string> bindTcp();

    void shutdown();

    void bindFixedHttpAddress(const std::string & uri);

    RestRequestRouter router;
    Accounts accounts;
    Date lastSavedState;
    BankerPersistence::PersistenceCallbackStatus lastSaveStatus;

    typedef ML::Spinlock Lock;
    typedef std::unique_lock<Lock> Guard;
    mutable Lock saveLock;
    int saving;

    Json::Value createAccount(const AccountKey & key, AccountType type);

    void saveState();

    void loadStateSync();

    void onStateLoaded(std::shared_ptr<Accounts> newAccounts,
                       BankerPersistence::PersistenceCallbackStatus status,
                       const std::string & info);
    void onStateSaved(BankerPersistence::PersistenceCallbackStatus status,
                      const std::string & info);

    /* Reponds to Monitor requests */
    MonitorProviderClient monitorProviderClient;

    /* MonitorProvider interface */
    std::string getProviderName() const;
    Json::Value getProviderIndicators() const;

    Date lastWin;
    Date lastImpression;
};

} // namespace RTBKIT

#endif /* __banker__master_banker_h__ */