flute

FLUTE - File Delivery over Unidirectional Transport

Massively scalable multicast distribution solution

The library implements a unidirectional file delivery, without the need of a return channel.

RFC

This library implements the following RFCs

| RFC | Title | Link | | ------------- | ------------- | ------------- | | RFC 6726 | FLUTE - File Delivery over Unidirectional Transport | https://www.rfc-editor.org/rfc/rfc6726.html | | RFC 5775 | Asynchronous Layered Coding (ALC) Protocol Instantiation | https://www.rfc-editor.org/rfc/rfc5775.html | | RFC 5052 | Forward Error Correction (FEC) Building Block | https://www.rfc-editor.org/rfc/rfc5052 | | RFC 5510 | Reed-Solomon Forward Error Correction (FEC) Schemes | https://www.rfc-editor.org/rfc/rfc5510.html |

Application-Level Forward Erasure Correction (AL-FEC)

The following error recovery algorithm are supported

Content Encoding (CENC)

The following scheme are supported during the transmission/reception

UDP/IP Multicast files sender

Transfer files over a UDP/IP network

```rust use flute::sender::Sender; use flute::sender::ObjectDesc; use flute::sender::Cenc; use std::net::UdpSocket;

// Create UDP Socket let udpsocket = UdpSocket::bind("0.0.0.0:0").unwrap(); udpsocket.connect("224.0.0.1:3400").expect("Connection failed");

// Create FLUTE Sender let tsi = 1; let fdtid = 1; let mut sender = Sender::new(tsi, fdtid, &Default::default(), Cenc::Null);

// Add object(s) (files) to the FLUTE sender let obj = ObjectDesc::createfrombuffer(b"hello world", "text/plain", &url::Url::parse("file:///hello.txt").unwrap(), 1, None, Cenc::Null, true, None, true).unwrap(); sender.add_object(obj);

// Always call publish after adding objects sender.publish();

// Send FLUTE packets over UDP/IP while let Some(pkt) = sender.read() { udpsocket.send(&pkt).unwrap(); std::thread::sleep(std::time::Duration::frommillis(1)); }

```

UDP/IP Multicast files receiver

Receive files from a UDP/IP network

```rust use flute::receiver::{objectwriter, MultiReceiver}; use std::net::UdpSocket;

// Create UDP/IP socket to receive FLUTE pkt let udp_socket = UdpSocket::bind("224.0.0.1:3400").expect("Fail to bind");

// Create a writer able to write received files to the filesystem let writer = objectwriter::FluteWriterFS::new(&std::path::Path::new("./flutedir")) .unwraporelse(|| std::process::exit(0));

// Create a multi-receiver capable of de-multiplexing several FLUTE sessions let mut receiver = MultiReceiver::new(None, writer, None);

// Receive pkt from UDP/IP socket and push it to the FLUTE receiver let mut buf = [0; 2048]; loop { let (n, src) = udpsocket.recv_from(&mut buf).expect("Failed to receive data"); receiver.push(&buf[..n]).unwrap(); receiver.cleanup(); } ```

License: MIT