O01eg/sendxmppd-rs - Change U3UZTFCHHGY3ZCBSFFCC76EPEJBBDTEAQDREM4KDYTNDSTVMUS2QC

Re-try to subscribe if not subscribed

Created by O01eg on October 27, 2019

U3UZTFCHHGY3ZCBSFFCC76EPEJBBDTEAQDREM4KDYTNDSTVMUS2QC

Dependencies

In channels

main

Change contents

Replacement in src/xmpp/xmpp_connection.rs at line 0 [3.21]

∅:D[3.21] → [2.0:34146]

use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
}
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            state: Some(from.state),
        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            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,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
    /// connects if nothing connected
    /// don't connect only if stop_future resolved
    pub 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,
    {
        info!("xmpp connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        } else {
            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                }
                                .processing(XmppConnection::online, stop_future.clone())
                                .map_err(|(acc, _)| acc)
                                .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),
                                })
                                .and_then(|conn| conn.initial_roster(stop_future2))
                                .and_then(|conn| conn.self_presence(stop_future3))
                                .and_then(|conn| conn.enter_mucs(stop_future4))
                                .then(|r| match r {
                                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                                }),
                            )
                        })
                        .map_err(|_: ()| ()),
                    )
                    .then(|r| match r {
                        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"))
                        }
                    }),
            )
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(roster) =
            element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
        {
            // RFC 6212 2.1.6. Roster Push
            info!("Got roster push {} from {:?}", id, from);
            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;
                    rdata.1 = i.ask;
                } else {
                    info!("Add {} to roster", i.jid);
                    self.state
                        .data
                        .roster
                        .insert(i.jid.clone(), (i.subscription, i.ask));
                }
                self.process_jid(&i.jid);
            }
            return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ set request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        use std::convert::TryInto;
        if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
            info!("Got ping {} from {:?}", id, from);
            return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
        }
        warn!(
            "Unsupported IQ get request from {:?}: {}",
            from,
            String::from(&element)
        );
        stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
    pub fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    where
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(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,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                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);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                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)))
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
            }
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        client
            .send(Packet::Stanza(get_roster))
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(move |conn, _| Ok(conn.state.data.roster_init), stop_future)
                .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),
                })
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {}", String::from(&presence));
        client
            .send(Packet::Stanza(presence))
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(
                    move |conn, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .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),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    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 {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub 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());
            info!(
                "Sending muc leave presence... {}",
                String::from(&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(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

[3.21]

use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
use std::collections::{HashMap, VecDeque};
use super::XmppCommand;
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// ids counter
    counter: usize,
    /// map from id of adding item to roster and jid of item
    pending_add_roster_ids: HashMap<String, xmpp_parsers::Jid>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
struct XmppElementProcessor {
    incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,
}
impl XmppElementProcessor {
    fn new() -> XmppElementProcessor {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {:#?}", e);
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        XmppElementProcessor { incoming }
    }
}
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            state: Some(from.state),
        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            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,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
    /// connects if nothing connected
    /// don't connect only if stop_future resolved
    pub 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,
    {
        info!("xmpp connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        } else {
            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                }
                                .processing(XmppConnection::online, stop_future.clone())
                                .map_err(|(acc, _)| acc)
                                .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),
                                })
                                .and_then(|conn| conn.initial_roster(stop_future2))
                                .and_then(|conn| conn.self_presence(stop_future3))
                                .and_then(|conn| conn.enter_mucs(stop_future4))
                                .then(|r| match r {
                                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                                }),
                            )
                        })
                        .map_err(|_: ()| ()),
                    )
                    .then(|r| match r {
                        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"))
                        }
                    }),
            )
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => {
                let processors = XmppElementProcessor::new();
                processors.incoming.process(self, stanza.clone())
            }
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        use std::convert::TryInto;
        if let Some((_, jid)) = self.state.data.pending_add_roster_ids.remove_entry(&iq.id) {
            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                if self.state.data.roster.contains_key(&jid) {
                    info!("Jid {} updated to roster", jid);
                } else {
                    info!("Jid {} added in roster", jid);
                    self.state.data.roster.insert(
                        jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                self.process_jid(&jid);
            } else {
                warn!(
                    "Wrong payload when adding {} to roster: {:?}",
                    jid, iq.payload
                );
            }
        }
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                if let Some(roster) =
                    element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                {
                    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;
                            rdata.1 = i.ask;
                        } else {
                            info!("Add {} to roster", i.jid);
                            self.state
                                .data
                                .roster
                                .insert(i.jid.clone(), (i.subscription, i.ask));
                        }
                        self.process_jid(&i.jid);
                    }
                }
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                if let Some(_ping) = element.try_into().ok() as Option<xmpp_parsers::ping::Ping> {
                    let pong = stanzas::make_pong(&iq.id, self.state.client.jid.clone(), iq.from);
                    self.state.data.send_queue.push_back(pong);
                }
            }
            _ => (), // ignore
        }
        true
    }
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
    pub fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    where
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(
                        client
                            .send(Packet::Stanza(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,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                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);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                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)))
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
            }
        }
    }
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
            use std::convert::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if iq.id == id_init_roster {
                        match iq.payload {
                            xmpp_parsers::iq::IqType::Error(_e) => {
                                error!("Get error instead of roster");
                                Err(())
                            }
                            xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                                    Ok(roster) => {
                                        self.state.data.roster.clear();
                                        info!("Got first roster:");
                                        for i in roster.items {
                                            info!(" >>> {:?}", i);
                                            self.state
                                                .data
                                                .roster
                                                .insert(i.jid, (i.subscription, i.ask));
                                        }
                                        Ok(true)
                                    }
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                                }
                            }
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }
                        }
                    } else {
                        Ok(false)
                    }
                }
                Err(_e) => Ok(false),
            }
        } else {
            error!("Wrong event while waiting roster");
            Err(())
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(Packet::Stanza(get_roster))
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )
                .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),
                })
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {:?}", presence);
        client
            .send(Packet::Stanza(presence))
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(
                    move |conn, event| {
                        if let Event::Stanza(s) = event {
                            use std::convert::TryInto;
                            match s.try_into() as Result<xmpp_parsers::presence::Presence, _> {
                                Ok(presence) => {
                                    Ok(presence.from.as_ref() == Some(&conn.state.client.jid))
                                }
                                Err(e) => {
                                    warn!("Not a self-presence: {}", e);
                                    Ok(false)
                                }
                            }
                        } else {
                            error!("Wrong event while waiting self-presence");
                            Err(())
                        }
                    },
                    stop_future,
                )
                .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),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    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 {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    } else {
                        warn!(
                            "Not subscribed to {}. Currently in {:?} state",
                            xmpp_to, rdata.1
                        );
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
            }
        }
    }
    pub 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());
            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(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {:?}", muc_presence);
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

Deletion in src/xmpp/stanzas.rs at line 7 [5.13]
∅:D[4.35465] → [2.34147:34223]
```
use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
```

Deletion in src/xmpp/stanzas.rs at line 43 [5.13]

∅:D[2.34704] → [2.34704:34956]

}
pub fn make_roster_push_answer(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut answer = Iq::from_result(id, None as Option<Roster>);
    answer.from = Some(from);
    answer.to = to;
    answer

Replacement in src/xmpp/stanzas.rs at line 94 [5.13]

∅:D[2.35186] → [2.35186:35277]

pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {

[2.35186]

[2.35277]

pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {

Replacement in src/xmpp/stanzas.rs at line 98 [5.13]

∅:D[2.35387] → [2.35387:35891]

    pong
}
pub fn make_iq_unsupported_error(
    id: String,
    from: xmpp_parsers::Jid,
    to: Option<xmpp_parsers::Jid>,
) -> Iq {
    let mut error = Iq::from_error(
        id,
        StanzaError {
            type_: ErrorType::Cancel,
            by: Some(from.clone()),
            defined_condition: DefinedCondition::ServiceUnavailable,
            texts: std::collections::BTreeMap::new(),
            other: None,
        },
    );
    error.from = Some(from);
    error.to = to;
    error

[2.35387]

[6.41574]

    pong.into()

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

∅:D[7.55931] → [2.36033:36071]

pub use xmpp_connection::XmppCommand;

[7.55931]

[7.60161]

#[derive(Debug)]
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
}

Replacement in src/xmpp/element_processor.rs at line 0 [9.11301]

∅:D[9.11301] → [2.36072:37169]

type Func<S, T, E> = dyn Fn(&mut S, E) -> T + Sync;
pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
    processors: Vec<Box<Func<S, Option<T>, E>>>,
    default: &'static Func<S, T, E>,
}
impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
    pub fn new<F>(f: &'static F) -> Processor<S, T, E>
    where
        F: Fn(&mut S, E) -> T + Sync + 'static,
    {
        Processor {
            processors: vec![],
            default: f,
        }
    }
    pub fn register<F, A>(&mut self, f: &'static F)
    where
        F: Fn(&mut S, A) -> T + Sync + 'static,
        A: std::convert::TryFrom<E>,
    {
        self.processors.push(Box::new(move |s, e: E| {
            use std::convert::TryInto;
            (e.try_into().ok() as Option<A>).map(|a| f(s, a))
        }));
    }
    pub fn process(&self, s: &mut S, e: E) -> T {
        for processor in self.processors.iter() {
            match processor(s, e.clone()) {
                Some(t) => return t,
                None => continue,
            }
        }
        (*self.default)(s, e)
    }
}

[9.11301]

type Func<S, T, E> = dyn Fn(&mut S, E) -> T;
pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
    processors: Vec<Box<Func<S, Option<T>, E>>>,
    default: &'static Func<S, T, E>,
}
impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
    pub fn new<F>(f: &'static F) -> Processor<S, T, E>
    where
        F: Fn(&mut S, E) -> T + 'static,
    {
        Processor {
            processors: vec![],
            default: f,
        }
    }
    pub fn register<F, A>(&mut self, f: &'static F)
    where
        F: Fn(&mut S, A) -> T + 'static,
        A: std::convert::TryFrom<E>,
    {
        self.processors.push(Box::new(move |s, e: E| {
            use std::convert::TryInto;
            (e.try_into().ok() as Option<A>).map(|a| f(s, a))
        }));
    }
    pub fn process(&self, s: &mut S, e: E) -> T {
        for processor in self.processors.iter() {
            match processor(s, e.clone()) {
                Some(t) => return t,
                None => continue,
            }
        }
        (*self.default)(s, e)
    }
}

Deletion in src/main.rs at line 21 [11.17]
∅:D[10.41232] → [2.37170:37209]
```
#[macro_use]
extern crate lazy_static;
```
Insertion in src/main.rs at line 215 [11.17]
[10.49351]
[10.49388]
```
    use hyper::rt::{Future, Stream};
```

Deletion in Cargo.toml at line 23 [11.11995]

∅:D[4.54630] → [2.37279:37356]

lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough

Insertion in Cargo.lock at line 2 [11.12201]

[6.47733]

[12.48451]

[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 28 [11.12201]
∅:D[10.53649] → [2.37450:37469]
```
version = "0.3.11"
```
[10.53649]
[13.46847]
```
version = "0.3.10"
```

Replacement in Cargo.lock at line 44 [11.12201]

∅:D[10.54069] → [2.37470:37616]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.54069]

[2.37616]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 51 [11.12201]
∅:D[4.55455] → [2.37690:37708]
```
version = "0.1.4"
```
[4.55455]
[10.54338]
```
version = "0.1.2"
```
Replacement in Cargo.lock at line 56 [11.12201]
∅:D[10.54435] → [2.37709:37728]
```
version = "0.3.30"
```
[10.54435]
[10.54454]
```
version = "0.3.15"
```

Replacement in Cargo.lock at line 59 [11.12201]

∅:D[10.54536] → [2.37729:37803]

 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.54536]

[4.55568]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 61 [11.12201]

∅:D[4.55649] → [2.37804:38031]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",

[4.55649]

[10.54991]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 72 [11.12201]

∅:D[10.55130] → [2.38032:38174]

 "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.55130]

[10.55272]

 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 81 [11.12201]

∅:D[10.55404] → [2.38175:38251]

 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.55404]

