O01eg/sendxmppd-rs - Change UIXIQHDY7E4DLLRQP4ATXF625QC4KGMHWOV24UEQ6WD7G2IPM4HAC

Wait for commands via new processing code

Created by O01eg on December 31, 2018

UIXIQHDY7E4DLLRQP4ATXF625QC4KGMHWOV24UEQ6WD7G2IPM4HAC

Dependencies

In channels

main

Change contents

Deletion in src/xmpp/mod.rs at line 7 [4.17]
∅:D[3.48] → [2.273:305]
```
use std::collections::HashMap;
```
Deletion in src/xmpp/mod.rs at line 14 [4.17]
∅:D[2.393] → [2.393:428]
```
    roster: HashMap<jid::Jid, ()>,
```

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

[2.577]

[5.666]

        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: std::rc::Rc::new(from),
            state: None,

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

∅:D[6.129] → [5.683:772]

impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {

[6.129]

[5.772]

impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {

Replacement in src/xmpp/mod.rs at line 47 [4.17]
∅:D[7.182] → [8.479:527]
∅:D[9.478] → [8.479:527]
∅:D[10.182] → [8.479:527]
∅:D[11.153] → [8.479:527]
∅:D[12.182] → [8.479:527]
∅:D[5.802] → [8.479:527]
∅:D[6.478] → [8.479:527]
∅:D[4.453] → [8.479:527]
```
            account: std::rc::Rc::new(account),
```
[5.802]
[2.578]
```
            account: from,
```
Insertion in src/xmpp/mod.rs at line 51 [4.17]
[4.515]
[4.515]
```
}
```
Insertion in src/xmpp/mod.rs at line 53 [4.17]
[4.516]
[4.516]
```
impl MaybeXmppConnection {
```

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

∅:D[4.554] → [5.830:876]

    /// don't connect if stop_future resolved

[4.554]

[5.876]

    /// don't connect only if stop_future resolved

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

∅:D[13.435] → [2.1067:1305]

                                            state: XmppState {
                                                client,
                                                roster: HashMap::new(),
                                            },

[13.435]

[13.494]

                                            state: XmppState { client },

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

[2.1403]

                                        .map(|(conn, _)| conn)

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

∅:D[2.1468] → [2.1468:1838]

                                        .and_then(|(conn, r)| match r {
                                            Ok(Either::A(_)) => future::ok(conn),
                                            Ok(Either::B(_)) => future::err(conn.account),
                                            Err(_e) => future::err(conn.account),
                                        })

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

∅:D[5.3983] → [2.2131:2282]

    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future

[5.3983]

[5.4019]

    /// or stop future was resolved

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

∅:D[5.4137] → [14.286:407]

        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),

[5.4137]

[5.4319]

        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),

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

∅:D[5.4375] → [2.2283:2339]

        S: FnMut(&mut Self, Event) -> Result<bool, ()>,

[5.4375]

[5.4476]

        E: Into<failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,

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

∅:D[5.4612] → [2.2340:2566]

∅:D[2.2566] → [15.534:708]

∅:D[16.539] → [15.534:708]

∅:D[15.534] → [15.534:708]

∅:D[15.708] → [2.2567:2636]

∅:D[2.2636] → [15.777:907]

∅:D[16.587] → [15.777:907]

∅:D[15.777] → [15.777:907]

∅:D[15.907] → [2.2637:3025]

                let XmppConnection {
                    state: XmppState { client, roster },
                    account,
                } = xmpp;
                client.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            };
                            xmpp.xmpp_processing(&event);
                            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)))

[5.4612]

[2.3025]

                let XmppConnection { state, account } = xmpp;
                state
                    .client
                    .into_future()
                    .select2(stop_future)
                    .then(|r| match r {
                        Ok(Either::A(((event, client), b))) => {
                            if let Some(event) = event {
                                let mut xmpp = XmppConnection {
                                    state: XmppState { client },
                                    account,
                                };
                                xmpp.xmpp_processing(&event);
                                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, Err(e))),

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

∅:D[2.3059] → [2.3059:3149]

                                Err(_e) => future::err((xmpp.account, Ok(Either::A(b)))),

[2.3059]

[17.3255]

                            } else {
                                future::err((account, Ok(Either::A(b))))

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

∅:D[17.3285] → [15.1376:1409]

                        } else {

[17.3285]

[15.1409]

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

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

∅:D[17.3311] → [15.1479:1548]

∅:D[15.1548] → [2.3150:3213]

∅:D[2.3213] → [15.1611:1672]

∅:D[16.650] → [15.1611:1672]

∅:D[15.1611] → [15.1611:1672]

∅:D[15.1672] → [2.3214:3416]

∅:D[2.3416] → [15.1874:2058]

∅:D[16.718] → [15.1874:2058]

∅:D[15.1874] → [15.1874:2058]

                    }
                    Ok(Either::B((t, a))) => {
                        if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState { client, roster },
                                    account,
                                },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))

