fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-05-06 08:02:18 +00:00
Code Issues Projects Releases Wiki Activity

MultiplexEnd->Endpoint

Browse Source
This commit is contained in:
Vurich 2017-12-11 16:38:59 +01:00
parent a4014bb08e
commit 496100cdb5
2 changed files with 37 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
multiplex-rs/src/header.rs
View File

@ -18,6 +18,8 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE. // DEALINGS IN THE SOFTWARE.
use swarm::Endpoint;
const FLAG_BITS: usize = 3; const FLAG_BITS: usize = 3;
const FLAG_MASK: usize = (1usize << FLAG_BITS) - 1; const FLAG_MASK: usize = (1usize << FLAG_BITS) - 1;
@ -29,12 +31,6 @@ pub mod errors {
} }
} }
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum MultiplexEnd {
Initiator,
Receiver,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct MultiplexHeader { pub struct MultiplexHeader {
pub packet_type: PacketType, pub packet_type: PacketType,
@ -44,9 +40,9 @@ pub struct MultiplexHeader {
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum PacketType { pub enum PacketType {
Open, Open,
Close(MultiplexEnd), Close(Endpoint),
Reset(MultiplexEnd), Reset(Endpoint),
Message(MultiplexEnd), Message(Endpoint),
} }
impl MultiplexHeader { impl MultiplexHeader {
@ -57,21 +53,21 @@ impl MultiplexHeader {
} }
} }
pub fn close(id: u32, end: MultiplexEnd) -> Self { pub fn close(id: u32, end: Endpoint) -> Self {
MultiplexHeader { MultiplexHeader {
substream_id: id, substream_id: id,
packet_type: PacketType::Close(end), packet_type: PacketType::Close(end),
} }
} }
pub fn reset(id: u32, end: MultiplexEnd) -> Self { pub fn reset(id: u32, end: Endpoint) -> Self {
MultiplexHeader { MultiplexHeader {
substream_id: id, substream_id: id,
packet_type: PacketType::Reset(end), packet_type: PacketType::Reset(end),
} }
} }
pub fn message(id: u32, end: MultiplexEnd) -> Self { pub fn message(id: u32, end: Endpoint) -> Self {
MultiplexHeader { MultiplexHeader {
substream_id: id, substream_id: id,
packet_type: PacketType::Message(end), packet_type: PacketType::Message(end),
@ -96,14 +92,14 @@ impl MultiplexHeader {
let packet_type = match flags { let packet_type = match flags {
0 => PacketType::Open, 0 => PacketType::Open,
1 => PacketType::Message(MultiplexEnd::Receiver), 1 => PacketType::Message(Endpoint::Listener),
2 => PacketType::Message(MultiplexEnd::Initiator), 2 => PacketType::Message(Endpoint::Dialer),
3 => PacketType::Close(MultiplexEnd::Receiver), 3 => PacketType::Close(Endpoint::Listener),
4 => PacketType::Close(MultiplexEnd::Initiator), 4 => PacketType::Close(Endpoint::Dialer),
5 => PacketType::Reset(MultiplexEnd::Receiver), 5 => PacketType::Reset(Endpoint::Listener),
6 => PacketType::Reset(MultiplexEnd::Initiator), 6 => PacketType::Reset(Endpoint::Dialer),
_ => { _ => {
use std::io; use std::io;
@ -128,14 +124,14 @@ impl MultiplexHeader {
let packet_type_id = match self.packet_type { let packet_type_id = match self.packet_type {
PacketType::Open => 0, PacketType::Open => 0,
PacketType::Message(MultiplexEnd::Receiver) => 1, PacketType::Message(Endpoint::Listener) => 1,
PacketType::Message(MultiplexEnd::Initiator) => 2, PacketType::Message(Endpoint::Dialer) => 2,
PacketType::Close(MultiplexEnd::Receiver) => 3, PacketType::Close(Endpoint::Listener) => 3,
PacketType::Close(MultiplexEnd::Initiator) => 4, PacketType::Close(Endpoint::Dialer) => 4,
PacketType::Reset(MultiplexEnd::Receiver) => 5, PacketType::Reset(Endpoint::Listener) => 5,
PacketType::Reset(MultiplexEnd::Initiator) => 6, PacketType::Reset(Endpoint::Dialer) => 6,
}; };
let substream_id = (self.substream_id as u64) << FLAG_BITS; let substream_id = (self.substream_id as u64) << FLAG_BITS;

34
multiplex-rs/src/lib.rs
View File

@ -39,9 +39,9 @@ mod header;
use bytes::Bytes; use bytes::Bytes;
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use futures::future::{self, FutureResult}; use futures::future::{self, FutureResult};
use header::{MultiplexEnd, MultiplexHeader}; use header::MultiplexHeader;
use swarm::muxing::StreamMuxer; use swarm::muxing::StreamMuxer;
use swarm::ConnectionUpgrade; use swarm::{ConnectionUpgrade, Endpoint};
use parking_lot::Mutex; use parking_lot::Mutex;
use read::{read_stream, MultiplexReadState}; use read::{read_stream, MultiplexReadState};
use shared::{buf_from_slice, ByteBuf, MultiplexShared}; use shared::{buf_from_slice, ByteBuf, MultiplexShared};
@ -66,7 +66,7 @@ use write::write_stream;
pub struct Substream<T> { pub struct Substream<T> {
id: u32, id: u32,
end: MultiplexEnd, end: Endpoint,
name: Option<Bytes>, name: Option<Bytes>,
state: Arc<Mutex<MultiplexShared<T>>>, state: Arc<Mutex<MultiplexShared<T>>>,
buffer: Option<io::Cursor<ByteBuf>>, buffer: Option<io::Cursor<ByteBuf>>,
@ -83,7 +83,7 @@ impl<T> Drop for Substream<T> {
impl<T> Substream<T> { impl<T> Substream<T> {
fn new<B: Into<Option<Bytes>>>( fn new<B: Into<Option<Bytes>>>(
id: u32, id: u32,
end: MultiplexEnd, end: Endpoint,
name: B, name: B,
state: Arc<Mutex<MultiplexShared<T>>>, state: Arc<Mutex<MultiplexShared<T>>>,
) -> Self { ) -> Self {
@ -158,7 +158,7 @@ impl<T: AsyncWrite> AsyncWrite for Substream<T> {
} }
pub struct InboundFuture<T> { pub struct InboundFuture<T> {
end: MultiplexEnd, end: Endpoint,
state: Arc<Mutex<MultiplexShared<T>>>, state: Arc<Mutex<MultiplexShared<T>>>,
} }
@ -216,8 +216,8 @@ impl<T> OutboundFuture<T> {
} }
} }
fn nonce_to_id(id: usize, end: MultiplexEnd) -> u32 { fn nonce_to_id(id: usize, end: Endpoint) -> u32 {
id as u32 * 2 + if end == MultiplexEnd::Initiator { 1 } else { 0 } id as u32 * 2 + if end == Endpoint::Dialer { 1 } else { 0 }
} }
impl<T: AsyncWrite> Future for OutboundFuture<T> { impl<T: AsyncWrite> Future for OutboundFuture<T> {
@ -276,7 +276,7 @@ impl<T: AsyncWrite> Future for OutboundFuture<T> {
pub struct MultiplexMetadata { pub struct MultiplexMetadata {
nonce: AtomicUsize, nonce: AtomicUsize,
end: MultiplexEnd, end: Endpoint,
} }
pub struct Multiplex<T> { pub struct Multiplex<T> {
@ -294,7 +294,7 @@ impl<T> Clone for Multiplex<T> {
} }
impl<T> Multiplex<T> { impl<T> Multiplex<T> {
pub fn new(stream: T, end: MultiplexEnd) -> Self { pub fn new(stream: T, end: Endpoint) -> Self {
Multiplex { Multiplex {
meta: Arc::new(MultiplexMetadata { meta: Arc::new(MultiplexMetadata {
nonce: AtomicUsize::new(0), nonce: AtomicUsize::new(0),
@ -305,11 +305,11 @@ impl<T> Multiplex<T> {
} }
pub fn dial(stream: T) -> Self { pub fn dial(stream: T) -> Self {
Self::new(stream, MultiplexEnd::Initiator) Self::new(stream, Endpoint::Dialer)
} }
pub fn listen(stream: T) -> Self { pub fn listen(stream: T) -> Self {
Self::new(stream, MultiplexEnd::Receiver) Self::new(stream, Endpoint::Listener)
} }
} }
@ -342,8 +342,8 @@ where
type NamesIter = iter::Once<(Bytes, ())>; type NamesIter = iter::Once<(Bytes, ())>;
#[inline] #[inline]
fn upgrade(self, i: C, _: ()) -> Self::Future { fn upgrade(self, i: C, _: (), end: Endpoint) -> Self::Future {
future::ok(Multiplex::dial(i)) future::ok(Multiplex::new(i, end))
} }
#[inline] #[inline]
@ -466,7 +466,7 @@ mod tests {
.chain( .chain(
varint::encode( varint::encode(
// ID for an unopened stream: 1 // ID for an unopened stream: 1
MultiplexHeader::message(1, MultiplexEnd::Initiator).to_u64(), MultiplexHeader::message(1, Endpoint::Dialer).to_u64(),
).into_iter(), ).into_iter(),
) )
// Body: `dummy_length` of zeroes // Body: `dummy_length` of zeroes
@ -477,7 +477,7 @@ mod tests {
.chain( .chain(
varint::encode( varint::encode(
// ID for an opened stream: 0 // ID for an opened stream: 0
MultiplexHeader::message(0, MultiplexEnd::Initiator).to_u64(), MultiplexHeader::message(0, Endpoint::Dialer).to_u64(),
).into_iter(), ).into_iter(),
) )
.chain(varint::encode(message.len())) .chain(varint::encode(message.len()))
@ -516,7 +516,7 @@ mod tests {
.chain( .chain(
varint::encode( varint::encode(
// ID for an unopened stream: 1 // ID for an unopened stream: 1
MultiplexHeader::close(0, MultiplexEnd::Initiator).to_u64(), MultiplexHeader::close(0, Endpoint::Dialer).to_u64(),
).into_iter(), ).into_iter(),
) )
.chain(varint::encode(dummy_length)) .chain(varint::encode(dummy_length))
@ -526,7 +526,7 @@ mod tests {
.chain( .chain(
varint::encode( varint::encode(
// ID for an opened stream: 0 // ID for an opened stream: 0
MultiplexHeader::message(0, MultiplexEnd::Initiator).to_u64(), MultiplexHeader::message(0, Endpoint::Dialer).to_u64(),
).into_iter(), ).into_iter(),
) )
.chain(varint::encode(dummy_length)) .chain(varint::encode(dummy_length))