[10.55480]

 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 86 [11.12201]
∅:D[10.55513] → [2.38252:38270]
```
version = "1.1.0"
```
[10.55513]
[10.55531]
```
version = "1.0.4"
```
Replacement in Cargo.lock at line 102 [11.12201]
∅:D[10.56068] → [2.38271:38289]
```
version = "0.7.3"
```
[10.56068]
[10.56538]
```
version = "0.7.0"
```

Replacement in Cargo.lock at line 105 [11.12201]

∅:D[10.56620] → [2.38290:38370]

 "block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.56620]

[4.56635]

 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 107 [11.12201]

∅:D[4.56712] → [2.38371:38447]

 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",

[4.56712]

[4.56788]

 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 113 [11.12201]
∅:D[4.56907] → [2.38448:38466]
```
version = "0.1.4"
```
[4.56907]
[4.56925]
```
version = "0.1.3"
```
Replacement in Cargo.lock at line 126 [11.12201]
∅:D[10.56847] → [2.38467:38485]
```
version = "1.3.2"
```
[10.56847]
[10.56865]
```
version = "1.3.1"
```

Replacement in Cargo.lock at line 134 [11.12201]

∅:D[10.57059] → [2.38506:38655]

 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.57059]

[10.57135]

 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 145 [11.12201]
