O01eg/sendxmppd-rs - Change AYQZ2UIA3HDOJAXF7WZZBFBQGNBLB63PPCMXJYLGES4FVIPXITPQC

Update deps

Created by O01eg on December 31, 2018

AYQZ2UIA3HDOJAXF7WZZBFBQGNBLB63PPCMXJYLGES4FVIPXITPQC

Dependencies

In channels

main

Change contents

Deletion in src/xmpp/stanzas.rs at line 2 [3.13]
∅:D[3.57] → [2.0:26]
```
use xmpp_parsers::iq::Iq;
```
Deletion in src/xmpp/stanzas.rs at line 3 [3.13]
∅:D[3.141] → [2.27:61]
```
use xmpp_parsers::roster::Roster;
```

Deletion in src/xmpp/stanzas.rs at line 12 [3.13]

∅:D[3.419] → [2.62:272]


pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}

Deletion in src/xmpp/mod.rs at line 9 [6.17]
∅:D[4.47] → [5.72:73]
∅:D[5.72] → [5.72:73]
∅:D[5.73] → [7.0:105]
```
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    inner: Option<Client>,
}
```

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

∅:D[8.74] → [7.107:126]

    inner: Client,

[8.74]

[7.126]

    inner: Option<(stream::SplitSink<Client>, stream::SplitStream<Client>)>,

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

∅:D[7.129] → [7.129:358]

∅:D[5.353] → [9.356:359]

∅:D[10.77] → [9.356:359]

∅:D[11.77] → [9.356:359]

∅:D[7.358] → [9.356:359]

∅:D[9.356] → [9.356:359]

∅:D[9.359] → [7.359:478]

impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            inner: Some(from.inner),
        }
    }
}
impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {

[7.129]

[3.479]

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

Replacement in src/xmpp/mod.rs at line 24 [6.17]

∅:D[6.554] → [12.0:302]

    /// don't connect if stop_future resolved
    fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {

[6.554]

[6.653]

    /// Error shoud be !
    fn connect<E: 'static>(self) -> impl Future<Item = Self, Error = E> {

Replacement in src/xmpp/mod.rs at line 27 [6.17]

∅:D[6.690] → [7.782:841]

        let MaybeXmppConnection { account, inner } = self;

[6.690]

[6.744]

        let XmppConnection { account, inner } = self;

Replacement in src/xmpp/mod.rs at line 30 [6.17]

∅:D[6.782] → [7.842:910]

∅:D[7.910] → [12.303:355]

            Box::new(future::ok(XmppConnection { account, inner }))
                as Box<Future<Item = _, Error = _>>

[6.782]

[6.944]

            Box::new(future::ok(XmppConnection {
                account,
                inner: Some(inner),
            })) as Box<Future<Item = _, Error = E>>

Replacement in src/xmpp/mod.rs at line 35 [6.17]

∅:D[6.961] → [12.356:1088]

∅:D[12.1088] → [2.273:349]

            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");
                                    let stop_future2 = stop_future.clone();
                                    let stop_future3 = stop_future.clone();

[6.961]

[6.1476]

            Box::new(future::loop_fn(account, |account| {
                info!("xmpp initialization...");
                let mut res_client = Client::new(&account.jid, &account.password);
                while let Err(e) = res_client {
                    error!("Cann't init xmpp client: {}", e);
                    res_client = Client::new(&account.jid, &account.password);
                }
                let client = res_client.expect("Cann't init xmpp client");
                info!("xmpp initialized");

Replacement in src/xmpp/mod.rs at line 45 [6.17]

∅:D[6.1477] → [12.1089:1636]

∅:D[12.1636] → [2.350:533]

∅:D[2.533] → [12.1727:2319]

∅:D[12.1727] → [12.1727:2319]

                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            inner: client,
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map(|(conn, _)| conn)
                                        .map_err(|(acc, _)| acc)
                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )
                                }
                            }
                        })
                        .map_err(|_: ()| ()),
                    )

[6.1477]

[12.2319]

                // future to wait for online
                Self::online(client.split(), account)
                    .and_then(Self::self_presence)

Replacement in src/xmpp/mod.rs at line 49 [6.17]

