Struct IoPool 

pub struct IoPool { /* private fields */ }

A small pool of dedicated writer threads fed by a bounded channel.

See the module docs for the full design rationale (issue #569 phase 1, ADR-0001).

Examples

use ssg::io_pool::IoPool;
use tempfile::tempdir;

let dir = tempdir().unwrap();
let pool = IoPool::with_threads(2);
pool.write(dir.path().join("page.html"), b"<html/>".to_vec()).unwrap();
pool.flush().unwrap();
assert!(dir.path().join("page.html").exists());

Implementations

impl IoPool

pub fn new() -> Self

Creates a pool with the default writer count: min(4, max(1, available_parallelism / 2)).

Examples

use ssg::io_pool::IoPool;

let pool = IoPool::new();
pool.flush().unwrap(); // empty pool flushes trivially

pub fn with_threads(threads: usize) -> Self

Creates a pool with an explicit writer-thread count.

threads is clamped to the 1..=4 range: zero writers would deadlock producers, and more than four writers only adds seek contention on the output disk.

Examples

use ssg::io_pool::IoPool;

let pool = IoPool::with_threads(0); // clamped to 1
pool.flush().unwrap();

pub fn write( &self, path: impl Into<PathBuf>, bytes: Vec<u8>, ) -> Result<(), SsgError>

Enqueues a write of bytes to path.

Blocks when the bounded queue is full (backpressure). The write itself happens asynchronously on a writer thread; any failure is captured and reported by the next flush.

Returns an error only if the job could not be enqueued at all (all writer threads gone); in the degenerate zero-worker fallback the write is performed inline instead.

Examples

use ssg::io_pool::IoPool;
use tempfile::tempdir;

let dir = tempdir().unwrap();
let pool = IoPool::new();
pool.write(dir.path().join("x.txt"), b"x".to_vec()).unwrap();
pool.flush().unwrap();

pub fn flush(&self) -> Result<(), SsgError>

Barrier: blocks until every job enqueued so far is fully processed, then reports write failures.

Returns the first captured error (with its path); any additional failures are logged at error level so nothing is silently dropped. The error buffer is cleared, and the pool stays alive — flush() does not shut the pool down and may be called repeatedly.

Examples

use ssg::io_pool::IoPool;

let pool = IoPool::new();
// Writing into a directory that does not exist fails at flush.
pool.write("/nonexistent-ssg-dir/x.txt", b"x".to_vec()).unwrap();
assert!(pool.flush().is_err());
// The pool remains usable after a failed flush.
pool.flush().unwrap();

pub fn completed_writes(&self) -> usize

Number of writes that have completed successfully since the pool was created. Primarily useful for tests and diagnostics.

Note: this is a live counter; call IoPool::flush first for a stable reading.

Examples

use ssg::io_pool::IoPool;
use tempfile::tempdir;

let dir = tempdir().unwrap();
let pool = IoPool::new();
assert_eq!(pool.completed_writes(), 0);
pool.write(dir.path().join("y.txt"), b"y".to_vec()).unwrap();
pool.flush().unwrap();
assert_eq!(pool.completed_writes(), 1);

pub const fn threads(&self) -> usize

Number of writer threads backing this pool.

Examples

use ssg::io_pool::IoPool;

assert_eq!(IoPool::with_threads(9).threads(), 4); // clamped
assert!(IoPool::new().threads() >= 1);

Trait Implementations

impl Debug for IoPool

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IoPool

fn default() -> Self

Returns the “default value” for a type.

impl Drop for IoPool

fn drop(&mut self)

Drains and joins: closes the channel so workers finish every queued job, then joins them. Errors never observed through IoPool::flush are logged — not silently discarded.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.