∅:D[10.57344] → [2.38656:38675]
```
version = "1.0.37"
```
[10.57344]
[10.57363]
```
version = "1.0.35"
```
Replacement in Cargo.lock at line 150 [11.12201]
∅:D[10.57457] → [2.38676:38694]
```
version = "0.1.9"
```
[10.57457]
[10.57475]
```
version = "0.1.7"
```

Replacement in Cargo.lock at line 158 [11.12201]

∅:D[10.57669] → [2.38695:38851]

 "num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",

[10.57669]

[4.57259]

 "num-integer 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 170 [11.12201]

∅:D[10.58176] → [2.38872:38947]

 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.58176]

[2.38947]

 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 182 [11.12201]

∅:D[10.58687] → [2.39097:39172]

 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.58687]

[10.58762]

 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 187 [11.12201]
∅:D[10.58802] → [2.39173:39191]
```
version = "0.6.4"
```
[10.58802]
[10.58820]
```
version = "0.5.1"
```

Replacement in Cargo.lock at line 190 [11.12201]

∅:D[10.58902] → [2.39192:39350]

 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.58902]

[10.59060]

 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 196 [11.12201]
∅:D[10.59104] → [2.39351:39369]
```
version = "0.6.2"
```
[10.59104]
[10.59638]
```
version = "0.5.1"
```

Insertion in Cargo.lock at line 198 [11.12201]

[10.59703]

[10.60184]

dependencies = [
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 217 [11.12201]

∅:D[14.71853] → [2.39370:39443]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[14.71853]

[14.71926]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 237 [11.12201]

∅:D[10.60544] → [2.39444:39517]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.60544]

[6.49467]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 267 [11.12201]
∅:D[10.61551] → [10.61551:61564]
∅:D[10.61551] → [10.61551:61564]
∅:D[10.61551] → [10.61551:61564]
∅:D[10.61564] → [2.39518:39617]
```
[[package]]
name = "either"
version = "1.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
```

Replacement in Cargo.lock at line 273 [11.12201]

∅:D[10.61686] → [2.39631:39704]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.61686]

[10.61759]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 284 [11.12201]

∅:D[4.59057] → [2.39724:39872]

 "regex 1.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",

[4.59057]

[10.62260]

 "regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 293 [11.12201]

∅:D[10.62396] → [2.39873:39950]

 "backtrace 0.3.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.62396]

[10.62473]

 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 301 [11.12201]

∅:D[10.62605] → [2.39951:40028]

 "backtrace 0.3.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.62605]

[4.59304]

 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 310 [11.12201]

∅:D[10.62902] → [2.40029:40108]

 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.62902]

[2.40108]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 312 [11.12201]

∅:D[2.40181] → [2.40181:40333]

 "syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",

[2.40181]

[10.63206]

 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 349 [11.12201]

∅:D[10.64039] → [2.40334:40409]

 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.64039]

[10.64114]

 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 369 [11.12201]
∅:D[10.64642] → [2.40410:40429]
```
version = "0.1.27"
```
[10.64642]
[10.64661]
```
version = "0.1.26"
```

Replacement in Cargo.lock at line 377 [11.12201]

∅:D[10.64864] → [2.40430:40581]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.64864]

[10.65015]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 391 [11.12201]
∅:D[10.65256] → [2.40582:40601]
```
version = "0.1.23"
```
[10.65256]
[10.65275]
```
version = "0.1.18"
```

Replacement in Cargo.lock at line 394 [11.12201]

∅:D[10.65357] → [2.40602:40678]

 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.65357]

[2.40678]

 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 397 [11.12201]

∅:D[10.65576] → [2.40752:40827]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[10.65576]

[2.40827]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 402 [11.12201]

∅:D[4.60570] → [2.40900:40973]

 "string 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",

[4.60570]

[6.50537]

 "string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 420 [11.12201]

∅:D[10.66500] → [2.40974:41046]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.66500]

[10.66572]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 431 [11.12201]

∅:D[10.66919] → [2.41141:41212]

 "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.66919]

[2.41212]

 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 435 [11.12201]

∅:D[2.41227] → [2.41227:41642]

∅:D[2.41642] → [10.66990:67005]

∅:D[10.66990] → [10.66990:67005]

name = "http-body"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-buf 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]

Replacement in Cargo.lock at line 449 [11.12201]
∅:D[10.67346] → [2.41643:41663]
```
version = "0.12.30"
```
[10.67346]
[10.67366]
```
version = "0.12.27"
```

Replacement in Cargo.lock at line 453 [11.12201]

∅:D[2.41737] → [2.41737:41812]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[2.41737]

[10.67596]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 455 [11.12201]

∅:D[10.67678] → [2.41813:41883]

 "h2 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)",

[10.67678]

[2.41883]

 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 457 [11.12201]

∅:D[2.41955] → [2.41955:42031]

 "http-body 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 459 [11.12201]

∅:D[10.67967] → [2.42032:42103]

 "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.67967]

[4.61498]

 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 464 [11.12201]

∅:D[4.61721] → [2.42104:42253]

 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-buf 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

[4.61721]

[2.42253]

 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 469 [11.12201]

∅:D[4.62107] → [2.42335:42498]

 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",

[4.62107]

[10.68881]

 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 494 [11.12201]

∅:D[10.69566] → [2.42499:42571]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.69566]

[10.69638]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 504 [11.12201]

∅:D[10.69922] → [2.42572:42646]

 "socket2 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.69922]

[10.69996]

 "socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 512 [11.12201]
∅:D[10.70248] → [2.42721:42739]
```
version = "0.4.4"
```
[10.70248]
[10.70266]
```
version = "0.4.3"
```

Insertion in Cargo.lock at line 542 [11.12201]

[6.51736]

[10.71142]

source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lazycell"
version = "1.2.1"

Replacement in Cargo.lock at line 551 [11.12201]
∅:D[10.71348] → [2.42740:42759]
```
version = "0.2.58"
```
[10.71348]
[10.71367]
```
version = "0.2.51"
```

Replacement in Cargo.lock at line 573 [11.12201]

∅:D[13.54885] → [2.42779:42852]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[13.54885]

[10.72039]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 596 [11.12201]

∅:D[4.63314] → [2.42955:43108]

 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",

[4.63314]

[6.52105]

 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 631 [11.12201]
∅:D[10.73854] → [2.43109:43128]
```
version = "0.6.19"
```
[10.73854]
[10.73873]
```
version = "0.6.16"
```

Replacement in Cargo.lock at line 638 [11.12201]

∅:D[10.74272] → [2.43129:43201]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.74272]

[4.64040]

 "lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 653 [11.12201]

∅:D[10.74980] → [2.43202:43345]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",

[10.74980]

[10.75123]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 670 [11.12201]
∅:D[10.75588] → [2.43346:43364]
```
version = "0.2.3"
```
[10.75588]
[10.75606]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 674 [11.12201]