∅:D[12.2359] → [12.2359:2804]

                        Ok(Either::A((_x, _b))) => future::err(format_err!("Stop XMMP connection")),
                        Ok(Either::B((x, _a))) => future::ok(x),
                        Err(Either::A((e, _b))) => future::err(e.into()),
                        Err(Either::B((_, _a))) => {
                            future::err(format_err!("Cann't initiate XMPP connection"))
                        }
                    }),
            )

[12.2359]

[6.1858]

                        Ok(conn) => future::ok(future::Loop::Break(conn)),
                        Err(acc) => future::ok(future::Loop::Continue(acc)),
                    })
            }))

Deletion in src/xmpp/mod.rs at line 55 [6.17]
∅:D[5.2890] → [7.3373:3375]
```
}
```

Replacement in src/xmpp/mod.rs at line 56 [6.17]

∅:D[5.2998] → [7.3376:3427]

∅:D[7.3427] → [12.2805:2913]

∅:D[12.2913] → [7.3535:3776]

∅:D[13.1190] → [7.3535:3776]

∅:D[7.3535] → [7.3535:3776]

∅:D[7.3776] → [12.2914:3096]

∅:D[12.3096] → [7.3958:4014]

∅:D[13.1312] → [7.3958:4014]

∅:D[7.3958] → [7.3958:4014]

∅:D[7.4014] → [12.3097:3130]

∅:D[12.3130] → [2.534:602]

∅:D[12.3199] → [7.4116:4611]

∅:D[2.602] → [7.4116:4611]

∅:D[14.602] → [7.4116:4611]

∅:D[13.1358] → [7.4116:4611]

∅:D[7.4116] → [7.4116:4611]

impl XmppConnection {
    /// base XMPP processing
    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);
    }
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved
    fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),
    >
    where
        F: Future<Item = T, Error = E>,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                inner: client,

[5.2998]

[5.3955]

    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(
        (sink, stream): (stream::SplitSink<Client>, stream::SplitStream<Client>),
        account: std::rc::Rc<config::Account>,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        Box::new(future::loop_fn(
            (sink, stream, account),
            |(sink, stream, account)| {
                stream.into_future().then(|r| match r {
                    Ok((event, stream)) => match event {
                        Some(Event::Online) => {
                            info!("Online");
                            future::ok(future::Loop::Break(XmppConnection {

Replacement in src/xmpp/mod.rs at line 71 [6.17]

∅:D[5.3996] → [7.4612:4701]

∅:D[7.4701] → [2.603:672]

∅:D[2.672] → [12.3270:3702]

∅:D[12.3270] → [12.3270:3702]

∅:D[12.3702] → [7.5203:5335]

∅:D[13.1647] → [7.5203:5335]

∅:D[7.5203] → [7.5203:5335]

                            };
                            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))),
                            }
                        } else {
                            future::err((account, Ok(Either::A(b))))

[5.3996]

[5.4505]

                                inner: Some((sink, stream)),
                            }))

Replacement in src/xmpp/mod.rs at line 74 [6.17]

∅:D[5.4531] → [7.5336:5779]

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

[5.4531]

[5.4974]

                        Some(Event::Stanza(s)) => {
                            info!("xmpp stanza: {:?}", s);
                            future::ok(future::Loop::Continue((sink, stream, account)))

Replacement in src/xmpp/mod.rs at line 78 [6.17]

∅:D[5.5000] → [7.5780:5802]

∅:D[7.5802] → [12.3703:3792]

∅:D[12.3792] → [7.5891:6129]

∅:D[13.1837] → [7.5891:6129]

∅:D[7.5891] → [7.5891:6129]

∅:D[7.6129] → [12.3793:3840]

∅:D[12.3840] → [7.6176:6241]

∅:D[13.1878] → [7.6176:6241]

∅:D[7.6176] → [7.6176:6241]

∅:D[7.6241] → [12.3841:3907]

                    }
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::B((e, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Err(e.into()),
                            )))
                        } else {
                            future::err((account, Err(e.into())))

[5.5000]

[5.5513]

                        _ => {
                            warn!("Disconnected");
                            future::err(account)

Insertion in src/xmpp/mod.rs at line 82 [6.17]

[5.5539]

                    },
                    Err((e, _)) => {
                        error!("xmpp receive error: {}", e);
                        future::err(account)

Replacement in src/xmpp/mod.rs at line 89 [6.17]
∅:D[5.5595] → [7.6308:6318]
```
        )
```
[5.5595]
[6.3349]
```
        ))
```

Replacement in src/xmpp/mod.rs at line 92 [6.17]

∅:D[6.3356] → [7.6319:6432]

∅:D[7.6432] → [2.673:746]

∅:D[2.746] → [12.3982:4396]

∅:D[12.3982] → [12.3982:4396]

∅:D[12.4396] → [14.3687:3693]

∅:D[13.3137] → [14.3687:3693]

∅:D[14.3687] → [14.3687:3693]

    /// get connection and wait for online status and set presence
    /// returns error if something went wrong
    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(format_err!("Disconnected while online"))
            }
        }
    }

