Sulkta-OSS/pallas
3
0
Fork 0
Code Issues 1 Pull requests 6 Projects Releases Packages Wiki Activity Actions

feat(multiplexer): Allow fine-grained control of concurrency strategy (#106)

Browse source
This commit is contained in:
Santiago Carmuega 2022-06-03 21:37:38 -03:00 • committed by GitHub
parent 07fb2ca016
commit e4784f444d
23 changed files with 822 additions and 559 deletions
Download patch file Download diff file Expand all files Collapse all files

15
examples/block-download/src/main.rs
View file

@ -5,7 +5,7 @@ use pallas::network::{
handshake::{n2n::VersionTable, Initiator},
run_agent, Point, MAINNET_MAGIC,
},
multiplexer::Multiplexer,
multiplexer::{spawn_demuxer, spawn_muxer, use_channel, StdPlexer},
};
use pallas::network::miniprotocols::blockfetch::{BatchClient, Observer};
@ -30,11 +30,15 @@ fn main() {
bearer.set_nodelay(true).unwrap();
bearer.set_keepalive_ms(Some(30_000u32)).unwrap();
let mut muxer = Multiplexer::setup(bearer, &[0, 3]).unwrap();
let mut plexer = StdPlexer::new(bearer);
let mut channel0 = use_channel(&mut plexer, 0);
let mut channel3 = use_channel(&mut plexer, 3);
spawn_muxer(plexer.muxer);
spawn_demuxer(plexer.demuxer);
let mut hs_channel = muxer.use_channel(0);
let versions = VersionTable::v4_and_above(MAINNET_MAGIC);
let _last = run_agent(Initiator::initial(versions), &mut hs_channel).unwrap();
let _last = run_agent(Initiator::initial(versions), &mut channel0).unwrap();
let range = (
Point::Specific(
@ -49,8 +53,7 @@ fn main() {
),
);
let mut bf_channel = muxer.use_channel(3);
let bf = BatchClient::initial(range, BlockPrinter {});
let bf_last = run_agent(bf, &mut bf_channel);
let bf_last = run_agent(bf, &mut channel3);
println!("{:?}", bf_last);
}

27
examples/n2c-miniprotocols/src/main.rs
View file

@ -1,6 +1,6 @@
use pallas::network::{
miniprotocols::{chainsync, handshake, localstate, run_agent, Point, MAINNET_MAGIC},
multiplexer::Multiplexer,
multiplexer,
};
use std::os::unix::net::UnixStream;
@ -45,15 +45,12 @@ impl chainsync::Observer<chainsync::HeaderContent> for LoggingObserver {
}
}
fn do_handshake(muxer: &mut Multiplexer) {
let mut channel = muxer.use_channel(0);
fn do_handshake(mut channel: multiplexer::StdChannel) {
let versions = handshake::n2c::VersionTable::v1_and_above(MAINNET_MAGIC);
let _last = run_agent(handshake::Initiator::initial(versions), &mut channel).unwrap();
}
fn do_localstate_query(muxer: &mut Multiplexer) {
let mut channel = muxer.use_channel(7);
fn do_localstate_query(mut channel: multiplexer::StdChannel) {
let agent = run_agent(
localstate::OneShotClient::<localstate::queries::QueryV10>::initial(
None,
@ -65,9 +62,7 @@ fn do_localstate_query(muxer: &mut Multiplexer) {
log::info!("state query result: {:?}", agent);
}
fn do_chainsync(muxer: &mut Multiplexer) {
let mut channel = muxer.use_channel(5);
fn do_chainsync(mut channel: multiplexer::StdChannel) {
let known_points = vec![Point::Specific(
43847831u64,
hex::decode("15b9eeee849dd6386d3770b0745e0450190f7560e5159b1b3ab13b14b2684a45").unwrap(),
@ -95,14 +90,20 @@ fn main() {
// setup the multiplexer by specifying the bearer and the IDs of the
// miniprotocols to use
let mut muxer = Multiplexer::setup(bearer, &[0, 4, 5]).unwrap();
let mut plexer = multiplexer::StdPlexer::new(bearer);
let channel0 = multiplexer::use_channel(&mut plexer, 0);
let channel7 = multiplexer::use_channel(&mut plexer, 7);
let channel5 = multiplexer::use_channel(&mut plexer, 5);
multiplexer::spawn_muxer(plexer.muxer);
multiplexer::spawn_demuxer(plexer.demuxer);
// execute the required handshake against the relay
do_handshake(&mut muxer);
do_handshake(channel0);
// execute an arbitrary "Local State" query against the node
do_localstate_query(&mut muxer);
do_localstate_query(channel7);
// execute the chainsync flow from an arbitrary point in the chain
do_chainsync(&mut muxer);
do_chainsync(channel5);
}

27
examples/n2n-miniprotocols/src/main.rs
View file

@ -2,7 +2,7 @@ use net2::TcpStreamExt;
use pallas::network::{
miniprotocols::{blockfetch, chainsync, handshake, run_agent, Point, MAINNET_MAGIC},
multiplexer::Multiplexer,
multiplexer::{spawn_demuxer, spawn_muxer, use_channel, StdChannel, StdPlexer},
};
use std::net::TcpStream;
@ -54,15 +54,12 @@ impl chainsync::Observer<chainsync::HeaderContent> for LoggingObserver {
}
}
fn do_handshake(muxer: &mut Multiplexer) {
let mut channel = muxer.use_channel(0);
fn do_handshake(mut channel: StdChannel) {
let versions = handshake::n2n::VersionTable::v4_and_above(MAINNET_MAGIC);
let _last = run_agent(handshake::Initiator::initial(versions), &mut channel).unwrap();
}
fn do_blockfetch(muxer: &mut Multiplexer) {
let mut channel = muxer.use_channel(3);
fn do_blockfetch(mut channel: StdChannel) {
let range = (
Point::Specific(
43847831,
@ -84,9 +81,7 @@ fn do_blockfetch(muxer: &mut Multiplexer) {
println!("{:?}", agent);
}
fn do_chainsync(muxer: &mut Multiplexer) {
let mut channel = muxer.use_channel(2);
fn do_chainsync(mut channel: StdChannel) {
let known_points = vec![Point::Specific(
43847831u64,
hex::decode("15b9eeee849dd6386d3770b0745e0450190f7560e5159b1b3ab13b14b2684a45").unwrap(),
@ -116,14 +111,20 @@ fn main() {
// setup the multiplexer by specifying the bearer and the IDs of the
// miniprotocols to use
let mut muxer = Multiplexer::setup(bearer, &[0, 2, 3, 4]).unwrap();
let mut plexer = StdPlexer::new(bearer);
let channel0 = use_channel(&mut plexer, 0);
let channel3 = use_channel(&mut plexer, 3);
let channel2 = use_channel(&mut plexer, 2);
spawn_muxer(plexer.muxer);
spawn_demuxer(plexer.demuxer);
// execute the required handshake against the relay
do_handshake(&mut muxer);
do_handshake(channel0);
// fetch an arbitrary batch of block
do_blockfetch(&mut muxer);
do_blockfetch(channel3);
// execute the chainsync flow from an arbitrary point in the chain
do_chainsync(&mut muxer);
do_chainsync(channel2);
}