Struct ockam_transport_tcp::TcpTransport
source · [−]pub struct TcpTransport { /* private fields */ }
Expand description
High level management interface for TCP transports
Be aware that only one TcpTransport
can exist per node, as it
registers itself as a router for the TCP
address type. Multiple
calls to TcpTransport::create
will fail.
To listen for incoming connections use
tcp.listen()
.
To register additional connections on an already initialised
TcpTransport
, use tcp.connect()
.
This step is optional because the underlying TcpRouter is capable of lazily
establishing a connection upon arrival of an initial message.
use ockam_transport_tcp::TcpTransport;
let tcp = TcpTransport::create(&ctx).await?;
tcp.listen("127.0.0.1:8000").await?; // Listen on port 8000
tcp.connect("127.0.0.1:5000").await?; // And connect to port 5000
The same TcpTransport
can also bind to multiple ports.
use ockam_transport_tcp::TcpTransport;
let tcp = TcpTransport::create(&ctx).await?;
tcp.listen("127.0.0.1:8000").await?; // Listen on port 8000
tcp.listen("127.0.0.1:9000").await?; // Listen on port 9000
Implementations
sourceimpl TcpTransport
impl TcpTransport
sourcepub async fn create(ctx: &Context) -> Result<Self>
pub async fn create(ctx: &Context) -> Result<Self>
Create a new TCP transport and router for the current node
use ockam_transport_tcp::TcpTransport;
let tcp = TcpTransport::create(&ctx).await?;
sourcepub async fn connect<S: AsRef<str>>(&self, peer: S) -> Result<Address>
pub async fn connect<S: AsRef<str>>(&self, peer: S) -> Result<Address>
Manually establish an outgoing TCP connection on an existing transport. This step is optional because the underlying TcpRouter is capable of lazily establishing a connection upon arrival of the initial message.
use ockam_transport_tcp::TcpTransport;
let tcp = TcpTransport::create(&ctx).await?;
tcp.listen("127.0.0.1:8000").await?; // Listen on port 8000
tcp.connect("127.0.0.1:5000").await?; // and connect to port 5000
sourcepub async fn listen<S: AsRef<str>>(&self, bind_addr: S) -> Result<SocketAddr>
pub async fn listen<S: AsRef<str>>(&self, bind_addr: S) -> Result<SocketAddr>
Start listening to incoming connections on an existing transport
Returns the local address that this transport is bound to.
This can be useful, for example, when binding to port 0 to figure out which port was actually bound.
use ockam_transport_tcp::TcpTransport;
let tcp = TcpTransport::create(&ctx).await?;
tcp.listen("127.0.0.1:8000").await?;
sourceimpl TcpTransport
impl TcpTransport
sourcepub async fn create_inlet(
&self,
bind_addr: impl Into<String>,
outlet_route: impl Into<Route>
) -> Result<(Address, SocketAddr)>
pub async fn create_inlet(
&self,
bind_addr: impl Into<String>,
outlet_route: impl Into<Route>
) -> Result<(Address, SocketAddr)>
Create Tcp Inlet that listens on bind_addr, transforms Tcp stream into Ockam Routable Messages and forward them to Outlet using outlet_route. Inlet is bidirectional: Ockam Messages sent to Inlet from Outlet (using return route) will be streamed to Tcp connection. Pair of corresponding Inlet and Outlet is called Portal.
use ockam_transport_tcp::{TcpTransport, TCP};
let hop_addr = "INTERMEDIARY_HOP:8000";
let route_path = route![(TCP, hop_addr), "outlet"];
let tcp = TcpTransport::create(&ctx).await?;
tcp.create_inlet("inlet", route_path).await?;
sourcepub async fn stop_inlet(&self, addr: impl Into<Address>) -> Result<()>
pub async fn stop_inlet(&self, addr: impl Into<Address>) -> Result<()>
Stop inlet at addr
use ockam_transport_tcp::{TcpTransport, TCP};
let hop_addr = "INTERMEDIARY_HOP:8000";
let route = route![(TCP, hop_addr), "outlet"];
let tcp = TcpTransport::create(&ctx).await?;
tcp.create_inlet("inlet", route).await?;
tcp.stop_inlet("inlet").await?;
sourcepub async fn create_outlet(
&self,
address: impl Into<Address>,
peer: impl Into<String>
) -> Result<()>
pub async fn create_outlet(
&self,
address: impl Into<Address>,
peer: impl Into<String>
) -> Result<()>
Create Tcp Outlet Listener at address, that connects to peer using Tcp, transforms Ockam Messages received from Inlet into stream and sends it to peer Tcp stream. Outlet is bidirectional: Tcp stream received from peer is transformed into Ockam Routable Messages and sent to Inlet using return route. Pair of corresponding Inlet and Outlet is called Portal.
use ockam_transport_tcp::TcpTransport;
let tcp = TcpTransport::create(&ctx).await?;
tcp.create_outlet("outlet", "localhost:9000").await?;
sourcepub async fn create_outlet_with_access_control<AC>(
&self,
address: impl Into<Address>,
peer: impl Into<String>,
access_control: AC
) -> Result<()> where
AC: AccessControl,
pub async fn create_outlet_with_access_control<AC>(
&self,
address: impl Into<Address>,
peer: impl Into<String>,
access_control: AC
) -> Result<()> where
AC: AccessControl,
FIXME
sourcepub async fn stop_outlet(&self, addr: impl Into<Address>) -> Result<()>
pub async fn stop_outlet(&self, addr: impl Into<Address>) -> Result<()>
Stop outlet at addr
use ockam_transport_tcp::TcpTransport;
const TARGET_PEER: &str = "127.0.0.1:5000";
let tcp = TcpTransport::create(&ctx).await?;
tcp.create_outlet("outlet", TARGET_PEER).await?;
tcp.stop_outlet("outlet").await?;
Trait Implementations
sourceimpl AsyncTryClone for TcpTransport
impl AsyncTryClone for TcpTransport
Auto Trait Implementations
impl !RefUnwindSafe for TcpTransport
impl Send for TcpTransport
impl Sync for TcpTransport
impl Unpin for TcpTransport
impl !UnwindSafe for TcpTransport
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more