[6.3356]

[14.3693]

    fn self_presence(self) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        let XmppConnection { account, inner } = self;
        if let Some((sink, stream)) = inner {
            use tokio::prelude::Sink;

Replacement in src/xmpp/mod.rs at line 97 [6.17]

∅:D[14.3694] → [2.747:2496]

    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection {
            account,
            inner: client,
        } = self;
        use tokio::prelude::Sink;
        let id_get_roster: String = "id_get_roster0".to_string();
        let get_roster = stanzas::make_get_roster(&id_get_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
                .processing(
                    move |_conn, event| {
                        if let Event::Stanza(s) = event {
                            use try_from::TryInto;
                            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                                Ok(iq) => {
                                    if let Some(id) = iq.id {
                                        if id == id_get_roster {
                                            match iq.payload {
                                                xmpp_parsers::iq::IqType::Error(_e) => {
                                                    Err(format_err!("Get error instead of roster"))
                                                }
                                                _ => Ok(true),

[14.3694]

[2.2496]

            let presence = stanzas::make_presence(&account);
            info!("Sending presence...");
            Box::new(
                sink.send(presence)
                    .map_err(|e| {
                        error!("Error on send self-presence: {}", e);
                        "Cann't send self-presence".to_owned()
                    })
                    .join(
                        future::loop_fn((account.clone(), stream), |(account, stream)| {
                            stream
                                .into_future()
                                .map_err(|(e, _)| {
                                    error!("Error on reading self-presence: {}", e);
                                    "Cann't read self-presence".to_owned()
                                })
                                .and_then(|(event, stream)| match event {
                                    Some(event) => {
                                        if let tokio_xmpp::Event::Stanza(e) = event {
                                            info!("Get stanza: {:?}", e);
                                            if e.name() == "presence"
                                                && e.attr("from")
                                                    .map_or(false, |f| f == account.jid)
                                                && e.attr("to").map_or(false, |f| f == account.jid)
                                            {
                                                info!("Self presence");
                                                future::ok(future::Loop::Break(stream))
                                            } else {
                                                future::ok(future::Loop::Continue((
                                                    account, stream,
                                                )))

Replacement in src/xmpp/mod.rs at line 130 [6.17]

∅:D[2.2591] → [2.2591:2645]

                                            Ok(false)

[2.2591]

[2.2645]

                                            future::err("Got wrong event".to_owned())

Deletion in src/xmpp/mod.rs at line 132 [6.17]

∅:D[2.2687] → [2.2687:2813]

                                    } else {
                                        Err(format_err!("Iq stanza without id"))

Replacement in src/xmpp/mod.rs at line 133 [6.17]

∅:D[2.2851] → [2.2851:3693]

∅:D[2.3693] → [12.4397:4614]

∅:D[14.3694] → [12.4397:4614]

∅:D[12.4614] → [2.3694:3789]

∅:D[2.3789] → [7.7173:7207]

∅:D[14.3790] → [7.7173:7207]

∅:D[13.3315] → [7.7173:7207]

∅:D[7.7173] → [7.7173:7207]

∅:D[5.6217] → [3.784:785]

∅:D[8.1012] → [3.784:785]

∅:D[9.1649] → [3.784:785]

∅:D[10.2775] → [3.784:785]

∅:D[11.1428] → [3.784:785]

∅:D[15.1927] → [3.784:785]

∅:D[7.7207] → [3.784:785]

∅:D[3.784] → [3.784:785]

∅:D[3.785] → [7.7208:7265]

∅:D[13.3354] → [7.7303:7343]

∅:D[7.7303] → [7.7303:7343]

∅:D[7.7343] → [2.3790:3844]

∅:D[2.3844] → [12.4615:5257]

∅:D[7.7343] → [12.4615:5257]

∅:D[12.5257] → [2.3845:3934]

∅:D[2.3934] → [12.5257:5558]

∅:D[12.5257] → [12.5257:5558]

                                }
                                Err(_e) => Ok(false),
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting roster"))
                        }
                    },
                    stop_future,
                )
            })
            .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),
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection {
            account,
            inner: client,
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {:?}", presence);
        client
            .send(presence)
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting self-presence"))

[2.2851]

[12.5558]

                                    None => future::err("Got closed stream".to_owned()),
                                })
                        })
                        .map_err(|e| format!("waiting self-presence: {}", e)),
                    )
                    .then(|r| match r {
                        Err(e) => {
                            error!("Self-presence waiting error: {}", e);
                            future::err(account)

Replacement in src/xmpp/mod.rs at line 143 [6.17]

∅:D[12.5584] → [12.5584:5705]

∅:D[12.5705] → [2.3935:3975]

∅:D[2.3975] → [12.5744:5926]

∅:D[12.5744] → [12.5744:5926]

                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                Err((account, _e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })

[12.5584]

[6.3783]

                        Ok(inner) => future::ok(XmppConnection {
                            account,
                            inner: Some(inner),
                        }),
                    }),
            )
        } else {
            warn!("Don't gen connection on self-presence");
            Box::new(future::err(account)) as Box<Future<Item = _, Error = _>>
        }

Replacement in src/xmpp/mod.rs at line 157 [6.17]

∅:D[16.60] → [2.3976:4055]

pub struct XmppCommand {
    pub xmpp_to: jid::Jid,
    pub message: String,
}

[16.60]

[6.3816]

pub struct XmppCommand;

Replacement in src/xmpp/mod.rs at line 162 [6.17]
∅:D[6.3891] → [7.8744:8775]
```
    conn: MaybeXmppConnection,
```
[6.3891]
[6.3917]
```
    conn: XmppConnection,
```

Replacement in src/xmpp/mod.rs at line 166 [6.17]

∅:D[16.133] → [7.8776:8859]

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

[16.133]

[6.4038]

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

Replacement in src/xmpp/mod.rs at line 181 [6.17]

∅:D[6.4311] → [12.5927:6054]

    F: future::Future + Clone + 'static,
    <F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,

[6.4311]

[17.465]

    F: future::Future<Item = ()> + 'static,

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

∅:D[13.5814] → [7.8988:9038]

∅:D[6.4357] → [7.8988:9038]

    let conn = MaybeXmppConnection::new(account);

[6.4357]

[6.4526]

    let signal = signal.map_err(|_| format_err!("Wrong shutdown signal"));
    let conn = XmppConnection::new(account);

Replacement in src/xmpp/mod.rs at line 194 [6.17]

∅:D[6.4692] → [12.6055:6123]

        conn.connect(signal.clone())
            .and_then(|conn| {

[6.4692]

[6.4761]

        signal
            .select2(conn.connect().and_then(|conn| {

Replacement in src/xmpp/mod.rs at line 203 [6.17]

∅:D[17.675] → [12.6124:6205]

                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })

[17.675]

[17.731]

                    .map(|f| (f, conn))
            }))

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

∅:D[6.5146] → [12.6206:6779]

                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))
                        }

[6.5146]

[13.6239]

                    Ok(Either::A((_x, b))) => {
                        info!("Got signal");
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok(Either::B((x, a))) => {
                        info!("Got cmd");
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1,
                        )))) as Box<Future<Item = _, Error = _>>

Replacement in src/xmpp/mod.rs at line 222 [6.17]

∅:D[13.6261] → [12.6780:6812]

                    Err(e) => {

[13.6261]

[6.6240]

                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::B((e, _a))) => {

Replacement in src/xmpp/mod.rs at line 231 [6.17]

∅:D[6.6342] → [2.4056:4095]

                        future::err(e)

[6.6342]

[6.6572]

                        Box::new(future::err(format_err!("Cmd error")))
                            as Box<Future<Item = _, Error = _>>

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

∅:D[17.900] → [7.9860:9934]

    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {

[17.900]

[17.969]

    .and_then(|(opt_cmd_recv, _conn): (Option<S>, XmppConnection)| {

Replacement in src/xmpp/mod.rs at line 247 [6.17]

∅:D[17.1354] → [12.6876:6913]

            Box::new(future::ok(()))

[17.1354]

[17.1422]

            Box::new(future::err(format_err!("cmd receiver gone")))

Insertion in src/main.rs at line 22 [18.17]
[8.3921]
[8.3953]
```
use hyper::service::service_fn;
```
Replacement in src/main.rs at line 28 [18.17]
∅:D[8.4066] → [2.4096:4140]
```
use tokio::prelude::{Future, Sink, Stream};
```
[8.4066]
[8.4092]
```
use tokio::prelude::Sink;
```

Deletion in src/main.rs at line 38 [18.17]

∅:D[8.4260] → [2.4141:5074]

∅:D[2.5074] → [19.4701:4702]

∅:D[19.4701] → [19.4701:4702]

∅:D[19.4702] → [2.5075:9738]


struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = Box<dyn std::error::Error + Sync + Send + 'static>;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<jid::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s).map_err(|e: jid::JidParseError| e.into())
                    })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        }),
                )) as Box<Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| {
                            Box::new(e) as Box<dyn std::error::Error + Sync + Send + 'static>
                        })
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| {
                                            Box::new(e)
                                                as Box<
                                                    dyn std::error::Error + Sync + Send + 'static,
                                                >
                                        }),
                                ))
                                    as Box<Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = Box<dyn std::error::Error + Sync + Send + 'static>;
    type Service = ServiceCmd;
    type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
    type MakeError = hyper::http::Error;
    fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
        tokio::prelude::future::ok(ServiceCmd {
            cmd_send: self.cmd_send.clone(),
        })
    }
}

