AssetServer

fastnet::assets

Struct AssetServer 

Source 
pub struct AssetServer { /* private fields */ }
Expand description

Server-side asset management.

Implementations§

Source§

impl AssetServer

Source

pub fn new(config: AssetConfig) -> Self

Create a new asset server.

Examples found in repository?
examples/asset_transfer.rs (line 38)
21async fn main() -> io::Result<()> {
22    println!("╔════════════════════════════════════════╗");
23    println!("║    FastNet Asset Transfer Example      ║");
24    println!("╚════════════════════════════════════════╝");
25    println!();
26    
27    // Create test file
28    let test_file = "/tmp/fastnet_test_asset.bin";
29    let output_file = "/tmp/fastnet_received_asset.bin";
30    
31    println!("1. Creating test file...");
32    create_test_file(test_file, 256 * 1024)?; // 256 KB
33    println!("   Created: {} (256 KB)", test_file);
34    println!();
35    
36    // Server: Register asset
37    println!("2. Registering asset on server...");
38    let mut server = AssetServer::new(AssetConfig::default());
39    let info = server.register("test-asset", test_file).await?;
40    println!("   Name: {}", info.name);
41    println!("   Size: {} bytes", info.size);
42    println!("   Chunks: {}", info.chunk_count);
43    println!("   Hash: {:?}...", &info.hash[..8]);
44    println!();
45    
46    // Client: Request download
47    println!("3. Client requesting asset...");
48    let mut client = AssetClient::new();
49    
50    // Simulate request/response
51    let peer_id = Uuid::new_v4();
52    let (transfer_id, asset_info) = server.handle_request(peer_id, "test-asset")
53        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Asset not found"))?;
54    
55    println!("   Transfer ID: {}", transfer_id);
56    client.start_download(transfer_id, asset_info.clone(), output_file)?;
57    println!();
58    
59    // Transfer chunks
60    println!("4. Transferring chunks...");
61    let mut chunks_sent = 0;
62    
63    while let Some(chunk) = server.get_next_chunk(transfer_id)? {
64        chunks_sent += 1;
65        
66        // Simulate network transfer
67        let complete = client.receive_chunk(chunk)?;
68        
69        // Print progress
70        if let Some(progress) = client.get_progress(transfer_id) {
71            print!("\r   Progress: {:.1}% ({}/{} chunks)", 
72                progress * 100.0, chunks_sent, asset_info.chunk_count);
73            io::stdout().flush()?;
74        }
75        
76        if complete {
77            println!();
78            break;
79        }
80    }
81    
82    // Process events
83    println!();
84    println!("5. Processing events...");
85    for event in client.poll_events() {
86        match event {
87            AssetEvent::Progress { received, total, .. } => {
88                println!("   Progress: {} / {} bytes", received, total);
89            }
90            AssetEvent::Completed { path, .. } => {
91                println!("   ✅ Transfer complete: {:?}", path);
92            }
93            AssetEvent::Failed { error, .. } => {
94                println!("   ❌ Transfer failed: {}", error);
95            }
96            _ => {}
97        }
98    }
99    
100    // Verify files match
101    println!();
102    println!("6. Verifying integrity...");
103    let original = std::fs::read(test_file)?;
104    let received = std::fs::read(output_file)?;
105    
106    if original == received {
107        println!("   ✅ Files match! Transfer verified.");
108    } else {
109        println!("   ❌ Files don't match! Transfer failed.");
110    }
111    
112    // Cleanup
113    println!();
114    println!("7. Cleanup...");
115    std::fs::remove_file(test_file)?;
116    std::fs::remove_file(output_file)?;
117    println!("   Temporary files removed.");
118    
119    println!();
120    println!("╔════════════════════════════════════════╗");
121    println!("║         Test Complete!                 ║");
122    println!("╚════════════════════════════════════════╝");
123    
124    Ok(())
125}
Source

pub async fn register(&mut self, name: &str, path: &str) -> Result<AssetInfo>

Register an asset for serving.

§Arguments
  • name - Unique name clients will use to request this asset
  • path - Local file path
