citadel_sdk/prefabs/server/
accept_file_transfer_kernel.rs

1//! Automatic File Transfer Acceptance
2//!
3//! This module provides a simple network kernel that automatically accepts and processes
4//! all incoming file transfers. It's useful for server-side implementations that need
5//! to handle file uploads without custom processing.
6//!
7//! # Features
8//! - Automatic file transfer acceptance
9//! - Silent processing of transfers
10//! - Zero configuration required
11//! - Minimal resource usage
12//! - Error handling for transfers
13//!
14//! # Example:
15//! ```rust
16//! use citadel_sdk::prelude::*;
17//! use citadel_sdk::prefabs::server::accept_file_transfer_kernel::AcceptFileTransferKernel;
18//!
19//! # fn main() -> Result<(), NetworkError> {
20//! let kernel = Box::new(AcceptFileTransferKernel::<StackedRatchet>::default());
21//! # Ok(())
22//! # }
23//! ```
24//!
25//! # Important Notes
26//! - All file transfers are automatically accepted
27//! - No customization of transfer handling
28//! - Transfers are processed silently
29//! - Errors are logged but not propagated
30//!
31//! # Related Components
32//! - [`NetKernel`]: Base trait for network kernels
33//! - [`ObjectTransferHandler`]: File transfer processing
34//! - [`NodeResult`]: Network event handling
35//!
36//! [`NetKernel`]: crate::prelude::NetKernel
37//! [`ObjectTransferHandler`]: crate::prelude::ObjectTransferHandler
38//! [`NodeResult`]: crate::prelude::NodeResult
39
40use crate::prelude::*;
41use std::marker::PhantomData;
42
43pub struct AcceptFileTransferKernel<R: Ratchet>(PhantomData<R>);
44
45impl<R: Ratchet> Default for AcceptFileTransferKernel<R> {
46    fn default() -> Self {
47        Self(Default::default())
48    }
49}
50
51#[async_trait]
52impl<R: Ratchet> NetKernel<R> for AcceptFileTransferKernel<R> {
53    fn load_remote(&mut self, _node_remote: NodeRemote<R>) -> Result<(), NetworkError> {
54        Ok(())
55    }
56
57    async fn on_start(&self) -> Result<(), NetworkError> {
58        Ok(())
59    }
60
61    async fn on_node_event_received(&self, message: NodeResult<R>) -> Result<(), NetworkError> {
62        if let NodeResult::ObjectTransferHandle(mut handle) = message {
63            let _ = handle
64                .handle
65                .exhaust_stream()
66                .await
67                .map_err(|err| NetworkError::Generic(err.into_string()))?;
68        }
69
70        Ok(())
71    }
72
73    async fn on_stop(&mut self) -> Result<(), NetworkError> {
74        Ok(())
75    }
76}