On this page

server.channels.Server.wait_for_channel

Module: server.channels
Declared in: Server
Package: libtmux
Source: crates/libtmux/src/server/channels.rs

wait_for_channel ( self , channel : &str , within : Duration ) → Result<ChannelWait, Error> method [source] ¶ method [source] ¶ wait_for_channel

Wait for a wait-for channel to be signalled.

The blocking half of Server::signal_channel . Nothing polls: tmux releases the wait when the channel is signalled, so a caller costs one idle client rather than a loop.

This waits for something to *say* it happened. It does not watch a pane, so what signals the channel is the caller's to arrange -- a command ending with `tmux wait-for -S <channel>` is the usual shape.

The channel latches. Signalling one nothing is waiting on is kept, and the next wait returns at once; the latch is one-shot, so a second wait blocks again. One signal releases every waiter present at the time. So signalling before the wait starts is safe, which is what makes this usable for a command that may finish first.

That holds across the supported range. cmd-wait-for.c is identical between 3.5a and 3.7c, and the only changes since 3.2a are an argument table gaining a field, an accessor replacing a direct index, and a local being renamed -- none of them near the flag the latch is kept in. Measured directly on 3.5a and 3.7c.

within is capped at Server::default_timeout , because a dispatch is bounded and this is one: ask for longer by building the server with a longer timeout.

Errors

Returns an error when tmux refuses the channel name or cannot be reached. Running out of time is ChannelWait::TimedOut rather than an error, so "nothing signalled it" stays distinct from "the command did not get through" -- the caller retries only one of those.

Examples

use libtmux::ChannelWait;
use std::time::Duration;

// Signalling first is safe: the channel keeps it.
server.signal_channel("ready").await?;
let outcome = server.wait_for_channel("ready", Duration::from_secs(5)).await?;
assert_eq!(outcome, ChannelWait::Signalled);

// The latch is spent, so a second wait runs out of time instead.
let again = server.wait_for_channel("ready", Duration::from_millis(200)).await?;
assert_eq!(again, ChannelWait::TimedOut);

Discussed in Waiting and retrying

0 declared, 0 inherited