Struct northstar_client::Client
source · pub struct Client<T> { /* private fields */ }
Expand description
Client for a Northstar runtime instance.
use futures::StreamExt;
use northstar_client::Client;
use northstar_client::model::Version;
async fn main() {
let mut client = Client::new(tokio::net::TcpStream::connect("localhost:4200").await.unwrap(), None).await.unwrap();
client.start("hello:0.0.1").await.expect("failed to start \"hello\"");
while let Some(notification) = client.next().await {
println!("{:?}", notification);
}
}
Implementations§
source§impl Client<UnixStream>
impl Client<UnixStream>
source§impl<'a, T: AsyncRead + AsyncWrite + Unpin> Client<T>
impl<'a, T: AsyncRead + AsyncWrite + Unpin> Client<T>
sourcepub async fn new(
io: T,
notifications: Option<usize>
) -> Result<Client<T>, Error>
pub async fn new( io: T, notifications: Option<usize> ) -> Result<Client<T>, Error>
Create a new northstar client and connect to a runtime instance running on host
.
Arguments
io
- Connection medium (e.g. Unix or TCP socket)notifications
- Optional buffer size for receiving notificationstimeout
- Timeout of connection establishment
Errors
In addition to the errors that can happen when trying to connect
, an Err
is returned
if the connection establishment times out.
sourcepub fn framed(self) -> Connection<T>
pub fn framed(self) -> Connection<T>
Convert client into a connection
sourcepub async fn request(&mut self, request: Request) -> Result<Response, Error>
pub async fn request(&mut self, request: Request) -> Result<Response, Error>
Perform a request response sequence
let response = client.request(List).await.expect("failed to request container list");
println!("{:?}", response);
sourcepub async fn ident(&mut self) -> Result<Container, Error>
pub async fn ident(&mut self) -> Result<Container, Error>
Request the identificaiton of this container
let ident = client.ident().await.expect("failed to identity");
println!("{}", ident);
sourcepub async fn list(&mut self) -> Result<Vec<Container>, Error>
pub async fn list(&mut self) -> Result<Vec<Container>, Error>
Request a list of installed containers
let containers = client.list().await.expect("failed to request container list");
println!("{:#?}", containers);
sourcepub async fn repositories(&mut self) -> Result<HashSet<RepositoryId>, Error>
pub async fn repositories(&mut self) -> Result<HashSet<RepositoryId>, Error>
Request a list of repositories
let repositories = client.repositories().await.expect("failed to request repository list");
println!("{:#?}", repositories);
sourcepub async fn start<C>(&mut self, container: C) -> Result<(), Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
pub async fn start<C>(&mut self, container: C) -> Result<(), Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static,
Start container with name
client.start("hello:0.0.1").await.expect("failed to start \"hello\"");
// Print start notification
println!("{:#?}", client.next().await);
sourcepub async fn start_command<C, A, E, K>(
&mut self,
container: C,
init: Option<A>,
args: impl IntoIterator<Item = A>,
env: impl IntoIterator<Item = (E, K)>
) -> Result<(), Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
A: TryInto<NonNulString>,
A::Error: Error + Send + Sync + 'static,
E: TryInto<NonNulString>,
E::Error: Error + Send + Sync + 'static,
K: TryInto<NonNulString>,
K::Error: Error + Send + Sync + 'static,
pub async fn start_command<C, A, E, K>( &mut self, container: C, init: Option<A>, args: impl IntoIterator<Item = A>, env: impl IntoIterator<Item = (E, K)> ) -> Result<(), Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static, A: TryInto<NonNulString>, A::Error: Error + Send + Sync + 'static, E: TryInto<NonNulString>, E::Error: Error + Send + Sync + 'static, K: TryInto<NonNulString>, K::Error: Error + Send + Sync + 'static,
Start container name and pass init, arguments and set additional env variables.
let mut env = HashMap::new();
env.insert("FOO", "blah");
client.start_command("hello:0.0.1", Some("/bin/hello"), ["--dump", "-v"], env).await.expect("failed to start \"hello\"");
// Print start notification
println!("{:#?}", client.next().await);
sourcepub async fn kill<C>(&mut self, container: C, signal: i32) -> Result<(), Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
pub async fn kill<C>(&mut self, container: C, signal: i32) -> Result<(), Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static,
Kill container with name
client.kill("hello:0.0.1", 15).await.expect("failed to start \"hello\"");
// Print stop notification
println!("{:#?}", client.next().await);
sourcepub async fn install_file(
&mut self,
npk: &Path,
repository: &str
) -> Result<Container, Error>
pub async fn install_file( &mut self, npk: &Path, repository: &str ) -> Result<Container, Error>
Install a npk from path
let npk = Path::new("test.npk");
client.install_file(npk, "default").await.expect("failed to install \"test.npk\" into repository \"default\"");
sourcepub async fn install(
&mut self,
npk: impl AsyncRead + Unpin,
size: u64,
repository: &str
) -> Result<Container, Error>
pub async fn install( &mut self, npk: impl AsyncRead + Unpin, size: u64, repository: &str ) -> Result<Container, Error>
Install a npk
let npk = fs::File::open("test.npk").await.expect("failed to open \"test.npk\"");
let size = npk.metadata().await.unwrap().len();
client.install(npk, size, "default").await.expect("failed to install \"test.npk\" into repository \"default\"");
sourcepub async fn uninstall<C>(
&mut self,
container: C,
wipe: bool
) -> Result<(), Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
pub async fn uninstall<C>( &mut self, container: C, wipe: bool ) -> Result<(), Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static,
Uninstall a npk and optionally wipe the containers persistent dir
client.uninstall("hello:0.0.1", false).await.expect("failed to uninstall \"hello\"");
// Print stop notification
println!("{:#?}", client.next().await);
sourcepub async fn mount<C>(&mut self, container: C) -> Result<MountResult, Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
pub async fn mount<C>(&mut self, container: C) -> Result<MountResult, Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static,
Mount a container
let mut client = Client::new(tokio::net::TcpStream::connect("localhost:4200").await.unwrap(), None).await.unwrap();
client.mount("test:0.0.1").await.expect("failed to mount");
sourcepub async fn mount_all<C, I>(
&mut self,
containers: I
) -> Result<Vec<MountResult>, Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
I: 'a + IntoIterator<Item = C>,
pub async fn mount_all<C, I>( &mut self, containers: I ) -> Result<Vec<MountResult>, Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static, I: 'a + IntoIterator<Item = C>,
Mount a list of containers
let mut client = Client::new(tokio::net::TcpStream::connect("localhost:4200").await.unwrap(), None).await.unwrap();
client.mount_all(vec!("hello-world:0.0.1", "cpueater:0.0.1")).await.expect("failed to mount");
sourcepub async fn umount<C>(&mut self, container: C) -> Result<UmountResult, Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
pub async fn umount<C>(&mut self, container: C) -> Result<UmountResult, Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static,
Umount a mounted container
client.umount("hello:0.0.1").await.expect("failed to unmount \"hello:0.0.1\"");
sourcepub async fn umount_all<C, I>(
&mut self,
containers: I
) -> Result<Vec<UmountResult>, Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
I: 'a + IntoIterator<Item = C>,
pub async fn umount_all<C, I>( &mut self, containers: I ) -> Result<Vec<UmountResult>, Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static, I: 'a + IntoIterator<Item = C>,
Umount a list of mounted containers
client.umount_all(vec!("hello:0.0.1", "cpueater:0.0.1")).await.expect("failed to unmount \"hello:0.0.1\" and \"cpueater:0.0.1\"");
sourcepub async fn inspect<C>(&mut self, container: C) -> Result<ContainerData, Error>where
C: TryInto<Container>,
C::Error: Error + Send + Sync + 'static,
pub async fn inspect<C>(&mut self, container: C) -> Result<ContainerData, Error>where C: TryInto<Container>, C::Error: Error + Send + Sync + 'static,
Gather container statistics
println!("{:?}", client.inspect("hello:0.0.1").await.unwrap());
sourcepub async fn create_token<R, S>(
&mut self,
target: R,
shared: S
) -> Result<Token, Error>where
R: TryInto<Name>,
R::Error: Error + Send + Sync + 'static,
S: AsRef<[u8]>,
pub async fn create_token<R, S>( &mut self, target: R, shared: S ) -> Result<Token, Error>where R: TryInto<Name>, R::Error: Error + Send + Sync + 'static, S: AsRef<[u8]>,
Create a token
The target
parameter must be the container name (without version) of the container that
will try to verify the token. The token can only be successfully verified by the container
that is started with the name target
!
The shared
parameter is added into the token in order to make it specific to a dedicated
purpose, e.g. “mqtt”.
println!("{:?}", client.create_token("webserver", "http").await.unwrap());
sourcepub async fn verify_token<R, S>(
&mut self,
token: &Token,
user: R,
shared: S
) -> Result<VerificationResult, Error>where
R: TryInto<Name>,
R::Error: Error + Send + Sync + 'static,
S: AsRef<[u8]>,
pub async fn verify_token<R, S>( &mut self, token: &Token, user: R, shared: S ) -> Result<VerificationResult, Error>where R: TryInto<Name>, R::Error: Error + Send + Sync + 'static, S: AsRef<[u8]>,
Verify a slice of bytes with a token
The token
parameter shall contain a token that is received from a container.
The user
parameter must match the name of the container, that created the token
and send it to the container that want to verify the token.
shared
is some salt that makes a token specific for a usecase can must just match
the value used when the the token is created.
let token = client.create_token("hello", "#noafd").await.unwrap(); // token can only verified by container `hello`
assert_eq!(client.verify_token(&token, "hello", "#noafd").await.unwrap(), VerificationResult::Ok);
assert_eq!(client.verify_token(&token, "hello", "").await.unwrap(), VerificationResult::Ok);
Trait Implementations§
source§impl<T: AsyncRead + AsyncWrite + Unpin> Stream for Client<T>
impl<T: AsyncRead + AsyncWrite + Unpin> Stream for Client<T>
Stream notifications
use futures::StreamExt;
async fn main() {
let mut client = Client::new(tokio::net::TcpStream::connect("localhost:4200").await.unwrap(), None).await.unwrap();
client.start("hello:0.0.1").await.expect("failed to start \"hello\"");
while let Some(notification) = client.next().await {
println!("{:?}", notification);
}
}
§type Item = Result<Notification, Error>
type Item = Result<Notification, Error>
Auto Trait Implementations§
impl<T> RefUnwindSafe for Client<T>where T: RefUnwindSafe,
impl<T> Send for Client<T>where T: Send,
impl<T> Sync for Client<T>where T: Sync,
impl<T> Unpin for Client<T>where T: Unpin,
impl<T> UnwindSafe for Client<T>where T: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> StreamExt for Twhere
T: Stream + ?Sized,
impl<T> StreamExt for Twhere T: Stream + ?Sized,
§fn next(&mut self) -> Next<'_, Self>where
Self: Unpin,
fn next(&mut self) -> Next<'_, Self>where Self: Unpin,
§fn into_future(self) -> StreamFuture<Self>where
Self: Sized + Unpin,
fn into_future(self) -> StreamFuture<Self>where Self: Sized + Unpin,
§fn map<T, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> T,
Self: Sized,
fn map<T, F>(self, f: F) -> Map<Self, F>where F: FnMut(Self::Item) -> T, Self: Sized,
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
§fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
§fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
Self: Sized,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
Self: Sized,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,
§fn collect<C>(self) -> Collect<Self, C>where
C: Default + Extend<Self::Item>,
Self: Sized,
fn collect<C>(self) -> Collect<Self, C>where C: Default + Extend<Self::Item>, Self: Sized,
§fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Stream<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,
§fn concat(self) -> Concat<Self>where
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Concat<Self>where Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
§fn count(self) -> Count<Self>where
Self: Sized,
fn count(self) -> Count<Self>where Self: Sized,
§fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
Self: Sized,
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>, Self: Sized,
§fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true
if any element in stream satisfied a predicate. Read more§fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true
if all element in stream satisfied a predicate. Read more§fn flatten(self) -> Flatten<Self>where
Self::Item: Stream,
Self: Sized,
fn flatten(self) -> Flatten<Self>where Self::Item: Stream, Self: Sized,
§fn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnorderedWithFlowController<Self, ()>where
Self::Item: Stream + Unpin,
Self: Sized,
fn flatten_unordered( self, limit: impl Into<Option<usize>> ) -> FlattenUnorderedWithFlowController<Self, ()>where Self::Item: Stream + Unpin, Self: Sized,
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
F: FnMut(Self::Item) -> U,
U: Stream,
Self: Sized,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where F: FnMut(Self::Item) -> U, U: Stream, Self: Sized,
§fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F>where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
Self: Sized,
fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F ) -> FlatMapUnordered<Self, U, F>where U: Stream + Unpin, F: FnMut(Self::Item) -> U, Self: Sized,
StreamExt::map
] but flattens nested Stream
s
and polls them concurrently, yielding items in any order, as they made
available. Read more§fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
Self: Sized,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option<B>>, Self: Sized,
StreamExt::fold
] that holds internal state
and produces a new stream. Read more§fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true
. Read more§fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Self: Sized,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
true
. Read more§fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where
Fut: Future,
Self: Sized,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where Fut: Future, Self: Sized,
§fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
Self: Sized,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
§fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
Self: Sized,
fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> ForEachConcurrent<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
n
items of the underlying stream. Read more§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
n
items of the underlying stream. Read more§fn catch_unwind(self) -> CatchUnwind<Self>where
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self>where Self: Sized + UnwindSafe,
§fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>where
Self: Sized + Send + 'a,
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>where Self: Sized + Send + 'a,
§fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where
Self: Sized + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where Self: Sized + 'a,
§fn buffered(self, n: usize) -> Buffered<Self>where
Self::Item: Future,
Self: Sized,
fn buffered(self, n: usize) -> Buffered<Self>where Self::Item: Future, Self: Sized,
§fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where
Self::Item: Future,
Self: Sized,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where Self::Item: Future, Self: Sized,
§fn zip<St>(self, other: St) -> Zip<Self, St>where
St: Stream,
Self: Sized,
fn zip<St>(self, other: St) -> Zip<Self, St>where St: Stream, Self: Sized,
§fn chain<St>(self, other: St) -> Chain<Self, St>where
St: Stream<Item = Self::Item>,
Self: Sized,
fn chain<St>(self, other: St) -> Chain<Self, St>where St: Stream<Item = Self::Item>, Self: Sized,
§fn peekable(self) -> Peekable<Self>where
Self: Sized,
fn peekable(self) -> Peekable<Self>where Self: Sized,
peek
method. Read more§fn chunks(self, capacity: usize) -> Chunks<Self>where
Self: Sized,
fn chunks(self, capacity: usize) -> Chunks<Self>where Self: Sized,
§fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
Self: Sized,
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where Self: Sized,
§fn forward<S>(self, sink: S) -> Forward<Self, S>where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream + Sized,
fn forward<S>(self, sink: S) -> Forward<Self, S>where S: Sink<Self::Ok, Error = Self::Error>, Self: TryStream + Sized,
§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F>where F: FnMut(&Self::Item), Self: Sized,
§fn left_stream<B>(self) -> Either<Self, B>where
B: Stream<Item = Self::Item>,
Self: Sized,
fn left_stream<B>(self) -> Either<Self, B>where B: Stream<Item = Self::Item>, Self: Sized,
§fn right_stream<B>(self) -> Either<B, Self>where
B: Stream<Item = Self::Item>,
Self: Sized,
fn right_stream<B>(self) -> Either<B, Self>where B: Stream<Item = Self::Item>, Self: Sized,
§fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
Self: Unpin,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where Self: Unpin,
Stream::poll_next
] on Unpin
stream types.§fn select_next_some(&mut self) -> SelectNextSome<'_, Self>where
Self: Unpin + FusedStream,
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>where Self: Unpin + FusedStream,
§impl<S> TryStreamExt for Swhere
S: TryStream + ?Sized,
impl<S> TryStreamExt for Swhere S: TryStream + ?Sized,
§fn err_into<E>(self) -> ErrInto<Self, E>where
Self: Sized,
Self::Error: Into<E>,
fn err_into<E>(self) -> ErrInto<Self, E>where Self: Sized, Self::Error: Into<E>,
§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where
Self: Sized,
F: FnMut(Self::Ok) -> T,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>where Self: Sized, F: FnMut(Self::Ok) -> T,
§fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where
Self: Sized,
F: FnMut(Self::Error) -> E,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>where Self: Sized, F: FnMut(Self::Error) -> E,
§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
Self: Sized,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>, Self: Sized,
f
. Read more§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
Self: Sized,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>, Self: Sized,
f
. Read more§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where
F: FnMut(&Self::Ok),
Self: Sized,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>where F: FnMut(&Self::Ok), Self: Sized,
§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where
F: FnMut(&Self::Error),
Self: Sized,
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>where F: FnMut(&Self::Error), Self: Sized,
§fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
fn into_stream(self) -> IntoStream<Self>where Self: Sized,
§fn try_next(&mut self) -> TryNext<'_, Self>where
Self: Unpin,
fn try_next(&mut self) -> TryNext<'_, Self>where Self: Unpin,
§fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
Self: Sized,
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = (), Error = Self::Error>, Self: Sized,
§fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Self: Sized,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>, Self: Sized,
true
. Read more§fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Self: Sized,
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>, Self: Sized,
true
. Read more§fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
Self: Sized,
fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> TryForEachConcurrent<Self, Fut, F>where F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = Result<(), Self::Error>>, Self: Sized,
§fn try_collect<C>(self) -> TryCollect<Self, C>where
C: Default + Extend<Self::Ok>,
Self: Sized,
fn try_collect<C>(self) -> TryCollect<Self, C>where C: Default + Extend<Self::Ok>, Self: Sized,
§fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
Self: Sized,
fn try_chunks(self, capacity: usize) -> TryChunks<Self>where Self: Sized,
§fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>where
Self: Sized,
fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>where Self: Sized,
§fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
Self: Sized,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>where Fut: Future<Output = bool>, F: FnMut(&Self::Ok) -> Fut, Self: Sized,
§fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
Self: Sized,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>where Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, F: FnMut(Self::Ok) -> Fut, Self: Sized,
§fn try_flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> TryFlattenUnordered<Self>where
Self::Ok: TryStream + Unpin,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Self: Sized,
fn try_flatten_unordered( self, limit: impl Into<Option<usize>> ) -> TryFlattenUnordered<Self>where Self::Ok: TryStream + Unpin, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized,
§fn try_flatten(self) -> TryFlatten<Self>where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Self: Sized,
fn try_flatten(self) -> TryFlatten<Self>where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized,
§fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
Self: Sized,
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>where F: FnMut(T, Self::Ok) -> Fut, Fut: TryFuture<Ok = T, Error = Self::Error>, Self: Sized,
§fn try_concat(self) -> TryConcat<Self>where
Self: Sized,
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item> + IntoIterator + Default,
fn try_concat(self) -> TryConcat<Self>where Self: Sized, Self::Ok: Extend<<Self::Ok as IntoIterator>::Item> + IntoIterator + Default,
§fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
§fn try_buffered(self, n: usize) -> TryBuffered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_buffered(self, n: usize) -> TryBuffered<Self>where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized,
§fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>>where
Self: Unpin,
fn try_poll_next_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Option<Result<Self::Ok, Self::Error>>>where Self: Unpin,
TryStream::try_poll_next
] on Unpin
stream types.§fn into_async_read(self) -> IntoAsyncRead<Self>where
Self: Sized + TryStreamExt<Error = Error>,
Self::Ok: AsRef<[u8]>,
fn into_async_read(self) -> IntoAsyncRead<Self>where Self: Sized + TryStreamExt<Error = Error>, Self::Ok: AsRef<[u8]>,
AsyncBufRead
. Read more§fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F>where
Self: Sized,
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = bool>,
fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F>where Self: Sized, F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = bool>,
Err
is encountered or if an Ok
item is found
that does not satisfy the predicate. Read more§fn try_any<Fut, F>(self, f: F) -> TryAny<Self, Fut, F>where
Self: Sized,
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = bool>,
fn try_any<Fut, F>(self, f: F) -> TryAny<Self, Fut, F>where Self: Sized, F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = bool>,
Err
is encountered or if an Ok
item is found
that satisfies the predicate. Read more