O01eg/sendxmppd-rs - Change EBETRYK7RNRATWD75LTFUTPF6M6KB6YPKTQUX4K232JB6CKVOZOQC

Add counter for id. Check for jid in roster

Created by O01eg on January 1, 2019

EBETRYK7RNRATWD75LTFUTPF6M6KB6YPKTQUX4K232JB6CKVOZOQC

Dependencies

In channels

main

Change contents

Insertion in src/xmpp/mod.rs at line 7 [5.17]
[3.48]
[4.420]
```
use std::collections::HashMap;
```

Insertion in src/xmpp/mod.rs at line 16 [5.17]

[6.393]

[6.428]

    roster: HashMap<jid::Jid, ()>,
    counter: usize,

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

∅:D[7.435] → [2.483:556]

                                            state: XmppState { client },

[7.435]

[7.494]

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

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

∅:D[6.1403] → [2.557:620]

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

Insertion in src/xmpp/mod.rs at line 103 [5.17]

[6.1468]

[6.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 137 [5.17]

∅:D[8.3788] → [2.621:672]

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

[8.3788]

[6.2073]

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

Insertion in src/xmpp/mod.rs at line 142 [5.17]
[6.2124]
[6.2124]
```
        future::ok(self)
```

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

∅:D[8.3983] → [2.673:709]

    /// or stop future was resolved

[8.3983]

[8.4019]

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

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

∅:D[8.4137] → [2.710:892]

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

[8.4137]

[8.4319]

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

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

∅:D[8.4335] → [2.893:1034]

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

[8.4335]

[8.4476]

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

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

∅:D[8.4612] → [2.1035:1147]

                let XmppConnection { state, account } = xmpp;
                state
                    .client

[8.4612]

[2.1147]

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

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

∅:D[2.1224] → [2.1224:1264]

                    .then(|r| match r {

[2.1224]

[2.1264]

                    .then(move |r| match r {

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

∅:D[2.1386] → [2.1386:1515]

                                let mut xmpp = XmppConnection {
                                    state: XmppState { client },

[2.1386]

[2.1515]

                                let xmpp = XmppConnection {
                                    state: XmppState {
                                        client,
                                        roster,
                                        counter,
                                    },

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

∅:D[2.1595] → [2.1595:1730]

∅:D[2.1730] → [9.1639:2096]

∅:D[10.2169] → [9.1639:2096]

∅:D[9.1639] → [9.1639:2096]

∅:D[9.2096] → [2.1731:1848]

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

[2.1595]

[2.1848]

                                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 = _>>

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

∅:D[2.1885] → [2.1885:1958]

                                future::err((account, Ok(Either::A(b))))

[2.1885]

[2.1958]

                                Box::new(future::err((account, Ok(Either::A(b)))))

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

∅:D[2.2014] → [2.2014:2368]

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

[2.2014]

[2.2368]

                        Ok(Either::B((t, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        roster,
                                        counter,

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

∅:D[2.2407] → [2.2407:2663]

                                    Ok(Either::B(t)),
                                )))
                            } else {
                                future::err((account, Ok(Either::B(t))))
                            }
                        }

[2.2407]

[2.2663]

                                    account,
                                },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }),

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

∅:D[2.2773] → [2.2773:2842]

                            future::err((account, Ok(Either::A(b))))

[2.2773]

[2.2842]

                            Box::new(future::err((account, Ok(Either::A(b)))))

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

∅:D[2.2868] → [2.2868:3223]

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

[2.2868]

[2.3223]

                        Err(Either::B((e, a))) => Box::new(if let Some(client) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        roster,
                                        counter,

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

∅:D[2.3262] → [2.3262:3486]

∅:D[2.3486] → [9.2940:2966]

∅:D[10.2573] → [9.2940:2966]

∅:D[9.2940] → [9.2940:2966]

                                    Err(e.into()),
                                )))
                            } else {
                                future::err((account, Err(e.into())))
                            }
                        }

[2.3262]

[2.3487]

                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),

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

∅:D[8.6691] → [2.3511:3630]

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

[8.6691]

[6.4011]

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

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

∅:D[6.4339] → [2.3631:3693]

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

[6.4339]

[6.4363]

                Err(())

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

∅:D[6.4394] → [2.3694:3783]

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

[6.4394]

[6.4471]

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

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

∅:D[6.4859] → [2.3784:3868]

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

[6.4859]

[6.4978]

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

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

∅:D[10.4441] → [2.3869:3967]

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

[10.4441]

[6.5907]

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

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

∅:D[10.4631] → [2.3968:4051]

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

[10.4631]

[6.6168]

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

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

∅:D[6.6299] → [2.4052:4117]

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

[6.6299]

[8.8819]

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

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

∅:D[6.6475] → [2.4118:4183]

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

[6.6475]

[6.6551]

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

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

∅:D[6.6717] → [2.4184:4247]

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

[6.6717]

[6.6747]

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

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

∅:D[6.6753] → [2.4248:4302]

        let XmppConnection { account, state } = self;

[6.6753]

[6.6870]

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

Replacement in src/xmpp/mod.rs at line 341 [5.17]
∅:D[6.7065] → [2.4303:4337]
```
        state
            .client
```
[6.7065]
[6.7080]
```
        client
```

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

∅:D[6.7201] → [2.4338:4407]

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

[6.7201]

[6.7226]

                account2

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

∅:D[6.7312] → [2.4408:4457]

                    state: XmppState { client },

[6.7312]

[6.7369]

                    state: XmppState {
                        client,
                        roster,
                        counter,
                    },

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

∅:D[6.7497] → [2.4458:4946]

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

[6.7497]

[6.7778]

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

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

∅:D[6.7942] → [2.4947:5010]

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

[6.7942]

[6.8005]

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

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

∅:D[6.8011] → [2.5011:5065]

        let XmppConnection { account, state } = self;

[6.8011]

[8.10624]

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

Replacement in src/xmpp/mod.rs at line 389 [5.17]
∅:D[6.8183] → [2.5066:5100]
```
        state
            .client
```
[6.8183]
[6.8198]
```
        client
```

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

∅:D[6.8315] → [2.5101:5170]

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

[6.8315]

[6.8340]

                account2

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

∅:D[6.8426] → [2.5171:5220]

                    state: XmppState { client },

[6.8426]

[6.8483]

                    state: XmppState {
                        client,
                        roster,
                        counter,
                    },

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

∅:D[6.9105] → [2.5221:5309]

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

[6.9105]

[6.9220]

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

Insertion in src/xmpp/mod.rs at line 422 [5.17]

[6.9320]

[2.5310]

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

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

∅:D[2.5325] → [2.5325:5597]

∅:D[2.5597] → [9.5425:5440]

∅:D[10.6094] → [9.5425:5440]

∅:D[6.9320] → [9.5425:5440]

∅:D[9.5440] → [2.5598:5631]

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            .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 433 [5.17]
∅:D[2.5676] → [2.5676:5704]
```
        _cmd: &XmppCommand,
```
[2.5676]
[2.5704]
```
        cmd: &XmppCommand,
```

Insertion in src/xmpp/mod.rs at line 436 [5.17]

[2.5808]

        if let Some(_jid_data) = self.state.roster.get(&cmd.xmpp_to) {
            info!("Jid {} in roster", cmd.xmpp_to);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
        }

Deletion in src/xmpp/mod.rs at line 442 [5.17]
∅:D[2.5833] → [2.5833:5866]
```
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
```