o01eg/sendxmppd-rs - Change 77USPY5IJSK7YN355CRGZQ2ZIG5WHRCD7JWKE3BVVBYIU6QLB5ZAC

Sending messages works!

Created by O01eg on January 2, 2019

77USPY5IJSK7YN355CRGZQ2ZIG5WHRCD7JWKE3BVVBYIU6QLB5ZAC

Dependencies

In channels

main

Change contents

Insertion in src/xmpp/stanzas.rs at line 3 [4.13]
[3.26]
[4.57]
```
use xmpp_parsers::message::{Body, Message, MessageType};
```

Insertion in src/xmpp/stanzas.rs at line 37 [4.13]

[5.445]

[3.270]

}
pub fn make_ask_subscribe(jid: jid::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);
    presence.into()

Insertion in src/xmpp/stanzas.rs at line 44 [4.13]

[3.272]


pub fn make_chat_message(jid: jid::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()
}

Replacement in src/xmpp/mod.rs at line 8 [8.17]
∅:D[6.1] → [7.0:43]
```
use std::collections::{HashMap, VecDeque};
```
[6.1]
[4.420]
```
use std::collections::HashMap;
```

Replacement in src/xmpp/mod.rs at line 15 [8.17]

∅:D[5.472] → [9.484:519]

∅:D[9.484] → [9.484:519]

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

[5.472]

[5.473]

    roster: HashMap<jid::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,

Deletion in src/xmpp/mod.rs at line 21 [8.17]

∅:D[5.670] → [7.44:112]

    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,

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

∅:D[10.3788] → [2.0:90]

    /// Returns false on error
    fn xmpp_processing(&mut self, event: &Event) -> bool {

[10.3788]

[5.792]

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

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

∅:D[5.1135] → [5.1135:1195]

                        if let Some((_, (jid, _message))) =

[5.1135]

[5.1195]

                        if let Some((_, (jid, message))) =

Insertion in src/xmpp/mod.rs at line 164 [8.17]

[5.1465]

                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&jid) {
                                    rdata.1.push(message);
                                } else {
                                    self.state.data.roster.insert(
                                        jid,
                                        (xmpp_parsers::roster::Subscription::None, vec![message]),
                                    );
                                }
                            } else {
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                );

Replacement in src/xmpp/mod.rs at line 184 [8.17]

∅:D[5.1788] → [5.1788:1980]

                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| {

[5.1788]

[5.1980]

                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    if !rdata.1.is_empty() {
                                        let sub_to = match rdata.0 {
                                            xmpp_parsers::roster::Subscription::To => true,
                                            xmpp_parsers::roster::Subscription::Both => true,
                                            _ => false,
                                        };
                                        if sub_to {
                                            info!("Subscribed to {}", i.jid);
                                            let jid = i.jid.clone();
                                            self.state.data.send_queue.extend(
                                                rdata.1.drain(..).map(|message| {
                                                    stanzas::make_chat_message(jid.clone(), message)
                                                }),
                                            )
                                        } else {
                                            info!("Not subscribed to {}", i.jid);
                                            self.state
                                                .data
                                                .send_queue
                                                .push_back(stanzas::make_ask_subscribe(i.jid));
                                        }
                                    }
                                } else {

Replacement in src/xmpp/mod.rs at line 213 [8.17]

∅:D[5.2050] → [5.2050:2135]

                                    (i.jid, ())
                                }));

[5.2050]

[5.2135]

                                    self.state
                                        .data
                                        .roster
                                        .insert(i.jid, (i.subscription, vec![]));
                                }
                            }

Replacement in src/xmpp/mod.rs at line 222 [8.17]
∅:D[5.2201] → [2.91:112]
```
                true
```
[5.2201]
[5.2234]
```
                future::ok(self)
```

Replacement in src/xmpp/mod.rs at line 224 [8.17]