Examples found in repository?
examples/asset_transfer.rs (line 39)
21async fn main() -> io::Result<()> {
22    println!("╔════════════════════════════════════════╗");
23    println!("║    FastNet Asset Transfer Example      ║");
24    println!("╚════════════════════════════════════════╝");
25    println!();
26    
27    // Create test file
28    let test_file = "/tmp/fastnet_test_asset.bin";
29    let output_file = "/tmp/fastnet_received_asset.bin";
30    
31    println!("1. Creating test file...");
32    create_test_file(test_file, 256 * 1024)?; // 256 KB
33    println!("   Created: {} (256 KB)", test_file);
34    println!();
35    
36    // Server: Register asset
37    println!("2. Registering asset on server...");
38    let mut server = AssetServer::new(AssetConfig::default());
39    let info = server.register("test-asset", test_file).await?;
40    println!("   Name: {}", info.name);
41    println!("   Size: {} bytes", info.size);
42    println!("   Chunks: {}", info.chunk_count);
43    println!("   Hash: {:?}...", &info.hash[..8]);
44    println!();
45    
46    // Client: Request download
47    println!("3. Client requesting asset...");
48    let mut client = AssetClient::new();
49    
50    // Simulate request/response
51    let peer_id = Uuid::new_v4();
52    let (transfer_id, asset_info) = server.handle_request(peer_id, "test-asset")
53        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Asset not found"))?;
54    
55    println!("   Transfer ID: {}", transfer_id);
56    client.start_download(transfer_id, asset_info.clone(), output_file)?;
57    println!();
58    
59    // Transfer chunks
60    println!("4. Transferring chunks...");
61    let mut chunks_sent = 0;
62    
63    while let Some(chunk) = server.get_next_chunk(transfer_id)? {
64        chunks_sent += 1;
65        
66        // Simulate network transfer
67        let complete = client.receive_chunk(chunk)?;
68        
69        // Print progress
70        if let Some(progress) = client.get_progress(transfer_id) {
71            print!("\r   Progress: {:.1}% ({}/{} chunks)", 
72                progress * 100.0, chunks_sent, asset_info.chunk_count);
73            io::stdout().flush()?;
74        }
75        
76        if complete {
77            println!();
78            break;
79        }
80    }
81    
82    // Process events
83    println!();
84    println!("5. Processing events...");
85    for event in client.poll_events() {
86        match event {
87            AssetEvent::Progress { received, total, .. } => {
88                println!("   Progress: {} / {} bytes", received, total);
89            }
90            AssetEvent::Completed { path, .. } => {
91                println!("   ✅ Transfer complete: {:?}", path);
92            }
93            AssetEvent::Failed { error, .. } => {
94                println!("   ❌ Transfer failed: {}", error);
95            }
96            _ => {}
97        }
98    }
99    
100    // Verify files match
101    println!();
102    println!("6. Verifying integrity...");
103    let original = std::fs::read(test_file)?;
104    let received = std::fs::read(output_file)?;
105    
106    if original == received {
107        println!("   ✅ Files match! Transfer verified.");
108    } else {
109        println!("   ❌ Files don't match! Transfer failed.");
110    }
111    
112    // Cleanup
113    println!();
114    println!("7. Cleanup...");
115    std::fs::remove_file(test_file)?;
116    std::fs::remove_file(output_file)?;
117    println!("   Temporary files removed.");
118    
119    println!();
120    println!("╔════════════════════════════════════════╗");
121    println!("║         Test Complete!                 ║");
122    println!("╚════════════════════════════════════════╝");
123    
124    Ok(())
125}
Source

pub fn get_asset_info(&self, name: &str) -> Option<&AssetInfo>

Get info about a registered asset.

Source

pub fn handle_request( &mut self, peer_id: PeerId, name: &str, ) -> Option<(TransferId, AssetInfo)>

Handle an asset request from a peer.

