flute 1.11.0

File Delivery over Unidirectional Transport (FLUTE)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use pyo3::exceptions::PyTypeError;
use pyo3::prelude::*;
use std::time::SystemTime;

use super::config;
use super::oti;

#[pyclass]
#[derive(Debug)]
pub struct Sender(crate::sender::Sender);

#[pymethods]
impl Sender {
    #[new]
    pub fn new(tsi: u64, oti: &oti::Oti, config: &config::Config) -> Self {
        Self {
            0: crate::sender::Sender::new(
                crate::core::UDPEndpoint::new(None, "224.0.0.1".to_owned(), 0), // FIXME
                tsi,
                &oti.0,
                &config.0,
            ),
        }
    }

    #[pyo3(signature = (content, content_type, content_location, oti=None))]
    fn add_object_from_buffer(
        &mut self,
        content: &[u8],
        content_type: &str,
        content_location: &str,
        oti: Option<&oti::Oti>,
    ) -> PyResult<u128> {
        let content_location =
            url::Url::parse(content_location).map_err(|e| PyTypeError::new_err(e.to_string()))?;

        let oti = oti.map(|o| o.0.clone());
        let object = crate::sender::ObjectDesc::create_from_buffer(
            content.to_vec(),
            content_type,
            &content_location,
            true,
            crate::sender::TransferConfig {
                oti,
                ..Default::default()
            },
        )
        .map_err(|e| PyTypeError::new_err(e.0.to_string()))?;

        self.0
            .add_object(0, object)
            .map_err(|e| PyTypeError::new_err(e.0.to_string()))
    }

    #[pyo3(signature = (filepath, cenc, content_type, content_location=None, oti=None))]
    fn add_file(
        &mut self,
        filepath: &str,
        cenc: u8,
        content_type: &str,
        content_location: Option<&str>,
        oti: Option<&oti::Oti>,
    ) -> PyResult<u128> {
        let cenc = cenc
            .try_into()
            .map_err(|_| PyTypeError::new_err("Unknown cenc"))?;
        let content_location = content_location.map(|content_location| {
            url::Url::parse(content_location).map_err(|e| PyTypeError::new_err(e.to_string()))
        });
        let content_location = match content_location {
            Some(Err(e)) => return Err(PyTypeError::new_err(e)),
            Some(Ok(url)) => Some(url),
            None => None,
        };

        let oti = oti.map(|o| o.0.clone());
        let object = crate::sender::ObjectDesc::create_from_file(
            std::path::Path::new(filepath),
            content_location.as_ref(),
            content_type,
            true,
            true,
            crate::sender::TransferConfig {
                cenc,
                inband_cenc: true,
                oti,
                ..Default::default()
            },
        )
        .map_err(|e| PyTypeError::new_err(e.0.to_string()))?;

        self.0
            .add_object(0, object)
            .map_err(|e| PyTypeError::new_err(e.0.to_string()))
    }

    fn remove_object(&mut self, toi: u128) -> bool {
        self.0.remove_object(toi)
    }

    fn nb_objects(&self) -> usize {
        self.0.nb_objects()
    }

    fn publish(&mut self) -> PyResult<()> {
        self.0
            .publish(SystemTime::now())
            .map_err(|e| PyTypeError::new_err(e.0.to_string()))
    }

    fn read(&mut self) -> PyResult<Option<Vec<u8>>> {
        Ok(self.0.read(SystemTime::now()))
    }
}