Leave MUC properly

[?]

Feb 18, 2019, 7:14 PM

VW7NVWAGIOHOEEYGAT77GV6GXXIAKWCXVXPZFRMAV7SPWXVGPTTQC

Dependencies

[2] 37OMJ4CK Send MUC message
[3] 5Y6YJ6UH Add shutdown function to make actions before offline
[4] VS6AHRWI Move XMPP to separate dir
[5] AA2ZWGRL Enter to MUC
[6] OB3HA2MD Use Client::new_with_jid to parse jid only once
[*] FV6BJ5K6 Send self-presence and store account info in Rc so it willbe used in some future in parallel
[*] J7VX56FW ToDo
[*] RGOSS73U Convert self-presence to xmpp_parser's type
[*] HKSQO7JZ Enable hyper http server and configuration

Change contents

edit in src/xmpp/stanzas.rs at line 68

[2.256]

pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
let mut presence = Presence::new(PresenceType::Unavailable);
presence.from = Some(from);
presence.to = Some(to);
presence.into()
}
edit in src/xmpp/mod.rs at line 616

[9.12365]

[9.12365]

fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
info!("Shutdown connection");
let XmppConnection { account, state } = self;
stream::iter_ok(
state
.data
.mucs
.values()
.map(std::clone::Clone::clone)
.collect::<Vec<_>>(),
)
.fold(state, move |XmppState { client, data }, muc_jid| {
let muc_presence =
stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
edit in src/xmpp/mod.rs at line 632

[9.12366]

[9.12366]

info!("Sending muc leave presence... {:?}", muc_presence);
use tokio::prelude::Sink;
client
.send(Packet::Stanza(muc_presence))
.map_err(|e| {
error!("Error on send muc presence: {}", e);
e
})
.and_then(|client| future::ok(XmppState { client, data }))
})
.map(|_| ())
}
replacement in src/xmpp/mod.rs at line 750

[3.24278]→[3.8487:8572](∅→∅)

future::err(format_err!("Command receiver is gone"))

[3.24278]

[3.24363]

error!("Command receiver is gone");
future::ok(future::Loop::Break(Some(conn)))
replacement in src/xmpp/mod.rs at line 764

[3.24895]→[3.8573:8641](∅→∅)

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

[3.24895]

[3.24963]

future::ok(future::Loop::Break(Some(conn)))
replacement in src/xmpp/mod.rs at line 767

[3.25019]→[3.8642:8732](∅→∅)

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

[3.25019]

[3.25109]

Err(_) => {
error!("Command receiver is broken");
future::ok(future::Loop::Break(Some(conn)))
}
replacement in src/xmpp/mod.rs at line 793

[3.26249]→[3.8733:8801](∅→∅)

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

[3.26249]

[3.26317]

future::ok(future::Loop::Break(None))
edit in src/xmpp/mod.rs at line 801

[10.6451]

[3.7379]

.and_then(|opt_conn| {
if let Some(conn) = opt_conn {
Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
} else {
Box::new(future::ok(()))
}
})
edit in src/config.rs at line 0

[11.1396]

[11.1397]

use std::collections::HashMap;
edit in src/config.rs at line 10

[11.1549]

[11.1549]

#[serde(default, deserialize_with = "deserialize_jid_map")]
pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
edit in src/config.rs at line 39

[11.1945]

fn deserialize_jid_map<'de, D>(
deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::Deserialize;
let s = HashMap::<String, String>::deserialize(deserializer)?;

let size = s.len();
s.into_iter()
.map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
.take_while(|(_k, r)| r.is_ok())
.fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
Ok(mut res) => match r {
Ok(v) => {
res.insert(k, v);
Ok(res)
}
Err(e) => Err(e),
},
Err(e) => Err(e),
})
.map_err(serde::de::Error::custom)
}