o01eg/sendxmppd-rs - Change SU4DNVCBZYNXKBPMMNL2TAUVXYVDGBJR2P3BAZJKG7GJMYWELMKQC

Start to processing roster data

Created by O01eg on January 1, 2019

SU4DNVCBZYNXKBPMMNL2TAUVXYVDGBJR2P3BAZJKG7GJMYWELMKQC

Dependencies

In channels

main

Change contents

Replacement in src/xmpp/mod.rs at line 12 [5.17]

∅:D[3.321] → [4.0:72]

∅:D[4.72] → [2.0:56]

∅:D[2.56] → [4.93:95]

∅:D[4.93] → [4.93:95]

#[derive(Default)]
struct XmppData {
    roster: HashMap<jid::Jid, ()>,
    counter: usize,
    id_init_roster: Option<String>,
}

[3.321]

[4.95]

const ID_GET_ROSTER: &str = "id_get_roster0";

Replacement in src/xmpp/mod.rs at line 16 [5.17]
∅:D[6.393] → [4.97:117]
```
    data: XmppData,
```
[6.393]
[6.428]
```
    roster: HashMap<jid::Jid, ()>,
```

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

∅:D[7.19] → [8.0:113]

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

[7.19]

[7.132]

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

Replacement in src/xmpp/mod.rs at line 41 [5.17]

∅:D[7.162] → [8.114:159]

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

[7.162]

[8.159]

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

Deletion in src/xmpp/mod.rs at line 45 [5.17]
∅:D[8.200] → [8.200:202]
```
}
```
Deletion in src/xmpp/mod.rs at line 46 [5.17]
∅:D[8.203] → [8.203:399]
∅:D[8.399] → [7.207:232]
∅:D[9.207] → [7.207:232]
∅:D[7.207] → [7.207:232]
∅:D[7.232] → [3.666:682]
∅:D[6.577] → [3.666:682]
∅:D[10.509] → [3.666:682]
∅:D[11.85] → [3.666:682]
∅:D[12.148] → [3.666:682]
∅:D[3.666] → [3.666:682]
∅:D[3.682] → [8.400:402]
∅:D[8.402] → [13.128:129]
∅:D[13.128] → [13.128:129]
∅:D[13.129] → [8.403:430]
```
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
```

Replacement in src/xmpp/mod.rs at line 47 [5.17]

∅:D[5.554] → [8.431:482]

    /// don't connect only if stop_future resolved

[5.554]

[3.876]

    /// don't connect if stop_future resolved

Replacement in src/xmpp/mod.rs at line 84 [5.17]

∅:D[14.208] → [4.118:206]

                                                data: std::default::Default::default(),

[14.208]

[14.340]

                                                roster: HashMap::new(),

Replacement in src/xmpp/mod.rs at line 128 [5.17]

∅:D[8.672] → [6.2073:2124]

∅:D[9.1000] → [6.2073:2124]

∅:D[14.894] → [6.2073:2124]

∅:D[6.2073] → [6.2073:2124]

∅:D[6.2124] → [14.895:920]

        info!("Incoming xmpp event: {:?}", event);
        future::ok(self)

[14.894]

[6.2124]

        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use try_from::TryInto;
                if let Some(_iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {}
                future::ok(self)
            }
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                future::err(self.account)
            }
        }

Replacement in src/xmpp/mod.rs at line 168 [5.17]

∅:D[14.1389] → [4.207:262]

                    state: XmppState { client, data },

[14.1389]

[14.1588]

                    state: XmppState { client, roster },

Replacement in src/xmpp/mod.rs at line 171 [5.17]

∅:D[14.1643] → [14.1643:1666]

∅:D[14.1666] → [8.1147:1224]

∅:D[8.1147] → [8.1147:1224]

∅:D[8.1224] → [14.1667:1712]

∅:D[14.1712] → [8.1264:1386]

∅:D[8.1264] → [8.1264:1386]

∅:D[8.1386] → [14.1713:1773]

∅:D[14.1773] → [4.263:334]

∅:D[4.334] → [8.1515:1595]

∅:D[14.2012] → [8.1515:1595]

∅:D[8.1515] → [8.1515:1595]

∅:D[8.1595] → [14.2013:3071]

∅:D[14.3071] → [8.1848:1885]

∅:D[8.1848] → [8.1848:1885]

∅:D[8.1885] → [14.3072:3155]

∅:D[14.3155] → [8.1958:2014]

∅:D[8.1958] → [8.1958:2014]

∅:D[8.2014] → [14.3156:3363]

∅:D[14.3363] → [4.335:406]

∅:D[4.406] → [14.3564:3609]

∅:D[8.2407] → [14.3564:3609]

                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,

[14.1643]

[14.3609]

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

Replacement in src/xmpp/mod.rs at line 190 [5.17]

∅:D[14.3644] → [14.3644:3726]

                                Ok(Either::B(t)),
                            )))

[14.3644]

[14.3726]

                                Err(account) => future::err((account, Ok(Either::A(b)))),
                            })) as Box<dyn Future<Item = _, Error = _>>