[17.3311]

[18.4505]

                        Err(Either::B((e, a))) => {
                            if let Some(client) = a.into_inner() {
                                future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client },
                                        account,
                                    },
                                    Err(e.into()),
                                )))
                            } else {
                                future::err((account, Err(e.into())))
                            }

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

∅:D[15.2248] → [15.2248:2270]

∅:D[15.2270] → [2.3417:3606]

∅:D[2.3606] → [15.2270:2318]

∅:D[16.808] → [15.2270:2318]

∅:D[15.2270] → [15.2270:2318]

∅:D[15.2318] → [2.3607:3670]

∅:D[2.3670] → [15.2381:2442]

∅:D[16.871] → [15.2381:2442]

∅:D[15.2381] → [15.2381:2442]

∅:D[15.2442] → [2.3671:3873]

∅:D[2.3873] → [14.743:783]

∅:D[16.939] → [14.743:783]

∅:D[14.783] → [15.2691:2756]

∅:D[15.2691] → [15.2691:2756]

∅:D[15.2756] → [14.784:843]

∅:D[7.2511] → [18.5513:5539]

∅:D[17.4667] → [18.5513:5539]

∅:D[19.3907] → [18.5513:5539]

∅:D[10.2511] → [18.5513:5539]

∅:D[14.843] → [18.5513:5539]

∅:D[13.2108] → [18.5513:5539]

∅:D[5.6612] → [18.5513:5539]

∅:D[15.2822] → [18.5513:5539]

∅:D[20.1938] → [18.5513:5539]

∅:D[6.6307] → [18.5513:5539]

∅:D[21.1272] → [18.5513:5539]

∅:D[18.5513] → [18.5513:5539]

∅:D[18.5539] → [15.2823:2864]

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

[18.4531]

[18.5580]

})

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

∅:D[5.6691] → [2.3874:4011]

    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {

[5.6691]

[2.4011]

    /// returns error if something went wrong
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {

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

∅:D[2.4339] → [2.4339:4363]

                Err(())

[2.4339]

[2.4363]

                Err(format_err!("Disconnected while online"))

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

∅:D[2.4394] → [2.4394:4471]

    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {

[2.4394]

[2.4471]

    fn process_initial_roster(&mut self, event: Event) -> Result<bool, failure::Error> {

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

∅:D[2.4859] → [2.4859:4978]

                                    error!("Get error instead of roster");
                                    Err(())

[2.4859]

[2.4978]

                                    Err(format_err!("Get error instead of roster"))

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

∅:D[2.5637] → [2.5637:5865]

                                        }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())

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

[2.5907]

                                        Err(e) => Err(format_err!("Cann't parse roster: {}", e)),

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

∅:D[2.5945] → [2.5945:6134]

                                }
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())

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

[2.6168]

                                _ => Err(format_err!("Unknown result of roster")),

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

∅:D[2.6299] → [2.6299:6387]

                        error!("Iq stanza without id");
                        Err(())

[2.6299]

[5.8819]

                        Err(format_err!("Iq stanza without id"))

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

∅:D[2.6475] → [2.6475:6551]

            error!("Wrong event while waiting roster");
            Err(())

[2.6475]

[2.6551]

            Err(format_err!("Wrong event while waiting roster"))

Insertion in src/xmpp/mod.rs at line 280 [4.17]
[2.6747]
[2.6747]
```
        E: Into<failure::Error>,
```

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

∅:D[2.6753] → [2.6753:6870]

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

[2.6753]

[2.6870]

        let XmppConnection { account, state } = self;

Replacement in src/xmpp/mod.rs at line 289 [4.17]
∅:D[2.7065] → [2.7065:7080]
```
        client
```
[2.7065]
[2.7080]
```
        state
            .client
```

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

∅:D[2.7201] → [2.7201:7226]

                account2

[2.7201]

[2.7226]

                (account2, Err(failure::SyncFailure::new(e).into()))

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

∅:D[2.7312] → [2.7312:7369]

                    state: XmppState { client, roster },

[2.7312]

[2.7369]

                    state: XmppState { client },

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

∅:D[2.7497] → [2.7497:7777]

∅:D[2.7777] → [14.1997:2016]

∅:D[5.8841] → [14.1997:2016]

                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })

[2.7497]

[2.7778]

            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),

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

∅:D[2.8011] → [2.8011:8128]

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

[2.8011]

[5.10624]

        let XmppConnection { account, state } = self;

Replacement in src/xmpp/mod.rs at line 333 [4.17]
∅:D[2.8183] → [2.8183:8198]
```
        client
```
[2.8183]
[2.8198]
```
        state
            .client
```

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

∅:D[2.8315] → [2.8315:8340]

                account2

[2.8315]

[2.8340]

                (account2, Err(failure::SyncFailure::new(e).into()))

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

∅:D[2.8426] → [2.8426:8483]

                    state: XmppState { client, roster },

