Multi-threaded Link Checker

Let us use our new knowledge to create a multi-threaded link checker. It should start at a webpage and check that links on the page are valid. It should recursively check other pages on the same domain and keep doing this until all pages have been validated.

For this, you will need an HTTP client such as reqwest. You will also need a way to find links, we can use scraper. Finally, we’ll need some way of handling errors, we will use thiserror.

Create a new Cargo project and reqwest it as a dependency with:

  1. cargo new link-checker
  2. cd link-checker
  3. cargo add --features blocking,rustls-tls reqwest
  4. cargo add scraper
  5. cargo add thiserror

If cargo add fails with error: no such subcommand, then please edit the Cargo.toml file by hand. Add the dependencies listed below.

The cargo add calls will update the Cargo.toml file to look like this:

  1. [package]
  2. name = "link-checker"
  3. version = "0.1.0"
  4. edition = "2021"
  5. publish = false
  7. [dependencies]
  8. reqwest = { version = "0.11.12", features = ["blocking", "rustls-tls"] }
  9. scraper = "0.13.0"
  10. thiserror = "1.0.37"

You can now download the start page. Try with a small site such as https://www.google.org/.

Your src/main.rs file should look something like this:

  1. use reqwest::blocking::Client;
  2. use reqwest::Url;
  3. use scraper::{Html, Selector};
  4. use thiserror::Error;
  6. #[derive(Error, Debug)]
  7. enum Error {
  8.     #[error("request error: {0}")]
  9.     ReqwestError(#[from] reqwest::Error),
  10.     #[error("bad http response: {0}")]
  11.     BadResponse(String),
  12. }
  14. #[derive(Debug)]
  15. struct CrawlCommand {
  16.     url: Url,
  17.     extract_links: bool,
  18. }
  20. fn visit_page(client: &Client, command: &CrawlCommand) -> Result<Vec<Url>, Error> {
  21.     println!("Checking {:#}", command.url);
  22.     let response = client.get(command.url.clone()).send()?;
  23.     if !response.status().is_success() {
  24.         return Err(Error::BadResponse(response.status().to_string()));
  25.     }
  27.     let mut link_urls = Vec::new();
  28.     if !command.extract_links {
  29.         return Ok(link_urls);
  30.     }
  32.     let base_url = response.url().to_owned();
  33.     let body_text = response.text()?;
  34.     let document = Html::parse_document(&body_text);
  36.     let selector = Selector::parse("a").unwrap();
  37.     let href_values = document
  38.         .select(&selector)
  39.         .filter_map(|element| element.value().attr("href"));
  40.     for href in href_values {
  41.         match base_url.join(href) {
  42.             Ok(link_url) => {
  43.                 link_urls.push(link_url);
  44.             }
  45.             Err(err) => {
  46.                 println!("On {base_url:#}: ignored unparsable {href:?}: {err}");
  47.             }
  48.         }
  49.     }
  50.     Ok(link_urls)
  51. }
  53. fn main() {
  54.     let client = Client::new();
  55.     let start_url = Url::parse("https://www.google.org").unwrap();
  56.     let crawl_command = CrawlCommand{ url: start_url, extract_links: true };
  57.     match visit_page(&client, &crawl_command) {
  58.         Ok(links) => println!("Links: {links:#?}"),
  59.         Err(err) => println!("Could not extract links: {err:#}"),
  60.     }
  61. }

Run the code in src/main.rs with

  1. cargo run

Tasks

  • Use threads to check the links in parallel: send the URLs to be checked to a channel and let a few threads check the URLs in parallel.
  • Extend this to recursively extract links from all pages on the www.google.org domain. Put an upper limit of 100 pages or so so that you don’t end up being blocked by the site.