Struct interledger_store_redis::RedisStore

pub struct RedisStore {
    pub ilp_address: Arc<RwLock<Address>>,
    // some fields omitted
}

A Store that uses Redis as its underlying database.

This store leverages atomic Redis transactions to do operations such as balance updates.

Currently the RedisStore polls the database for the routing table and rate updates, but future versions of it will use PubSub to subscribe to updates.

Fields

ilp_address: Arc<RwLock<Address>>

Methods

impl RedisStore

pub fn get_all_accounts_ids(
    &self
) -> impl Future<Item = Vec<AccountId>, Error = ()>

Trait Implementations

impl Clone for RedisStore

fn clone(&self) -> RedisStore

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl NodeStore for RedisStore

type Account = Account

fn insert_account(
    &self,
    account: AccountDetails
) -> Box<dyn Future<Item = Account, Error = ()> + Send>

fn delete_account(
    &self,
    id: AccountId
) -> Box<dyn Future<Item = Account, Error = ()> + Send>

fn update_account(
    &self,
    id: AccountId,
    account: AccountDetails
) -> Box<dyn Future<Item = Self::Account, Error = ()> + Send>

fn modify_account_settings(
    &self,
    id: <Self::Account as AccountTrait>::AccountId,
    settings: AccountSettings
) -> Box<dyn Future<Item = Self::Account, Error = ()> + Send>

fn get_all_accounts(
    &self
) -> Box<dyn Future<Item = Vec<Self::Account>, Error = ()> + Send>

fn set_static_routes<R>(
    &self,
    routes: R
) -> Box<dyn Future<Item = (), Error = ()> + Send> where
    R: IntoIterator<Item = (String, AccountId)>, 

fn set_static_route(
    &self,
    prefix: String,
    account_id: AccountId
) -> Box<dyn Future<Item = (), Error = ()> + Send>

fn set_default_route(
    &self,
    account_id: AccountId
) -> Box<dyn Future<Item = (), Error = ()> + Send>

fn set_settlement_engines(
    &self,
    asset_to_url_map: impl IntoIterator<Item = (String, Url)>
) -> Box<dyn Future<Item = (), Error = ()> + Send>

fn get_asset_settlement_engine(
    &self,
    asset_code: &str
) -> Box<dyn Future<Item = Option<Url>, Error = ()> + Send>

impl HttpStore for RedisStore

type Account = Account

fn get_account_from_http_auth(
    &self,
    username: &Username,
    token: &str
) -> Box<dyn Future<Item = Self::Account, Error = ()> + Send>

Checks if the stored token for the provided account id matches the provided token, and if so, returns the account associated with that token

impl RouterStore for RedisStore

fn routing_table(
    &self
) -> Arc<HashMap<String, <Self::Account as AccountTrait>::AccountId>>

Synchronously return the routing table. Note that this is synchronous because it assumes that Stores should keep the routing table in memory and use PubSub or polling to keep it updated. This ensures that individual packets can be routed without hitting the underlying store. An Arc is returned to avoid copying the underlying data while processing each packet.

impl AddressStore for RedisStore

fn set_ilp_address(
    &self,
    ilp_address: Address
) -> Box<dyn Future<Item = (), Error = ()> + Send>

Saves the ILP Address in the store's memory and database

fn clear_ilp_address(&self) -> Box<dyn Future<Item = (), Error = ()> + Send>

fn get_ilp_address(&self) -> Address

Get's the store's ilp address from memory

impl BalanceStore for RedisStore

fn get_balance(
    &self,
    account: Account
) -> Box<dyn Future<Item = i64, Error = ()> + Send>

Returns the balance from the account holder's perspective, meaning the sum of the Payable Balance and Pending Outgoing minus the Receivable Balance and the Pending Incoming.

fn update_balances_for_prepare(
    &self,
    from_account: Account,
    incoming_amount: u64
) -> Box<dyn Future<Item = (), Error = ()> + Send>

fn update_balances_for_fulfill(
    &self,
    to_account: Account,
    outgoing_amount: u64
) -> Box<dyn Future<Item = (i64, u64), Error = ()> + Send>

Increases the account's balance, and returns the updated balance along with the amount which should be settled

fn update_balances_for_reject(
    &self,
    from_account: Account,
    incoming_amount: u64
) -> Box<dyn Future<Item = (), Error = ()> + Send>

impl ExchangeRateStore for RedisStore

fn get_exchange_rates(&self, asset_codes: &[&str]) -> Result<Vec<f64>, ()>

