2019-02-17 08:38:36 -08:00
|
|
|
//! The `pubsub` module implements a threaded subscription service on client RPC request
|
|
|
|
|
2019-03-06 14:31:16 -08:00
|
|
|
use core::hash::Hash;
|
2019-02-17 08:38:36 -08:00
|
|
|
use jsonrpc_core::futures::Future;
|
2020-03-24 09:53:32 -07:00
|
|
|
use jsonrpc_pubsub::{
|
|
|
|
typed::{Sink, Subscriber},
|
|
|
|
SubscriptionId,
|
|
|
|
};
|
2019-05-06 07:31:50 -07:00
|
|
|
use serde::Serialize;
|
2020-03-23 05:34:42 -07:00
|
|
|
use solana_client::rpc_response::{Response, RpcAccount, RpcKeyedAccount, RpcResponseContext};
|
2019-10-20 08:54:38 -07:00
|
|
|
use solana_ledger::bank_forks::BankForks;
|
2019-04-05 09:42:54 -07:00
|
|
|
use solana_runtime::bank::Bank;
|
2019-11-02 00:38:30 -07:00
|
|
|
use solana_sdk::{
|
|
|
|
account::Account, clock::Slot, pubkey::Pubkey, signature::Signature, transaction,
|
|
|
|
};
|
2019-11-20 10:12:43 -08:00
|
|
|
use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
|
2020-01-20 13:08:29 -08:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
|
use std::sync::mpsc::{Receiver, RecvTimeoutError, SendError, Sender};
|
|
|
|
use std::thread::{Builder, JoinHandle};
|
|
|
|
use std::time::Duration;
|
2020-01-15 10:52:02 -08:00
|
|
|
use std::{
|
2020-02-13 09:00:50 -08:00
|
|
|
collections::{HashMap, HashSet},
|
2020-02-25 20:23:54 -08:00
|
|
|
iter,
|
2020-01-20 13:08:29 -08:00
|
|
|
sync::{Arc, Mutex, RwLock},
|
2020-01-15 10:52:02 -08:00
|
|
|
};
|
2020-02-25 20:23:54 -08:00
|
|
|
use tokio::runtime::{Builder as RuntimeBuilder, Runtime, TaskExecutor};
|
2019-02-17 08:38:36 -08:00
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
const RECEIVE_DELAY_MILLIS: u64 = 100;
|
|
|
|
|
2019-05-06 07:31:50 -07:00
|
|
|
pub type Confirmations = usize;
|
|
|
|
|
2020-02-25 20:23:54 -08:00
|
|
|
#[derive(Serialize, Deserialize, Clone, Copy, Debug)]
|
2019-11-26 00:42:54 -08:00
|
|
|
pub struct SlotInfo {
|
|
|
|
pub slot: Slot,
|
|
|
|
pub parent: Slot,
|
|
|
|
pub root: Slot,
|
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
enum NotificationEntry {
|
|
|
|
Slot(SlotInfo),
|
|
|
|
Bank((Slot, Arc<RwLock<BankForks>>)),
|
|
|
|
}
|
|
|
|
|
|
|
|
impl std::fmt::Debug for NotificationEntry {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
|
|
match self {
|
|
|
|
NotificationEntry::Slot(slot_info) => write!(f, "Slot({:?})", slot_info),
|
|
|
|
NotificationEntry::Bank((current_slot, _)) => {
|
|
|
|
write!(f, "Bank({{current_slot: {:?}}})", current_slot)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-06 07:31:50 -07:00
|
|
|
type RpcAccountSubscriptions =
|
2020-03-23 05:34:42 -07:00
|
|
|
RwLock<HashMap<Pubkey, HashMap<SubscriptionId, (Sink<Response<RpcAccount>>, Confirmations)>>>;
|
|
|
|
type RpcProgramSubscriptions = RwLock<
|
|
|
|
HashMap<Pubkey, HashMap<SubscriptionId, (Sink<Response<RpcKeyedAccount>>, Confirmations)>>,
|
|
|
|
>;
|
2019-05-06 07:31:50 -07:00
|
|
|
type RpcSignatureSubscriptions = RwLock<
|
2020-03-23 05:34:42 -07:00
|
|
|
HashMap<
|
|
|
|
Signature,
|
|
|
|
HashMap<SubscriptionId, (Sink<Response<transaction::Result<()>>>, Confirmations)>,
|
|
|
|
>,
|
2019-05-06 07:31:50 -07:00
|
|
|
>;
|
2019-11-26 00:42:54 -08:00
|
|
|
type RpcSlotSubscriptions = RwLock<HashMap<SubscriptionId, Sink<SlotInfo>>>;
|
2019-03-06 14:31:16 -08:00
|
|
|
|
|
|
|
fn add_subscription<K, S>(
|
2019-05-06 07:31:50 -07:00
|
|
|
subscriptions: &mut HashMap<K, HashMap<SubscriptionId, (Sink<S>, Confirmations)>>,
|
2020-03-24 09:53:32 -07:00
|
|
|
hashmap_key: K,
|
2019-05-06 07:31:50 -07:00
|
|
|
confirmations: Option<Confirmations>,
|
2020-03-24 09:53:32 -07:00
|
|
|
sub_id: SubscriptionId,
|
|
|
|
subscriber: Subscriber<S>,
|
2019-03-06 14:31:16 -08:00
|
|
|
) where
|
2020-03-24 09:53:32 -07:00
|
|
|
K: Eq + Hash,
|
2019-03-06 14:31:16 -08:00
|
|
|
S: Clone,
|
|
|
|
{
|
2020-03-24 09:53:32 -07:00
|
|
|
let sink = subscriber.assign_id(sub_id.clone()).unwrap();
|
2019-05-06 07:31:50 -07:00
|
|
|
let confirmations = confirmations.unwrap_or(0);
|
|
|
|
let confirmations = if confirmations > MAX_LOCKOUT_HISTORY {
|
|
|
|
MAX_LOCKOUT_HISTORY
|
|
|
|
} else {
|
|
|
|
confirmations
|
|
|
|
};
|
2020-03-24 09:53:32 -07:00
|
|
|
if let Some(current_hashmap) = subscriptions.get_mut(&hashmap_key) {
|
|
|
|
current_hashmap.insert(sub_id, (sink, confirmations));
|
2019-03-06 14:31:16 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
let mut hashmap = HashMap::new();
|
2020-03-24 09:53:32 -07:00
|
|
|
hashmap.insert(sub_id, (sink, confirmations));
|
|
|
|
subscriptions.insert(hashmap_key, hashmap);
|
2019-03-06 14:31:16 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
fn remove_subscription<K, S>(
|
2019-05-06 07:31:50 -07:00
|
|
|
subscriptions: &mut HashMap<K, HashMap<SubscriptionId, (Sink<S>, Confirmations)>>,
|
2019-03-06 14:31:16 -08:00
|
|
|
sub_id: &SubscriptionId,
|
|
|
|
) -> bool
|
|
|
|
where
|
2020-03-24 09:53:32 -07:00
|
|
|
K: Eq + Hash,
|
2019-03-06 14:31:16 -08:00
|
|
|
S: Clone,
|
|
|
|
{
|
|
|
|
let mut found = false;
|
|
|
|
subscriptions.retain(|_, v| {
|
|
|
|
v.retain(|k, _| {
|
2020-03-24 09:53:32 -07:00
|
|
|
let retain = k != sub_id;
|
2020-02-11 17:09:40 -08:00
|
|
|
if !retain {
|
2019-03-06 14:31:16 -08:00
|
|
|
found = true;
|
|
|
|
}
|
2020-02-11 17:09:40 -08:00
|
|
|
retain
|
2019-03-06 14:31:16 -08:00
|
|
|
});
|
|
|
|
!v.is_empty()
|
|
|
|
});
|
|
|
|
found
|
|
|
|
}
|
|
|
|
|
2020-03-23 05:34:42 -07:00
|
|
|
#[allow(clippy::type_complexity)]
|
2020-02-25 20:23:54 -08:00
|
|
|
fn check_confirmations_and_notify<K, S, B, F, X>(
|
2020-03-23 05:34:42 -07:00
|
|
|
subscriptions: &HashMap<K, HashMap<SubscriptionId, (Sink<Response<S>>, Confirmations)>>,
|
2019-05-06 07:31:50 -07:00
|
|
|
hashmap_key: &K,
|
2019-11-02 00:38:30 -07:00
|
|
|
current_slot: Slot,
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks: &Arc<RwLock<BankForks>>,
|
2020-02-25 20:23:54 -08:00
|
|
|
bank_method: B,
|
|
|
|
filter_results: F,
|
|
|
|
notifier: &RpcNotifier,
|
2020-02-13 09:00:50 -08:00
|
|
|
) -> HashSet<SubscriptionId>
|
|
|
|
where
|
2019-05-06 07:31:50 -07:00
|
|
|
K: Eq + Hash + Clone + Copy,
|
|
|
|
S: Clone + Serialize,
|
2020-02-25 20:23:54 -08:00
|
|
|
B: Fn(&Bank, &K) -> X,
|
|
|
|
F: Fn(X, u64) -> Box<dyn Iterator<Item = S>>,
|
2019-05-06 07:31:50 -07:00
|
|
|
X: Clone + Serialize,
|
|
|
|
{
|
|
|
|
let current_ancestors = bank_forks
|
|
|
|
.read()
|
|
|
|
.unwrap()
|
|
|
|
.get(current_slot)
|
|
|
|
.unwrap()
|
|
|
|
.ancestors
|
|
|
|
.clone();
|
2020-02-13 09:00:50 -08:00
|
|
|
|
|
|
|
let mut notified_set: HashSet<SubscriptionId> = HashSet::new();
|
2019-05-06 07:31:50 -07:00
|
|
|
if let Some(hashmap) = subscriptions.get(hashmap_key) {
|
2020-03-23 05:34:42 -07:00
|
|
|
for (sub_id, (sink, confirmations)) in hashmap.iter() {
|
2019-05-06 07:31:50 -07:00
|
|
|
let desired_slot: Vec<u64> = current_ancestors
|
|
|
|
.iter()
|
|
|
|
.filter(|(_, &v)| v == *confirmations)
|
|
|
|
.map(|(k, _)| k)
|
|
|
|
.cloned()
|
|
|
|
.collect();
|
|
|
|
let root: Vec<u64> = current_ancestors
|
|
|
|
.iter()
|
|
|
|
.filter(|(_, &v)| v == 32)
|
|
|
|
.map(|(k, _)| k)
|
|
|
|
.cloned()
|
|
|
|
.collect();
|
|
|
|
let root = if root.len() == 1 { root[0] } else { 0 };
|
|
|
|
if desired_slot.len() == 1 {
|
2020-03-23 05:34:42 -07:00
|
|
|
let slot = desired_slot[0];
|
|
|
|
let desired_bank = bank_forks.read().unwrap().get(slot).unwrap().clone();
|
2020-02-25 20:23:54 -08:00
|
|
|
let results = bank_method(&desired_bank, hashmap_key);
|
|
|
|
for result in filter_results(results, root) {
|
2020-03-23 05:34:42 -07:00
|
|
|
notifier.notify(
|
|
|
|
Response {
|
|
|
|
context: RpcResponseContext { slot },
|
|
|
|
value: result,
|
|
|
|
},
|
|
|
|
sink,
|
|
|
|
);
|
|
|
|
notified_set.insert(sub_id.clone());
|
2020-02-13 09:00:50 -08:00
|
|
|
}
|
2019-05-06 07:31:50 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-02-13 09:00:50 -08:00
|
|
|
notified_set
|
2019-05-06 07:31:50 -07:00
|
|
|
}
|
|
|
|
|
2020-02-25 20:23:54 -08:00
|
|
|
struct RpcNotifier(TaskExecutor);
|
|
|
|
|
|
|
|
impl RpcNotifier {
|
|
|
|
fn notify<T>(&self, value: T, sink: &Sink<T>)
|
|
|
|
where
|
|
|
|
T: serde::Serialize,
|
|
|
|
{
|
|
|
|
self.0
|
|
|
|
.spawn(sink.notify(Ok(value)).map(|_| ()).map_err(|_| ()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn filter_account_result(
|
|
|
|
result: Option<(Account, Slot)>,
|
|
|
|
root: Slot,
|
|
|
|
) -> Box<dyn Iterator<Item = RpcAccount>> {
|
2019-05-06 07:31:50 -07:00
|
|
|
if let Some((account, fork)) = result {
|
|
|
|
if fork >= root {
|
2020-02-25 20:23:54 -08:00
|
|
|
return Box::new(iter::once(RpcAccount::encode(account)));
|
2019-05-06 07:31:50 -07:00
|
|
|
}
|
|
|
|
}
|
2020-02-25 20:23:54 -08:00
|
|
|
Box::new(iter::empty())
|
2019-05-06 07:31:50 -07:00
|
|
|
}
|
|
|
|
|
2020-02-25 20:23:54 -08:00
|
|
|
fn filter_signature_result<S>(result: Option<S>, _root: Slot) -> Box<dyn Iterator<Item = S>>
|
2019-05-06 07:31:50 -07:00
|
|
|
where
|
2020-02-25 20:23:54 -08:00
|
|
|
S: 'static + Clone + Serialize,
|
2019-05-06 07:31:50 -07:00
|
|
|
{
|
2020-02-25 20:23:54 -08:00
|
|
|
Box::new(result.into_iter())
|
2019-05-06 07:31:50 -07:00
|
|
|
}
|
|
|
|
|
2020-02-25 20:23:54 -08:00
|
|
|
fn filter_program_results(
|
2020-02-13 09:00:50 -08:00
|
|
|
accounts: Vec<(Pubkey, Account)>,
|
|
|
|
_root: Slot,
|
2020-02-25 20:23:54 -08:00
|
|
|
) -> Box<dyn Iterator<Item = RpcKeyedAccount>> {
|
|
|
|
Box::new(
|
|
|
|
accounts
|
|
|
|
.into_iter()
|
|
|
|
.map(|(pubkey, account)| RpcKeyedAccount {
|
|
|
|
pubkey: pubkey.to_string(),
|
|
|
|
account: RpcAccount::encode(account),
|
|
|
|
}),
|
|
|
|
)
|
2019-05-06 07:31:50 -07:00
|
|
|
}
|
|
|
|
|
2019-02-17 08:38:36 -08:00
|
|
|
pub struct RpcSubscriptions {
|
2020-01-20 13:08:29 -08:00
|
|
|
account_subscriptions: Arc<RpcAccountSubscriptions>,
|
|
|
|
program_subscriptions: Arc<RpcProgramSubscriptions>,
|
|
|
|
signature_subscriptions: Arc<RpcSignatureSubscriptions>,
|
|
|
|
slot_subscriptions: Arc<RpcSlotSubscriptions>,
|
2020-02-20 16:03:46 -08:00
|
|
|
notification_sender: Arc<Mutex<Sender<NotificationEntry>>>,
|
2020-01-20 13:08:29 -08:00
|
|
|
t_cleanup: Option<JoinHandle<()>>,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier_runtime: Option<Runtime>,
|
2020-01-20 13:08:29 -08:00
|
|
|
exit: Arc<AtomicBool>,
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for RpcSubscriptions {
|
|
|
|
fn default() -> Self {
|
2020-01-20 13:08:29 -08:00
|
|
|
Self::new(&Arc::new(AtomicBool::new(false)))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Drop for RpcSubscriptions {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
self.shutdown().unwrap_or_else(|err| {
|
|
|
|
warn!("RPC Notification - shutdown error: {:?}", err);
|
|
|
|
});
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl RpcSubscriptions {
|
2020-01-20 13:08:29 -08:00
|
|
|
pub fn new(exit: &Arc<AtomicBool>) -> Self {
|
|
|
|
let (notification_sender, notification_receiver): (
|
2020-02-20 16:03:46 -08:00
|
|
|
Sender<NotificationEntry>,
|
|
|
|
Receiver<NotificationEntry>,
|
2020-01-20 13:08:29 -08:00
|
|
|
) = std::sync::mpsc::channel();
|
|
|
|
|
|
|
|
let account_subscriptions = Arc::new(RpcAccountSubscriptions::default());
|
|
|
|
let program_subscriptions = Arc::new(RpcProgramSubscriptions::default());
|
|
|
|
let signature_subscriptions = Arc::new(RpcSignatureSubscriptions::default());
|
|
|
|
let slot_subscriptions = Arc::new(RpcSlotSubscriptions::default());
|
|
|
|
let notification_sender = Arc::new(Mutex::new(notification_sender));
|
|
|
|
|
|
|
|
let exit_clone = exit.clone();
|
|
|
|
let account_subscriptions_clone = account_subscriptions.clone();
|
|
|
|
let program_subscriptions_clone = program_subscriptions.clone();
|
|
|
|
let signature_subscriptions_clone = signature_subscriptions.clone();
|
|
|
|
let slot_subscriptions_clone = slot_subscriptions.clone();
|
|
|
|
|
2020-02-25 20:23:54 -08:00
|
|
|
let notifier_runtime = RuntimeBuilder::new()
|
|
|
|
.core_threads(1)
|
|
|
|
.name_prefix("solana-rpc-notifier-")
|
|
|
|
.build()
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let notifier = RpcNotifier(notifier_runtime.executor());
|
2020-01-20 13:08:29 -08:00
|
|
|
let t_cleanup = Builder::new()
|
|
|
|
.name("solana-rpc-notifications".to_string())
|
|
|
|
.spawn(move || {
|
|
|
|
Self::process_notifications(
|
|
|
|
exit_clone,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier,
|
2020-01-20 13:08:29 -08:00
|
|
|
notification_receiver,
|
|
|
|
account_subscriptions_clone,
|
|
|
|
program_subscriptions_clone,
|
|
|
|
signature_subscriptions_clone,
|
|
|
|
slot_subscriptions_clone,
|
|
|
|
);
|
|
|
|
})
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
Self {
|
|
|
|
account_subscriptions,
|
|
|
|
program_subscriptions,
|
|
|
|
signature_subscriptions,
|
|
|
|
slot_subscriptions,
|
|
|
|
notification_sender,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier_runtime: Some(notifier_runtime),
|
2020-01-20 13:08:29 -08:00
|
|
|
t_cleanup: Some(t_cleanup),
|
|
|
|
exit: exit.clone(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_account(
|
2019-05-06 07:31:50 -07:00
|
|
|
pubkey: &Pubkey,
|
2019-11-02 00:38:30 -07:00
|
|
|
current_slot: Slot,
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks: &Arc<RwLock<BankForks>>,
|
2020-01-20 13:08:29 -08:00
|
|
|
account_subscriptions: Arc<RpcAccountSubscriptions>,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier: &RpcNotifier,
|
2019-05-06 07:31:50 -07:00
|
|
|
) {
|
2020-01-20 13:08:29 -08:00
|
|
|
let subscriptions = account_subscriptions.read().unwrap();
|
2019-05-06 07:31:50 -07:00
|
|
|
check_confirmations_and_notify(
|
|
|
|
&subscriptions,
|
|
|
|
pubkey,
|
|
|
|
current_slot,
|
|
|
|
bank_forks,
|
|
|
|
Bank::get_account_modified_since_parent,
|
2020-02-25 20:23:54 -08:00
|
|
|
filter_account_result,
|
|
|
|
notifier,
|
2019-05-06 07:31:50 -07:00
|
|
|
);
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
fn check_program(
|
2019-05-06 07:31:50 -07:00
|
|
|
program_id: &Pubkey,
|
2019-11-02 00:38:30 -07:00
|
|
|
current_slot: Slot,
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks: &Arc<RwLock<BankForks>>,
|
2020-01-20 13:08:29 -08:00
|
|
|
program_subscriptions: Arc<RpcProgramSubscriptions>,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier: &RpcNotifier,
|
2019-05-06 07:31:50 -07:00
|
|
|
) {
|
2020-01-20 13:08:29 -08:00
|
|
|
let subscriptions = program_subscriptions.read().unwrap();
|
2019-05-06 07:31:50 -07:00
|
|
|
check_confirmations_and_notify(
|
|
|
|
&subscriptions,
|
|
|
|
program_id,
|
|
|
|
current_slot,
|
|
|
|
bank_forks,
|
|
|
|
Bank::get_program_accounts_modified_since_parent,
|
2020-02-25 20:23:54 -08:00
|
|
|
filter_program_results,
|
|
|
|
notifier,
|
2019-05-06 07:31:50 -07:00
|
|
|
);
|
2019-03-06 14:31:58 -08:00
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
fn check_signature(
|
2019-05-06 07:31:50 -07:00
|
|
|
signature: &Signature,
|
2019-11-02 00:38:30 -07:00
|
|
|
current_slot: Slot,
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks: &Arc<RwLock<BankForks>>,
|
2020-01-20 13:08:29 -08:00
|
|
|
signature_subscriptions: Arc<RpcSignatureSubscriptions>,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier: &RpcNotifier,
|
2019-05-06 07:31:50 -07:00
|
|
|
) {
|
2020-01-20 13:08:29 -08:00
|
|
|
let mut subscriptions = signature_subscriptions.write().unwrap();
|
2020-02-13 09:00:50 -08:00
|
|
|
let notified_ids = check_confirmations_and_notify(
|
2019-05-06 07:31:50 -07:00
|
|
|
&subscriptions,
|
|
|
|
signature,
|
|
|
|
current_slot,
|
|
|
|
bank_forks,
|
2020-03-23 17:00:34 -07:00
|
|
|
Bank::get_signature_status_processed_since_parent,
|
2020-02-25 20:23:54 -08:00
|
|
|
filter_signature_result,
|
|
|
|
notifier,
|
2019-05-06 07:31:50 -07:00
|
|
|
);
|
2020-02-13 09:00:50 -08:00
|
|
|
if let Some(subscription_ids) = subscriptions.get_mut(signature) {
|
|
|
|
subscription_ids.retain(|k, _| !notified_ids.contains(k));
|
|
|
|
if subscription_ids.is_empty() {
|
|
|
|
subscriptions.remove(&signature);
|
|
|
|
}
|
|
|
|
}
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn add_account_subscription(
|
|
|
|
&self,
|
2020-03-24 09:53:32 -07:00
|
|
|
pubkey: Pubkey,
|
2019-05-06 07:31:50 -07:00
|
|
|
confirmations: Option<Confirmations>,
|
2020-03-24 09:53:32 -07:00
|
|
|
sub_id: SubscriptionId,
|
|
|
|
subscriber: Subscriber<Response<RpcAccount>>,
|
2019-02-17 08:38:36 -08:00
|
|
|
) {
|
|
|
|
let mut subscriptions = self.account_subscriptions.write().unwrap();
|
2020-03-24 09:53:32 -07:00
|
|
|
add_subscription(
|
|
|
|
&mut subscriptions,
|
|
|
|
pubkey,
|
|
|
|
confirmations,
|
|
|
|
sub_id,
|
|
|
|
subscriber,
|
|
|
|
);
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn remove_account_subscription(&self, id: &SubscriptionId) -> bool {
|
|
|
|
let mut subscriptions = self.account_subscriptions.write().unwrap();
|
2019-03-06 14:31:16 -08:00
|
|
|
remove_subscription(&mut subscriptions, id)
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
2019-03-06 14:31:58 -08:00
|
|
|
pub fn add_program_subscription(
|
|
|
|
&self,
|
2020-03-24 09:53:32 -07:00
|
|
|
program_id: Pubkey,
|
2019-05-06 07:31:50 -07:00
|
|
|
confirmations: Option<Confirmations>,
|
2020-03-24 09:53:32 -07:00
|
|
|
sub_id: SubscriptionId,
|
|
|
|
subscriber: Subscriber<Response<RpcKeyedAccount>>,
|
2019-03-06 14:31:58 -08:00
|
|
|
) {
|
|
|
|
let mut subscriptions = self.program_subscriptions.write().unwrap();
|
2020-03-24 09:53:32 -07:00
|
|
|
add_subscription(
|
|
|
|
&mut subscriptions,
|
|
|
|
program_id,
|
|
|
|
confirmations,
|
|
|
|
sub_id,
|
|
|
|
subscriber,
|
|
|
|
);
|
2019-03-06 14:31:58 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn remove_program_subscription(&self, id: &SubscriptionId) -> bool {
|
|
|
|
let mut subscriptions = self.program_subscriptions.write().unwrap();
|
|
|
|
remove_subscription(&mut subscriptions, id)
|
|
|
|
}
|
|
|
|
|
2019-02-17 08:38:36 -08:00
|
|
|
pub fn add_signature_subscription(
|
|
|
|
&self,
|
2020-03-24 09:53:32 -07:00
|
|
|
signature: Signature,
|
2019-05-06 07:31:50 -07:00
|
|
|
confirmations: Option<Confirmations>,
|
2020-03-24 09:53:32 -07:00
|
|
|
sub_id: SubscriptionId,
|
|
|
|
subscriber: Subscriber<Response<transaction::Result<()>>>,
|
2019-02-17 08:38:36 -08:00
|
|
|
) {
|
|
|
|
let mut subscriptions = self.signature_subscriptions.write().unwrap();
|
2020-03-24 09:53:32 -07:00
|
|
|
add_subscription(
|
|
|
|
&mut subscriptions,
|
|
|
|
signature,
|
|
|
|
confirmations,
|
|
|
|
sub_id,
|
|
|
|
subscriber,
|
|
|
|
);
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn remove_signature_subscription(&self, id: &SubscriptionId) -> bool {
|
|
|
|
let mut subscriptions = self.signature_subscriptions.write().unwrap();
|
2019-03-06 14:31:16 -08:00
|
|
|
remove_subscription(&mut subscriptions, id)
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
2019-02-18 14:21:23 -08:00
|
|
|
|
|
|
|
/// Notify subscribers of changes to any accounts or new signatures since
|
|
|
|
/// the bank's last checkpoint.
|
2019-11-02 00:38:30 -07:00
|
|
|
pub fn notify_subscribers(&self, current_slot: Slot, bank_forks: &Arc<RwLock<BankForks>>) {
|
2020-01-20 13:08:29 -08:00
|
|
|
self.enqueue_notification(NotificationEntry::Bank((current_slot, bank_forks.clone())));
|
2019-02-18 14:21:23 -08:00
|
|
|
}
|
2019-11-26 00:42:54 -08:00
|
|
|
|
2020-03-24 09:53:32 -07:00
|
|
|
pub fn add_slot_subscription(&self, sub_id: SubscriptionId, subscriber: Subscriber<SlotInfo>) {
|
|
|
|
let sink = subscriber.assign_id(sub_id.clone()).unwrap();
|
2019-11-26 00:42:54 -08:00
|
|
|
let mut subscriptions = self.slot_subscriptions.write().unwrap();
|
2020-03-24 09:53:32 -07:00
|
|
|
subscriptions.insert(sub_id, sink);
|
2019-11-26 00:42:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn remove_slot_subscription(&self, id: &SubscriptionId) -> bool {
|
|
|
|
let mut subscriptions = self.slot_subscriptions.write().unwrap();
|
|
|
|
subscriptions.remove(id).is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn notify_slot(&self, slot: Slot, parent: Slot, root: Slot) {
|
2020-01-20 13:08:29 -08:00
|
|
|
self.enqueue_notification(NotificationEntry::Slot(SlotInfo { slot, parent, root }));
|
|
|
|
}
|
|
|
|
|
|
|
|
fn enqueue_notification(&self, notification_entry: NotificationEntry) {
|
|
|
|
match self
|
|
|
|
.notification_sender
|
|
|
|
.lock()
|
|
|
|
.unwrap()
|
2020-02-20 16:03:46 -08:00
|
|
|
.send(notification_entry)
|
2020-01-20 13:08:29 -08:00
|
|
|
{
|
|
|
|
Ok(()) => (),
|
|
|
|
Err(SendError(notification)) => {
|
|
|
|
warn!(
|
|
|
|
"Dropped RPC Notification - receiver disconnected : {:?}",
|
|
|
|
notification
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn process_notifications(
|
|
|
|
exit: Arc<AtomicBool>,
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier: RpcNotifier,
|
2020-02-20 16:03:46 -08:00
|
|
|
notification_receiver: Receiver<NotificationEntry>,
|
2020-01-20 13:08:29 -08:00
|
|
|
account_subscriptions: Arc<RpcAccountSubscriptions>,
|
|
|
|
program_subscriptions: Arc<RpcProgramSubscriptions>,
|
|
|
|
signature_subscriptions: Arc<RpcSignatureSubscriptions>,
|
|
|
|
slot_subscriptions: Arc<RpcSlotSubscriptions>,
|
|
|
|
) {
|
|
|
|
loop {
|
|
|
|
if exit.load(Ordering::Relaxed) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
match notification_receiver.recv_timeout(Duration::from_millis(RECEIVE_DELAY_MILLIS)) {
|
2020-02-20 16:03:46 -08:00
|
|
|
Ok(notification_entry) => match notification_entry {
|
|
|
|
NotificationEntry::Slot(slot_info) => {
|
|
|
|
let subscriptions = slot_subscriptions.read().unwrap();
|
|
|
|
for (_, sink) in subscriptions.iter() {
|
2020-02-25 20:23:54 -08:00
|
|
|
notifier.notify(slot_info, sink);
|
2020-02-20 16:03:46 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
NotificationEntry::Bank((current_slot, bank_forks)) => {
|
|
|
|
let pubkeys: Vec<_> = {
|
|
|
|
let subs = account_subscriptions.read().unwrap();
|
|
|
|
subs.keys().cloned().collect()
|
|
|
|
};
|
|
|
|
for pubkey in &pubkeys {
|
|
|
|
Self::check_account(
|
|
|
|
pubkey,
|
|
|
|
current_slot,
|
|
|
|
&bank_forks,
|
|
|
|
account_subscriptions.clone(),
|
2020-02-25 20:23:54 -08:00
|
|
|
¬ifier,
|
2020-02-20 16:03:46 -08:00
|
|
|
);
|
2020-01-20 13:08:29 -08:00
|
|
|
}
|
2020-02-20 16:03:46 -08:00
|
|
|
|
|
|
|
let programs: Vec<_> = {
|
|
|
|
let subs = program_subscriptions.read().unwrap();
|
|
|
|
subs.keys().cloned().collect()
|
|
|
|
};
|
|
|
|
for program_id in &programs {
|
|
|
|
Self::check_program(
|
|
|
|
program_id,
|
|
|
|
current_slot,
|
|
|
|
&bank_forks,
|
|
|
|
program_subscriptions.clone(),
|
2020-02-25 20:23:54 -08:00
|
|
|
¬ifier,
|
2020-02-20 16:03:46 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
let signatures: Vec<_> = {
|
|
|
|
let subs = signature_subscriptions.read().unwrap();
|
|
|
|
subs.keys().cloned().collect()
|
|
|
|
};
|
|
|
|
for signature in &signatures {
|
|
|
|
Self::check_signature(
|
|
|
|
signature,
|
|
|
|
current_slot,
|
|
|
|
&bank_forks,
|
|
|
|
signature_subscriptions.clone(),
|
2020-02-25 20:23:54 -08:00
|
|
|
¬ifier,
|
2020-02-20 16:03:46 -08:00
|
|
|
);
|
2020-01-20 13:08:29 -08:00
|
|
|
}
|
|
|
|
}
|
2020-02-20 16:03:46 -08:00
|
|
|
},
|
2020-01-20 13:08:29 -08:00
|
|
|
Err(RecvTimeoutError::Timeout) => {
|
|
|
|
// not a problem - try reading again
|
|
|
|
}
|
|
|
|
Err(RecvTimeoutError::Disconnected) => {
|
|
|
|
warn!("RPC Notification thread - sender disconnected");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn shutdown(&mut self) -> std::thread::Result<()> {
|
2020-02-25 20:23:54 -08:00
|
|
|
if let Some(runtime) = self.notifier_runtime.take() {
|
|
|
|
info!("RPC Notifier runtime - shutting down");
|
|
|
|
let _ = runtime.shutdown_now().wait();
|
|
|
|
info!("RPC Notifier runtime - shut down");
|
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
if self.t_cleanup.is_some() {
|
|
|
|
info!("RPC Notification thread - shutting down");
|
|
|
|
self.exit.store(true, Ordering::Relaxed);
|
|
|
|
let x = self.t_cleanup.take().unwrap().join();
|
|
|
|
info!("RPC Notification thread - shut down.");
|
|
|
|
x
|
|
|
|
} else {
|
|
|
|
warn!("RPC Notification thread - already shut down.");
|
|
|
|
Ok(())
|
2019-11-26 00:42:54 -08:00
|
|
|
}
|
|
|
|
}
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
2020-01-20 13:08:29 -08:00
|
|
|
pub(crate) mod tests {
|
2019-02-17 08:38:36 -08:00
|
|
|
use super::*;
|
2020-03-02 17:44:39 -08:00
|
|
|
use jsonrpc_core::futures::{self, stream::Stream};
|
2019-02-17 10:17:58 -08:00
|
|
|
use jsonrpc_pubsub::typed::Subscriber;
|
2019-11-20 16:32:19 -08:00
|
|
|
use solana_budget_program;
|
2020-03-21 10:54:40 -07:00
|
|
|
use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
|
2020-01-15 10:52:02 -08:00
|
|
|
use solana_sdk::{
|
2020-02-20 13:28:55 -08:00
|
|
|
signature::{Keypair, Signer},
|
2020-01-15 10:52:02 -08:00
|
|
|
system_transaction,
|
|
|
|
};
|
2020-03-02 17:44:39 -08:00
|
|
|
use std::{fmt::Debug, sync::mpsc::channel, time::Instant};
|
|
|
|
use tokio::{prelude::FutureExt, runtime::Runtime, timer::Delay};
|
|
|
|
|
|
|
|
pub(crate) fn robust_poll_or_panic<T: Debug + Send + 'static>(
|
|
|
|
receiver: futures::sync::mpsc::Receiver<T>,
|
|
|
|
) -> T {
|
|
|
|
let (inner_sender, inner_receiver) = channel();
|
|
|
|
let mut rt = Runtime::new().unwrap();
|
|
|
|
rt.spawn(futures::lazy(|| {
|
|
|
|
let recv_timeout = receiver
|
|
|
|
.into_future()
|
|
|
|
.timeout(Duration::from_millis(RECEIVE_DELAY_MILLIS))
|
|
|
|
.map(move |result| match result {
|
|
|
|
(Some(value), _) => inner_sender.send(value).expect("send error"),
|
|
|
|
(None, _) => panic!("unexpected end of stream"),
|
|
|
|
})
|
|
|
|
.map_err(|err| panic!("stream error {:?}", err));
|
|
|
|
|
|
|
|
const INITIAL_DELAY_MS: u64 = RECEIVE_DELAY_MILLIS * 2;
|
|
|
|
Delay::new(Instant::now() + Duration::from_millis(INITIAL_DELAY_MS))
|
|
|
|
.and_then(|_| recv_timeout)
|
|
|
|
.map_err(|err| panic!("timer error {:?}", err))
|
|
|
|
}));
|
|
|
|
inner_receiver.recv().expect("recv error")
|
2020-01-20 13:08:29 -08:00
|
|
|
}
|
|
|
|
|
2019-02-17 08:38:36 -08:00
|
|
|
#[test]
|
|
|
|
fn test_check_account_subscribe() {
|
2019-11-08 20:56:57 -08:00
|
|
|
let GenesisConfigInfo {
|
|
|
|
genesis_config,
|
2019-05-22 20:39:00 -07:00
|
|
|
mint_keypair,
|
|
|
|
..
|
2019-11-08 20:56:57 -08:00
|
|
|
} = create_genesis_config(100);
|
|
|
|
let bank = Bank::new(&genesis_config);
|
2019-03-02 10:25:16 -08:00
|
|
|
let blockhash = bank.last_blockhash();
|
2019-05-06 07:31:50 -07:00
|
|
|
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
|
|
|
|
let alice = Keypair::new();
|
2019-04-03 08:45:57 -07:00
|
|
|
let tx = system_transaction::create_account(
|
2019-02-17 08:38:36 -08:00
|
|
|
&mint_keypair,
|
2019-11-08 02:27:35 -08:00
|
|
|
&alice,
|
2019-03-02 10:25:16 -08:00
|
|
|
blockhash,
|
2019-02-17 08:38:36 -08:00
|
|
|
1,
|
|
|
|
16,
|
2019-11-20 16:32:19 -08:00
|
|
|
&solana_budget_program::id(),
|
2019-02-17 08:38:36 -08:00
|
|
|
);
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks
|
|
|
|
.write()
|
|
|
|
.unwrap()
|
|
|
|
.get(0)
|
|
|
|
.unwrap()
|
|
|
|
.process_transaction(&tx)
|
|
|
|
.unwrap();
|
2019-02-17 08:38:36 -08:00
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
let (subscriber, _id_receiver, transport_receiver) =
|
2019-02-17 08:38:36 -08:00
|
|
|
Subscriber::new_test("accountNotification");
|
|
|
|
let sub_id = SubscriptionId::Number(0 as u64);
|
2020-01-20 13:08:29 -08:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
let subscriptions = RpcSubscriptions::new(&exit);
|
2020-03-24 09:53:32 -07:00
|
|
|
subscriptions.add_account_subscription(alice.pubkey(), None, sub_id.clone(), subscriber);
|
2019-02-17 08:38:36 -08:00
|
|
|
|
|
|
|
assert!(subscriptions
|
|
|
|
.account_subscriptions
|
2019-02-18 14:21:23 -08:00
|
|
|
.read()
|
2019-02-17 08:38:36 -08:00
|
|
|
.unwrap()
|
|
|
|
.contains_key(&alice.pubkey()));
|
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
subscriptions.notify_subscribers(0, &bank_forks);
|
|
|
|
let response = robust_poll_or_panic(transport_receiver);
|
2020-03-23 05:34:42 -07:00
|
|
|
let expected = json!({
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "accountNotification",
|
|
|
|
"params": {
|
|
|
|
"result": {
|
|
|
|
"context": { "slot": 0 },
|
|
|
|
"value": {
|
|
|
|
"data": "1111111111111111",
|
|
|
|
"executable": false,
|
|
|
|
"lamports": 1,
|
|
|
|
"owner": "Budget1111111111111111111111111111111111111",
|
|
|
|
"rentEpoch": 1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
"subscription": 0,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
assert_eq!(serde_json::to_string(&expected).unwrap(), response);
|
2019-02-17 08:38:36 -08:00
|
|
|
|
|
|
|
subscriptions.remove_account_subscription(&sub_id);
|
|
|
|
assert!(!subscriptions
|
|
|
|
.account_subscriptions
|
2019-02-18 14:21:23 -08:00
|
|
|
.read()
|
2019-02-17 08:38:36 -08:00
|
|
|
.unwrap()
|
|
|
|
.contains_key(&alice.pubkey()));
|
|
|
|
}
|
2019-03-06 14:31:58 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_check_program_subscribe() {
|
2019-11-08 20:56:57 -08:00
|
|
|
let GenesisConfigInfo {
|
|
|
|
genesis_config,
|
2019-05-22 20:39:00 -07:00
|
|
|
mint_keypair,
|
|
|
|
..
|
2019-11-08 20:56:57 -08:00
|
|
|
} = create_genesis_config(100);
|
|
|
|
let bank = Bank::new(&genesis_config);
|
2019-03-06 14:31:58 -08:00
|
|
|
let blockhash = bank.last_blockhash();
|
2019-05-06 07:31:50 -07:00
|
|
|
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
|
|
|
|
let alice = Keypair::new();
|
2019-04-03 08:45:57 -07:00
|
|
|
let tx = system_transaction::create_account(
|
2019-03-06 14:31:58 -08:00
|
|
|
&mint_keypair,
|
2019-11-08 02:27:35 -08:00
|
|
|
&alice,
|
2019-03-06 14:31:58 -08:00
|
|
|
blockhash,
|
|
|
|
1,
|
|
|
|
16,
|
2019-11-20 16:32:19 -08:00
|
|
|
&solana_budget_program::id(),
|
2019-03-06 14:31:58 -08:00
|
|
|
);
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks
|
|
|
|
.write()
|
|
|
|
.unwrap()
|
|
|
|
.get(0)
|
|
|
|
.unwrap()
|
|
|
|
.process_transaction(&tx)
|
|
|
|
.unwrap();
|
2019-03-06 14:31:58 -08:00
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
let (subscriber, _id_receiver, transport_receiver) =
|
2019-03-06 14:31:58 -08:00
|
|
|
Subscriber::new_test("programNotification");
|
|
|
|
let sub_id = SubscriptionId::Number(0 as u64);
|
2020-01-20 13:08:29 -08:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
let subscriptions = RpcSubscriptions::new(&exit);
|
2020-03-24 09:53:32 -07:00
|
|
|
subscriptions.add_program_subscription(
|
|
|
|
solana_budget_program::id(),
|
|
|
|
None,
|
|
|
|
sub_id.clone(),
|
|
|
|
subscriber,
|
|
|
|
);
|
2019-03-06 14:31:58 -08:00
|
|
|
|
|
|
|
assert!(subscriptions
|
|
|
|
.program_subscriptions
|
|
|
|
.read()
|
|
|
|
.unwrap()
|
2019-11-20 16:32:19 -08:00
|
|
|
.contains_key(&solana_budget_program::id()));
|
2019-03-06 14:31:58 -08:00
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
subscriptions.notify_subscribers(0, &bank_forks);
|
|
|
|
let response = robust_poll_or_panic(transport_receiver);
|
2020-03-23 05:34:42 -07:00
|
|
|
let expected = json!({
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "programNotification",
|
|
|
|
"params": {
|
|
|
|
"result": {
|
|
|
|
"context": { "slot": 0 },
|
|
|
|
"value": {
|
|
|
|
"account": {
|
|
|
|
"data": "1111111111111111",
|
|
|
|
"executable": false,
|
|
|
|
"lamports": 1,
|
|
|
|
"owner": "Budget1111111111111111111111111111111111111",
|
|
|
|
"rentEpoch": 1,
|
|
|
|
},
|
|
|
|
"pubkey": alice.pubkey().to_string(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
"subscription": 0,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
assert_eq!(serde_json::to_string(&expected).unwrap(), response);
|
2019-03-06 14:31:58 -08:00
|
|
|
|
|
|
|
subscriptions.remove_program_subscription(&sub_id);
|
|
|
|
assert!(!subscriptions
|
|
|
|
.program_subscriptions
|
|
|
|
.read()
|
|
|
|
.unwrap()
|
2019-11-20 16:32:19 -08:00
|
|
|
.contains_key(&solana_budget_program::id()));
|
2019-03-06 14:31:58 -08:00
|
|
|
}
|
2020-02-11 17:09:40 -08:00
|
|
|
|
2019-02-17 08:38:36 -08:00
|
|
|
#[test]
|
|
|
|
fn test_check_signature_subscribe() {
|
2019-11-08 20:56:57 -08:00
|
|
|
let GenesisConfigInfo {
|
|
|
|
genesis_config,
|
2019-05-22 20:39:00 -07:00
|
|
|
mint_keypair,
|
|
|
|
..
|
2019-11-08 20:56:57 -08:00
|
|
|
} = create_genesis_config(100);
|
|
|
|
let bank = Bank::new(&genesis_config);
|
2019-03-02 10:25:16 -08:00
|
|
|
let blockhash = bank.last_blockhash();
|
2020-03-23 17:00:34 -07:00
|
|
|
let mut bank_forks = BankForks::new(0, bank);
|
2019-05-06 07:31:50 -07:00
|
|
|
let alice = Keypair::new();
|
2020-03-23 17:00:34 -07:00
|
|
|
|
|
|
|
let past_bank_tx =
|
|
|
|
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 1, blockhash);
|
2020-02-13 09:00:50 -08:00
|
|
|
let unprocessed_tx =
|
2020-03-23 17:00:34 -07:00
|
|
|
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 2, blockhash);
|
|
|
|
let processed_tx =
|
|
|
|
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 3, blockhash);
|
|
|
|
|
2019-05-06 07:31:50 -07:00
|
|
|
bank_forks
|
|
|
|
.get(0)
|
|
|
|
.unwrap()
|
2020-03-23 17:00:34 -07:00
|
|
|
.process_transaction(&past_bank_tx)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let next_bank =
|
|
|
|
Bank::new_from_parent(&bank_forks.banks[&0].clone(), &Pubkey::new_rand(), 1);
|
|
|
|
bank_forks.insert(next_bank);
|
|
|
|
|
|
|
|
bank_forks
|
|
|
|
.get(1)
|
|
|
|
.unwrap()
|
|
|
|
.process_transaction(&processed_tx)
|
2019-05-06 07:31:50 -07:00
|
|
|
.unwrap();
|
2019-02-17 08:38:36 -08:00
|
|
|
|
2020-03-23 17:00:34 -07:00
|
|
|
let bank_forks = Arc::new(RwLock::new(bank_forks));
|
|
|
|
|
2020-01-20 13:08:29 -08:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
let subscriptions = RpcSubscriptions::new(&exit);
|
2020-03-24 09:53:32 -07:00
|
|
|
|
|
|
|
let (past_bank_sub, _id_receiver, past_bank_recv) =
|
|
|
|
Subscriber::new_test("signatureNotification");
|
|
|
|
let (processed_sub, _id_receiver, processed_recv) =
|
|
|
|
Subscriber::new_test("signatureNotification");
|
2020-02-13 09:00:50 -08:00
|
|
|
subscriptions.add_signature_subscription(
|
2020-03-24 09:53:32 -07:00
|
|
|
past_bank_tx.signatures[0],
|
2020-03-23 17:00:34 -07:00
|
|
|
Some(0),
|
2020-03-24 09:53:32 -07:00
|
|
|
SubscriptionId::Number(1 as u64),
|
|
|
|
Subscriber::new_test("signatureNotification").0,
|
2020-03-23 17:00:34 -07:00
|
|
|
);
|
|
|
|
subscriptions.add_signature_subscription(
|
2020-03-24 09:53:32 -07:00
|
|
|
past_bank_tx.signatures[0],
|
|
|
|
Some(1),
|
|
|
|
SubscriptionId::Number(2 as u64),
|
|
|
|
past_bank_sub,
|
|
|
|
);
|
|
|
|
subscriptions.add_signature_subscription(
|
|
|
|
processed_tx.signatures[0],
|
2020-03-23 17:00:34 -07:00
|
|
|
Some(0),
|
2020-03-24 09:53:32 -07:00
|
|
|
SubscriptionId::Number(3 as u64),
|
|
|
|
processed_sub,
|
2020-03-23 17:00:34 -07:00
|
|
|
);
|
|
|
|
subscriptions.add_signature_subscription(
|
2020-03-24 09:53:32 -07:00
|
|
|
unprocessed_tx.signatures[0],
|
2020-03-23 17:00:34 -07:00
|
|
|
Some(0),
|
2020-03-24 09:53:32 -07:00
|
|
|
SubscriptionId::Number(4 as u64),
|
|
|
|
Subscriber::new_test("signatureNotification").0,
|
2020-02-13 09:00:50 -08:00
|
|
|
);
|
2019-02-17 08:38:36 -08:00
|
|
|
|
2020-02-13 09:00:50 -08:00
|
|
|
{
|
|
|
|
let sig_subs = subscriptions.signature_subscriptions.read().unwrap();
|
2020-03-24 09:53:32 -07:00
|
|
|
assert_eq!(sig_subs.get(&past_bank_tx.signatures[0]).unwrap().len(), 2);
|
2020-03-23 17:00:34 -07:00
|
|
|
assert!(sig_subs.contains_key(&unprocessed_tx.signatures[0]));
|
|
|
|
assert!(sig_subs.contains_key(&processed_tx.signatures[0]));
|
2020-02-13 09:00:50 -08:00
|
|
|
}
|
2019-02-17 08:38:36 -08:00
|
|
|
|
2020-03-23 17:00:34 -07:00
|
|
|
subscriptions.notify_subscribers(1, &bank_forks);
|
2020-01-20 13:08:29 -08:00
|
|
|
let expected_res: Option<transaction::Result<()>> = Some(Ok(()));
|
2020-03-24 09:53:32 -07:00
|
|
|
|
|
|
|
let expected = json!({
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "signatureNotification",
|
|
|
|
"params": {
|
|
|
|
"result": {
|
|
|
|
"context": { "slot": 0 },
|
|
|
|
"value": expected_res,
|
|
|
|
},
|
|
|
|
"subscription": 2,
|
|
|
|
}
|
|
|
|
});
|
|
|
|
let response = robust_poll_or_panic(past_bank_recv);
|
|
|
|
assert_eq!(serde_json::to_string(&expected).unwrap(), response);
|
|
|
|
|
2020-03-23 05:34:42 -07:00
|
|
|
let expected = json!({
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "signatureNotification",
|
|
|
|
"params": {
|
|
|
|
"result": {
|
2020-03-23 17:00:34 -07:00
|
|
|
"context": { "slot": 1 },
|
2020-03-23 05:34:42 -07:00
|
|
|
"value": expected_res,
|
|
|
|
},
|
2020-03-24 09:53:32 -07:00
|
|
|
"subscription": 3,
|
2020-03-23 05:34:42 -07:00
|
|
|
}
|
|
|
|
});
|
2020-03-24 09:53:32 -07:00
|
|
|
let response = robust_poll_or_panic(processed_recv);
|
2020-03-23 05:34:42 -07:00
|
|
|
assert_eq!(serde_json::to_string(&expected).unwrap(), response);
|
2019-02-17 08:38:36 -08:00
|
|
|
|
2020-03-23 17:00:34 -07:00
|
|
|
let sig_subs = subscriptions.signature_subscriptions.read().unwrap();
|
|
|
|
|
2020-02-13 09:00:50 -08:00
|
|
|
// Subscription should be automatically removed after notification
|
2020-03-23 17:00:34 -07:00
|
|
|
assert!(!sig_subs.contains_key(&processed_tx.signatures[0]));
|
|
|
|
|
|
|
|
// Only one notification is expected for signature processed in previous bank
|
|
|
|
assert_eq!(sig_subs.get(&past_bank_tx.signatures[0]).unwrap().len(), 1);
|
2020-02-13 09:00:50 -08:00
|
|
|
|
|
|
|
// Unprocessed signature subscription should not be removed
|
2020-03-23 17:00:34 -07:00
|
|
|
assert_eq!(
|
|
|
|
sig_subs.get(&unprocessed_tx.signatures[0]).unwrap().len(),
|
|
|
|
1
|
|
|
|
);
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|
2020-02-11 17:09:40 -08:00
|
|
|
|
2019-11-26 00:42:54 -08:00
|
|
|
#[test]
|
|
|
|
fn test_check_slot_subscribe() {
|
2020-01-20 13:08:29 -08:00
|
|
|
let (subscriber, _id_receiver, transport_receiver) =
|
2019-11-26 00:42:54 -08:00
|
|
|
Subscriber::new_test("slotNotification");
|
|
|
|
let sub_id = SubscriptionId::Number(0 as u64);
|
2020-01-20 13:08:29 -08:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
|
|
|
let subscriptions = RpcSubscriptions::new(&exit);
|
2020-03-24 09:53:32 -07:00
|
|
|
subscriptions.add_slot_subscription(sub_id.clone(), subscriber);
|
2019-11-26 00:42:54 -08:00
|
|
|
|
|
|
|
assert!(subscriptions
|
|
|
|
.slot_subscriptions
|
|
|
|
.read()
|
|
|
|
.unwrap()
|
|
|
|
.contains_key(&sub_id));
|
|
|
|
|
|
|
|
subscriptions.notify_slot(0, 0, 0);
|
2020-01-20 13:08:29 -08:00
|
|
|
let response = robust_poll_or_panic(transport_receiver);
|
|
|
|
let expected_res = SlotInfo {
|
|
|
|
parent: 0,
|
|
|
|
slot: 0,
|
|
|
|
root: 0,
|
|
|
|
};
|
|
|
|
let expected_res_str =
|
|
|
|
serde_json::to_string(&serde_json::to_value(expected_res).unwrap()).unwrap();
|
|
|
|
let expected = format!(
|
|
|
|
r#"{{"jsonrpc":"2.0","method":"slotNotification","params":{{"result":{},"subscription":0}}}}"#,
|
|
|
|
expected_res_str
|
|
|
|
);
|
|
|
|
assert_eq!(expected, response);
|
2019-11-26 00:42:54 -08:00
|
|
|
|
|
|
|
subscriptions.remove_slot_subscription(&sub_id);
|
|
|
|
assert!(!subscriptions
|
|
|
|
.slot_subscriptions
|
|
|
|
.read()
|
|
|
|
.unwrap()
|
|
|
|
.contains_key(&sub_id));
|
|
|
|
}
|
2020-02-11 17:09:40 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_add_and_remove_subscription() {
|
|
|
|
let mut subscriptions: HashMap<u64, HashMap<SubscriptionId, (Sink<()>, Confirmations)>> =
|
|
|
|
HashMap::new();
|
|
|
|
|
|
|
|
let num_keys = 5;
|
2020-03-24 09:53:32 -07:00
|
|
|
for key in 0..num_keys {
|
|
|
|
let (subscriber, _id_receiver, _transport_receiver) =
|
|
|
|
Subscriber::new_test("notification");
|
|
|
|
let sub_id = SubscriptionId::Number(key);
|
|
|
|
add_subscription(&mut subscriptions, key, None, sub_id, subscriber);
|
2020-02-11 17:09:40 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add another subscription to the "0" key
|
2020-03-24 09:53:32 -07:00
|
|
|
let (subscriber, _id_receiver, _transport_receiver) = Subscriber::new_test("notification");
|
|
|
|
let extra_sub_id = SubscriptionId::Number(num_keys);
|
|
|
|
add_subscription(
|
|
|
|
&mut subscriptions,
|
|
|
|
0,
|
|
|
|
None,
|
|
|
|
extra_sub_id.clone(),
|
|
|
|
subscriber,
|
|
|
|
);
|
2020-02-11 17:09:40 -08:00
|
|
|
|
2020-03-24 09:53:32 -07:00
|
|
|
assert_eq!(subscriptions.len(), num_keys as usize);
|
2020-02-11 17:09:40 -08:00
|
|
|
assert_eq!(subscriptions.get(&0).unwrap().len(), 2);
|
|
|
|
assert_eq!(subscriptions.get(&1).unwrap().len(), 1);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
remove_subscription(&mut subscriptions, &SubscriptionId::Number(0)),
|
|
|
|
true
|
|
|
|
);
|
2020-03-24 09:53:32 -07:00
|
|
|
assert_eq!(subscriptions.len(), num_keys as usize);
|
2020-02-11 17:09:40 -08:00
|
|
|
assert_eq!(subscriptions.get(&0).unwrap().len(), 1);
|
|
|
|
assert_eq!(
|
|
|
|
remove_subscription(&mut subscriptions, &SubscriptionId::Number(0)),
|
|
|
|
false
|
|
|
|
);
|
|
|
|
|
2020-03-24 09:53:32 -07:00
|
|
|
assert_eq!(remove_subscription(&mut subscriptions, &extra_sub_id), true);
|
|
|
|
assert_eq!(subscriptions.len(), (num_keys - 1) as usize);
|
2020-02-11 17:09:40 -08:00
|
|
|
assert!(subscriptions.get(&0).is_none());
|
|
|
|
}
|
2019-02-17 08:38:36 -08:00
|
|
|
}
|