Struct FsLimits 

pub struct FsLimits {
    pub max_total_bytes: u64,
    pub max_file_size: u64,
    pub max_file_count: u64,
}

Filesystem resource limits.

Controls maximum resource consumption for in-memory filesystems. Applied to both InMemoryFs and OverlayFs.

Example

use bashkit::{Bash, FsLimits, InMemoryFs};
use std::sync::Arc;

// Create filesystem with custom limits
let limits = FsLimits::new()
    .max_total_bytes(50_000_000)  // 50MB total
    .max_file_size(5_000_000)     // 5MB per file
    .max_file_count(1000);        // 1000 files max

let fs = Arc::new(InMemoryFs::with_limits(limits));
let bash = Bash::builder().fs(fs).build();

Default Limits

Limit	Default	Purpose
max_total_bytes	100MB	Total filesystem memory
max_file_size	10MB	Single file size
max_file_count	10,000	Number of files

Fields

max_total_bytes: u64

Maximum total bytes across all files. Default: 100MB (100,000,000 bytes)

max_file_size: u64

Maximum size of a single file in bytes. Default: 10MB (10,000,000 bytes)

max_file_count: u64

Maximum number of files (not including directories). Default: 10,000

Implementations

impl FsLimits

pub fn new() -> Self

Create new limits with defaults.

Example

use bashkit::FsLimits;

let limits = FsLimits::new();
assert_eq!(limits.max_total_bytes, 100_000_000);

pub fn unlimited() -> Self

Create unlimited limits (no restrictions).

Warning

Using unlimited limits removes protection against memory exhaustion. Only use in trusted environments.

Example

use bashkit::FsLimits;

let limits = FsLimits::unlimited();
assert_eq!(limits.max_total_bytes, u64::MAX);

pub fn max_total_bytes(self, bytes: u64) -> Self

Set maximum total filesystem size.

Example

use bashkit::FsLimits;

let limits = FsLimits::new().max_total_bytes(50_000_000); // 50MB

pub fn max_file_size(self, bytes: u64) -> Self

Set maximum single file size.

Example

use bashkit::FsLimits;

let limits = FsLimits::new().max_file_size(1_000_000); // 1MB

pub fn max_file_count(self, count: u64) -> Self

Set maximum file count.

Example

use bashkit::FsLimits;

let limits = FsLimits::new().max_file_count(100);

pub fn check_total_bytes( &self, current: u64, additional: u64, ) -> Result<(), FsLimitExceeded>

Check if adding bytes would exceed total limit.

Returns Ok(()) if within limits, Err(FsLimitExceeded) otherwise.

pub fn check_file_size(&self, size: u64) -> Result<(), FsLimitExceeded>

Check if a file size exceeds the limit.

pub fn check_file_count(&self, current: u64) -> Result<(), FsLimitExceeded>

Check if adding a file would exceed the count limit.

Trait Implementations

impl Clone for FsLimits

fn clone(&self) -> FsLimits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FsLimits

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

Formats the value using the given formatter.

impl Default for FsLimits

fn default() -> Self

Returns the “default value” for a type.