fn get_all_exchange_rates(&self) -> Result<HashMap<String, f64>, ()>

fn set_exchange_rates(&self, rates: HashMap<String, f64>) -> Result<(), ()>

impl StreamNotificationsStore for RedisStore

type Account = Account

fn add_payment_notification_subscription(
    &self,
    id: AccountId,
    sender: UnboundedSender<PaymentNotification>
)

fn publish_payment_notification(&self, payment: PaymentNotification)

impl SettlementStore for RedisStore

type Account = Account

fn update_balance_for_incoming_settlement(
    &self,
    account_id: AccountId,
    amount: u64,
    idempotency_key: Option<String>
) -> Box<dyn Future<Item = (), Error = ()> + Send>

fn refund_settlement(
    &self,
    account_id: AccountId,
    settle_amount: u64
) -> Box<dyn Future<Item = (), Error = ()> + Send>

impl AccountStore for RedisStore

type Account = Account

fn get_accounts(
    &self,
    account_ids: Vec<<Self::Account as AccountTrait>::AccountId>
) -> Box<dyn Future<Item = Vec<Account>, Error = ()> + Send>

fn get_account_id_from_username(
    &self,
    username: &Username
) -> Box<dyn Future<Item = AccountId, Error = ()> + Send>

impl IdempotentStore for RedisStore

fn load_idempotent_data(
    &self,
    idempotency_key: String
) -> Box<dyn Future<Item = Option<IdempotentData>, Error = ()> + Send>

Returns the API response that was saved when the idempotency key was used Also returns a hash of the input data which resulted in the response

fn save_idempotent_data(
    &self,
    idempotency_key: String,
    input_hash: [u8; 32],
    status_code: StatusCode,
    data: Bytes
) -> Box<dyn Future<Item = (), Error = ()> + Send>

Saves the data that was passed along with the api request for later The store MUST also save a hash of the input, so that it errors out on requests

impl RateLimitStore for RedisStore

type Account = Account

fn apply_rate_limits(
    &self,
    account: Account,
    prepare_amount: u64
) -> Box<dyn Future<Item = (), Error = RateLimitError> + Send>

Apply rate limits for number of packets per minute and amount of money per minute

This uses https://github.com/brandur/redis-cell so the redis-cell module MUST be loaded into redis before this is run

fn refund_throughput_limit(
    &self,
    account: Account,
    prepare_amount: u64
) -> Box<dyn Future<Item = (), Error = ()> + Send>

impl LeftoversStore for RedisStore

type AccountId = AccountId

type AssetType = BigUint

fn get_uncredited_settlement_amount(
    &self,
    account_id: Self::AccountId
) -> Box<dyn Future<Item = (Self::AssetType, u8), Error = ()> + Send>

fn save_uncredited_settlement_amount(
    &self,
    account_id: Self::AccountId,
    uncredited_settlement_amount: (Self::AssetType, u8)
) -> Box<dyn Future<Item = (), Error = ()> + Send>

Saves the leftover data

fn load_uncredited_settlement_amount(
    &self,
    account_id: Self::AccountId,
    local_scale: u8
) -> Box<dyn Future<Item = Self::AssetType, Error = ()> + Send>

Returns the leftover data scaled to local_scale from the saved scale. If any precision loss occurs during the scaling, it should be saved as the new leftover value.

impl BtpStore for RedisStore

type Account = Account

fn get_account_from_btp_auth(
    &self,
    username: &Username,
    token: &str
) -> Box<dyn Future<Item = Self::Account, Error = ()> + Send>

Load Account details based on the auth token received via BTP.

fn get_btp_outgoing_accounts(
    &self
) -> Box<dyn Future<Item = Vec<Self::Account>, Error = ()> + Send>

Load accounts that have a ilp_over_btp_url configured

impl RouteManagerStore for RedisStore

type Account = Account

fn get_accounts_to_send_routes_to(
    &self,
    ignore_accounts: Vec<AccountId>
) -> Box<dyn Future<Item = Vec<Account>, Error = ()> + Send>

fn get_accounts_to_receive_routes_from(
    &self
) -> Box<dyn Future<Item = Vec<Account>, Error = ()> + Send>

fn get_local_and_configured_routes(
    &self
) -> Box<dyn Future<Item = (HashMap<String, Account>, HashMap<String, Account>), Error = ()> + Send>

fn set_routes(
    &mut self,
    routes: impl IntoIterator<Item = (String, Account)>
) -> Box<dyn Future<Item = (), Error = ()> + Send>