o01eg/sendxmppd-rs - Change UMTLHH77LGABTVKULH6ONVSBTMSFGH3CJ6GPNTFWH73AWNJZV6LQC

Process commands in the separate function

Created by O01eg on January 1, 2019

UMTLHH77LGABTVKULH6ONVSBTMSFGH3CJ6GPNTFWH73AWNJZV6LQC

Dependencies

In channels

main

Change contents

Deletion in src/xmpp/mod.rs at line 7 [4.17]
∅:D[3.48] → [2.0:32]
```
use std::collections::HashMap;
```
Deletion in src/xmpp/mod.rs at line 14 [4.17]
∅:D[5.393] → [2.33:68]
```
    roster: HashMap<jid::Jid, ()>,
```

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

∅:D[6.19] → [2.69:158]

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

[6.19]

[6.132]

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

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

∅:D[6.162] → [2.159:207]

            account: std::rc::Rc::new(account),

[6.162]

[6.207]

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

Insertion in src/xmpp/mod.rs at line 51 [4.17]
[7.682]
[8.128]
```
}
```
Insertion in src/xmpp/mod.rs at line 53 [4.17]
[8.129]
[4.516]
```
impl MaybeXmppConnection {
```

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

∅:D[4.554] → [2.208:254]

    /// don't connect if stop_future resolved

[4.554]

[7.876]

    /// don't connect only if stop_future resolved

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

∅:D[9.435] → [2.255:493]

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

[9.435]

[9.494]

                                            state: XmppState { client },

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

[5.1403]

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

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

∅:D[5.1468] → [2.494:864]

                                        .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 125 [4.17]

∅:D[7.3788] → [2.865:1000]

    fn xmpp_processing(
        self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {

[7.3788]

[5.2073]

    fn xmpp_processing(&mut self, event: &Event) {

Deletion in src/xmpp/mod.rs at line 127 [4.17]
∅:D[5.2124] → [2.1001:1026]
```
        future::ok(self)
```

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

∅:D[7.3983] → [2.1027:1178]

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

[7.3983]

[7.4019]

    /// or stop future was resolved

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

∅:D[7.4137] → [2.1179:1300]

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

[7.4137]

[7.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 144 [4.17]

∅:D[7.4335] → [2.1301:1457]

        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,

[7.4335]

[7.4476]

        F: Future<Item = T, Error = E>,
        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[7.4612] → [2.1458:2169]

                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 xmpp = XmppConnection {
                                state: XmppState { client, roster },
                                account,
                            };
                            Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                Ok(mut xmpp) => match stop_condition(&mut xmpp, event) {

[7.4612]

[6.1639]

                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) {

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

∅:D[6.2096] → [2.2170:2573]

                                    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)))))

[6.2096]

[6.2940]

                                    Err(e) => future::err((xmpp.account, Err(e))),
                                }
                            } else {
                                future::err((account, Ok(Either::A(b))))
                            }
                        }
                        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);
                            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 },
                                        account,
                                    },
                                    Err(e.into()),
                                )))
                            } else {
                                future::err((account, Err(e.into())))
                            }

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

∅:D[6.2966] → [2.2574:3851]

                    }
                    Ok(Either::B((t, a))) => Box::new(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))))
                    }),
                    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, roster },
                                account,
                            },
                            Err(e),
                        )))
                    } else {
                        future::err((account, Err(e)))
                    }),
                })

[6.2966]

[10.5580]

})

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

∅:D[7.6691] → [2.3852:3989]

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

[7.6691]