∅:D[6.52505] → [2.43365:43437]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[6.52505]

[4.64406]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 676 [11.12201]

∅:D[4.64476] → [2.43438:43514]

 "openssl 0.10.23 (registry+https://github.com/rust-lang/crates.io-index)",

[4.64476]

[10.75984]

 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 678 [11.12201]

∅:D[10.76064] → [2.43515:43594]

 "openssl-sys 0.9.47 (registry+https://github.com/rust-lang/crates.io-index)",

[10.76064]

[6.52734]

 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 680 [11.12201]

∅:D[6.52810] → [2.43595:43844]

 "security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.8 (registry+https://github.com/rust-lang/crates.io-index)",

[6.52810]

[10.76468]

 "security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 690 [11.12201]

∅:D[10.76598] → [2.43845:43990]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.76598]

[2.43990]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 707 [11.12201]
∅:D[10.77092] → [2.44064:44083]
```
version = "0.1.41"
```
[10.77092]
[10.77111]
```
version = "0.1.39"
```

Replacement in Cargo.lock at line 710 [11.12201]

∅:D[10.77193] → [2.44084:44235]

 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",

[10.77193]

[10.77270]

 "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 715 [11.12201]
∅:D[10.77305] → [2.44236:44254]
```
version = "0.2.8"
```
[10.77305]
[10.77323]
```
version = "0.2.6"
```

Deletion in Cargo.lock at line 717 [11.12201]

∅:D[10.77388] → [2.44255:44348]

dependencies = [
 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 720 [11.12201]
∅:D[10.77419] → [2.44349:44368]
```
version = "1.10.1"
```
[10.77419]
[10.77438]
```
version = "1.10.0"
```

Replacement in Cargo.lock at line 723 [11.12201]

∅:D[10.77520] → [2.44369:44441]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.77520]

[10.77592]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 727 [11.12201]
∅:D[2.44455] → [2.44455:44554]
∅:D[2.44554] → [4.65309:65322]
∅:D[10.77594] → [4.65309:65322]
```
name = "numtoa"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
```
Replacement in Cargo.lock at line 733 [11.12201]
∅:D[10.77742] → [2.44555:44575]
```
version = "0.10.23"
```
[10.77742]
[10.77762]
```
version = "0.10.20"
```

Replacement in Cargo.lock at line 736 [11.12201]

∅:D[10.77844] → [2.44576:44724]

 "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.77844]

[10.77992]

 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 740 [11.12201]

∅:D[6.53391] → [2.44725:44876]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.47 (registry+https://github.com/rust-lang/crates.io-index)",

[6.53391]

[10.78301]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 751 [11.12201]
∅:D[10.78456] → [2.44877:44896]
```
version = "0.9.47"
```
[10.78456]
[10.78475]
```
version = "0.9.43"
```

Replacement in Cargo.lock at line 754 [11.12201]

∅:D[10.78557] → [2.44897:45113]

 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.78557]

[10.78699]

 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 757 [11.12201]

[10.78777]

[10.78857]

 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 783 [11.12201]

∅:D[10.79584] → [2.45114:45186]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.79584]

[4.66285]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 786 [11.12201]

∅:D[10.79807] → [2.45187:45263]

 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.79807]

[2.45263]

 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 795 [11.12201]

∅:D[4.66636] → [2.45337:45413]

 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",

[4.66636]

[4.66712]

 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 850 [11.12201]
∅:D[10.81639] → [2.45414:45433]
```
version = "0.4.30"
```
[10.81639]
[10.81658]
```
version = "0.4.27"
```

Replacement in Cargo.lock at line 882 [11.12201]

∅:D[10.82609] → [2.45454:45533]

 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.82609]

[10.82688]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 892 [11.12201]

∅:D[4.67870] → [2.45534:45606]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[4.67870]

[4.67942]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 902 [11.12201]

∅:D[4.68192] → [2.45681:45827]

 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[4.68192]

[4.68338]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 908 [11.12201]

∅:D[4.68643] → [2.45828:45906]

 "rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

[4.68643]

[2.45906]

 "rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 920 [11.12201]

∅:D[10.83322] → [2.46055:46129]

 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.83322]

[4.69152]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 955 [11.12201]
∅:D[4.69861] → [2.46130:46148]
```
version = "0.1.4"
```
[4.69861]
[4.69879]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 958 [11.12201]

∅:D[4.69961] → [2.46149:46221]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[4.69961]

[4.70033]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 970 [11.12201]

∅:D[4.70469] → [2.46315:46387]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[4.70469]

[4.70541]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 981 [11.12201]

∅:D[4.70896] → [2.46462:46536]

 "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

[4.70896]

[6.55053]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1016 [11.12201]
∅:D[10.87194] → [2.46639:46657]
```
version = "1.1.7"
```
[10.87194]
[10.87212]
```
version = "1.1.5"
```

Replacement in Cargo.lock at line 1021 [11.12201]

∅:D[6.55403] → [2.46738:46817]

 "regex-syntax 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",

[6.55403]

[10.87525]

 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1023 [11.12201]

∅:D[10.87604] → [2.46818:46896]

 "utf8-ranges 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.87604]

[10.87682]

 "utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1028 [11.12201]
∅:D[10.87719] → [2.46897:46915]
```
version = "0.6.7"
```
[10.87719]
[10.87737]
```
version = "0.6.6"
```
Replacement in Cargo.lock at line 1036 [11.12201]
∅:D[10.87933] → [2.46916:46934]
```
version = "0.5.2"
```
[10.87933]
[10.87951]
```
version = "0.5.1"
```
Replacement in Cargo.lock at line 1053 [11.12201]
∅:D[10.88434] → [2.47009:47028]
```
version = "0.1.15"
```
[10.88434]
[10.88453]
```
version = "0.1.14"
```
Replacement in Cargo.lock at line 1066 [11.12201]
∅:D[10.88755] → [2.47029:47047]
```
version = "0.2.8"
```
[10.88755]
[10.88773]
```
version = "0.2.7"
```
Replacement in Cargo.lock at line 1098 [11.12201]
∅:D[10.89844] → [2.47197:47215]
```
version = "0.3.1"
```
[10.89844]
[10.89862]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 1101 [11.12201]

∅:D[10.89944] → [2.47216:47545]

 "core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.89944]

[10.90273]

 "core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1109 [11.12201]
∅:D[10.90320] → [2.47546:47564]
```
version = "0.3.1"
```
[10.90320]
[10.90338]
```
version = "0.2.3"
```

Replacement in Cargo.lock at line 1112 [11.12201]

∅:D[10.90420] → [2.47565:47651]

 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.90420]

[10.90657]

 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1137 [11.12201]

∅:D[4.73268] → [2.47802:47954]

 "hyper 0.12.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

[4.73268]