Examples found in repository?
examples/asset_transfer.rs (line 52)
21async fn main() -> io::Result<()> {
22    println!("╔════════════════════════════════════════╗");
23    println!("║    FastNet Asset Transfer Example      ║");
24    println!("╚════════════════════════════════════════╝");
25    println!();
26    
27    // Create test file
28    let test_file = "/tmp/fastnet_test_asset.bin";
29    let output_file = "/tmp/fastnet_received_asset.bin";
30    
31    println!("1. Creating test file...");
32    create_test_file(test_file, 256 * 1024)?; // 256 KB
33    println!("   Created: {} (256 KB)", test_file);
34    println!();
35    
36    // Server: Register asset
37    println!("2. Registering asset on server...");
38    let mut server = AssetServer::new(AssetConfig::default());
39    let info = server.register("test-asset", test_file).await?;
40    println!("   Name: {}", info.name);
41    println!("   Size: {} bytes", info.size);
42    println!("   Chunks: {}", info.chunk_count);
43    println!("   Hash: {:?}...", &info.hash[..8]);
44    println!();
45    
46    // Client: Request download
47    println!("3. Client requesting asset...");
48    let mut client = AssetClient::new();
49    
50    // Simulate request/response
51    let peer_id = Uuid::new_v4();
52    let (transfer_id, asset_info) = server.handle_request(peer_id, "test-asset")
53        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Asset not found"))?;
54    
55    println!("   Transfer ID: {}", transfer_id);
56    client.start_download(transfer_id, asset_info.clone(), output_file)?;
57    println!();
58    
59    // Transfer chunks
60    println!("4. Transferring chunks...");
61    let mut chunks_sent = 0;
62    
63    while let Some(chunk) = server.get_next_chunk(transfer_id)? {
64        chunks_sent += 1;
65        
66        // Simulate network transfer
67        let complete = client.receive_chunk(chunk)?;
68        
69        // Print progress
70        if let Some(progress) = client.get_progress(transfer_id) {
71            print!("\r   Progress: {:.1}% ({}/{} chunks)", 
72                progress * 100.0, chunks_sent, asset_info.chunk_count);
73            io::stdout().flush()?;
74        }
75        
76        if complete {
77            println!();
78            break;
79        }
80    }
81    
82    // Process events
83    println!();
84    println!("5. Processing events...");
85    for event in client.poll_events() {
86        match event {
87            AssetEvent::Progress { received, total, .. } => {
88                println!("   Progress: {} / {} bytes", received, total);
89            }
90            AssetEvent::Completed { path, .. } => {
91                println!("   ✅ Transfer complete: {:?}", path);
92            }
93            AssetEvent::Failed { error, .. } => {
94                println!("   ❌ Transfer failed: {}", error);
95            }
96            _ => {}
97        }
98    }
99    
100    // Verify files match
101    println!();
102    println!("6. Verifying integrity...");
103    let original = std::fs::read(test_file)?;
104    let received = std::fs::read(output_file)?;
105    
106    if original == received {
107        println!("   ✅ Files match! Transfer verified.");
108    } else {
109        println!("   ❌ Files don't match! Transfer failed.");
110    }
111    
112    // Cleanup
113    println!();
114    println!("7. Cleanup...");
115    std::fs::remove_file(test_file)?;
116    std::fs::remove_file(output_file)?;
117    println!("   Temporary files removed.");
118    
119    println!();
120    println!("╔════════════════════════════════════════╗");
121    println!("║         Test Complete!                 ║");
122    println!("╚════════════════════════════════════════╝");
123    
124    Ok(())
125}
Source

pub fn get_next_chunk( &mut self, transfer_id: TransferId, ) -> Result<Option<AssetChunk>>

Get the next chunk for a transfer.

