imap-next 0.2.0

Thin sans I/O abstraction over IMAP's distinct protocol flows
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{collections::VecDeque, convert::Infallible};

use imap_codec::{
    encode::{Encoded, Encoder, Fragment},
    imap_types::response::{Greeting, Response},
    GreetingCodec, ResponseCodec,
};

use crate::{server::ResponseHandle, Interrupt, Io};

pub struct ServerSendState {
    greeting_codec: GreetingCodec,
    response_codec: ResponseCodec,
    // FIFO queue for messages that should be sent next.
    queued_messages: VecDeque<QueuedMessage>,
    // The message that is currently being sent.
    current_message: Option<CurrentMessage>,
}

impl ServerSendState {
    pub fn new(greeting_codec: GreetingCodec, response_codec: ResponseCodec) -> Self {
        Self {
            greeting_codec,
            response_codec,
            queued_messages: VecDeque::new(),
            current_message: None,
        }
    }

    pub fn enqueue_greeting(&mut self, greeting: Greeting<'static>) {
        self.queued_messages
            .push_back(QueuedMessage::Greeting { greeting });
    }

    pub fn enqueue_response(
        &mut self,
        handle: Option<ResponseHandle>,
        response: Response<'static>,
    ) {
        self.queued_messages
            .push_back(QueuedMessage::Response { handle, response });
    }

    pub fn next(&mut self) -> Result<Option<ServerSendEvent>, Interrupt<Infallible>> {
        match self.current_message.take() {
            Some(current_message) => {
                // Continue the message that was interrupted.
                let event = match current_message {
                    CurrentMessage::Greeting { greeting } => ServerSendEvent::Greeting { greeting },
                    CurrentMessage::Response { handle, response } => {
                        ServerSendEvent::Response { handle, response }
                    }
                };
                Ok(Some(event))
            }
            None => {
                let Some(queued_message) = self.queued_messages.pop_front() else {
                    // There is currently no message that needs to be sent
                    return Ok(None);
                };

                // Creates a buffer for writing the current message
                let mut write_buffer = Vec::new();

                // Push the bytes of the message to the buffer
                let current_message = queued_message.push_to_buffer(
                    &mut write_buffer,
                    &self.greeting_codec,
                    &self.response_codec,
                );

                self.current_message = Some(current_message);

                // Interrupt the state for sending all bytes of current message
                Err(Interrupt::Io(Io::Output(write_buffer)))
            }
        }
    }
}

/// Message that is queued but not sent yet.
enum QueuedMessage {
    Greeting {
        greeting: Greeting<'static>,
    },
    Response {
        handle: Option<ResponseHandle>,
        response: Response<'static>,
    },
}

impl QueuedMessage {
    fn push_to_buffer(
        self,
        write_buffer: &mut Vec<u8>,
        greeting_codec: &GreetingCodec,
        response_codec: &ResponseCodec,
    ) -> CurrentMessage {
        match self {
            QueuedMessage::Greeting { greeting } => {
                let encoded = greeting_codec.encode(&greeting);
                push_encoded_to_buffer(write_buffer, encoded);
                CurrentMessage::Greeting { greeting }
            }
            QueuedMessage::Response { handle, response } => {
                let encoded = response_codec.encode(&response);
                push_encoded_to_buffer(write_buffer, encoded);
                CurrentMessage::Response { handle, response }
            }
        }
    }
}

fn push_encoded_to_buffer(write_buffer: &mut Vec<u8>, encoded: Encoded) {
    for fragment in encoded {
        let data = match fragment {
            Fragment::Line { data } => data,
            // Note: The server doesn't need to wait before sending a literal.
            //       Thus, non-sync literals doesn't make sense here.
            //       This is currently an issue in imap-codec,
            //       see https://github.com/duesee/imap-codec/issues/332
            Fragment::Literal { data, .. } => data,
        };
        write_buffer.extend(data);
    }
}

/// Message that is currently being sent.
enum CurrentMessage {
    Greeting {
        greeting: Greeting<'static>,
    },
    Response {
        handle: Option<ResponseHandle>,
        response: Response<'static>,
    },
}

/// Message was sent.
pub enum ServerSendEvent {
    Greeting {
        greeting: Greeting<'static>,
    },
    Response {
        handle: Option<ResponseHandle>,
        response: Response<'static>,
    },
}