[4.73420]

 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1140 [11.12201]

∅:D[4.73565] → [2.47955:48181]

 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",

[4.73565]

[10.91695]

 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1146 [11.12201]

∅:D[4.73948] → [2.48182:48253]

 "toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",

[4.73948]

[2.48253]

 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1152 [11.12201]
∅:D[10.92112] → [2.48334:48353]
```
version = "1.0.92"
```
[10.92112]
[10.92131]
```
version = "1.0.90"
```
Replacement in Cargo.lock at line 1157 [11.12201]
∅:D[10.92231] → [2.48354:48373]
```
version = "1.0.92"
```
[10.92231]
[10.92250]
```
version = "1.0.90"
```

Replacement in Cargo.lock at line 1160 [11.12201]

∅:D[10.92332] → [2.48374:48453]

 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.92332]

[2.48453]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1162 [11.12201]

∅:D[2.48526] → [2.48526:48598]

 "syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)",

[2.48526]

[10.92556]

 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1170 [11.12201]

∅:D[10.92692] → [2.48599:48813]

 "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",

[10.92692]

[10.92906]

 "itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1180 [11.12201]

∅:D[10.93036] → [2.48814:48893]

 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.93036]

[4.74627]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1191 [11.12201]

∅:D[10.93472] → [2.48894:48973]

 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.93472]

[4.74879]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1199 [11.12201]
∅:D[10.93808] → [2.48974:48992]
```
version = "0.8.2"
```
[10.93808]
[10.93826]
```
version = "0.8.1"
```

Replacement in Cargo.lock at line 1202 [11.12201]

∅:D[10.93908] → [2.48993:49072]

 "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.93908]

[4.75131]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1211 [11.12201]
∅:D[10.94325] → [2.49073:49091]
```
version = "0.1.9"
```
[10.94325]
[2.49091]
```
version = "0.1.8"
```

Replacement in Cargo.lock at line 1214 [11.12201]

∅:D[2.49173] → [2.49173:49332]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "signal-hook-registry 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",

[2.49173]

[2.49332]

 "arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 1219 [11.12201]
∅:D[2.49347] → [2.49347:49395]
∅:D[4.75380] → [10.94343:94425]
∅:D[12.57031] → [10.94343:94425]
∅:D[13.63707] → [10.94343:94425]
∅:D[14.80173] → [10.94343:94425]
∅:D[15.47651] → [10.94343:94425]
∅:D[2.49395] → [10.94343:94425]
∅:D[6.57209] → [10.94343:94425]
∅:D[10.94343] → [10.94343:94425]
∅:D[10.94425] → [2.49396:49544]
∅:D[4.75529] → [10.94573:94588]
∅:D[12.57179] → [10.94573:94588]
∅:D[13.63855] → [10.94573:94588]
∅:D[14.80321] → [10.94573:94588]
∅:D[15.47800] → [10.94573:94588]
∅:D[2.49544] → [10.94573:94588]
∅:D[6.57358] → [10.94573:94588]
∅:D[10.94573] → [10.94573:94588]
```
name = "signal-hook-registry"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
```
Replacement in Cargo.lock at line 1230 [11.12201]
∅:D[10.94831] → [2.49545:49564]
```
version = "0.6.10"
```
[10.94831]
[10.94849]
```
version = "0.6.9"
```
Replacement in Cargo.lock at line 1235 [11.12201]
∅:D[10.94944] → [2.49565:49583]
```
version = "0.3.9"
```
[10.94944]
[10.94962]
```
version = "0.3.8"
```

Replacement in Cargo.lock at line 1238 [11.12201]

∅:D[10.95044] → [2.49584:49729]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.95044]

[2.49729]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1251 [11.12201]
∅:D[10.95498] → [2.49884:49902]
```
version = "0.2.0"
```
[10.95498]
[10.95516]
```
version = "0.1.3"
```

Deletion in Cargo.lock at line 1253 [11.12201]

∅:D[10.95581] → [2.49903:49995]

dependencies = [
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 1263 [11.12201]

∅:D[10.96043] → [2.49996:50069]

 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",

[10.96043]

[10.96116]

 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1275 [11.12201]

∅:D[4.76365] → [2.50070:50149]

 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",

[4.76365]

[2.50149]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1307 [11.12201]
∅:D[10.97562] → [2.50242:50262]
```
version = "0.15.36"
```
[10.97562]
[10.97582]
```
version = "0.15.30"
```

Replacement in Cargo.lock at line 1310 [11.12201]

∅:D[10.97664] → [2.50263:50342]

 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.97664]

[2.50342]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1325 [11.12201]
∅:D[10.98140] → [2.50416:50435]
```
version = "0.10.2"
```
[10.98140]
[10.98159]
```
version = "0.10.1"
```

Replacement in Cargo.lock at line 1328 [11.12201]

∅:D[10.98241] → [2.50436:50515]

 "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",

[10.98241]

[2.50515]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1330 [11.12201]

∅:D[2.50588] → [2.50588:50660]

 "syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)",

[2.50588]

[10.98465]

 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1336 [11.12201]
∅:D[10.98576] → [2.50661:50679]
```
version = "3.0.8"
```
[10.98576]
[10.98594]
```
version = "3.0.7"
```

Replacement in Cargo.lock at line 1339 [11.12201]

∅:D[10.98676] → [2.50680:50825]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.98676]

[4.77232]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1343 [11.12201]

∅:D[2.50907] → [2.50907:50988]

 "remove_dir_all 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",

[2.50907]

[2.50988]

 "remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1359 [11.12201]
∅:D[10.99506] → [2.51062:51080]
```
version = "1.0.5"
```
[10.99506]
[10.99524]
```
version = "1.0.4"
```
Replacement in Cargo.lock at line 1367 [11.12201]
∅:D[10.99713] → [2.51081:51099]
```
version = "1.5.3"
```
[10.99713]
[10.99731]
```
version = "1.5.1"
```

Replacement in Cargo.lock at line 1370 [11.12201]

∅:D[10.99813] → [2.51100:51245]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.99813]

[2.51245]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1396 [11.12201]

∅:D[10.100605] → [2.51347:51419]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.100605]

[2.51419]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1403 [11.12201]
∅:D[10.100861] → [2.51574:51593]
```
version = "0.1.21"
```
[10.100861]
[10.100880]
```
version = "0.1.18"
```

Replacement in Cargo.lock at line 1407 [11.12201]

∅:D[2.51667] → [2.51667:51889]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",

[2.51667]

[10.101257]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1416 [11.12201]

∅:D[6.59699] → [2.52059:52136]

 "tokio-sync 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[6.59699]

[4.78773]

 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1418 [11.12201]

∅:D[4.78849] → [2.52137:52383]

 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",

[4.78849]

[4.79095]

 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 1423 [11.12201]