Examples found in repository?
examples/asset_transfer.rs (line 63)
21async fn main() -> io::Result<()> {
22    println!("╔════════════════════════════════════════╗");
23    println!("║    FastNet Asset Transfer Example      ║");
24    println!("╚════════════════════════════════════════╝");
25    println!();
26    
27    // Create test file
28    let test_file = "/tmp/fastnet_test_asset.bin";
29    let output_file = "/tmp/fastnet_received_asset.bin";
30    
31    println!("1. Creating test file...");
32    create_test_file(test_file, 256 * 1024)?; // 256 KB
33    println!("   Created: {} (256 KB)", test_file);
34    println!();
35    
36    // Server: Register asset
37    println!("2. Registering asset on server...");
38    let mut server = AssetServer::new(AssetConfig::default());
39    let info = server.register("test-asset", test_file).await?;
40    println!("   Name: {}", info.name);
41    println!("   Size: {} bytes", info.size);
42    println!("   Chunks: {}", info.chunk_count);
43    println!("   Hash: {:?}...", &info.hash[..8]);
44    println!();
45    
46    // Client: Request download
47    println!("3. Client requesting asset...");
48    let mut client = AssetClient::new();
49    
50    // Simulate request/response
51    let peer_id = Uuid::new_v4();
52    let (transfer_id, asset_info) = server.handle_request(peer_id, "test-asset")
53        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Asset not found"))?;
54    
55    println!("   Transfer ID: {}", transfer_id);
56    client.start_download(transfer_id, asset_info.clone(), output_file)?;
57    println!();
58    
59    // Transfer chunks
60    println!("4. Transferring chunks...");
61    let mut chunks_sent = 0;
62    
63    while let Some(chunk) = server.get_next_chunk(transfer_id)? {
64        chunks_sent += 1;
65        
66        // Simulate network transfer
67        let complete = client.receive_chunk(chunk)?;
68        
69        // Print progress
70        if let Some(progress) = client.get_progress(transfer_id) {
71            print!("\r   Progress: {:.1}% ({}/{} chunks)", 
72                progress * 100.0, chunks_sent, asset_info.chunk_count);
73            io::stdout().flush()?;
74        }
75        
76        if complete {
77            println!();
78            break;
79        }
80    }
81    
82    // Process events
83    println!();
84    println!("5. Processing events...");
85    for event in client.poll_events() {
86        match event {
87            AssetEvent::Progress { received, total, .. } => {
88                println!("   Progress: {} / {} bytes", received, total);
89            }
90            AssetEvent::Completed { path, .. } => {
91                println!("   ✅ Transfer complete: {:?}", path);
92            }
93            AssetEvent::Failed { error, .. } => {
94                println!("   ❌ Transfer failed: {}", error);
95            }
96            _ => {}
97        }
98    }
99    
100    // Verify files match
101    println!();
102    println!("6. Verifying integrity...");
103    let original = std::fs::read(test_file)?;
104    let received = std::fs::read(output_file)?;
105    
106    if original == received {
107        println!("   ✅ Files match! Transfer verified.");
108    } else {
109        println!("   ❌ Files don't match! Transfer failed.");
110    }
111    
112    // Cleanup
113    println!();
114    println!("7. Cleanup...");
115    std::fs::remove_file(test_file)?;
116    std::fs::remove_file(output_file)?;
117    println!("   Temporary files removed.");
118    
119    println!();
120    println!("╔════════════════════════════════════════╗");
121    println!("║         Test Complete!                 ║");
122    println!("╚════════════════════════════════════════╝");
123    
124    Ok(())
125}
Source

pub fn poll_events(&mut self) -> Vec<AssetEvent>

Get pending events.

Source

pub fn pause_transfer(&mut self, transfer_id: TransferId) -> bool

Pause a transfer.

Source

pub fn resume_transfer(&mut self, transfer_id: TransferId) -> bool

Resume a paused transfer.

Source

pub fn cancel_transfer(&mut self, transfer_id: TransferId) -> bool

Cancel a transfer.

Source

pub fn get_chunk( &self, transfer_id: TransferId, chunk_index: u32, ) -> Result<Option<AssetChunk>>

Get a specific chunk by index (for retries/resumes).

Source

pub fn get_transfer_stats( &self, transfer_id: TransferId, ) -> Option<TransferStats>

Get transfer statistics.

Source

pub fn list_transfers(&self) -> Vec<TransferId> ⓘ

List all active transfers.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V