[5.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[5.4339] → [2.3990:4014]

                Err(())

[5.4339]

[5.4363]

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

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

∅:D[5.4394] → [2.4015:4092]

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

[5.4394]

[5.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[5.4859] → [2.4093:4212]

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

[5.4859]

[5.4978]

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

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

∅:D[5.5865] → [5.5865:5907]

∅:D[5.5907] → [2.4213:4399]

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

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

[2.4441]

[5.5907]

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

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

∅:D[5.6134] → [5.6134:6168]

∅:D[5.6168] → [2.4442:4597]

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

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

[2.4631]

[5.6168]

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

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

∅:D[5.6299] → [2.4632:4720]

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

[5.6299]

[7.8819]

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

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

∅:D[5.6475] → [2.4721:4797]

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

[5.6475]

[5.6551]

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

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

∅:D[5.6717] → [2.4798:4858]

        F: Future<Error = E> + 'static,
        E: 'static,

[5.6717]

[5.6747]

        F: Future<Error = E>,
        E: Into<failure::Error>,

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

∅:D[5.6753] → [2.4859:4976]

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

[5.6753]

[5.6870]

        let XmppConnection { account, state } = self;

Replacement in src/xmpp/mod.rs at line 289 [4.17]
∅:D[5.7065] → [2.4977:4992]
```
        client
```
[5.7065]
[5.7080]
```
        state
            .client
```

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

∅:D[5.7201] → [2.4993:5018]

                account2

[5.7201]

[5.7226]

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

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

∅:D[5.7312] → [2.5019:5076]

                    state: XmppState { client, roster },

[5.7312]

[5.7369]

                    state: XmppState { client },

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

∅:D[5.7497] → [2.5077:5376]

                .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),
                })

[5.7497]

[5.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 323 [4.17]

∅:D[5.7942] → [2.5377:5460]

        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,

[5.7942]

[5.8005]

        F: Future<Error = E>,
        E: Into<failure::Error>,

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

∅:D[5.8011] → [2.5461:5578]

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

[5.8011]

[7.10624]

        let XmppConnection { account, state } = self;

Replacement in src/xmpp/mod.rs at line 333 [4.17]
∅:D[5.8183] → [2.5579:5594]
```
        client
```
[5.8183]
[5.8198]
```
        state
            .client
```

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

∅:D[5.8315] → [2.5595:5620]

                account2

[5.8315]

[5.8340]

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

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

∅:D[5.8426] → [2.5621:5678]

                    state: XmppState { client, roster },

[5.8426]

[5.8483]

                    state: XmppState { client },

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

∅:D[5.9105] → [2.5679:5794]

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

[5.9105]

[5.9220]

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

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

∅:D[5.9320] → [2.5795:6094]

                .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),
                })

[5.9320]

[6.5425]

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

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

[6.5440]

[7.12130]

================================
    }
    fn process_command(
        self,
        _cmd: &XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        info!("Got command");
        future::ok(self)
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Replacement in src/xmpp/mod.rs at line 387 [4.17]
∅:D[4.3817] → [2.6095:6120]
```
struct XmppState<F, S> {
```
[4.3817]
[11.86]
```
struct XmppProcessState<F, S> {
```

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

∅:D[4.3920] → [2.6121:6253]

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 413 [4.17]
∅:D[4.4357] → [2.6254:6304]
```
    let conn = MaybeXmppConnection::new(account);
```
[4.4357]
[4.4526]
```
    let conn = account.into();
```

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

∅:D[4.4527] → [2.6305:6395]

    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 421 [4.17]

∅:D[4.4692] → [2.6396:7143]

        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(

[4.4692]

[2.7143]

        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)) => Box::new(if let Some(cmd_recv) = f.into_inner() {
                            future::ok(future::Loop::Continue(XmppProcessState {

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

∅:D[2.7225] → [2.7225:7302]

                                conn.into(),
                            )))

[2.7225]

[2.7302]

                                conn: conn.into(),
                            }))

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

∅:D[2.7335] → [2.7335:7416]

                            future::ok(future::Loop::Break((None, conn.into())))

[2.7335]

[7.13130]

                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(cmd) = cmd {
                                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(),
                                        },
                                    }))
                                }))
                                    as Box<dyn Future<Item = _, Error = _>>
                            } else {
                                Box::new(future::ok(future::Loop::Break(())))
                            }
                        }
                        Err(_) => Box::new(future::err(format_err!("Command receiver is broken"))),
                    },
                    Err((account, r)) => Box::new(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"))
                            }

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

∅:D[7.13156] → [2.7417:8180]

                    }
                    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(()))
        }

[7.13156]

[5.10245]

                        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")),
                    }),
                })
        })