cstats-cli 0.1.1

Command line interface for cstats
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Cache command implementation

use cstats_core::{cache::FileCache, config::Config, Result};
use tracing::info;

use crate::{CacheAction, CacheArgs};

/// Manage cache operations
pub async fn cache_command(args: CacheArgs, config: &Config) -> Result<()> {
    let cache = FileCache::new(config.cache.clone());

    match args.action {
        CacheAction::Stats => {
            info!("Getting cache statistics");
            let stats = cache.stats().await?;

            println!("\n=== Cache Statistics ===");
            println!("Cache directory: {}", stats.cache_dir.display());
            println!("Total entries: {}", stats.entry_count);
            println!("Expired entries: {}", stats.expired_count);
            println!(
                "Total size: {} bytes ({:.2} MB)",
                stats.total_size_bytes,
                stats.total_size_bytes as f64 / 1024.0 / 1024.0
            );

            let active_entries = stats.entry_count - stats.expired_count;
            println!("Active entries: {}", active_entries);
        }

        CacheAction::Clear => {
            info!("Clearing cache");
            cache.clear().await?;
            println!("Cache cleared successfully");
        }

        CacheAction::List => {
            info!("Listing cache entries");
            let stats = cache.stats().await?;

            println!("\n=== Cache Entries ===");
            println!("Cache directory: {}", stats.cache_dir.display());

            if stats.cache_dir.exists() {
                let mut entries = tokio::fs::read_dir(&stats.cache_dir).await?;
                let mut count = 0;

                while let Some(entry) = entries.next_entry().await? {
                    if entry.file_type().await?.is_file() {
                        let metadata = entry.metadata().await?;
                        let modified = metadata.modified()?;
                        let size = metadata.len();

                        println!(
                            "{}: {} bytes, modified: {:?}",
                            entry.file_name().to_string_lossy(),
                            size,
                            modified
                        );
                        count += 1;
                    }
                }

                if count == 0 {
                    println!("No cache entries found");
                }
            } else {
                println!("Cache directory does not exist");
            }
        }
    }

    Ok(())
}