ggemini 0.20.0

Glib/Gio-oriented network API for Gemini protocol
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

pub mod error;
pub mod size;

pub use error::Error;
pub use size::Size;

use gio::{
    Cancellable, FileOutputStream, IOStream,
    prelude::{IOStreamExt, InputStreamExt, OutputStreamExtManual},
};
use glib::{Bytes, Priority, object::IsA};

/// Asynchronously move all bytes from [IOStream](https://docs.gtk.org/gio/class.IOStream.html)
/// to [FileOutputStream](https://docs.gtk.org/gio/class.FileOutputStream.html)
/// * require `IOStream` reference to keep `Connection` active in async thread
pub fn from_stream_async(
    io_stream: impl IsA<IOStream>,
    file_output_stream: FileOutputStream,
    cancellable: Cancellable,
    priority: Priority,
    mut size: Size,
    (on_chunk, on_complete): (
        impl Fn(Bytes, usize) + 'static, // on_chunk
        impl FnOnce(Result<(FileOutputStream, usize), Error>) + 'static, // on_complete
    ),
) {
    io_stream.input_stream().read_bytes_async(
        size.chunk,
        priority,
        Some(&cancellable.clone()),
        move |result| match result {
            Ok(bytes) => {
                size.total += bytes.len();
                on_chunk(bytes.clone(), size.total);

                if let Some(limit) = size.limit
                    && size.total > limit
                {
                    return on_complete(Err(Error::BytesTotal(size.total, limit)));
                }

                if bytes.is_empty() {
                    return on_complete(Ok((file_output_stream, size.total)));
                }

                // Make sure **all bytes** sent to the destination
                // > A partial write is performed with the size of a message block, which is 16kB
                // > https://docs.openssl.org/3.0/man3/SSL_write/#notes
                file_output_stream.clone().write_all_async(
                    bytes,
                    priority,
                    Some(&cancellable.clone()),
                    move |result| match result {
                        Ok(_) => from_stream_async(
                            io_stream,
                            file_output_stream,
                            cancellable,
                            priority,
                            size,
                            (on_chunk, on_complete),
                        ),
                        Err((b, e)) => on_complete(Err(Error::OutputStream(b, e))),
                    },
                )
            }
            Err(e) => on_complete(Err(Error::InputStream(e))),
        },
    )
}