Deletion in src/xmpp/mod.rs at line 193 [5.17]

∅:D[14.3759] → [14.3759:3856]

∅:D[14.3856] → [8.2663:2773]

∅:D[8.2663] → [8.2663:2773]

                            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 195 [5.17]

∅:D[8.2868] → [14.3937:4145]

∅:D[14.4145] → [4.407:478]

∅:D[4.478] → [14.4346:4618]

∅:D[8.3262] → [14.4346:4618]

∅:D[14.4618] → [8.3487:3510]

∅:D[7.2966] → [8.3487:3510]

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

[8.2868]

[15.5580]

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

Replacement in src/xmpp/mod.rs at line 252 [5.17]

∅:D[6.4690] → [2.57:129]

                        if Some(id) == self.state.data.id_init_roster {

[6.4690]

[6.4739]

                        if id == ID_GET_ROSTER {

Replacement in src/xmpp/mod.rs at line 263 [5.17]

∅:D[6.5333] → [6.5333:5399]

                                            info!("Got roster:");

[6.5333]

[6.5399]

                                            self.state.data.roster.clear();
                                            info!("Got first roster:");

Deletion in src/xmpp/mod.rs at line 267 [5.17]

∅:D[6.5538] → [4.479:569]

                                                self.state.data.roster.insert(i.jid, ());

Replacement in src/xmpp/mod.rs at line 307 [5.17]

∅:D[14.5676] → [2.130:181]

            state: XmppState { client, mut data },

[14.5676]

[14.5827]

            state: XmppState { client, roster },

Replacement in src/xmpp/mod.rs at line 311 [5.17]

∅:D[6.6905] → [2.182:389]

        data.counter += 1;
        let id_init_roster = format!("id{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        data.id_init_roster = Some(id_init_roster);

[6.6905]

[6.6971]

        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);

Replacement in src/xmpp/mod.rs at line 323 [5.17]

∅:D[6.7312] → [4.618:673]

                    state: XmppState { client, data },

[6.7312]

[6.7369]

                    state: XmppState { client, roster },

Replacement in src/xmpp/mod.rs at line 346 [5.17]

∅:D[14.6482] → [4.674:721]

            state: XmppState { client, data },

[14.6482]

[14.6633]

            state: XmppState { client, roster },

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

∅:D[6.8426] → [4.722:777]

                    state: XmppState { client, data },

[6.8426]

[6.8483]

                    state: XmppState { client, roster },

Deletion in src/xmpp/mod.rs at line 390 [5.17]

∅:D[8.5631] → [8.5631:5676]

∅:D[8.5676] → [14.7270:7297]

∅:D[14.7297] → [8.5704:5808]

∅:D[8.5704] → [8.5704:5808]

∅:D[8.5808] → [4.778:854]

∅:D[4.854] → [14.7369:7504]

∅:D[14.7369] → [14.7369:7504]

∅:D[14.7504] → [8.5808:5833]

∅:D[8.5808] → [8.5808:5833]

    }
    fn process_command(
        self,
        cmd: &XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        info!("Got command");
        if let Some(_jid_data) = self.state.data.roster.get(&cmd.xmpp_to) {
            info!("Jid {} in roster", cmd.xmpp_to);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
        }
        future::ok(self)

Replacement in src/xmpp/mod.rs at line 396 [5.17]
∅:D[5.3817] → [8.5867:5899]
```
struct XmppProcessState<F, S> {
```
[5.3817]
[16.86]
```
struct XmppState<F, S> {
```

Replacement in src/xmpp/mod.rs at line 402 [5.17]

∅:D[5.3920] → [8.5900:6053]

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

[5.3920]

[5.4058]

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

Replacement in src/xmpp/mod.rs at line 422 [5.17]
∅:D[5.4357] → [8.6054:6085]
```
    let conn = account.into();
```
[5.4357]
[5.4526]
```
    let conn = MaybeXmppConnection::new(account);
```

Replacement in src/xmpp/mod.rs at line 424 [5.17]

∅:D[5.4527] → [8.6086:6190]

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

[5.4527]

[5.4617]

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

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

∅:D[5.4692] → [8.6191:6612]

        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 {

[5.4692]

[9.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(

Replacement in src/xmpp/mod.rs at line 450 [5.17]

∅:D[9.7225] → [8.6613:6696]

                                conn: conn.into(),
                            }))

[9.7225]

[9.7302]

                                conn.into(),
                            )))

Replacement in src/xmpp/mod.rs at line 453 [5.17]

∅:D[9.7335] → [8.6697:8539]

∅:D[7.6783] → [3.13130:13156]

∅:D[6.9698] → [3.13130:13156]

∅:D[17.118] → [3.13130:13156]

∅:D[8.8539] → [3.13130:13156]

∅:D[9.7416] → [3.13130:13156]

∅:D[3.13130] → [3.13130:13156]

∅:D[3.13156] → [8.8540:9142]

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

[9.7335]

[8.9142]

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

Replacement in src/xmpp/mod.rs at line 455 [5.17]

∅:D[8.9168] → [8.9168:9312]

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

[8.9168]

[6.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(()))
        }