Backing up my gmail account with rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
extern crate imap;
extern crate native_tls;
extern crate chrono;

type ImapSession = imap::Session<native_tls::TlsStream<std::net::TcpStream>>;
type DateTime = chrono::DateTime<chrono::offset::FixedOffset>;

fn message_date(n: u64, imap_session: &mut ImapSession) -> Option<DateTime> {
    if let Ok(messages) = imap_session.fetch(n.to_string(), "INTERNALDATE") {
        if let Some(message) = messages.first() {
            return message.internal_date();
        }
    }

    None
}

fn main() {
    let tls = native_tls::TlsConnector::builder().build().unwrap();

    let client = imap::connect(
        ("imap.gmail.com", 993),
        "imap.gmail.com",
        &tls,
    ).unwrap();

    let username = std::env::var("USERNAME").unwrap();
    let password = std::env::var("PASSWORD").unwrap();

    let mut imap_session = client.login(username, password).unwrap();

    imap_session.select("[Gmail]/All Mail").unwrap();

    for idx in 0.. {
       let msg = if idx == 0 { 1 } else { idx * 1000 };

       if let Some(date) = message_date(msg, &mut imap_session) {
           println!("{} {}", msg, date.to_rfc3339());
       } else {
           break;
       }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
fn highest_message_number(imap_session: &mut ImapSession) -> u64 {
    let mut lower = 0;
    let mut upper = 0;
    for e in 0.. {
        let idx = 2u64.pow(e);

        if let Some(_date) = message_date(idx, imap_session) {
            lower = idx;
        } else {
            upper = idx;
            break
        }
    }

    while lower + 1 != upper {
        let middle = (lower + upper) / 2;

        if let Some(_date) = message_date(middle, imap_session) {
            lower = middle;
        } else {
            upper = middle;
        }
    }

    lower
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
extern crate imap;
extern crate native_tls;
extern crate chrono;

type ImapSession = imap::Session<native_tls::TlsStream<std::net::TcpStream>>;

#[derive(Debug)]
struct Message {
    uid: imap::types::Uid,
    body: Vec<u8>,
}

fn messages(from: u64, to: u64, imap_session: &mut ImapSession) -> Vec<Message> {
  let result = imap_session.fetch(format!("{}:{}", from, to), "(UID RFC822)")

    if let Ok(messages) = result {
        return messages.iter().map(|message|
            Message {
                uid: message.uid.unwrap(),
                body: message
                  .body()
                  .map(|x| x.into_iter().map(|&x| x).collect())
                  .unwrap(),
            }
        ).collect::<Vec<_>>();
    }

    vec![]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
fn main() {
    // ...

    {
        let now = Instant::now();
        println!("one by one");

        for i in 1..101 {
            println!("{:?}", messages(i, i, &mut imap_session).first().unwrap().uid);
        }

        println!("{}", now.elapsed().as_secs());
    }

    {
        let now = Instant::now();
        println!("batched");

        for message in messages(1, 101, &mut imap_session).into_iter() {
            println!("{:?}", message.uid);
        }

        println!("{}", now.elapsed().as_secs());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
pub fn message_store(message: &Message) -> Result<(), Box<dyn std::error::Error>> {
    let mut file = std::fs::File::create(format!("messages/{:07}.txt", message.uid))?;

    file.write_all(&message.body)?;

    Ok(())
}

pub fn messages_store_from(base: u64, imap_session: &mut ImapSession) {
    let max = highest_message_number(imap_session);
    println!("Going up to {}", max);

    let step = 500;

    for i in 0.. {
        let lower = base + i * step;
        let upper = base + (i + 1) * step;

        if lower > max {
            break;
        }

        println!("batching {}:{}", lower, upper);
        for message in messages(lower, upper, imap_session).into_iter() {
            message_store(&message).unwrap();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
extern crate chrono;

use itertools::Itertools;

use std::fs;
use std::io;

use chrono::{DateTime, NaiveDateTime, Utc};
use std::io::prelude::*;
use mailparse::*;

fn main() {
    let mut entries = fs::read_dir("messages")
        .unwrap()
        .map(|res| res.map(|e| e.path()))
        .collect::<Result<Vec<_>, io::Error>>()
        .unwrap();

    entries.sort();

    let dates = entries
        .iter()
        .map(|path| {
            let mut file = fs::File::open(path).unwrap();
            let mut contents = Vec::<u8>::new();
            file.read_to_end(&mut contents).unwrap();

            contents
        })
        .map(|contents| {
            parse_headers(&contents)
                .unwrap()
                .0
                .get_first_value("Date")
                .unwrap()
                .replace("Pacific Standard Time", "PST")
                .replace(" --", " -")
                .replace("-Nov-", " Nov ")
                .replace("Dom", "Sun").replace("Dez", "Dec")
        })
        .map(|date| dateparse(&date).unwrap())
        .map(|ts| NaiveDateTime::from_timestamp(ts, 0))
        .map(|datetime| DateTime::<Utc>::from_utc(datetime, Utc).date())
        .group_by(|&date| date)
        .into_iter()
        .map(|(_date, v)| v.count())
        .max();

    println!("{}", entries.len());
    println!("{:?}", dates);
}