o01eg/sendxmppd-rs - Change DKXSFTDY6FVCBUAFNKOFBKKIKWQI7L7WSD3MRVEW7WFRT3R5VIFQC

Send stanzas via send queue

Created by O01eg on January 2, 2019

DKXSFTDY6FVCBUAFNKOFBKKIKWQI7L7WSD3MRVEW7WFRT3R5VIFQC

Dependencies

In channels

main

Change contents

Replacement in src/xmpp/mod.rs at line 8 [4.17]
∅:D[3.1] → [3.1:32]
```
use std::collections::HashMap;
```
[3.1]
[5.420]
```
use std::collections::{HashMap, VecDeque};
```

Insertion in src/xmpp/mod.rs at line 21 [4.17]

[2.670]

    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,

Replacement in src/xmpp/mod.rs at line 216 [4.17]

∅:D[3.1389] → [6.1228:1283]

                    state: XmppState { client, data },

[3.1389]

[3.1588]

                    state: XmppState { client, mut data },

Replacement in src/xmpp/mod.rs at line 219 [4.17]

∅:D[3.1643] → [6.1284:2575]

                client
                    .into_future()
                    .select2(stop_future)
                    .then(move |r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let xmpp = XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                };
                                Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                    Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {
                                        Ok(true) => future::ok(future::Loop::Break((
                                            xmpp,
                                            Ok(Either::A(b)),
                                        ))),
                                        Ok(false) => future::ok(future::Loop::Continue((
                                            xmpp,
                                            b,
                                            stop_condition,
                                        ))),
                                        Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),

[3.1643]

[6.2575]


                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(client.send(send_element).select2(stop_future).then(
                        move |r| match r {
                            Ok(Either::A((client, b))) => {
                                Box::new(future::ok(future::Loop::Continue((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,

Replacement in src/xmpp/mod.rs at line 232 [4.17]

∅:D[6.2614] → [6.2614:2744]

                                    Err(account) => future::err((account, Ok(Either::A(b)))),
                                }))

[6.2614]

[6.2744]

                                    b,
                                    stop_condition,
                                ))))

Replacement in src/xmpp/mod.rs at line 236 [4.17]

∅:D[6.2820] → [6.2820:2857]

                            } else {

[6.2820]

[6.2857]

                            }
                            Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Ok(Either::B(t)),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Ok(Either::B(t))))
                                }
                            })),
                            Err(Either::A((e, b))) => {
                                warn!("XMPP sending error: {}", e);

Replacement in src/xmpp/mod.rs at line 254 [4.17]

∅:D[6.2970] → [6.2970:3319]

∅:D[7.2043] → [3.3609:3644]

∅:D[6.3319] → [3.3609:3644]

∅:D[3.3609] → [3.3609:3644]

∅:D[3.3644] → [6.3320:3402]

∅:D[7.2206] → [3.3726:3759]

∅:D[6.3402] → [3.3726:3759]

∅:D[3.3726] → [3.3726:3759]

∅:D[3.3759] → [6.3403:3610]

∅:D[6.3610] → [3.3857:3936]

∅:D[8.2773] → [3.3857:3936]

∅:D[3.3936] → [8.2842:2868]

∅:D[8.2842] → [8.2842:2868]

∅:D[8.2868] → [6.3611:4185]

                        }
                        Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }),
                        Err(Either::A((e, b))) => {
                            warn!("XMPP error: {}", e.0);
                            Box::new(future::err((account, Ok(Either::A(b)))))
                        }
                        Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, data },
                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),
                    })

[6.2970]

[9.5580]

                            Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Err(e),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Err(e)))
                                }
                            })),
                        },
                    )) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                                }
                                            }
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                    } else {
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    })
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    })
                                }
                            }),
                    )
                }

Replacement in src/xmpp/mod.rs at line 516 [4.17]

∅:D[6.4553] → [6.4553:4591]

∅:D[6.4591] → [2.2940:2966]

∅:D[2.2966] → [6.4618:4692]

