Assignment 2

You can start with:

cargo new mail_search

You can either put your code in src/main.rs or create a new file src/lib.rs if you want to keep your library functions separate (see the section in the book on this for details).

The goal of this assignment is to find the first email which satisfies a given condition. Thus, you'll need to write a function of this name in your code which takes as an argument an email of type &str and returns a bool. For now, have it just return false.¹

Implement a function email_from_str which takes as an argument an mbox of type &str and returns an email of type String which is the first email in mbox such that condition(email) holds. The email should consist of everything after its From-line until the next From-line or the end of the input. You may assume that email has LF line endings.² Furthermore, you don't need to handle errors gracefully. In any edge case (e.g., if no email satisfies condition) you can panic!³

You'll have to deal with the From-munging done to the email in the mbox. It may be useful to write a function revert_from_munge which takes a line of type &str and returns a &str whch is the same as line except with the first character removed if necessary (Note. Because of implicit coercions, we can use this function on String reference).

Once you've completed this function, you should implement an additional function get_email_read_to_string which takes as input a filename of type &str and returns an email of type String. This function should just use fs::read_to_string to read in the contents of the file and pass that to email_from_str.

The problem with the function gen_email_read_to_string is that (as we've learned) it will put the entire mbox in memory, this is fine for anything less than a couple GBs, but once you get above ~12GBs, it can exert some notable memory pressure.

To address this, implement another function get_email_bufread_lines which takes as an argument a filename of type &str and returns an email of type String. This function should open the given file as a BufReader then using the iterator returned by io::BufRead::lines.

The code will be almost identical, it'll just use a different iterator.

There's yet another way that we can do this: ipmlement a function get_email_bufread_read_line which takes as an argument a filename of type &str and returns an email of type String. This function should open the given file as BufReader, but should call io::BufRead::read_line repeatedly until the end of the file is reached.

Your main function should look something like this:

fn main() {
  let args: Vec<String> = env::args().collect();
  let filename: &str = &args[1];
  let email = mail_search::get_email_read_to_string(filename); // dropping the `mail_search::` part if you don't have src/lib.rs
  print!("{email}");
}

The first part of this function (unsafely) grabs the file name as a command line argument. So if you run

cargo run mbox_filename > out.eml

You can open out.eml in your favorite email client.⁴ You can use a condition like email.contains("SOME STRING") to find the first email in the collection to have a certain word or phrase.

If you use GMail, you can use Google Takeout to generate an mbox of all of your emails.

The last think you need to do for this assignment is to benchmark your code on two mboxes, one of 3GB and one of 12GB (you can try larger if you want, or smaller if you're machine won't be able to handle putting 12GB in memory). For the test, you should use the condition false so that it is required to get to the end of the mbox (and panic). This gives you six numbers, two for each version of the function.

If you don't have access to large email collections⁵ then the easiest way to generate a large email mbox is to stack an mbox on top of itself a bunch of times. I'll leave it as an (ungraded) exercise to (look up how to) write something that will do this.

You can benchmark in a couple ways, the easy way is to use time, e.g.,

time cargo run --release < large_mbox

Make sure to use the --release flag or you'll be waiting for a while. Alternatively, you can use std::time in Rust.⁶

You should put your numbers in a short comment in your file src/main.rs. Please also include a sentence or two about how the numbers. Do they fit your expectations? Any guesses why they look like they do?