Replacement in src/main.rs at line 63 [18.17]

∅:D[8.4954] → [12.6914:7021]

        .map_err(|e| {
            error!("Cann't get CTRL+C signal: {}", e.0);
            e.0
        })

[8.4954]

[8.5020]

        .map_err(|e| error!("Cann't get CTRL+C signal: {}", e.0))

Replacement in src/main.rs at line 69 [18.17]

∅:D[8.5155] → [2.9740:9784]

        .serve(MakeServiceCmd { cmd_send })

[8.5155]

[8.5935]

        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })

Replacement in src/main.rs at line 97 [18.17]

∅:D[8.6389] → [12.7022:7110]

        let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));

[8.6389]

[8.6536]

        let result = ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            recv,
            config.account,
        ));

Replacement in Cargo.toml at line 23 [18.11995]

∅:D[8.7111] → [2.9785:9878]

try_from = "=0.2.2" # dependency of xmpp-parsers
jid = "=0.5.2" # dependency of xmpp-parsers

[8.7111]

Replacement in Cargo.lock at line 603 [18.12201]
∅:D[20.3558] → [8.26771:26849]
∅:D[2.12571] → [8.26771:26849]
∅:D[10.10594] → [8.26771:26849]
∅:D[15.7688] → [8.26771:26849]
∅:D[21.5210] → [8.26771:26849]
∅:D[19.7327] → [8.26771:26849]
∅:D[22.7967] → [8.26771:26849]
∅:D[8.26771] → [8.26771:26849]
```
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
```
[2.12571]
[8.26849]
```
 "serde_json 1.0.34 (registry+https://github.com/rust-lang/crates.io-index)",
```
Deletion in Cargo.lock at line 1116 [18.12201]
∅:D[2.15026] → [2.15026:15096]
```
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
```
Deletion in Cargo.lock at line 1125 [18.12201]
∅:D[8.44807] → [2.15329:15404]
```
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
```
Replacement in Cargo.lock at line 1145 [18.12201]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
∅:D[8.45396] → [8.45396:45415]
```
version = "1.0.33"
```
[8.45396]
[8.45415]
```
version = "1.0.34"
```
Replacement in Cargo.lock at line 1984 [18.12201]
∅:D[20.12481] → [8.92248:92402]
∅:D[2.21640] → [8.92248:92402]
∅:D[10.20129] → [8.92248:92402]
∅:D[15.15588] → [8.92248:92402]
∅:D[21.12956] → [8.92248:92402]
∅:D[19.16471] → [8.92248:92402]
∅:D[22.16499] → [8.92248:92402]
∅:D[8.92248] → [8.92248:92402]
```
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
```
[2.21640]
[8.92402]
```
"checksum serde_json 1.0.34 (registry+https://github.com/rust-lang/crates.io-index)" = "bdf540260cfee6da923831f4776ddc495ada940c30117977c70f1313a6130545"
```