∅:D[6.4618] → [6.4618:4692]

    fn process_command(
        self,
        cmd: XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {

[6.4553]

[6.4692]

    fn process_command(&mut self, cmd: XmppCommand) {

Deletion in src/xmpp/mod.rs at line 520 [4.17]

∅:D[6.4838] → [2.3032:3111]

            Box::new(future::ok(self)) as Box<dyn Future<Item = _, Error = _>>

Deletion in src/xmpp/mod.rs at line 522 [4.17]

∅:D[6.4940] → [2.3112:3247]

            let XmppConnection {
                account,
                state: XmppState { client, mut data },
            } = self;

Replacement in src/xmpp/mod.rs at line 523 [4.17]

∅:D[2.3248] → [2.3248:3353]

            data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", data.counter);

[2.3248]

[2.3353]

            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);

Replacement in src/xmpp/mod.rs at line 526 [4.17]

∅:D[2.3445] → [2.3445:3489]

            let account2 = account.clone();

[2.3445]

[2.3489]

            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));

Deletion in src/xmpp/mod.rs at line 531 [4.17]
∅:D[2.3552] → [2.3552:3590]
```
            use tokio::prelude::Sink;
```

Replacement in src/xmpp/mod.rs at line 532 [4.17]

∅:D[2.3591] → [2.3591:4233]

            Box::new(
                client
                    .send(add_roster)
                    .map_err(|e| {
                        error!("Error on send adding to roster: {}", e);
                        account2
                    })
                    .and_then(move |client| {
                        data.pending_add_roster_ids
                            .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
                        future::ok(XmppConnection {
                            account,
                            state: XmppState { client, data },
                        })
                    }),
            )

[2.3591]

[6.5454]

            self.state.data.send_queue.push_back(add_roster);

Replacement in src/xmpp/mod.rs at line 578 [4.17]

∅:D[6.5994] → [6.5994:6216]

∅:D[7.5015] → [10.7143:7225]

∅:D[8.6612] → [10.7143:7225]

∅:D[6.6216] → [10.7143:7225]

∅:D[10.7143] → [10.7143:7225]

∅:D[10.7225] → [6.6217:6300]

∅:D[7.5093] → [10.7302:7335]

∅:D[8.6696] → [10.7302:7335]

∅:D[6.6300] → [10.7302:7335]

∅:D[10.7302] → [10.7302:7335]

∅:D[10.7335] → [6.6301:6478]

                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => Box::new(if let Some(cmd_recv) = f.into_inner() {
                            future::ok(future::Loop::Continue(XmppProcessState {
                                cmd_recv,
                                signal,
                                conn: conn.into(),
                            }))
                        } else {
                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,

[6.5994]

[6.6478]

                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }

Replacement in src/xmpp/mod.rs at line 592 [4.17]

∅:D[6.6591] → [2.4234:4312]

∅:D[2.4312] → [6.6670:7141]

∅:D[6.6670] → [6.6670:7141]

                                Box::new(conn.process_command(cmd).then(|r| {
                                    future::ok(future::Loop::Continue(XmppProcessState {
                                        cmd_recv,
                                        signal,
                                        conn: match r {
                                            Ok(conn) => conn.into(),
                                            Err(account) => account.into(),
                                        },
                                    }))

[6.6591]

[6.7141]

                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),

Deletion in src/xmpp/mod.rs at line 599 [4.17]

∅:D[6.7177] → [6.7177:7253]

                                    as Box<dyn Future<Item = _, Error = _>>

Replacement in src/xmpp/mod.rs at line 600 [4.17]

∅:D[6.7290] → [6.7290:7368]

                                Box::new(future::ok(future::Loop::Break(())))

[6.7290]

[6.7368]

                                future::ok(future::Loop::Break(()))

Replacement in src/xmpp/mod.rs at line 603 [4.17]

∅:D[8.9168] → [6.7399:7499]

                        Err(_) => Box::new(future::err(format_err!("Command receiver is broken"))),

[8.9168]

[6.7499]

                        Err(_) => future::err(format_err!("Command receiver is broken")),

Replacement in src/xmpp/mod.rs at line 605 [4.17]

∅:D[6.7522] → [6.7522:7582]

                    Err((account, r)) => Box::new(match r {

[6.7522]

[6.7582]

                    Err((account, r)) => match r {

Replacement in src/xmpp/mod.rs at line 630 [4.17]
∅:D[6.8862] → [6.8862:8886]
```
                    }),
```
[6.8862]
[6.8886]
```
                    },
```