∅:D[5.2248] → [2.113:148]

            Event::Online => true,

[5.2248]

[5.2295]

            Event::Online => future::ok(self),

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

∅:D[5.2365] → [2.149:171]

                false

[5.2365]

[5.2407]

                future::err(self.account)

Replacement in src/xmpp/mod.rs at line 255 [8.17]

∅:D[6.1389] → [7.113:172]

                    state: XmppState { client, mut data },

[6.1389]

[6.1588]

                    state: XmppState { client, data },

Replacement in src/xmpp/mod.rs at line 258 [8.17]

∅:D[6.1643] → [7.173:791]


                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(client.send(send_element).select2(stop_future).then(
                        move |r| match r {
                            Ok(Either::A((client, b))) => {
                                Box::new(future::ok(future::Loop::Continue((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,

[6.1643]

[9.2575]

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

Replacement in src/xmpp/mod.rs at line 281 [8.17]

∅:D[9.2614] → [7.792:920]

                                    b,
                                    stop_condition,
                                ))))

[9.2614]

[9.2744]

                                    Err(account) => future::err((account, Ok(Either::A(b)))),
                                }))

Replacement in src/xmpp/mod.rs at line 284 [8.17]

∅:D[9.2820] → [7.921:1806]

                            }
                            Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Ok(Either::B(t)),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Ok(Either::B(t))))
                                }
                            })),
                            Err(Either::A((e, b))) => {
                                warn!("XMPP sending error: {}", e);

[9.2820]

[9.2857]

                            } else {

Replacement in src/xmpp/mod.rs at line 287 [8.17]

∅:D[9.2970] → [7.1807:2979]

∅:D[7.2979] → [2.172:244]

∅:D[2.244] → [7.3047:3222]

∅:D[7.3047] → [7.3047:3222]

∅:D[7.3222] → [2.245:1169]

∅:D[2.1169] → [7.4515:4611]

∅:D[7.4515] → [7.4515:4611]

∅:D[7.4611] → [2.1170:1351]

∅:D[2.1351] → [7.4936:4981]

∅:D[7.4936] → [7.4936:4981]

∅:D[7.4981] → [2.1352:1433]

∅:D[2.1433] → [7.5072:5203]

∅:D[7.5072] → [7.5072:5203]

∅:D[7.5203] → [2.1434:1509]

∅:D[2.1509] → [7.5287:5840]

∅:D[7.5287] → [7.5287:5840]

∅:D[7.5840] → [2.1510:1548]

∅:D[2.1548] → [7.5879:6039]

∅:D[7.5879] → [7.5879:6039]

∅:D[7.6039] → [2.1549:1626]

∅:D[2.1626] → [7.6126:6220]

∅:D[7.6126] → [7.6126:6220]

∅:D[7.6220] → [2.1627:1702]

∅:D[2.1702] → [7.6304:6837]

∅:D[7.6304] → [7.6304:6837]

∅:D[7.6837] → [2.1703:1741]

∅:D[2.1741] → [7.6876:6982]

∅:D[7.6876] → [7.6876:6982]

                            Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Err(e),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Err(e)))
                                }
                            })),
                        },
                    )) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        if 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, Ok(Either::A(b))))
                                                }
                                            }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                    } 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, data },
                                                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, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    }
                                }
                            }),
                    )
                }

[9.2970]

[11.5580]

                        }
                        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,
                                },
                                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, data },
                                    account,
                                },
                                Err(e),
                            )))
                        } else {
                            future::err((account, Err(e)))
                        }),
                    })

Replacement in src/xmpp/mod.rs at line 359 [8.17]

∅:D[3.5538] → [9.4253:4343]

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

[3.5538]

                                                self.state
                                                    .data
                                                    .roster
                                                    .insert(i.jid, (i.subscription, vec![]));

Replacement in src/xmpp/mod.rs at line 491 [8.17]

