Struct PluggableServerTransport

pub struct PluggableServerTransport {
    inner: Option<AsyncPtChild>,
    pub(crate) binary_path: PathBuf,
    arguments: Vec<String>,
    common_params: PtCommonParameters,
    server_params: PtServerParameters,
    smethods: HashMap<PtTransportName, PtClientMethod>,
}

Available on crate feature managed-pts only.

A pluggable transport server binary in a child process.

These start out inert, and must be launched with PluggableServerTransport::launch in order to be useful.

Fields

inner: Option<AsyncPtChild>

The currently running child, if there is one.

binary_path: PathBuf

The path to the binary to run.

arguments: Vec<String>

Arguments to pass to the binary.

common_params: PtCommonParameters

Configured parameters.

server_params: PtServerParameters

Configured server-only parameters.

smethods: HashMap<PtTransportName, PtClientMethod>

Information about server methods obtained from the PT.

Implementations

impl PluggableServerTransport

pub fn new( binary_path: PathBuf, arguments: Vec<String>, common_params: PtCommonParameters, server_params: PtServerParameters, ) -> Self

Create a new pluggable transport wrapper, wrapping the binary at binary_path and passing the params to it.

You must call PluggableServerTransport::launch to actually run the PT.

pub async fn launch<R: Runtime>(&mut self, rt: R) -> Result<()>

Launch the pluggable transport, executing the binary.

Will return an error if the launch fails, one of the transports fail, not all transports were launched, or the launch times out.

Trait Implementations

impl Debug for PluggableServerTransport

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PluggableTransport for PluggableServerTransport

fn transport_methods(&self) -> &HashMap<PtTransportName, PtClientMethod>

Get all client methods returned by the binary, if it has been launched.

fn next_message<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<PtMessage>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Get the next PtMessage from the running transport. It is recommended to call this in a loop once a PT has been launched, in order to forward log messages and find out about status updates.

impl PluggableTransportPrivate for PluggableServerTransport

fn inner(&mut self) -> Result<&mut AsyncPtChild, PtError>

Return the AsyncPtChild if it exists

fn set_inner(&mut self, newval: Option<AsyncPtChild>)

Set the AsyncPtChild

fn identifier(&self) -> &str

Return a loggable identifier for this transport.

fn specific_params_contains(&self, transport: &PtTransportName) -> bool

Checks whether a transport is specified in our specific parameters

fn common_transport_launched_handler( &self, protocol: Option<String>, transport: PtTransportName, endpoint: SocketAddr, methods: &mut HashMap<PtTransportName, PtClientMethod>, ) -> Result<(), PtError>

Common handler for ClientTransportLaunched and ServerTransportLaunched

fn get_child_from_pt_launch( inner: &Option<AsyncPtChild>, transports: &Vec<PtTransportName>, binary_path: &PathBuf, arguments: &[String], all_env_vars: HashMap<OsString, OsString>, ) -> Result<AsyncPtChild, PtError>

Attempt to launch the PT and return the corresponding [AsyncPtChild]

fn try_match_common_messages<'life0, 'life1, 'life2, 'async_trait, R>( &'life0 self, rt: &'life1 R, deadline: Instant, async_child: &'life2 mut AsyncPtChild, ) -> Pin<Box<dyn Future<Output = Result<Option<PtMessage>, PtError>> + Send + 'async_trait>>

where R: 'async_trait + Runtime, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Consolidates some of the PtMessage potential matches to deduplicate code