llange
/
meli
forked from meli/meli
1
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity

melib/imap: remove some debug prints

jmap-eventsource
Manos Pitsidianakis 2020-11-30 01:52:48 +02:00
parent 8e7583a32f
commit 4939a1ad9e
Signed by: Manos Pitsidianakis
GPG Key ID: 73627C2F690DF710
7 changed files with 30 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
melib/src/backends/imap.rs
View File

@ -450,11 +450,11 @@ impl MailBackend for ImapType {
match timeout(timeout_dur, connection.lock()).await { match timeout(timeout_dur, connection.lock()).await {
Ok(mut conn) => { Ok(mut conn) => {
debug!("is_online"); debug!("is_online");
match debug!(timeout(timeout_dur, conn.connect()).await) { match timeout(timeout_dur, conn.connect()).await {
Ok(Ok(())) => Ok(()), Ok(Ok(())) => Ok(()),
Err(err) | Ok(Err(err)) => { Err(err) | Ok(Err(err)) => {
conn.stream = Err(err.clone()); conn.stream = Err(err.clone());
debug!(conn.connect().await) conn.connect().await
} }
} }
} }
@ -481,7 +481,6 @@ impl MailBackend for ImapType {
_ => false, _ => false,
}; };
Ok(Box::pin(async move { Ok(Box::pin(async move {
debug!(has_idle);
while let Err(err) = if has_idle { while let Err(err) = if has_idle {
idle(ImapWatchKit { idle(ImapWatchKit {
conn: ImapConnection::new_connection(&server_conf, uid_store.clone()), conn: ImapConnection::new_connection(&server_conf, uid_store.clone()),
@ -501,16 +500,16 @@ impl MailBackend for ImapType {
if err.kind.is_network() { if err.kind.is_network() {
uid_store.is_online.lock().unwrap().1 = Err(err.clone()); uid_store.is_online.lock().unwrap().1 = Err(err.clone());
} }
debug!("failure: {}", err.to_string()); debug!("Watch failure: {}", err.to_string());
match timeout(uid_store.timeout, main_conn_lck.connect()) match timeout(uid_store.timeout, main_conn_lck.connect())
.await .await
.and_then(|res| res) .and_then(|res| res)
{ {
Err(err2) => { Err(err2) => {
debug!("reconnect attempt failed: {}", err2.to_string()); debug!("Watch reconnect attempt failed: {}", err2.to_string());
} }
Ok(()) => { Ok(()) => {
debug!("reconnect attempt succesful"); debug!("Watch reconnect attempt succesful");
continue; continue;
} }
} }
@ -1420,7 +1419,7 @@ impl ImapType {
conn.read_response(&mut res, RequiredResponses::LIST_REQUIRED) conn.read_response(&mut res, RequiredResponses::LIST_REQUIRED)
.await?; .await?;
} }
debug!("out: {}", String::from_utf8_lossy(&res)); debug!("LIST reply: {}", String::from_utf8_lossy(&res));
let mut lines = res.split_rn(); let mut lines = res.split_rn();
/* Remove "M__ OK .." line */ /* Remove "M__ OK .." line */
lines.next_back(); lines.next_back();
@ -1472,7 +1471,7 @@ impl ImapType {
conn.read_response(&mut res, RequiredResponses::LSUB_REQUIRED) conn.read_response(&mut res, RequiredResponses::LSUB_REQUIRED)
.await?; .await?;
let mut lines = res.split_rn(); let mut lines = res.split_rn();
debug!("out: {}", String::from_utf8_lossy(&res)); debug!("LSUB reply: {}", String::from_utf8_lossy(&res));
/* Remove "M__ OK .." line */ /* Remove "M__ OK .." line */
lines.next_back(); lines.next_back();
for l in lines { for l in lines {
@ -1489,7 +1488,7 @@ impl ImapType {
debug!("parse error for {:?}", l); debug!("parse error for {:?}", l);
} }
} }
Ok(debug!(mailboxes)) Ok(mailboxes)
} }
pub fn validate_config(s: &AccountSettings) -> Result<()> { pub fn validate_config(s: &AccountSettings) -> Result<()> {
@ -1663,7 +1662,7 @@ async fn fetch_hlpr(state: &mut FetchState) -> Result<Vec<Envelope>> {
FetchStage::ResyncCache => { FetchStage::ResyncCache => {
let mailbox_hash = state.mailbox_hash; let mailbox_hash = state.mailbox_hash;
let mut conn = state.connection.lock().await; let mut conn = state.connection.lock().await;
let res = debug!(conn.resync(mailbox_hash).await); let res = conn.resync(mailbox_hash).await;
if let Ok(Some(payload)) = res { if let Ok(Some(payload)) = res {
state.stage = FetchStage::Finished; state.stage = FetchStage::Finished;
return Ok(payload); return Ok(payload);
@ -1740,7 +1739,7 @@ async fn fetch_hlpr(state: &mut FetchState) -> Result<Vec<Envelope>> {
} in v.iter_mut() } in v.iter_mut()
{ {
if uid.is_none() || envelope.is_none() || flags.is_none() { if uid.is_none() || envelope.is_none() || flags.is_none() {
debug!("in fetch is none"); debug!("BUG? in fetch is none");
debug!(uid); debug!(uid);
debug!(envelope); debug!(envelope);
debug!(flags); debug!(flags);
@ -1782,14 +1781,14 @@ async fn fetch_hlpr(state: &mut FetchState) -> Result<Vec<Envelope>> {
} }
} }
if let Some(ref mut cache_handle) = cache_handle { if let Some(ref mut cache_handle) = cache_handle {
if let Err(err) = debug!(cache_handle if let Err(err) = cache_handle
.insert_envelopes(mailbox_hash, &v) .insert_envelopes(mailbox_hash, &v)
.chain_err_summary(|| { .chain_err_summary(|| {
format!( format!(
"Could not save envelopes in cache for mailbox {}", "Could not save envelopes in cache for mailbox {}",
mailbox_path mailbox_path
) )
})) })
{ {
(state.uid_store.event_consumer)( (state.uid_store.event_consumer)(
state.uid_store.account_hash, state.uid_store.account_hash,

16
melib/src/backends/imap/cache.rs
View File

@ -365,7 +365,7 @@ mod sqlite3_m {
fn envelopes(&mut self, mailbox_hash: MailboxHash) -> Result<Option<Vec<EnvelopeHash>>> { fn envelopes(&mut self, mailbox_hash: MailboxHash) -> Result<Option<Vec<EnvelopeHash>>> {
debug!("envelopes mailbox_hash {}", mailbox_hash); debug!("envelopes mailbox_hash {}", mailbox_hash);
if debug!(self.mailbox_state(mailbox_hash)?.is_none()) { if self.mailbox_state(mailbox_hash)?.is_none() {
return Ok(None); return Ok(None);
} }
@ -429,7 +429,6 @@ mod sqlite3_m {
.cloned() .cloned()
.unwrap_or_default(); .unwrap_or_default();
if self.mailbox_state(mailbox_hash)?.is_none() { if self.mailbox_state(mailbox_hash)?.is_none() {
debug!(self.mailbox_state(mailbox_hash)?.is_none());
return Err(MeliError::new("Mailbox is not in cache").set_kind(ErrorKind::Bug)); return Err(MeliError::new("Mailbox is not in cache").set_kind(ErrorKind::Bug));
} }
let Self { let Self {
@ -471,13 +470,7 @@ mod sqlite3_m {
mailbox_hash: MailboxHash, mailbox_hash: MailboxHash,
refresh_events: &[(UID, RefreshEvent)], refresh_events: &[(UID, RefreshEvent)],
) -> Result<()> { ) -> Result<()> {
debug!(
"update with refresh_events mailbox_hash {} len {}",
mailbox_hash,
refresh_events.len()
);
if self.mailbox_state(mailbox_hash)?.is_none() { if self.mailbox_state(mailbox_hash)?.is_none() {
debug!(self.mailbox_state(mailbox_hash)?.is_none());
return Err(MeliError::new("Mailbox is not in cache").set_kind(ErrorKind::Bug)); return Err(MeliError::new("Mailbox is not in cache").set_kind(ErrorKind::Bug));
} }
let Self { let Self {
@ -488,7 +481,7 @@ mod sqlite3_m {
let tx = connection.transaction()?; let tx = connection.transaction()?;
let mut hash_index_lck = uid_store.hash_index.lock().unwrap(); let mut hash_index_lck = uid_store.hash_index.lock().unwrap();
for (uid, event) in refresh_events { for (uid, event) in refresh_events {
match debug!(&event.kind) { match &event.kind {
RefreshEventKind::Remove(env_hash) => { RefreshEventKind::Remove(env_hash) => {
hash_index_lck.remove(&env_hash); hash_index_lck.remove(&env_hash);
tx.execute( tx.execute(
@ -655,14 +648,13 @@ pub(super) async fn fetch_cached_envs(state: &mut FetchState) -> Result<Option<V
ref uid_store, ref uid_store,
cache_handle: _, cache_handle: _,
} = state; } = state;
debug!(uid_store.keep_offline_cache);
let mailbox_hash = *mailbox_hash; let mailbox_hash = *mailbox_hash;
if !uid_store.keep_offline_cache { if !uid_store.keep_offline_cache {
return Ok(None); return Ok(None);
} }
{ {
let mut conn = connection.lock().await; let mut conn = connection.lock().await;
match debug!(conn.load_cache(mailbox_hash).await) { match conn.load_cache(mailbox_hash).await {
None => return Ok(None), None => return Ok(None),
Some(Ok(env_hashes)) => { Some(Ok(env_hashes)) => {
let env_lck = uid_store.envelopes.lock().unwrap(); let env_lck = uid_store.envelopes.lock().unwrap();
@ -675,7 +667,7 @@ pub(super) async fn fetch_cached_envs(state: &mut FetchState) -> Result<Option<V
.collect::<Vec<Envelope>>(), .collect::<Vec<Envelope>>(),
)); ));
} }
Some(Err(err)) => return debug!(Err(err)), Some(Err(err)) => return Err(err),
} }
} }
} }

27
melib/src/backends/imap/cache/sync.rs vendored
View File

@ -63,14 +63,14 @@ impl ImapConnection {
Ok(v) => v, Ok(v) => v,
Err(err) => return Some(Err(err)), Err(err) => return Some(Err(err)),
}; };
match debug!(cache_handle.mailbox_state(mailbox_hash)) { match cache_handle.mailbox_state(mailbox_hash) {
Err(err) => return Some(Err(err)), Err(err) => return Some(Err(err)),
Ok(Some(())) => {} Ok(Some(())) => {}
Ok(None) => { Ok(None) => {
return None; return None;
} }
}; };
match debug!(cache_handle.envelopes(mailbox_hash)) { match cache_handle.envelopes(mailbox_hash) {
Ok(Some(envs)) => Some(Ok(envs)), Ok(Some(envs)) => Some(Ok(envs)),
Ok(None) => None, Ok(None) => None,
Err(err) => Some(Err(err)), Err(err) => Some(Err(err)),
@ -116,16 +116,10 @@ impl ImapConnection {
) )
}; };
let mut new_unseen = BTreeSet::default(); let mut new_unseen = BTreeSet::default();
debug!("current_uidvalidity is {}", current_uidvalidity);
debug!("max_uid is {}", max_uid);
let select_response = self let select_response = self
.select_mailbox(mailbox_hash, &mut response, true) .select_mailbox(mailbox_hash, &mut response, true)
.await? .await?
.unwrap(); .unwrap();
debug!(
"select_response.uidvalidity is {}",
select_response.uidvalidity
);
// 1. check UIDVALIDITY. If fail, discard cache and rebuild // 1. check UIDVALIDITY. If fail, discard cache and rebuild
if select_response.uidvalidity != current_uidvalidity { if select_response.uidvalidity != current_uidvalidity {
cache_handle.clear(mailbox_hash, &select_response)?; cache_handle.clear(mailbox_hash, &select_response)?;
@ -193,14 +187,14 @@ impl ImapConnection {
} }
} }
{ {
debug!(cache_handle cache_handle
.insert_envelopes(mailbox_hash, &v) .insert_envelopes(mailbox_hash, &v)
.chain_err_summary(|| { .chain_err_summary(|| {
format!( format!(
"Could not save envelopes in cache for mailbox {}", "Could not save envelopes in cache for mailbox {}",
mailbox_path mailbox_path
) )
}))?; })?;
} }
for FetchResponse { for FetchResponse {
@ -352,9 +346,6 @@ impl ImapConnection {
.unwrap() .unwrap()
.get(&mailbox_hash) .get(&mailbox_hash)
.cloned(); .cloned();
debug!(&cached_uidvalidity);
debug!(&cached_max_uid);
debug!(&cached_highestmodseq);
if cached_uidvalidity.is_none() if cached_uidvalidity.is_none()
|| cached_max_uid.is_none() || cached_max_uid.is_none()
|| cached_highestmodseq.is_none() || cached_highestmodseq.is_none()
@ -381,17 +372,11 @@ impl ImapConnection {
) )
}; };
let mut new_unseen = BTreeSet::default(); let mut new_unseen = BTreeSet::default();
debug!("current_uidvalidity is {}", cached_uidvalidity);
debug!("max_uid is {}", cached_max_uid);
// 1. check UIDVALIDITY. If fail, discard cache and rebuild // 1. check UIDVALIDITY. If fail, discard cache and rebuild
let select_response = self let select_response = self
.select_mailbox(mailbox_hash, &mut response, true) .select_mailbox(mailbox_hash, &mut response, true)
.await? .await?
.unwrap(); .unwrap();
debug!(
"select_response.uidvalidity is {}",
select_response.uidvalidity
);
if select_response.uidvalidity != cached_uidvalidity { if select_response.uidvalidity != cached_uidvalidity {
// 1a) Check the mailbox UIDVALIDITY (see section 4.1 for more // 1a) Check the mailbox UIDVALIDITY (see section 4.1 for more
//details) with SELECT/EXAMINE/STATUS. //details) with SELECT/EXAMINE/STATUS.
@ -497,14 +482,14 @@ impl ImapConnection {
} }
} }
{ {
debug!(cache_handle cache_handle
.insert_envelopes(mailbox_hash, &v) .insert_envelopes(mailbox_hash, &v)
.chain_err_summary(|| { .chain_err_summary(|| {
format!( format!(
"Could not save envelopes in cache for mailbox {}", "Could not save envelopes in cache for mailbox {}",
mailbox_path mailbox_path
) )
}))?; })?;
} }
for FetchResponse { uid, envelope, .. } in v { for FetchResponse { uid, envelope, .. } in v {

11
melib/src/backends/imap/connection.rs
View File

@ -467,7 +467,6 @@ impl ImapStream {
if !termination_string.is_empty() if !termination_string.is_empty()
&& ret[last_line_idx..].starts_with(termination_string) && ret[last_line_idx..].starts_with(termination_string)
{ {
debug!(String::from_utf8_lossy(&ret[last_line_idx..]));
if !keep_termination_string { if !keep_termination_string {
ret.splice(last_line_idx.., std::iter::empty::<u8>()); ret.splice(last_line_idx.., std::iter::empty::<u8>());
} }
@ -595,7 +594,7 @@ impl ImapConnection {
self.stream = Err(err); self.stream = Err(err);
} }
} }
if debug!(self.stream.is_ok()) { if self.stream.is_ok() {
let mut ret = Vec::new(); let mut ret = Vec::new();
if let Err(err) = try_await(async { if let Err(err) = try_await(async {
self.send_command(b"NOOP").await?; self.send_command(b"NOOP").await?;
@ -613,7 +612,7 @@ impl ImapConnection {
return Ok(()); return Ok(());
} }
} }
let new_stream = debug!(ImapStream::new_connection(&self.server_conf).await); let new_stream = ImapStream::new_connection(&self.server_conf).await;
if let Err(err) = new_stream.as_ref() { if let Err(err) = new_stream.as_ref() {
self.uid_store.is_online.lock().unwrap().1 = Err(err.clone()); self.uid_store.is_online.lock().unwrap().1 = Err(err.clone());
} else { } else {
@ -727,7 +726,6 @@ impl ImapConnection {
); );
} }
ImapResponse::No(ref response_code) => { ImapResponse::No(ref response_code) => {
//FIXME return error
debug!( debug!(
"Received NO response: {:?} {:?}", "Received NO response: {:?} {:?}",
response_code, response_code,
@ -745,7 +743,6 @@ impl ImapConnection {
return r.into(); return r.into();
} }
ImapResponse::Bad(ref response_code) => { ImapResponse::Bad(ref response_code) => {
//FIXME return error
debug!( debug!(
"Received BAD response: {:?} {:?}", "Received BAD response: {:?} {:?}",
response_code, response_code,
@ -1087,7 +1084,6 @@ impl ImapBlockingConnection {
let mut prev_failure = None; let mut prev_failure = None;
async move { async move {
if self.conn.stream.is_err() { if self.conn.stream.is_err() {
debug!(&self.conn.stream);
return None; return None;
} }
loop { loop {
@ -1121,7 +1117,6 @@ async fn read(
} }
Ok(b) => { Ok(b) => {
result.extend_from_slice(&buf[0..b]); result.extend_from_slice(&buf[0..b]);
debug!(unsafe { std::str::from_utf8_unchecked(result) });
if let Some(pos) = result.find(b"\r\n") { if let Some(pos) = result.find(b"\r\n") {
*prev_res_length = pos + b"\r\n".len(); *prev_res_length = pos + b"\r\n".len();
return Some(result[0..*prev_res_length].to_vec()); return Some(result[0..*prev_res_length].to_vec());
@ -1129,8 +1124,6 @@ async fn read(
*prev_failure = None; *prev_failure = None;
} }
Err(_err) => { Err(_err) => {
debug!(&conn.stream);
debug!(&_err);
*err = Some(Into::<MeliError>::into(_err).set_kind(crate::error::ErrorKind::Network)); *err = Some(Into::<MeliError>::into(_err).set_kind(crate::error::ErrorKind::Network));
*break_flag = true; *break_flag = true;
*prev_failure = Some(SystemTime::now()); *prev_failure = Some(SystemTime::now());

4
melib/src/backends/imap/operations.rs
View File

@ -144,9 +144,9 @@ impl BackendOp for ImapOp {
.map_err(MeliError::from)?; .map_err(MeliError::from)?;
if v.len() != 1 { if v.len() != 1 {
debug!("responses len is {}", v.len()); debug!("responses len is {}", v.len());
debug!(&response); debug!(String::from_utf8_lossy(&response));
/* TODO: Trigger cache invalidation here. */ /* TODO: Trigger cache invalidation here. */
debug!(format!("message with UID {} was not found", uid)); debug!("message with UID {} was not found", uid);
return Err(MeliError::new(format!( return Err(MeliError::new(format!(
"Invalid/unexpected response: {:?}", "Invalid/unexpected response: {:?}",
response response

1
melib/src/backends/imap/untagged.rs
View File

@ -486,7 +486,6 @@ impl ImapConnection {
self.read_response(&mut response, RequiredResponses::SEARCH) self.read_response(&mut response, RequiredResponses::SEARCH)
.await, .await,
); );
debug!(to_str!(&response));
match super::protocol_parser::search_results( match super::protocol_parser::search_results(
response.split_rn().next().unwrap_or(b""), response.split_rn().next().unwrap_or(b""),
) )

10
melib/src/backends/imap/watch.rs
View File

@ -79,7 +79,6 @@ pub async fn idle(kit: ImapWatchKit) -> Result<()> {
.examine_mailbox(mailbox_hash, &mut response, true) .examine_mailbox(mailbox_hash, &mut response, true)
.await? .await?
.unwrap(); .unwrap();
debug!("select response {}", String::from_utf8_lossy(&response));
{ {
let mut uidvalidities = uid_store.uidvalidity.lock().unwrap(); let mut uidvalidities = uid_store.uidvalidity.lock().unwrap();
@ -219,7 +218,6 @@ pub async fn examine_updates(
.examine_mailbox(mailbox_hash, &mut response, true) .examine_mailbox(mailbox_hash, &mut response, true)
.await? .await?
.unwrap(); .unwrap();
debug!(&select_response);
{ {
let mut uidvalidities = uid_store.uidvalidity.lock().unwrap(); let mut uidvalidities = uid_store.uidvalidity.lock().unwrap();
@ -311,7 +309,7 @@ pub async fn examine_updates(
return Ok(()); return Ok(());
} }
if debug!(select_response.recent > 0) { if select_response.recent > 0 {
/* UID SEARCH RECENT */ /* UID SEARCH RECENT */
conn.send_command(b"UID SEARCH RECENT").await?; conn.send_command(b"UID SEARCH RECENT").await?;
conn.read_response(&mut response, RequiredResponses::SEARCH) conn.read_response(&mut response, RequiredResponses::SEARCH)
@ -340,7 +338,7 @@ pub async fn examine_updates(
conn.send_command(cmd.as_bytes()).await?; conn.send_command(cmd.as_bytes()).await?;
conn.read_response(&mut response, RequiredResponses::FETCH_REQUIRED) conn.read_response(&mut response, RequiredResponses::FETCH_REQUIRED)
.await?; .await?;
} else if debug!(select_response.exists > mailbox.exists.lock().unwrap().len()) { } else if select_response.exists > mailbox.exists.lock().unwrap().len() {
conn.send_command( conn.send_command(
format!( format!(
"FETCH {}:* (UID FLAGS ENVELOPE BODY.PEEK[HEADER.FIELDS (REFERENCES)] BODYSTRUCTURE)", "FETCH {}:* (UID FLAGS ENVELOPE BODY.PEEK[HEADER.FIELDS (REFERENCES)] BODYSTRUCTURE)",
@ -404,14 +402,14 @@ pub async fn examine_updates(
} }
} }
if uid_store.keep_offline_cache { if uid_store.keep_offline_cache {
debug!(cache_handle cache_handle
.insert_envelopes(mailbox_hash, &v) .insert_envelopes(mailbox_hash, &v)
.chain_err_summary(|| { .chain_err_summary(|| {
format!( format!(
"Could not save envelopes in cache for mailbox {}", "Could not save envelopes in cache for mailbox {}",
mailbox.imap_path() mailbox.imap_path()
) )
}))?; })?;
} }
for FetchResponse { uid, envelope, .. } in v { for FetchResponse { uid, envelope, .. } in v {