Struct Client 

pub struct Client { /* private fields */ }

Async client for the 4chan JSON API. Cheap to clone, internal config is Arc-shared. Construct with Client::new for sensible defaults, or Client::with_client to plug in your own reqwest::Client (matching backgrounds/rchan ergonomics).

Implementations

impl Client

pub fn new() -> Self

New client with a fresh reqwest::Client and a chan-rs/<ver> User-Agent.

Examples found in repository

examples/list_boards.rs (line 6)

async fn main() -> chan::Result<()> {
    let client = chan::Client::new();
    let boards = client.get_boards().await?;
    for b in &boards {
        let ws = if b.is_ws() { "ws" } else { "nsfw" };
        println!("/{:>3}/ [{}] {}", b.board, ws, b.title);
    }
    println!("\n{} boards.", boards.len());
    Ok(())
}

examples/catalog_images.rs (line 9)

async fn main() -> chan::Result<()> {
    let board = env::args().nth(1).unwrap_or_else(|| "po".to_string());
    let client = chan::Client::new();
    let catalog = client.get_board_catalog(&board).await?;

    let mut count = 0usize;
    for thread in catalog.threads() {
        if let Some(att) = &thread.op.attachment {
            if !att.is_animated() {
                println!("{}", att.url(&board));
                count += 1;
            }
        }
        for reply in &thread.last_replies {
            if let Some(att) = &reply.attachment {
                if !att.is_animated() {
                    println!("{}", att.url(&board));
                    count += 1;
                }
            }
        }
    }
    eprintln!("/{}/: {} still-image URLs", board, count);
    Ok(())
}

examples/poll_thread.rs (line 23)

async fn main() -> chan::Result<()> {
    let mut args = env::args().skip(1);
    let board = args.next().unwrap_or_else(|| "po".to_string());
    let thread_no: u64 = args
        .next()
        .and_then(|s| s.parse().ok())
        .expect("usage: poll_thread <board> <thread_no>");

    let client = Client::new();
    let mut seen: HashSet<u64> = HashSet::new();
    let mut since: Option<String> = None;

    loop {
        match client
            .get_full_thread_if_modified(&board, thread_no, since.as_deref())
            .await
        {
            Ok(None) => {
                eprintln!("304 Not Modified");
            }
            Ok(Some(cond)) => {
                since = cond.last_modified;
                for post in &cond.value.posts {
                    if seen.insert(post.no) {
                        print_post(&board, post);
                    }
                }
                if cond.value.op().archived || cond.value.op().closed {
                    eprintln!("Thread archived or closed. Exiting.");
                    return Ok(());
                }
            }
            Err(chan::Error::NotFound(_)) => {
                eprintln!("Thread 404'd. Exiting.");
                return Ok(());
            }
            Err(e) => return Err(e),
        }
        tokio::time::sleep(Duration::from_secs(30)).await;
    }
}

pub fn with_client(http: Client) -> Self

New client reusing an existing reqwest::Client. Lets callers share connection pools and proxy/TLS config across multiple APIs.

pub fn with_api_host(self, host: impl Into<String>) -> Self

Override the API host. Useful for tests or proxies.

pub async fn get_boards(&self) -> Result<Vec<Board>>

GET /boards.json, return every board the API exposes.

Examples found in repository

examples/list_boards.rs (line 7)

async fn main() -> chan::Result<()> {
    let client = chan::Client::new();
    let boards = client.get_boards().await?;
    for b in &boards {
        let ws = if b.is_ws() { "ws" } else { "nsfw" };
        println!("/{:>3}/ [{}] {}", b.board, ws, b.title);
    }
    println!("\n{} boards.", boards.len());
    Ok(())
}

pub async fn get_board_catalog(&self, board: &str) -> Result<Catalog>

GET /{board}/catalog.json, every thread on the board, with up to 5 reply previews per thread.

Examples found in repository

examples/catalog_images.rs (line 10)

async fn main() -> chan::Result<()> {
    let board = env::args().nth(1).unwrap_or_else(|| "po".to_string());
    let client = chan::Client::new();
    let catalog = client.get_board_catalog(&board).await?;

    let mut count = 0usize;
    for thread in catalog.threads() {
        if let Some(att) = &thread.op.attachment {
            if !att.is_animated() {
                println!("{}", att.url(&board));
                count += 1;
            }
        }
        for reply in &thread.last_replies {
            if let Some(att) = &reply.attachment {
                if !att.is_animated() {
                    println!("{}", att.url(&board));
                    count += 1;
                }
            }
        }
    }
    eprintln!("/{}/: {} still-image URLs", board, count);
    Ok(())
}

pub async fn get_threads(&self, board: &str) -> Result<ThreadList>

GET /{board}/threads.json, a lightweight per-thread last_modified summary

pub async fn get_archive(&self, board: &str) -> Result<Archive>

GET /{board}/archive.json, archived OP numbers, oldest first. Errors with Error::NotFound on boards that have no archive.

pub async fn get_index_page(&self, board: &str, page: u8) -> Result<IndexPage>

GET /{board}/{page}.json, one index page (1.=15) with full thread previews.

pub async fn get_full_thread( &self, board: &str, thread_no: u64, ) -> Result<Thread>

GET /{board}/thread/{no}.json, every post in a thread.

pub async fn get_threads_if_modified( &self, board: &str, since: Option<&str>, ) -> Result<Option<Conditional<ThreadList>>>

pub async fn get_catalog_if_modified( &self, board: &str, since: Option<&str>, ) -> Result<Option<Conditional<Catalog>>>

pub async fn get_full_thread_if_modified( &self, board: &str, thread_no: u64, since: Option<&str>, ) -> Result<Option<Conditional<Thread>>>

Examples found in repository

examples/poll_thread.rs (line 29)

async fn main() -> chan::Result<()> {
    let mut args = env::args().skip(1);
    let board = args.next().unwrap_or_else(|| "po".to_string());
    let thread_no: u64 = args
        .next()
        .and_then(|s| s.parse().ok())
        .expect("usage: poll_thread <board> <thread_no>");

    let client = Client::new();
    let mut seen: HashSet<u64> = HashSet::new();
    let mut since: Option<String> = None;

    loop {
        match client
            .get_full_thread_if_modified(&board, thread_no, since.as_deref())
            .await
        {
            Ok(None) => {
                eprintln!("304 Not Modified");
            }
            Ok(Some(cond)) => {
                since = cond.last_modified;
                for post in &cond.value.posts {
                    if seen.insert(post.no) {
                        print_post(&board, post);
                    }
                }
                if cond.value.op().archived || cond.value.op().closed {
                    eprintln!("Thread archived or closed. Exiting.");
                    return Ok(());
                }
            }
            Err(chan::Error::NotFound(_)) => {
                eprintln!("Thread 404'd. Exiting.");
                return Ok(());
            }
            Err(e) => return Err(e),
        }
        tokio::time::sleep(Duration::from_secs(30)).await;
    }
}

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Client

fn default() -> Self

Returns the “default value” for a type.