∅:D[4.79247] → [2.52384:52739]

]
[[package]]
name = "tokio-buf"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1430 [11.12201]

∅:D[10.102423] → [2.52740:52815]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[10.102423]

[10.102498]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1439 [11.12201]

∅:D[2.52889] → [2.52889:52964]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[2.52889]

[6.60170]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1448 [11.12201]

∅:D[10.103003] → [2.52984:53059]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[10.103003]

[2.53059]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1458 [11.12201]

∅:D[4.79826] → [2.53160:53235]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[4.79826]

[10.103455]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1466 [11.12201]

∅:D[10.103588] → [2.53236:53311]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[10.103588]

[6.60612]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1468 [11.12201]

∅:D[6.60688] → [2.53312:53396]

 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",

[6.60688]

[10.103823]

 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1477 [11.12201]

∅:D[2.53470] → [2.53470:53545]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[2.53470]

[4.80325]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1487 [11.12201]

∅:D[4.80497] → [2.53546:53621]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[4.80497]

[6.61036]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1490 [11.12201]

∅:D[4.80720] → [2.53622:53769]

 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",

[4.80720]

[4.80797]

 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1496 [11.12201]

∅:D[6.61349] → [2.53852:53929]

 "tokio-sync 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

[6.61349]

[10.105148]

 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1504 [11.12201]

∅:D[10.105285] → [2.53930:54148]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",

[10.105285]

[10.105503]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1508 [11.12201]

∅:D[10.105577] → [2.54149:54227]

 "signal-hook 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.105577]

[2.54227]

 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1517 [11.12201]
∅:D[4.81771] → [2.54383:54401]
```
version = "0.1.6"
```
[4.81771]
[4.81789]
```
version = "0.1.4"
```

Replacement in Cargo.lock at line 1521 [11.12201]

∅:D[6.62053] → [2.54402:54477]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[6.62053]

[10.105965]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1530 [11.12201]

∅:D[2.54551] → [2.54551:54626]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[2.54551]

[10.106527]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1532 [11.12201]

∅:D[10.106599] → [2.54627:54698]

 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",

[10.106599]

[6.62278]

 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1539 [11.12201]
∅:D[10.106867] → [2.54699:54718]
```
version = "0.1.14"
```
[10.106867]
[10.106886]
```
version = "0.1.13"
```

Replacement in Cargo.lock at line 1545 [11.12201]

∅:D[4.82608] → [2.54719:54794]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[4.82608]

[4.82683]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1547 [11.12201]

∅:D[4.82753] → [2.54795:54871]

 "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)",

[4.82753]

[4.82829]

 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1555 [11.12201]
∅:D[10.107694] → [2.54954:54973]
```
version = "0.2.11"
```
[10.107694]
[10.107713]
```
version = "0.2.10"
```

Replacement in Cargo.lock at line 1559 [11.12201]

∅:D[4.83155] → [2.54974:55049]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[4.83155]

[4.83230]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1569 [11.12201]

∅:D[10.108238] → [2.55132:55284]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.108238]

[6.63089]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1576 [11.12201]
∅:D[2.55311] → [2.55311:55329]
```
version = "0.2.0"
```
[2.55311]
[2.55329]
```
version = "0.1.0"
```

Replacement in Cargo.lock at line 1588 [11.12201]

∅:D[2.55578] → [2.55578:55653]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[2.55578]

[4.83941]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1590 [11.12201]

∅:D[4.84011] → [2.55654:55725]

 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",

[4.84011]

[10.109108]

 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1602 [11.12201]

∅:D[2.55799] → [2.55799:55874]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[2.55799]

[10.109624]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1604 [11.12201]

∅:D[10.109696] → [2.55875:55947]

 "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",

[10.109696]

[4.84409]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1606 [11.12201]

∅:D[4.84479] → [2.55948:56019]

 "mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)",

[4.84479]

[10.109909]

 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1620 [11.12201]

∅:D[10.110504] → [2.56094:56169]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[10.110504]

[10.110579]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1622 [11.12201]

∅:D[10.110650] → [2.56170:56247]

 "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.110650]

[6.64220]

 "native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1625 [11.12201]

∅:D[4.85032] → [2.56248:56321]

 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",

[4.85032]

[10.110948]

 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1637 [11.12201]
∅:D[10.111531] → [2.56322:56340]
```
version = "0.5.1"
```
[10.111531]
[10.111549]
```
version = "0.5.0"
```

Replacement in Cargo.lock at line 1640 [11.12201]

∅:D[10.111631] → [2.56341:56414]

 "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",

[10.111631]

[10.111704]

 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1648 [11.12201]

∅:D[10.111844] → [2.56415:56491]

 "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.111844]

[4.85771]

 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1650 [11.12201]

∅:D[4.85845] → [2.56492:56567]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[4.85845]

[10.112069]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1655 [11.12201]

∅:D[4.86140] → [2.56568:56718]

 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",

[4.86140]

[2.56718]

 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1661 [11.12201]

∅:D[4.86529] → [2.56800:56879]

 "tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",

[4.86529]

[4.86608]

 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1671 [11.12201]

∅:D[10.113190] → [2.56880:56953]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.113190]

[4.86848]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1673 [11.12201]

∅:D[4.86922] → [2.56954:57029]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[4.86922]

[4.86997]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1679 [11.12201]

∅:D[4.87374] → [2.57107:57256]

 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",

[4.87374]

[4.87522]

 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1694 [11.12201]

∅:D[4.87641] → [2.57257:57330]

 "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[4.87641]

[4.87714]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1720 [11.12201]

∅:D[4.87772] → [2.57331:57407]

 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",

[4.87772]

[4.87847]

 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1755 [11.12201]
∅:D[10.115838] → [2.57408:57426]
```
version = "1.0.3"
```
[10.115838]
[10.115856]
```
version = "1.0.2"
```

Replacement in Cargo.lock at line 1773 [11.12201]

∅:D[10.116272] → [2.57427:57502]

 "futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)",

[10.116272]

[4.87982]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1878 [11.12201]

∅:D[4.89236] → [2.57818:57889]

 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",

[4.89236]

[4.89307]

 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1895 [11.12201]

∅:D[2.58609] → [2.58609:58680]

 "sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",

[2.58609]

[10.120691]

 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 1899 [11.12201]

[10.120705]

[2.58681]

"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"

Replacement in Cargo.lock at line 1902 [11.12201]

∅:D[10.121168] → [2.58837:58989]

"checksum arc-swap 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)" = "bc4662175ead9cd84451d5c35070517777949a2ed84551764129cedb88384841"

[10.121168]

[4.90636]

"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"

Replacement in Cargo.lock at line 1905 [11.12201]

∅:D[10.121620] → [2.58990:59293]

