Struct GoshTransferEngine 

pub struct GoshTransferEngine { /* private fields */ }

The main engine that coordinates all file transfer operations

This is the primary interface for using the library. It manages:

• The HTTP server for receiving files
• The HTTP client for sending files
• Configuration and state

Implementations

impl GoshTransferEngine

pub fn new(config: EngineConfig, event_handler: Arc<dyn EventHandler>) -> Self

Create a new engine with the given configuration and event handler

pub fn with_history( config: EngineConfig, event_handler: Arc<dyn EventHandler>, history: Arc<dyn HistoryPersistence>, ) -> Self

Create a new engine with the given configuration, event handler, and history persistence

The history will automatically record completed and failed transfers.

pub fn with_channel_events( config: EngineConfig, ) -> (Self, Receiver<EngineEvent>)

Create a new engine with a channel-based event handler

This is a convenience constructor that returns both the engine and a receiver for events.

pub fn with_channel_events_and_history( config: EngineConfig, history: Arc<dyn HistoryPersistence>, ) -> (Self, Receiver<EngineEvent>)

Create a new engine with a channel-based event handler and history persistence

This is a convenience constructor that returns both the engine and a receiver for events.

pub fn history(&self) -> Option<&Arc<dyn HistoryPersistence>>

Get the history persistence (if configured)

pub async fn start_server(&mut self) -> EngineResult<()>

Start the HTTP server for receiving files

The server binds to all interfaces (0.0.0.0) on the configured port. Returns a handle that can be used to stop the server.

pub async fn stop_server(&mut self) -> EngineResult<()>

Stop the HTTP server

pub fn is_server_running(&self) -> bool

Check if the server is running

pub fn server_state(&self) -> &Arc<ServerState>

Get the server state for advanced operations

pub fn port(&self) -> u16

Get the current server port

pub async fn change_port(&mut self, new_port: u16) -> EngineResult<()>

Change the server port at runtime

This will gracefully stop the current server, bind to the new port, and emit appropriate events. If binding to the new port fails, it will attempt to restore the previous port.

Arguments

• new_port - The new port to bind to

Errors

• EngineError::InvalidConfig if the port is invalid (e.g., port 0)
• EngineError::Network if binding to the new port fails

pub async fn change_port_with_options( &mut self, new_port: u16, rollback_on_failure: bool, ) -> EngineResult<()>

Change the server port with configurable rollback behavior

Arguments

• new_port - The new port to bind to
• rollback_on_failure - If true, attempt to restore the old port if new binding fails

Behavior

1. Validates the new port
2. If server is running, stops it gracefully
3. Attempts to bind to the new port
4. On success: updates config, emits PortChanged and ServerStarted events
5. On failure with rollback: attempts to restore old port
6. On failure without rollback: leaves server stopped

pub async fn send_files( &self, address: &str, port: u16, file_paths: Vec<PathBuf>, ) -> EngineResult<()>

Send files to a peer

This will:

1. Request permission from the peer
2. Wait for approval (or auto-accept if trusted)
3. Stream the files to the peer
4. Emit progress events during transfer

pub async fn send_directory( &self, address: &str, port: u16, dir_path: impl AsRef<Path>, ) -> EngineResult<()>

Send a directory and all its contents to a peer

The directory structure will be preserved on the receiving end. Files are sent with relative paths from the base directory.

pub async fn accept_transfer(&self, transfer_id: &str) -> EngineResult<String>

Accept a pending transfer

Returns the token that the sender will use to upload files. Requires the server to be running.

pub async fn reject_transfer(&self, transfer_id: &str) -> EngineResult<()>

Reject a pending transfer

Requires the server to be running.

pub async fn get_pending_transfers(&self) -> Vec<PendingTransfer>

Get all pending transfers awaiting approval

pub async fn cancel_transfer(&self, transfer_id: &str) -> EngineResult<()>

Cancel an in-progress transfer

This will stop the transfer and emit a TransferFailed event. Subsequent chunk uploads will be rejected.

pub async fn accept_all_transfers(&self) -> Vec<(String, EngineResult<String>)>

Accept all pending transfers

Returns a list of (transfer_id, result) pairs. Each result contains either the token or the error.

pub async fn reject_all_transfers(&self) -> Vec<(String, EngineResult<()>)>

Reject all pending transfers

Returns a list of (transfer_id, result) pairs.

pub fn resolve_address(address: &str) -> ResolveResult

Resolve a hostname or IP to all available addresses

pub fn resolve_address_or_err(address: &str) -> EngineResult<Vec<String>>

Resolve a hostname or IP, returning an error if resolution fails

pub fn get_network_interfaces() -> Vec<NetworkInterface>

Get all network interfaces with their IP addresses

pub async fn check_peer(&self, address: &str, port: u16) -> EngineResult<bool>

Check if a peer is reachable

pub async fn get_peer_info( &self, address: &str, port: u16, ) -> EngineResult<Value>

Get peer device information

pub async fn update_config(&mut self, config: EngineConfig)

Update the engine configuration

This updates the engine config, client config, and server state config.

pub fn config(&self) -> &EngineConfig

Get the current configuration

pub async fn add_trusted_host(&mut self, host: String)

Add a trusted host for auto-accepting transfers

pub async fn remove_trusted_host(&mut self, host: &str)

Remove a trusted host

pub fn trusted_hosts(&self) -> &[String]

Get the list of trusted hosts

Trait Implementations

impl Drop for GoshTransferEngine

fn drop(&mut self)

Executes the destructor for this type.