Re-try to subscribe if not subscribed

[?]

Oct 27, 2019, 12:35 PM

U3UZTFCHHGY3ZCBSFFCC76EPEJBBDTEAQDREM4KDYTNDSTVMUS2QC

Dependencies

[2] 5WHNHD42 Update dependencies
[3] Z3NQEYVI Rename IqSetHandler to IqResuestHandler as it should provide both get and set handling
[4] S754Y5DF Refactor IQ processing Always answer to set and get requests. Use XML encoding for stanzas.
[5] ZFBPXPAD Cleanup timeouted iq requests with ping Output elapsed time. Refactor iq handling.
[6] AEH7WP42 Make element processors static
[7] SH3LIQ4S Starting commands support
[8] BYJPYYSM Process iq ping response
[9] 3DSOPLCG Add rustdoc
[10] WDCZNZOP Fix rustdoc
[11] 4IPZTMFI Update dependencies
[12] PLWPCM47 Add id to initital presence
[13] LL3D5CXK Staring using element processor
[14] PJV5HPIF Starting to imlements timeouts for iqs
[15] GXQCDLYQ Use element processor for incoming iq get
[16] YTN366WA Support disco#items
[17] RQZCVDFD Implement applying timeout for expired iq await
[18] ZT3YEIVX Consume connection on processing command
[19] CCLGGFKR Move out XmppConnection into own file
[20] FV6BJ5K6 Send self-presence and store account info in Rc so it willbe used in some future in parallel
[21] JY4F7VBC Use element processor for incoming iq set
[22] GVZ4JAR5 Process self-presence with incoming stanza processor
[23] DYRPAV6T Update dependencies
[24] YEMBT7TB Add support for XEP-0092: Software Version
[25] 2THKW66M Ignore .orig files
[26] OFLAP2G2 Fix possible utf8 errors
[27] DCMDASHV Mention XEP-0050 and XEP-0203 support
[28] HDLI2X4H Ignore delayed XEP-0203 messages
[29] LNUU5R56 Support disco#info from XEP-0030 Service Discovery
[30] LQXBWNFT Remove unneeded requirement
[31] SSOKGGCE Update dependencies
[32] QDHDTOLM Starting support for commands XEP-0050: Ad-Hoc Commands (there no support in xmpp_parsers still)
[33] RRLRZTMR Use element processor for iq
[34] 6UKCVM6E Use new iq processng for initial roster
[*] VS6AHRWI Move XMPP to separate dir
[*] FVVPKFTL Initial commit

Change contents

replacement in src/xmpp/xmpp_connection.rs at line 0

[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,
})
}
}
edit in src/xmpp/stanzas.rs at line 7

[3.35465]→[2.34147:34223](∅→∅)

use xmpp_parsers::stanza_error::{DefinedCondition, ErrorType, StanzaError};
edit in src/xmpp/stanzas.rs at line 43