"checksum autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "0e49efa51329a5fd37e7c79db4621af617cd4e3e5bc224939808d076077077bf"
"checksum backtrace 0.3.30 (registry+https://github.com/rust-lang/crates.io-index)" = "ada4c783bb7e7443c14e0480f429ae2cc99da95065aeab7ee1b81ada0419404f"

[10.121620]

[4.91092]

"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"

Replacement in Cargo.lock at line 1909 [11.12201]

∅:D[4.91399] → [2.59294:59445]

"checksum bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3d155346769a6855b86399e9bc3814ab343cd3d62c7e985113d46a0ec3c281fd"

[4.91399]

[4.91400]

"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"

Replacement in Cargo.lock at line 1911 [11.12201]

∅:D[4.91549] → [2.59446:59757]

"checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
"checksum block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "6d4dc3af3ee2e12f3e5d224e5e1e3d73668abbeb69e566d361f7d5563a4fdf09"

[4.91549]

[4.91860]

"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d75255892aeb580d3c566f213a2b6fdc1c66667839f45719ee1d30ebf2aea591"

Replacement in Cargo.lock at line 1914 [11.12201]

∅:D[4.92013] → [2.59758:59910]

"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"

[4.92013]

[2.59910]

"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"

Replacement in Cargo.lock at line 1917 [11.12201]

∅:D[10.123442] → [2.60060:60355]

"checksum cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)" = "39f75544d7bbaf57560d2168f28fd649ff9c76153874db88bdbdfd839b1a7e7d"
"checksum cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33"

[10.123442]

[10.123737]

"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"

Replacement in Cargo.lock at line 1922 [11.12201]

∅:D[10.124185] → [2.60505:60825]

"checksum core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "25b9e03f145fd4f2bf705e07b900cd41fc636598fe5dc452fd0db1441c3f496d"
"checksum core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"

[10.124185]

[6.68012]

"checksum core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "286e0b41c3a20da26536c6000a280585d519fd07b3956b43aed8a79e9edce980"
"checksum core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "716c271e8613ace48344f723b60b900a93150271e5be206212d052bbc0883efa"

Deletion in Cargo.lock at line 1931 [11.12201]

∅:D[4.93695] → [2.60826:60975]

"checksum either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5527cfe0d098f36e3f8839852688e63c8fff1c90b2b405aef730615f9a7bcf7b"

Replacement in Cargo.lock at line 1944 [11.12201]

∅:D[10.127601] → [2.61130:61281]

"checksum futures 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)" = "a2037ec1c6c1c4f79557762eab1f7eae1f64f6cb418ace90fae88f0942b60139"

[10.127601]

[10.127752]

"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"

Replacement in Cargo.lock at line 1947 [11.12201]

∅:D[4.94778] → [2.61282:61428]

"checksum h2 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)" = "1e42e3daed5a7e17b12a0c23b5b2fbff23a925a570938ebee4baca1a9a1a2240"

[4.94778]

[4.94924]

"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"

Deletion in Cargo.lock at line 1951 [11.12201]

∅:D[2.61577] → [2.61577:61729]

"checksum http-body 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6741c859c1b2463a423a1dbce98d418e6c3c3fc720fb0d45528657320920292d"

Replacement in Cargo.lock at line 1953 [11.12201]

∅:D[4.95373] → [2.61730:61880]

"checksum hyper 0.12.30 (registry+https://github.com/rust-lang/crates.io-index)" = "40e7692b2009a70b1e9b362284add4d8b75880fefddb4acaa5e67194e843f219"

[4.95373]

[10.129112]

"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"

Replacement in Cargo.lock at line 1958 [11.12201]

∅:D[4.95675] → [2.61881:62028]

"checksum itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f"

[4.95675]

[4.95676]

"checksum itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"

Replacement in Cargo.lock at line 1963 [11.12201]

∅:D[6.69392] → [2.62029:62177]

"checksum libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)" = "6281b86796ba5e4366000be6e9e18bf35580adf9e63fbe2294aadb587613a319"

[6.69392]

[2.62177]

"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"

Replacement in Cargo.lock at line 1975 [11.12201]

∅:D[4.97340] → [2.62489:62636]

"checksum mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)" = "83f51996a3ed004ef184e16818edc51fadffe8e7ca68be67f9dee67d84d0ff23"

[4.97340]

[10.132415]

"checksum mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)" = "71646331f2619b1026cc302f87a2b8b648d5c6dd6937846a16cc8ce0f347f432"

Replacement in Cargo.lock at line 1978 [11.12201]

∅:D[10.132712] → [2.62637:62790]

"checksum native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4b2df1a4c22fd44a62147fd8f13dd0f95c9d8ca7b2610299b2a2f9cf8964274e"

[10.132712]

[10.132865]

"checksum native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ff8e08de0070bbf4c31f452ea2a70db092f36f6f2e4d897adf5674477d488fb2"

Replacement in Cargo.lock at line 1982 [11.12201]

∅:D[4.97655] → [2.62791:63400]

"checksum num-integer 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "b85e541ef8255f6cf42bbfe4ef361305c6c135d10919ecc26126c4e5ae94bc09"
"checksum num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "6ba9a427cfca2be13aa6f6403b0b7e7368fe982bfa16fccc450ce74c46cd9b32"
"checksum num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcef43580c035376c0705c42792c294b66974abbfd2789b511784023f71f3273"
"checksum numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"

[4.97655]

[4.97808]

"checksum num-integer 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)" = "e83d528d2677f0518c570baf2b7abdcf0cd2d248860b68507bdcb3e91d4c0cea"
"checksum num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0b3a5d7cc97d6d30d8b9bc8fa19bf45349ffe46241e8816f50f62f6d6aaabee1"
"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"

Replacement in Cargo.lock at line 1986 [11.12201]

∅:D[4.97963] → [2.63401:63553]

"checksum openssl 0.10.23 (registry+https://github.com/rust-lang/crates.io-index)" = "97c140cbb82f3b3468193dd14c1b88def39f341f68257f8a7fe8ed9ed3f628a5"

[4.97963]

[10.134094]

"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"

Replacement in Cargo.lock at line 1988 [11.12201]

∅:D[10.134250] → [2.63554:63709]

"checksum openssl-sys 0.9.47 (registry+https://github.com/rust-lang/crates.io-index)" = "75bdd6dbbb4958d38e47a1d2348847ad1eb4dc205dc5d37473ae504391865acc"

[10.134250]

[4.98271]

"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"

Replacement in Cargo.lock at line 2000 [11.12201]

∅:D[10.136105] → [2.63710:63865]

"checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"

[10.136105]

[10.136260]

"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"

Replacement in Cargo.lock at line 2012 [11.12201]

∅:D[4.101015] → [2.64016:64170]

"checksum rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b"

[4.101015]

[2.64170]

"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"

Replacement in Cargo.lock at line 2019 [11.12201]