[2.8426]

[2.8483]

                    state: XmppState { client },

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

∅:D[2.9105] → [2.9105:9220]

                            error!("Wrong event while waiting self-presence");
                            Err(())

[2.9105]

[2.9220]

                            Err(format_err!("Wrong event while waiting self-presence"))

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

∅:D[2.9320] → [2.9320:9600]

∅:D[2.9600] → [14.2485:2504]

∅:D[14.2485] → [14.2485:2504]

                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })

[2.9320]

[2.9601]

            })
            .then(|r| match r {
                Err((account, _e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),

Replacement in src/xmpp/mod.rs at line 376 [4.17]
∅:D[4.3817] → [17.10286:10311]
```
struct XmppState<F, S> {
```
[4.3817]
[22.86]
```
struct XmppProcessState<F, S> {
```

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

∅:D[4.3920] → [17.10312:10444]

impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
        XmppState {

[4.3920]

[4.4058]

impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {

Replacement in src/xmpp/mod.rs at line 402 [4.17]
∅:D[4.4357] → [5.12381:12431]
```
    let conn = MaybeXmppConnection::new(account);
```
[4.4357]
[4.4526]
```
    let conn = account.into();
```

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

∅:D[4.4527] → [17.10445:10535]

    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {

[4.4527]

[4.4617]

    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {

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

∅:D[4.4692] → [5.12432:12500]

∅:D[18.8720] → [4.4761:4955]

∅:D[7.6088] → [4.4761:4955]

∅:D[19.6123] → [4.4761:4955]

∅:D[10.5985] → [4.4761:4955]

∅:D[5.12500] → [4.4761:4955]

∅:D[20.5884] → [4.4761:4955]

∅:D[6.9107] → [4.4761:4955]

∅:D[4.4761] → [4.4761:4955]

∅:D[4.4955] → [3.595:675]

∅:D[3.675] → [5.12501:12582]

∅:D[18.8802] → [3.731:755]

∅:D[7.6145] → [3.731:755]

∅:D[19.6205] → [3.731:755]

∅:D[10.6042] → [3.731:755]

∅:D[5.12582] → [3.731:755]

∅:D[20.5941] → [3.731:755]

∅:D[6.9189] → [3.731:755]

∅:D[3.731] → [3.731:755]

∅:D[23.723] → [4.5120:5146]

∅:D[24.482] → [4.5120:5146]

∅:D[3.755] → [4.5120:5146]

∅:D[4.5120] → [4.5120:5146]

∅:D[4.5146] → [5.12583:12779]

∅:D[5.12779] → [17.10536:10614]

∅:D[17.10614] → [5.12857:13049]

∅:D[13.6240] → [5.12857:13049]

∅:D[5.12857] → [5.12857:13049]

∅:D[5.13049] → [2.9617:9698]

        conn.connect(signal.clone())
            .and_then(|conn| {
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        format_err!("Receive cmd error")
                    })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
            .then(|r| {
                match r {
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))

[4.4692]

[5.13130]

        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
                    Ok((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 426 [4.17]

∅:D[5.13156] → [7.7148:7170]

∅:D[7.7148] → [7.7148:7170]

∅:D[7.7170] → [5.13157:13189]

∅:D[18.9409] → [4.6240:6342]

∅:D[7.7219] → [4.6240:6342]

∅:D[19.6812] → [4.6240:6342]

∅:D[10.7116] → [4.6240:6342]

∅:D[5.13189] → [4.6240:6342]

∅:D[20.7036] → [4.6240:6342]

∅:D[6.9796] → [4.6240:6342]

∅:D[4.6240] → [4.6240:6342]

∅:D[4.6342] → [2.9699:9738]

∅:D[18.9472] → [4.6572:6627]

∅:D[7.7356] → [4.6572:6627]

∅:D[2.9738] → [4.6572:6627]

∅:D[17.10654] → [4.6572:6627]

∅:D[19.6875] → [4.6572:6627]

∅:D[25.4095] → [4.6572:6627]

∅:D[26.331] → [4.6572:6627]

∅:D[27.3926] → [4.6572:6627]

∅:D[23.954] → [4.6572:6627]

∅:D[10.7253] → [4.6572:6627]

∅:D[14.4726] → [4.6572:6627]

∅:D[13.6303] → [4.6572:6627]

∅:D[5.13229] → [4.6572:6627]

∅:D[20.7173] → [4.6572:6627]

∅:D[3.892] → [4.6572:6627]

∅:D[6.9859] → [4.6572:6627]

∅:D[4.6572] → [4.6572:6627]

∅:D[4.6627] → [3.893:900]

∅:D[3.900] → [2.9739:10245]

                    }
                    Err(e) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                        future::err(e)
                    }
                }
            })
    })
    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
            Box::new(future::ok(()))
        }

[5.13156]

[2.10245]

                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                info!("Got command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                    Err((account, 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: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                })
        })