O01eg/sendxmppd-rs - Change CBWCXUZZBPQYFROVZFCIWHW3CPNAGXO3PUARLGOF4DUF6VVCYKVQC

Prepare adding new items to roster

Created by O01eg on January 1, 2019

CBWCXUZZBPQYFROVZFCIWHW3CPNAGXO3PUARLGOF4DUF6VVCYKVQC

Dependencies

In channels

main

Change contents

Replacement in src/xmpp/stanzas.rs at line 4 [3.13]
∅:D[3.141] → [4.27:61]
```
use xmpp_parsers::roster::Roster;
```
[3.141]
[3.141]
```
use xmpp_parsers::roster::{Item, Roster};
```
Insertion in src/xmpp/stanzas.rs at line 17 [3.13]
[4.156]
[4.156]
```
        items: vec![],
```
Deletion in src/xmpp/stanzas.rs at line 19 [3.13]
∅:D[4.175] → [4.175:198]
```
        items: vec![],
```

Insertion in src/xmpp/stanzas.rs at line 22 [3.13]

[4.270]

}
pub fn make_add_roster(id: &str, jid: jid::Jid) -> Element {
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()

Insertion in src/xmpp/mod.rs at line 13 [7.17]

[5.46]

[6.95]


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

Replacement in src/xmpp/mod.rs at line 22 [7.17]
∅:D[4.393] → [5.47:82]
```
    roster: HashMap<jid::Jid, ()>,
```
[4.393]
[4.428]
```
    data: XmppData,
```

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

∅:D[8.19] → [5.83:172]

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

[8.19]

[8.132]

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

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

∅:D[8.162] → [5.173:221]

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

[8.162]

[9.159]

            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 60 [7.17]
[9.200]
[9.202]
```
}
```
Insertion in src/xmpp/mod.rs at line 62 [7.17]
[9.203]
[7.516]
```
impl MaybeXmppConnection {
```

Replacement in src/xmpp/mod.rs at line 64 [7.17]

∅:D[7.554] → [5.222:268]

    /// don't connect if stop_future resolved

[7.554]

[10.876]

    /// don't connect only if stop_future resolved

Replacement in src/xmpp/mod.rs at line 101 [7.17]

∅:D[11.208] → [5.269:341]

                                                roster: HashMap::new(),

[11.208]

[11.340]

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

Replacement in src/xmpp/mod.rs at line 142 [7.17]
∅:D[11.783] → [2.0:18]
```
        mut self,
```
[11.783]
[11.797]
```
        self,
```

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

∅:D[11.894] → [5.342:548]

∅:D[5.548] → [2.19:626]

∅:D[2.626] → [5.641:871]

∅:D[5.641] → [5.641:871]

        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> {
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| (i.jid, ())));
                        }
                    }
                }
                future::ok(self)
            }
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                future::err(self.account)
            }
        }

[11.894]

[4.2124]

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

Replacement in src/xmpp/mod.rs at line 172 [7.17]

∅:D[11.1389] → [5.872:929]

                    state: XmppState { client, roster },

[11.1389]

[11.1588]

                    state: XmppState { client, data },

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

∅:D[11.1643] → [5.930:2043]

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

[11.1643]

[11.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,

Replacement in src/xmpp/mod.rs at line 211 [7.17]

∅:D[11.3644] → [5.2044:2206]

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

[11.3644]

[11.3726]

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

Insertion in src/xmpp/mod.rs at line 214 [7.17]

[11.3759]

[11.3857]

                            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 220 [7.17]

∅:D[9.2868] → [5.2207:3484]

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

[9.2868]

[12.5580]

                        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 272 [7.17]

∅:D[4.5333] → [5.3535:3683]

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

[4.5333]

[4.5399]

                                            info!("Got roster:");

Insertion in src/xmpp/mod.rs at line 275 [7.17]

[4.5538]

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

Replacement in src/xmpp/mod.rs at line 316 [7.17]

∅:D[11.5676] → [5.3684:3733]

            state: XmppState { client, roster },

[11.5676]

[11.5827]

            state: XmppState { client, data },

Replacement in src/xmpp/mod.rs at line 332 [7.17]

∅:D[4.7312] → [5.3801:3858]

                    state: XmppState { client, roster },

[4.7312]

[4.7369]

                    state: XmppState { client, data },

Replacement in src/xmpp/mod.rs at line 355 [7.17]

∅:D[11.6482] → [5.3859:3908]

            state: XmppState { client, roster },

[11.6482]

[11.6633]

            state: XmppState { client, data },

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

∅:D[4.8426] → [5.3909:3966]

                    state: XmppState { client, roster },

[4.8426]

[4.8483]

                    state: XmppState { client, data },

Insertion in src/xmpp/mod.rs at line 400 [7.17]

[10.12136]

[7.3789]


    fn process_command(
        self,
        cmd: &XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        info!("Got command");
        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {
            info!("Jid {} in roster", cmd.xmpp_to);
            future::ok(self)
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
            let XmppConnection {
                account,
                state: XmppState { client, mut data },
            } = self;
            data.counter += 1;
            let id_add_roster = format!("id{}", data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            info!("Add jid to roster... {:?}", add_roster);
            future::ok(XmppConnection {
                account,
                state: XmppState { client, data },
            })
        }
    }

Replacement in src/xmpp/mod.rs at line 432 [7.17]
∅:D[7.3817] → [5.3967:3992]
```
struct XmppState<F, S> {
```
[7.3817]
[13.86]
```
struct XmppProcessState<F, S> {
```

Replacement in src/xmpp/mod.rs at line 438 [7.17]

∅:D[7.3920] → [5.3993:4125]

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

[7.3920]

[7.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 458 [7.17]
∅:D[7.4357] → [5.4126:4176]
```
    let conn = MaybeXmppConnection::new(account);
```
[7.4357]
[7.4526]
```
    let conn = account.into();
```

Replacement in src/xmpp/mod.rs at line 460 [7.17]

∅:D[7.4527] → [5.4177:4267]

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

[7.4527]

[7.4617]

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

Replacement in src/xmpp/mod.rs at line 466 [7.17]

∅:D[7.4692] → [5.4268:5015]

        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(

[7.4692]

[14.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 475 [7.17]

∅:D[14.7225] → [5.5016:5093]

                                conn.into(),
                            )))

[14.7225]

[14.7302]

                                conn: conn.into(),
                            }))

Replacement in src/xmpp/mod.rs at line 478 [7.17]

∅:D[14.7335] → [5.5094:5175]

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

[14.7335]

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

Replacement in src/xmpp/mod.rs at line 498 [7.17]

∅:D[9.9168] → [5.5176:5939]

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

[9.9168]

[4.10245]

                        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(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    }),
                })
        })