∅:D[10.138993] → [2.64479:64939]

"checksum regex 1.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "0b2f0808e7d7e4fb1cb07feb6ff2f4bc827938f24f8c2e6a3beb7370af544bdd"
"checksum regex-syntax 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9d76410686f9e3a17f06128962e0ecc5755870bb890c34820c7af7f1db2e1d48"
"checksum remove_dir_all 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4a83fa3702a688b9359eccba92d153ac33fd2e8462f9e0e3fdf155239ea7792e"

[10.138993]

[4.102237]

"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"
"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"

Replacement in Cargo.lock at line 2023 [11.12201]

∅:D[4.102391] → [2.64940:65098]

"checksum rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "a7f4dccf6f4891ebcc0c39f9b6eb1a83b9bf5d747cb439ec6fba4f3b977038af"

[4.102391]

[10.139765]

"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"

Replacement in Cargo.lock at line 2025 [11.12201]

∅:D[10.139921] → [2.65099:65245]

"checksum ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "b96a9549dc8d48f2c283938303c4b5a77aa29bfbc5b54b084fb1630408899a8f"

[10.139921]

[4.102696]

"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"

Replacement in Cargo.lock at line 2029 [11.12201]

∅:D[10.140519] → [2.65246:65572]

"checksum security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eee63d0f4a9ec776eeb30e220f0bc1e092c3ad744b2a379e3993070364d3adc2"
"checksum security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9636f8989cbf61385ae4824b98c1aaa54c994d7d8b41f11c601ed799f0549a56"

[10.140519]

[10.140845]

"checksum security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "bfab8dda0e7a327c696d893df9ffa19cadc4bd195797997f5223cf5831beaf05"
"checksum security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3d6696852716b589dff9e886ff83778bb635150168e83afa8ac6b8a78cb82abc"

Replacement in Cargo.lock at line 2033 [11.12201]

∅:D[10.141150] → [2.65573:65878]

"checksum serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)" = "32746bf0f26eab52f06af0d0aa1984f641341d06d8d673c693871da2d188c9be"
"checksum serde_derive 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)" = "46a3223d0c9ba936b61c0d2e3e559e3217dbfb8d65d06d26e8b3c25de38bae3e"

[10.141150]

[6.72315]

"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"

Replacement in Cargo.lock at line 2038 [11.12201]

∅:D[4.104077] → [2.65879:66343]

"checksum sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
"checksum signal-hook 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "72ab58f1fda436857e6337dcb6a5aaa34f16c5ddc87b3a8b6ef7a212f90b9c5a"
"checksum signal-hook-registry 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cded4ffa32146722ec54ab1f16320568465aa922aa9ab4708129599740da85d7"

[4.104077]

[10.142205]

"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"

Replacement in Cargo.lock at line 2042 [11.12201]

∅:D[4.104526] → [2.66344:66646]

"checksum smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "ab606a9c5e214920bb66c458cd7be8ef094f813f20fe77a54cc7dbfff220d4b7"
"checksum socket2 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "4e626972d3593207547f14bf5fc9efa4d0e7283deb73fef1dff313dae9ab8878"

[4.104526]

[10.142805]

"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "c4d11a52082057d87cb5caa31ad812f4504b97ab44732cd8359df2e9ff9f48e7"

Replacement in Cargo.lock at line 2045 [11.12201]

∅:D[10.142966] → [2.66647:66796]

"checksum string 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0bbfb8937e38e34c3444ff00afb28b0811d9554f15c5ad64d12b0308d1d1995"

[10.142966]

[10.143115]

"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"

Replacement in Cargo.lock at line 2052 [11.12201]

∅:D[10.144041] → [2.66947:67095]

"checksum syn 0.15.36 (registry+https://github.com/rust-lang/crates.io-index)" = "8b4f551a91e2e3848aeef8751d0d4eec9489b6474c720fd4c55958d8d31a430c"

[10.144041]

[10.144189]

"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"

Replacement in Cargo.lock at line 2054 [11.12201]

∅:D[10.144338] → [2.67096:67403]

"checksum synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "02353edf96d6e4dc81aea2d8490a7e9db177bf8acb0e951c24940bf866cb313f"
"checksum tempfile 3.0.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7dc4738f2e68ed2855de5ac9cdbe05c9216773ecde4739b2f095002ab03a13ef"

[10.144338]

[4.105583]

"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"

Replacement in Cargo.lock at line 2057 [11.12201]

∅:D[4.105733] → [2.67404:67706]

"checksum termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "96d6098003bde162e4277c70665bd87c326f5a0c3f3fbfb285787fa482d54e6e"
"checksum termion 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6a8fb22f7cde82c8220e5aeacb3258ed7ce996142c77cba193f203515e26c330"

[4.105733]

[2.67706]

"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f"
"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"

Replacement in Cargo.lock at line 2062 [11.12201]

∅:D[4.106035] → [2.67859:68160]

"checksum tokio 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)" = "ec2ffcf4bcfc641413fa0f1427bf8f91dfc78f56a6559cbf50e04837ae442a87"
"checksum tokio-buf 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8fb220f46c53859a4b7ec083e41dec9778ff0b1851c0942b211edb89e0ccdc46"

[4.106035]

[10.145701]

"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"

Replacement in Cargo.lock at line 2071 [11.12201]

∅:D[4.107119] → [2.68482:68635]

"checksum tokio-sync 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2162248ff317e2bc713b261f242b69dbb838b85248ed20bb21df56d60ea4cae7"

[4.107119]

[4.107272]

"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"

Replacement in Cargo.lock at line 2073 [11.12201]

∅:D[4.107424] → [2.68636:68951]

"checksum tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "72558af20be886ea124595ea0f806dd5703b8958e4705429dd58b3d8231f72f2"
"checksum tokio-timer 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "f2106812d500ed25a4f38235b9cae8f78a09edf43203e16e59c3b769a342a60e"

[4.107424]

[4.107739]

"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"

Replacement in Cargo.lock at line 2076 [11.12201]

∅:D[4.107891] → [2.68952:69111]

"checksum tokio-trace-core 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a9c8a256d6956f7cb5e2bdfe8b1e8022f1a09206c6c2b1ba00f3b746b260c613"

[4.107891]

[4.108050]

"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"

Replacement in Cargo.lock at line 2080 [11.12201]

∅:D[4.108507] → [2.69112:69259]

"checksum toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b8c96d7873fa7ef8bdeb3a9cda3ac48389b4154f32b9803b4bc26220b677b039"

[4.108507]

[4.108654]

"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"

Replacement in Cargo.lock at line 2094 [11.12201]

∅:D[4.109738] → [2.69260:69414]

"checksum utf8-ranges 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "9d50aa7650df78abf942826607c62468ce18d9019673d4a2ebe1865dbb96ffde"

[4.109738]

[10.150635]

"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"