∅:D[9.4553] → [7.6983:7037]

    fn process_command(&mut self, cmd: XmppCommand) {

[9.4553]

[9.4692]

    fn process_command(
        self,
        cmd: XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {

Replacement in src/xmpp/mod.rs at line 496 [8.17]

∅:D[9.4722] → [5.2967:3031]

        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {

[9.4722]

[9.4786]

        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&cmd.xmpp_to) {

Insertion in src/xmpp/mod.rs at line 498 [8.17]

[9.4838]

[9.4867]

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            Box::new(future::ok(self)) as Box<dyn Future<Item = _, Error = _>>
================================
            let sub_to = match rdata.0 {
                xmpp_parsers::roster::Subscription::To => true,
                xmpp_parsers::roster::Subscription::Both => true,
                _ => false,
            };
            if sub_to {
                info!("Subscribed to {}", cmd.xmpp_to);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_chat_message(cmd.xmpp_to, cmd.message));
            } else {
                info!("Not subscribed to {}", cmd.xmpp_to);
                rdata.1.push(cmd.message);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_ask_subscribe(cmd.xmpp_to));
            }
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Insertion in src/xmpp/mod.rs at line 523 [8.17]

[9.4940]

[5.3247]

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

Replacement in src/xmpp/mod.rs at line 528 [8.17]

∅:D[5.3248] → [7.7038:7165]

            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);

[5.3248]

[5.3353]

            data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", data.counter);

Replacement in src/xmpp/mod.rs at line 531 [8.17]

∅:D[5.3445] → [7.7166:7319]

            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));

[5.3445]

[5.3489]

            let account2 = account.clone();

Insertion in src/xmpp/mod.rs at line 533 [8.17]
[5.3552]
[5.3590]
```
            use tokio::prelude::Sink;
```

Replacement in src/xmpp/mod.rs at line 535 [8.17]

∅:D[5.3591] → [7.7320:7382]

            self.state.data.send_queue.push_back(add_roster);

[5.3591]

[9.5454]

            Box::new(
                client
                    .send(add_roster)
                    .map_err(|e| {
                        error!("Error on send adding to roster: {}", e);
                        account2
                    })
                    .and_then(move |client| {
                        data.pending_add_roster_ids
                            .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
                        future::ok(XmppConnection {
                            account,
                            state: XmppState { client, data },
                        })
                    }),
            )

Replacement in src/xmpp/mod.rs at line 596 [8.17]

∅:D[9.5994] → [7.7383:7993]

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

[9.5994]

[9.6478]

                    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 {
                                cmd_recv,
                                signal,
                                conn: conn.into(),
                            }))
                        } else {
                            future::err(format_err!("Command receiver is gone"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,

Replacement in src/xmpp/mod.rs at line 609 [8.17]

∅:D[9.6591] → [7.7994:8284]

                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),

[9.6591]

[9.7141]

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

Insertion in src/xmpp/mod.rs at line 619 [8.17]

[9.7177]

[9.7253]

                                    as Box<dyn Future<Item = _, Error = _>>

Replacement in src/xmpp/mod.rs at line 621 [8.17]

∅:D[9.7290] → [7.8285:8353]

                                future::ok(future::Loop::Break(()))

[9.7290]

[9.7368]

                                Box::new(future::ok(future::Loop::Break(())))

Replacement in src/xmpp/mod.rs at line 624 [8.17]

∅:D[12.9168] → [7.8354:8444]

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

[12.9168]

[9.7499]

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

Replacement in src/xmpp/mod.rs at line 626 [8.17]

∅:D[9.7522] → [7.8445:8496]

                    Err((account, r)) => match r {

[9.7522]

[9.7582]

                    Err((account, r)) => Box::new(match r {

Replacement in src/xmpp/mod.rs at line 651 [8.17]
∅:D[9.8862] → [7.8497:8520]
```
                    },
```
[9.8862]
[9.8886]
```
                    }),
```