[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

[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

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

[3.41574]

pong.into()
replacement in src/xmpp/mod.rs at line 12

[3.55931]→[2.36033:36071](∅→∅)

pub use xmpp_connection::XmppCommand;

[3.55931]

[3.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

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

[3.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)
}
}
edit in src/main.rs at line 21

[3.41232]→[2.37170:37209](∅→∅)

#[macro_use]
extern crate lazy_static;
edit in src/main.rs at line 215

[3.49351]

[3.49388]

use hyper::rt::{Future, Stream};
edit in Cargo.toml at line 23

[3.54630]→[2.37279:37356](∅→∅)

lazy_static = "1.3.0" # ToDo: remove after const fn will be powerfull enough
edit in Cargo.lock at line 2

[3.47733]

[3.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

[3.53649]→[2.37450:37469](∅→∅)

version = "0.3.11"

[3.53649]

[3.46847]

version = "0.3.10"
replacement in Cargo.lock at line 44

[3.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)",

[3.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

[3.55455]→[2.37690:37708](∅→∅)

version = "0.1.4"

[3.55455]

[3.54338]

version = "0.1.2"
replacement in Cargo.lock at line 56

[3.54435]→[2.37709:37728](∅→∅)

version = "0.3.30"

[3.54435]

[3.54454]

version = "0.3.15"
replacement in Cargo.lock at line 59

[3.54536]→[2.37729:37803](∅→∅)

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

[3.54536]

[3.55568]

"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 61

[3.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)",

[3.55649]

[3.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

[3.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)",

[3.55130]

[3.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

[3.55404]→[2.38175:38251](∅→∅)

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

[3.55404]

[3.55480]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 86

[3.55513]→[2.38252:38270](∅→∅)

version = "1.1.0"

[3.55513]

[3.55531]

version = "1.0.4"
replacement in Cargo.lock at line 102

[3.56068]→[2.38271:38289](∅→∅)

version = "0.7.3"

[3.56068]

[3.56538]

version = "0.7.0"
replacement in Cargo.lock at line 105

[3.56620]→[2.38290:38370](∅→∅)

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

[3.56620]

[3.56635]

"block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 107

[3.56712]→[2.38371:38447](∅→∅)

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

[3.56712]

[3.56788]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 113

[3.56907]→[2.38448:38466](∅→∅)

version = "0.1.4"

[3.56907]

[3.56925]

version = "0.1.3"
replacement in Cargo.lock at line 126

[3.56847]→[2.38467:38485](∅→∅)

version = "1.3.2"

[3.56847]

[3.56865]

version = "1.3.1"
replacement in Cargo.lock at line 134

[3.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)",

[3.57059]

[3.57135]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 145

[3.57344]→[2.38656:38675](∅→∅)

version = "1.0.37"

[3.57344]

[3.57363]

version = "1.0.35"
replacement in Cargo.lock at line 150

[3.57457]→[2.38676:38694](∅→∅)

version = "0.1.9"

[3.57457]

[3.57475]

version = "0.1.7"
replacement in Cargo.lock at line 158

[3.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)",

[3.57669]

[3.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

[3.58176]→[2.38872:38947](∅→∅)

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

[3.58176]

[2.38947]

"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 182

[3.58687]→[2.39097:39172](∅→∅)

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

[3.58687]

[3.58762]

"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 187

[3.58802]→[2.39173:39191](∅→∅)

version = "0.6.4"

[3.58802]

[3.58820]

version = "0.5.1"
replacement in Cargo.lock at line 190

[3.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)",

[3.58902]

[3.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

[3.59104]→[2.39351:39369](∅→∅)

version = "0.6.2"

[3.59104]

[3.59638]

version = "0.5.1"
edit in Cargo.lock at line 198

[3.59703]

[3.60184]

dependencies = [
"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 217

[3.71853]→[2.39370:39443](∅→∅)

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

[3.71853]

[3.71926]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 237

[3.60544]→[2.39444:39517](∅→∅)

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

[3.60544]

[3.49467]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 267

[3.61551]→[3.61551:61564](∅→∅),[3.61551]→[3.61551:61564](∅→∅),[3.61551]→[3.61551:61564](∅→∅),[3.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

[3.61686]→[2.39631:39704](∅→∅)

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

[3.61686]

[3.61759]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 284

[3.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)",

[3.59057]

[3.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

[3.62396]→[2.39873:39950](∅→∅)

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

[3.62396]

[3.62473]

"backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 301

[3.62605]→[2.39951:40028](∅→∅)

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

[3.62605]

[3.59304]

"backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 310

[3.62902]→[2.40029:40108](∅→∅)

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

[3.62902]

[2.40108]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 312

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

[3.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

[3.64039]→[2.40334:40409](∅→∅)

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

[3.64039]

[3.64114]

"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 369

[3.64642]→[2.40410:40429](∅→∅)

version = "0.1.27"

[3.64642]

[3.64661]

version = "0.1.26"
replacement in Cargo.lock at line 377

[3.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)",

[3.64864]

[3.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

[3.65256]→[2.40582:40601](∅→∅)

version = "0.1.23"

[3.65256]

[3.65275]

version = "0.1.18"
replacement in Cargo.lock at line 394

[3.65357]→[2.40602:40678](∅→∅)

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

[3.65357]

[2.40678]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 397

[3.65576]→[2.40752:40827](∅→∅)

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

[3.65576]

[2.40827]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 402

[3.60570]→[2.40900:40973](∅→∅)

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

[3.60570]

[3.50537]

"string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 420

[3.66500]→[2.40974:41046](∅→∅)

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

[3.66500]

[3.66572]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 431

[3.66919]→[2.41141:41212](∅→∅)

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

[3.66919]

[2.41212]

"itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 435

[2.41227]→[2.41227:41642](∅→∅),[2.41642]→[3.66990:67005](∅→∅),[3.66990]→[3.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

[3.67346]→[2.41643:41663](∅→∅)

version = "0.12.30"

[3.67346]

[3.67366]

version = "0.12.27"
replacement in Cargo.lock at line 453

[2.41737]→[2.41737:41812](∅→∅)

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

[2.41737]

[3.67596]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 455

[3.67678]→[2.41813:41883](∅→∅)

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

[3.67678]

[2.41883]

"h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 457

[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

[3.67967]→[2.42032:42103](∅→∅)

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

[3.67967]

[3.61498]

"itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 464

[3.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)",

[3.61721]

[2.42253]

"tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 469

[3.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)",

[3.62107]

[3.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

[3.69566]→[2.42499:42571](∅→∅)

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

[3.69566]

[3.69638]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 504

[3.69922]→[2.42572:42646](∅→∅)

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

[3.69922]

[3.69996]

"socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 512

[3.70248]→[2.42721:42739](∅→∅)

version = "0.4.4"

[3.70248]

[3.70266]

version = "0.4.3"
edit in Cargo.lock at line 542

[3.51736]

[3.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

[3.71348]→[2.42740:42759](∅→∅)

version = "0.2.58"

[3.71348]

[3.71367]

version = "0.2.51"
replacement in Cargo.lock at line 573

[3.54885]→[2.42779:42852](∅→∅)

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

[3.54885]

[3.72039]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 596

[3.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)",

[3.63314]

[3.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

[3.73854]→[2.43109:43128](∅→∅)

version = "0.6.19"

[3.73854]

[3.73873]

version = "0.6.16"
replacement in Cargo.lock at line 638

[3.74272]→[2.43129:43201](∅→∅)

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

[3.74272]

[3.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

[3.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)",

[3.74980]

[3.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

[3.75588]→[2.43346:43364](∅→∅)

version = "0.2.3"

[3.75588]

[3.75606]

version = "0.2.2"
replacement in Cargo.lock at line 674

[3.52505]→[2.43365:43437](∅→∅)

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

[3.52505]

[3.64406]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 676

[3.64476]→[2.43438:43514](∅→∅)

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

[3.64476]

[3.75984]

"openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 678

[3.76064]→[2.43515:43594](∅→∅)

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

[3.76064]

[3.52734]

"openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 680

[3.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)",

[3.52810]

[3.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

[3.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)",

[3.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

[3.77092]→[2.44064:44083](∅→∅)

version = "0.1.41"

[3.77092]

[3.77111]

version = "0.1.39"
replacement in Cargo.lock at line 710

[3.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)",

[3.77193]

[3.77270]

"num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 715

[3.77305]→[2.44236:44254](∅→∅)

version = "0.2.8"

[3.77305]

[3.77323]

version = "0.2.6"
edit in Cargo.lock at line 717

[3.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

[3.77419]→[2.44349:44368](∅→∅)

version = "1.10.1"

[3.77419]

[3.77438]

version = "1.10.0"
replacement in Cargo.lock at line 723

[3.77520]→[2.44369:44441](∅→∅)

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

[3.77520]

[3.77592]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 727

[2.44455]→[2.44455:44554](∅→∅),[2.44554]→[3.65309:65322](∅→∅),[3.77594]→[3.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

[3.77742]→[2.44555:44575](∅→∅)

version = "0.10.23"

[3.77742]

[3.77762]

version = "0.10.20"
replacement in Cargo.lock at line 736

[3.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)",

[3.77844]

[3.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

[3.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)",

[3.53391]

[3.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

[3.78456]→[2.44877:44896](∅→∅)

version = "0.9.47"

[3.78456]

[3.78475]

version = "0.9.43"
replacement in Cargo.lock at line 754

[3.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)",

[3.78557]

[3.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)",
edit in Cargo.lock at line 757

[3.78777]

[3.78857]

"rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 783

[3.79584]→[2.45114:45186](∅→∅)

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

[3.79584]

[3.66285]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 786

[3.79807]→[2.45187:45263](∅→∅)

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

[3.79807]

[2.45263]

"smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 795

[3.66636]→[2.45337:45413](∅→∅)

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

[3.66636]

[3.66712]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 850

[3.81639]→[2.45414:45433](∅→∅)

version = "0.4.30"

[3.81639]

[3.81658]

version = "0.4.27"
replacement in Cargo.lock at line 882

[3.82609]→[2.45454:45533](∅→∅)

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

[3.82609]

[3.82688]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 892

[3.67870]→[2.45534:45606](∅→∅)

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

[3.67870]

[3.67942]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 902

[3.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)",

[3.68192]

[3.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

[3.68643]→[2.45828:45906](∅→∅)

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

[3.68643]

[2.45906]

"rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 920

[3.83322]→[2.46055:46129](∅→∅)

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

[3.83322]

[3.69152]

"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 955

[3.69861]→[2.46130:46148](∅→∅)

version = "0.1.4"

[3.69861]

[3.69879]

version = "0.1.3"
replacement in Cargo.lock at line 958

[3.69961]→[2.46149:46221](∅→∅)

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

[3.69961]

[3.70033]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 970

[3.70469]→[2.46315:46387](∅→∅)

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

[3.70469]

[3.70541]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 981

[3.70896]→[2.46462:46536](∅→∅)

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

[3.70896]

[3.55053]

"autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1016

[3.87194]→[2.46639:46657](∅→∅)

version = "1.1.7"

[3.87194]

[3.87212]

version = "1.1.5"
replacement in Cargo.lock at line 1021

[3.55403]→[2.46738:46817](∅→∅)

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

[3.55403]

[3.87525]

"regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1023

[3.87604]→[2.46818:46896](∅→∅)

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

[3.87604]

[3.87682]

"utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1028

[3.87719]→[2.46897:46915](∅→∅)

version = "0.6.7"

[3.87719]

[3.87737]

version = "0.6.6"
replacement in Cargo.lock at line 1036

[3.87933]→[2.46916:46934](∅→∅)

version = "0.5.2"

[3.87933]

[3.87951]

version = "0.5.1"
replacement in Cargo.lock at line 1053

[3.88434]→[2.47009:47028](∅→∅)

version = "0.1.15"

[3.88434]

[3.88453]

version = "0.1.14"
replacement in Cargo.lock at line 1066

[3.88755]→[2.47029:47047](∅→∅)

version = "0.2.8"

[3.88755]

[3.88773]

version = "0.2.7"
replacement in Cargo.lock at line 1098

[3.89844]→[2.47197:47215](∅→∅)

version = "0.3.1"

[3.89844]

[3.89862]

version = "0.2.2"
replacement in Cargo.lock at line 1101

[3.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)",

[3.89944]

[3.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

[3.90320]→[2.47546:47564](∅→∅)

version = "0.3.1"

[3.90320]

[3.90338]

version = "0.2.3"
replacement in Cargo.lock at line 1112

[3.90420]→[2.47565:47651](∅→∅)

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

[3.90420]

[3.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

[3.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)",

[3.73268]

[3.73420]

"hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1140

[3.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)",

[3.73565]

[3.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

[3.73948]→[2.48182:48253](∅→∅)

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

[3.73948]

[2.48253]

"toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1152

[3.92112]→[2.48334:48353](∅→∅)

version = "1.0.92"

[3.92112]

[3.92131]

version = "1.0.90"
replacement in Cargo.lock at line 1157

[3.92231]→[2.48354:48373](∅→∅)

version = "1.0.92"

[3.92231]

[3.92250]

version = "1.0.90"
replacement in Cargo.lock at line 1160

[3.92332]→[2.48374:48453](∅→∅)

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

[3.92332]

[2.48453]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1162

[2.48526]→[2.48526:48598](∅→∅)

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

[2.48526]

[3.92556]

"syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1170

[3.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)",

[3.92692]

[3.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

[3.93036]→[2.48814:48893](∅→∅)

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

[3.93036]

[3.74627]

"block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1191

[3.93472]→[2.48894:48973](∅→∅)

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

[3.93472]

[3.74879]

"block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1199

[3.93808]→[2.48974:48992](∅→∅)

version = "0.8.2"

[3.93808]

[3.93826]

version = "0.8.1"
replacement in Cargo.lock at line 1202

[3.93908]→[2.48993:49072](∅→∅)

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

[3.93908]

[3.75131]

"block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1211

[3.94325]→[2.49073:49091](∅→∅)

version = "0.1.9"

[3.94325]

[2.49091]

version = "0.1.8"
replacement in Cargo.lock at line 1214

[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)",
edit in Cargo.lock at line 1219

[2.49347]→[2.49347:49395](∅→∅),[3.75380]→[3.94343:94425](∅→∅),[3.57031]→[3.94343:94425](∅→∅),[3.63707]→[3.94343:94425](∅→∅),[3.80173]→[3.94343:94425](∅→∅),[3.47651]→[3.94343:94425](∅→∅),[2.49395]→[3.94343:94425](∅→∅),[3.57209]→[3.94343:94425](∅→∅),[3.94343]→[3.94343:94425](∅→∅),[3.94425]→[2.49396:49544](∅→∅),[3.75529]→[3.94573:94588](∅→∅),[3.57179]→[3.94573:94588](∅→∅),[3.63855]→[3.94573:94588](∅→∅),[3.80321]→[3.94573:94588](∅→∅),[3.47800]→[3.94573:94588](∅→∅),[2.49544]→[3.94573:94588](∅→∅),[3.57358]→[3.94573:94588](∅→∅),[3.94573]→[3.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

[3.94831]→[2.49545:49564](∅→∅)

version = "0.6.10"

[3.94831]

[3.94849]

version = "0.6.9"
replacement in Cargo.lock at line 1235

[3.94944]→[2.49565:49583](∅→∅)

version = "0.3.9"

[3.94944]

[3.94962]

version = "0.3.8"
replacement in Cargo.lock at line 1238

[3.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)",

[3.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

[3.95498]→[2.49884:49902](∅→∅)

version = "0.2.0"

[3.95498]

[3.95516]

version = "0.1.3"
edit in Cargo.lock at line 1253

[3.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

[3.96043]→[2.49996:50069](∅→∅)

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

[3.96043]

[3.96116]

"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1275

[3.76365]→[2.50070:50149](∅→∅)

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

[3.76365]

[2.50149]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1307

[3.97562]→[2.50242:50262](∅→∅)

version = "0.15.36"

[3.97562]

[3.97582]

version = "0.15.30"
replacement in Cargo.lock at line 1310

[3.97664]→[2.50263:50342](∅→∅)

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

[3.97664]

[2.50342]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1325

[3.98140]→[2.50416:50435](∅→∅)

version = "0.10.2"

[3.98140]

[3.98159]

version = "0.10.1"
replacement in Cargo.lock at line 1328

[3.98241]→[2.50436:50515](∅→∅)

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

[3.98241]

[2.50515]

"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1330

[2.50588]→[2.50588:50660](∅→∅)

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

[2.50588]

[3.98465]

"syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1336

[3.98576]→[2.50661:50679](∅→∅)

version = "3.0.8"

[3.98576]

[3.98594]

version = "3.0.7"
replacement in Cargo.lock at line 1339

[3.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)",

[3.98676]

[3.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

[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

[3.99506]→[2.51062:51080](∅→∅)

version = "1.0.5"

[3.99506]

[3.99524]

version = "1.0.4"
replacement in Cargo.lock at line 1367

[3.99713]→[2.51081:51099](∅→∅)

version = "1.5.3"

[3.99713]

[3.99731]

version = "1.5.1"
replacement in Cargo.lock at line 1370

[3.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)",

[3.99813]

[2.51245]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1396

[3.100605]→[2.51347:51419](∅→∅)

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

[3.100605]

[2.51419]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1403

[3.100861]→[2.51574:51593](∅→∅)

version = "0.1.21"

[3.100861]

[3.100880]

version = "0.1.18"
replacement in Cargo.lock at line 1407

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

[3.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

[3.59699]→[2.52059:52136](∅→∅)

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

[3.59699]

[3.78773]

"tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1418

[3.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)",

[3.78849]

[3.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)",
edit in Cargo.lock at line 1423

[3.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

[3.102423]→[2.52740:52815](∅→∅)

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

[3.102423]

[3.102498]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1439

[2.52889]→[2.52889:52964](∅→∅)

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

[2.52889]

[3.60170]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1448

[3.103003]→[2.52984:53059](∅→∅)

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

[3.103003]

[2.53059]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1458

[3.79826]→[2.53160:53235](∅→∅)

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

[3.79826]

[3.103455]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1466

[3.103588]→[2.53236:53311](∅→∅)

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

[3.103588]

[3.60612]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1468

[3.60688]→[2.53312:53396](∅→∅)

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

[3.60688]

[3.103823]

"tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1477

[2.53470]→[2.53470:53545](∅→∅)

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

[2.53470]

[3.80325]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1487

[3.80497]→[2.53546:53621](∅→∅)

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

[3.80497]

[3.61036]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1490

[3.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)",

[3.80720]

[3.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

[3.61349]→[2.53852:53929](∅→∅)

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

[3.61349]

[3.105148]

"tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1504

[3.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)",

[3.105285]

[3.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

[3.105577]→[2.54149:54227](∅→∅)

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

[3.105577]

[2.54227]

"signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1517

[3.81771]→[2.54383:54401](∅→∅)

version = "0.1.6"

[3.81771]

[3.81789]

version = "0.1.4"
replacement in Cargo.lock at line 1521

[3.62053]→[2.54402:54477](∅→∅)

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

[3.62053]

[3.105965]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1530

[2.54551]→[2.54551:54626](∅→∅)

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

[2.54551]

[3.106527]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1532

[3.106599]→[2.54627:54698](∅→∅)

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

[3.106599]

[3.62278]

"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1539

[3.106867]→[2.54699:54718](∅→∅)

version = "0.1.14"

[3.106867]

[3.106886]

version = "0.1.13"
replacement in Cargo.lock at line 1545

[3.82608]→[2.54719:54794](∅→∅)

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

[3.82608]

[3.82683]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1547

[3.82753]→[2.54795:54871](∅→∅)

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

[3.82753]

[3.82829]

"num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1555

[3.107694]→[2.54954:54973](∅→∅)

version = "0.2.11"

[3.107694]

[3.107713]

version = "0.2.10"
replacement in Cargo.lock at line 1559

[3.83155]→[2.54974:55049](∅→∅)

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

[3.83155]

[3.83230]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1569

[3.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)",

[3.108238]

[3.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

[2.55311]→[2.55311:55329](∅→∅)

version = "0.2.0"

[2.55311]

[2.55329]

version = "0.1.0"
replacement in Cargo.lock at line 1588

[2.55578]→[2.55578:55653](∅→∅)

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

[2.55578]

[3.83941]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1590

[3.84011]→[2.55654:55725](∅→∅)

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

[3.84011]

[3.109108]

"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1602

[2.55799]→[2.55799:55874](∅→∅)

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

[2.55799]

[3.109624]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1604

[3.109696]→[2.55875:55947](∅→∅)

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

[3.109696]

[3.84409]

"libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1606

[3.84479]→[2.55948:56019](∅→∅)

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

[3.84479]

[3.109909]

"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1620

[3.110504]→[2.56094:56169](∅→∅)

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

[3.110504]

[3.110579]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1622

[3.110650]→[2.56170:56247](∅→∅)

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

[3.110650]

[3.64220]

"native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1625

[3.85032]→[2.56248:56321](∅→∅)

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

[3.85032]

[3.110948]

"tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1637

[3.111531]→[2.56322:56340](∅→∅)

version = "0.5.1"

[3.111531]

[3.111549]

version = "0.5.0"
replacement in Cargo.lock at line 1640

[3.111631]→[2.56341:56414](∅→∅)

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

[3.111631]

[3.111704]

"serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1648

[3.111844]→[2.56415:56491](∅→∅)

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

[3.111844]

[3.85771]

"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1650

[3.85845]→[2.56492:56567](∅→∅)

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

[3.85845]

[3.112069]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1655

[3.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)",

[3.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

[3.86529]→[2.56800:56879](∅→∅)

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

[3.86529]

[3.86608]

"tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1671

[3.113190]→[2.56880:56953](∅→∅)

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

[3.113190]

[3.86848]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1673

[3.86922]→[2.56954:57029](∅→∅)

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

[3.86922]

[3.86997]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1679

[3.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)",

[3.87374]

[3.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

[3.87641]→[2.57257:57330](∅→∅)

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

[3.87641]

[3.87714]

"cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1720

[3.87772]→[2.57331:57407](∅→∅)

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

[3.87772]

[3.87847]

"smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1755

[3.115838]→[2.57408:57426](∅→∅)

version = "1.0.3"

[3.115838]

[3.115856]

version = "1.0.2"
replacement in Cargo.lock at line 1773

[3.116272]→[2.57427:57502](∅→∅)

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

[3.116272]

[3.87982]

"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1878

[3.89236]→[2.57818:57889](∅→∅)

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

[3.89236]

[3.89307]

"sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1895

[2.58609]→[2.58609:58680](∅→∅)

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

[2.58609]

[3.120691]

"sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1899

[3.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

[3.121168]→[2.58837:58989](∅→∅)

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

[3.121168]

[3.90636]

"checksum arc-swap 0.3.10 (registry+https://github.com/rust-lang/crates.io-index)" = "a57a5698f85c6fd92f19dad87ff2d822fc4ba79dd85c13914d8c4dad589cb815"
replacement in Cargo.lock at line 1905

[3.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"

[3.121620]

[3.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

[3.91399]→[2.59294:59445](∅→∅)

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

[3.91399]

[3.91400]

"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
replacement in Cargo.lock at line 1911

[3.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"

[3.91549]

[3.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

[3.92013]→[2.59758:59910](∅→∅)

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

[3.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

[3.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"

[3.123442]

[3.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

[3.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"

[3.124185]

[3.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"
edit in Cargo.lock at line 1931

[3.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

[3.127601]→[2.61130:61281](∅→∅)

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

[3.127601]

[3.127752]

"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
replacement in Cargo.lock at line 1947

[3.94778]→[2.61282:61428](∅→∅)

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

[3.94778]

[3.94924]

"checksum h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "85ab6286db06040ddefb71641b50017c06874614001a134b423783e2db2920bd"
edit in Cargo.lock at line 1951

[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

[3.95373]→[2.61730:61880](∅→∅)

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

[3.95373]

[3.129112]

"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
replacement in Cargo.lock at line 1958

[3.95675]→[2.61881:62028](∅→∅)

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

[3.95675]

[3.95676]

"checksum itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
replacement in Cargo.lock at line 1963

[3.69392]→[2.62029:62177](∅→∅)

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

[3.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

[3.97340]→[2.62489:62636](∅→∅)

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

[3.97340]

[3.132415]

"checksum mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)" = "71646331f2619b1026cc302f87a2b8b648d5c6dd6937846a16cc8ce0f347f432"
replacement in Cargo.lock at line 1978

[3.132712]→[2.62637:62790](∅→∅)

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

[3.132712]

[3.132865]

"checksum native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ff8e08de0070bbf4c31f452ea2a70db092f36f6f2e4d897adf5674477d488fb2"
replacement in Cargo.lock at line 1982

[3.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"

[3.97655]

[3.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

[3.97963]→[2.63401:63553](∅→∅)

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

[3.97963]

[3.134094]

"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"
replacement in Cargo.lock at line 1988

[3.134250]→[2.63554:63709](∅→∅)

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

[3.134250]

[3.98271]

"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
replacement in Cargo.lock at line 2000

[3.136105]→[2.63710:63865](∅→∅)

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

[3.136105]

[3.136260]

"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
replacement in Cargo.lock at line 2012

[3.101015]→[2.64016:64170](∅→∅)

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

[3.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

[3.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"

[3.138993]

[3.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

[3.102391]→[2.64940:65098](∅→∅)

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

[3.102391]

[3.139765]

"checksum rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ccc78bfd5acd7bf3e89cffcf899e5cb1a52d6fafa8dec2739ad70c9577a57288"
replacement in Cargo.lock at line 2025

[3.139921]→[2.65099:65245](∅→∅)

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

[3.139921]

[3.102696]

"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
replacement in Cargo.lock at line 2029

[3.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"

[3.140519]

[3.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

[3.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"

[3.141150]

[3.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

[3.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"

[3.104077]

[3.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

[3.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"

[3.104526]

[3.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

[3.142966]→[2.66647:66796](∅→∅)

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

[3.142966]

[3.143115]

"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
replacement in Cargo.lock at line 2052

[3.144041]→[2.66947:67095](∅→∅)

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

[3.144041]

[3.144189]

"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
replacement in Cargo.lock at line 2054

[3.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"

[3.144338]

[3.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

[3.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"

[3.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

[3.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"

[3.106035]

[3.145701]

"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"
replacement in Cargo.lock at line 2071

[3.107119]→[2.68482:68635](∅→∅)

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

[3.107119]

[3.107272]

"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
replacement in Cargo.lock at line 2073

[3.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"

[3.107424]

[3.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

[3.107891]→[2.68952:69111](∅→∅)

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

[3.107891]

[3.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

[3.108507]→[2.69112:69259](∅→∅)

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

[3.108507]

[3.108654]

"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
replacement in Cargo.lock at line 2094

[3.109738]→[2.69260:69414](∅→∅)

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

[3.109738]

[3.150635]

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