Struct Logger

pub struct Logger {
    pub verbose: bool,
    pub quiet: bool,
    pub start_time: Option<Instant>,
}

Logger responsible for all user-visible output

Fields

verbose: bool

quiet: bool

start_time: Option<Instant>

Implementations

impl Logger

pub fn new(verbose: bool) -> Self

Examples found in repository

examples/basic_usage_demo.rs (line 36)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Basic Usage Demo");
    println!("==========================================");
    println!("This demo corresponds to README Quick Start examples");
    println!();

    // Initialize logger for verbose output
    let logger = Logger::new(true);
    
    // Configuration from environment
    let registry_username = env::var("REGISTRY_USERNAME").unwrap_or_else(|_| {
        println!("⚠️  REGISTRY_USERNAME not set, using demo credentials");
        "demo_user".to_string()
    });
    
    let registry_password = env::var("REGISTRY_PASSWORD").unwrap_or_else(|_| {
        println!("⚠️  REGISTRY_PASSWORD not set, using demo credentials");
        "demo_pass".to_string()
    });
    
    let target_registry = env::var("TARGET_REGISTRY").unwrap_or_else(|_| {
        "registry.example.com".to_string()
    });

    let cache_dir = ".cache_basic_demo";
    
    // Clean up previous demo
    let _ = std::fs::remove_dir_all(cache_dir);
    
    logger.section("Demo 1: Basic Extract and Push Workflow");
    println!("📝 Scenario: Extract tar file → Cache → Push to registry");
    println!("📄 Command equivalent:");
    println!("   docker-image-pusher extract --file image.tar --verbose");
    println!("   docker-image-pusher push --source image:tag --target {}/app:v1.0", target_registry);
    println!();
    
    // Demo the basic workflow
    demo_extract_and_push(&logger, cache_dir, &target_registry, &registry_username, &registry_password).await?;
    
    logger.section("Demo 2: Pull and Cache Workflow");
    println!("📝 Scenario: Pull from registry → Cache locally");
    println!("📄 Command equivalent:");
    println!("   docker-image-pusher pull --image nginx:latest --verbose");
    println!();
    
    demo_pull_and_cache(&logger, cache_dir, &registry_username, &registry_password).await?;
    
    logger.section("Demo 3: Complete Pull-to-Push Migration");
    println!("📝 Scenario: Pull from source → Cache → Push to target");
    println!("📄 Command equivalent:");
    println!("   docker-image-pusher pull --image alpine:latest");
    println!("   docker-image-pusher push --source alpine:latest --target {}/alpine:migrated", target_registry);
    println!();
    
    demo_complete_migration(&logger, cache_dir, &target_registry, &registry_username, &registry_password).await?;
    
    println!("✅ Basic usage demo completed successfully!");
    println!("📚 These examples correspond to the README Quick Start section");
    
    Ok(())
}

examples/concurrency_monitoring_demo.rs (line 15)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Docker Image Pusher - Concurrency Monitoring Demo");
    println!("====================================================");
    
    let logger = Logger::new(false); // false for non-verbose mode
    
    // Create blob handler with different concurrency configurations
    println!("\n📊 Testing different concurrency configurations:");
    
    // Test 1: Default configuration (should be 3 concurrent tasks now)
    let default_config = PipelineConfig::default();
    let _blob_handler_default = BlobHandler::with_config(logger.clone(), default_config.clone());
    
    println!("✅ Default Configuration:");
    println!("   - Max concurrent tasks: {}", default_config.max_concurrent);
    println!("   - Retry attempts: {}", default_config.retry_attempts);
    println!("   - Timeout: {}s", default_config.timeout_seconds);
    
    // Test 2: Conservative configuration (1 concurrent task)
    let conservative_config = PipelineConfig {
        max_concurrent: 1,
        ..PipelineConfig::default()
    };
    let _blob_handler_conservative = BlobHandler::with_config(logger.clone(), conservative_config.clone());
    
    println!("\n🔒 Conservative Configuration:");
    println!("   - Max concurrent tasks: {}", conservative_config.max_concurrent);
    println!("   - This prevents memory exhaustion for very large images");
    
    // Test 3: Aggressive configuration (5 concurrent tasks)
    let aggressive_config = PipelineConfig {
        max_concurrent: 5,
        ..PipelineConfig::default()
    };
    let _blob_handler_aggressive = BlobHandler::with_config(logger.clone(), aggressive_config.clone());
    
    println!("\n⚡ Aggressive Configuration:");
    println!("   - Max concurrent tasks: {}", aggressive_config.max_concurrent);
    println!("   - Use with caution - may cause SIGKILL for large blobs");
    
    println!("\n🎯 Key Features of Concurrency Monitoring:");
    println!("   • Real-time active task count in upload logs");
    println!("   • Adaptive concurrency based on blob sizes:");
    println!("     - Blobs > 1GB: Max 1 concurrent task");
    println!("     - Blobs > 500MB: Max 2 concurrent tasks");
    println!("     - Memory-based scaling for smaller blobs");
    println!("   • Peak concurrent tasks summary");
    println!("   • Periodic progress updates every 5 seconds");
    
    println!("\n📈 Sample Upload Logs with Concurrency Info:");
    println!("   Upload task 1: Processing layer blob abcd1234... (150.2 MB) [Active tasks: 1]");
    println!("   Upload task 2: Processing layer blob efgh5678... (75.8 MB) [Active tasks: 2]");
    println!("   ✅ Blob abcd1234 uploaded in 15.3s (9.8 MB/s) [Active tasks: 1]");
    println!("   📊 Upload progress: 2 active tasks, 1 remaining");
    println!("   ✅ Unified Pipeline completed successfully (avg speed: 12.5 MB/s) [Peak concurrent tasks: 3]");
    
    println!("\n🛡️  Memory Protection Benefits:");
    println!("   • Prevents SIGKILL termination from excessive memory usage");
    println!("   • 2GB memory limit with intelligent blob size detection");
    println!("   • Conservative handling of large total image sizes (>10GB)");
    println!("   • 10MB overhead estimation per concurrent blob");
    
    println!("\n✨ Enhanced Error Handling:");
    println!("   • Individual task failure tracking");
    println!("   • Active task count shown in error messages");
    println!("   • Graceful degradation under memory pressure");
    
    logger.success("Demo completed successfully! Your blob uploads now have full visibility into concurrent task execution.");
    
    Ok(())
}

pub fn new_quiet() -> Self

pub fn section(&self, title: &str)

Main section heading

Examples found in repository

examples/basic_usage_demo.rs (line 58)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Basic Usage Demo");
    println!("==========================================");
    println!("This demo corresponds to README Quick Start examples");
    println!();

    // Initialize logger for verbose output
    let logger = Logger::new(true);
    
    // Configuration from environment
    let registry_username = env::var("REGISTRY_USERNAME").unwrap_or_else(|_| {
        println!("⚠️  REGISTRY_USERNAME not set, using demo credentials");
        "demo_user".to_string()
    });
    
    let registry_password = env::var("REGISTRY_PASSWORD").unwrap_or_else(|_| {
        println!("⚠️  REGISTRY_PASSWORD not set, using demo credentials");
        "demo_pass".to_string()
    });
    
    let target_registry = env::var("TARGET_REGISTRY").unwrap_or_else(|_| {
        "registry.example.com".to_string()
    });

    let cache_dir = ".cache_basic_demo";
    
    // Clean up previous demo
    let _ = std::fs::remove_dir_all(cache_dir);
    
    logger.section("Demo 1: Basic Extract and Push Workflow");
    println!("📝 Scenario: Extract tar file → Cache → Push to registry");
    println!("📄 Command equivalent:");
    println!("   docker-image-pusher extract --file image.tar --verbose");
    println!("   docker-image-pusher push --source image:tag --target {}/app:v1.0", target_registry);
    println!();
    
    // Demo the basic workflow
    demo_extract_and_push(&logger, cache_dir, &target_registry, &registry_username, &registry_password).await?;
    
    logger.section("Demo 2: Pull and Cache Workflow");
    println!("📝 Scenario: Pull from registry → Cache locally");
    println!("📄 Command equivalent:");
    println!("   docker-image-pusher pull --image nginx:latest --verbose");
    println!();
    
    demo_pull_and_cache(&logger, cache_dir, &registry_username, &registry_password).await?;
    
    logger.section("Demo 3: Complete Pull-to-Push Migration");
    println!("📝 Scenario: Pull from source → Cache → Push to target");
    println!("📄 Command equivalent:");
    println!("   docker-image-pusher pull --image alpine:latest");
    println!("   docker-image-pusher push --source alpine:latest --target {}/alpine:migrated", target_registry);
    println!();
    
    demo_complete_migration(&logger, cache_dir, &target_registry, &registry_username, &registry_password).await?;
    
    println!("✅ Basic usage demo completed successfully!");
    println!("📚 These examples correspond to the README Quick Start section");
    
    Ok(())
}

pub fn subsection(&self, title: &str)

Sub-section heading

pub fn trace(&self, message: &str)

pub fn debug(&self, message: &str)

pub fn verbose(&self, message: &str)

pub fn info(&self, message: &str)

Information message

Examples found in repository

examples/basic_usage_demo.rs (line 98)

async fn demo_extract_and_push(
    logger: &Logger,
    _cache_dir: &str,
    target_registry: &str,
    username: &str,
    _password: &str,
) -> Result<()> {
    logger.info("Creating demo tar file (simulated)...");
    
    // In a real scenario, you would have an actual tar file
    // For demo purposes, we'll simulate the operation
    println!("📦 Would extract tar file and cache locally");
    println!("🚀 Would push cached image to: {}/project/app:v1.0", target_registry);
    
    // Create registry client for demonstration
    let registry_url = format!("https://{}", target_registry);
    let _client = RegistryClientBuilder::new(registry_url)
        .with_verbose(true)
        .build()?;
    
    logger.info(&format!("Registry client created for: {}", target_registry));
    logger.info(&format!("Would authenticate with username: {}", username));
    
    // Note: In production, you would:
    // 1. Use ExtractAndCache operation mode with actual tar file
    // 2. Use PushFromCacheUsingManifest operation mode
    
    Ok(())
}

async fn demo_pull_and_cache(
    logger: &Logger,
    cache_dir: &str,
    _username: &str,
    _password: &str,
) -> Result<()> {
    logger.info("Demonstrating pull and cache workflow...");
    
    // Create image manager
    let mut _image_manager = ImageManager::new(Some(cache_dir), true)?;
    
    println!("🔽 Would pull nginx:latest from Docker Hub");
    println!("💾 Would cache image locally in: {}", cache_dir);
    
    // In production, you would use:
    // let operation = OperationMode::PullAndCache {
    //     registry_url: "https://registry-1.docker.io".to_string(),
    //     repository: "library/nginx".to_string(),
    //     reference: "latest".to_string(),
    //     cache_dir: cache_dir.to_string(),
    //     auth_config: Some(auth_config),
    // };
    
    logger.info("Pull and cache operation configured (demo mode)");
    
    Ok(())
}

async fn demo_complete_migration(
    logger: &Logger,
    _cache_dir: &str,
    target_registry: &str,
    _username: &str,
    _password: &str,
) -> Result<()> {
    logger.info("Demonstrating complete migration workflow...");
    
    println!("🔄 Complete migration workflow:");
    println!("   1. Pull alpine:latest from Docker Hub");
    println!("   2. Cache locally");
    println!("   3. Push to target registry: {}/alpine:migrated", target_registry);
    
    // This would involve:
    // 1. PullAndCache operation
    // 2. PushFromCacheUsingManifest operation
    
    logger.info("Migration workflow completed (demo mode)");
    
    Ok(())
}

pub fn success(&self, message: &str)

Success message

Examples found in repository

examples/concurrency_monitoring_demo.rs (line 78)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Docker Image Pusher - Concurrency Monitoring Demo");
    println!("====================================================");
    
    let logger = Logger::new(false); // false for non-verbose mode
    
    // Create blob handler with different concurrency configurations
    println!("\n📊 Testing different concurrency configurations:");
    
    // Test 1: Default configuration (should be 3 concurrent tasks now)
    let default_config = PipelineConfig::default();
    let _blob_handler_default = BlobHandler::with_config(logger.clone(), default_config.clone());
    
    println!("✅ Default Configuration:");
    println!("   - Max concurrent tasks: {}", default_config.max_concurrent);
    println!("   - Retry attempts: {}", default_config.retry_attempts);
    println!("   - Timeout: {}s", default_config.timeout_seconds);
    
    // Test 2: Conservative configuration (1 concurrent task)
    let conservative_config = PipelineConfig {
        max_concurrent: 1,
        ..PipelineConfig::default()
    };
    let _blob_handler_conservative = BlobHandler::with_config(logger.clone(), conservative_config.clone());
    
    println!("\n🔒 Conservative Configuration:");
    println!("   - Max concurrent tasks: {}", conservative_config.max_concurrent);
    println!("   - This prevents memory exhaustion for very large images");
    
    // Test 3: Aggressive configuration (5 concurrent tasks)
    let aggressive_config = PipelineConfig {
        max_concurrent: 5,
        ..PipelineConfig::default()
    };
    let _blob_handler_aggressive = BlobHandler::with_config(logger.clone(), aggressive_config.clone());
    
    println!("\n⚡ Aggressive Configuration:");
    println!("   - Max concurrent tasks: {}", aggressive_config.max_concurrent);
    println!("   - Use with caution - may cause SIGKILL for large blobs");
    
    println!("\n🎯 Key Features of Concurrency Monitoring:");
    println!("   • Real-time active task count in upload logs");
    println!("   • Adaptive concurrency based on blob sizes:");
    println!("     - Blobs > 1GB: Max 1 concurrent task");
    println!("     - Blobs > 500MB: Max 2 concurrent tasks");
    println!("     - Memory-based scaling for smaller blobs");
    println!("   • Peak concurrent tasks summary");
    println!("   • Periodic progress updates every 5 seconds");
    
    println!("\n📈 Sample Upload Logs with Concurrency Info:");
    println!("   Upload task 1: Processing layer blob abcd1234... (150.2 MB) [Active tasks: 1]");
    println!("   Upload task 2: Processing layer blob efgh5678... (75.8 MB) [Active tasks: 2]");
    println!("   ✅ Blob abcd1234 uploaded in 15.3s (9.8 MB/s) [Active tasks: 1]");
    println!("   📊 Upload progress: 2 active tasks, 1 remaining");
    println!("   ✅ Unified Pipeline completed successfully (avg speed: 12.5 MB/s) [Peak concurrent tasks: 3]");
    
    println!("\n🛡️  Memory Protection Benefits:");
    println!("   • Prevents SIGKILL termination from excessive memory usage");
    println!("   • 2GB memory limit with intelligent blob size detection");
    println!("   • Conservative handling of large total image sizes (>10GB)");
    println!("   • 10MB overhead estimation per concurrent blob");
    
    println!("\n✨ Enhanced Error Handling:");
    println!("   • Individual task failure tracking");
    println!("   • Active task count shown in error messages");
    println!("   • Graceful degradation under memory pressure");
    
    logger.success("Demo completed successfully! Your blob uploads now have full visibility into concurrent task execution.");
    
    Ok(())
}

pub fn warning(&self, message: &str)

Warning message

pub fn error(&self, message: &str)

Error message

pub fn step(&self, message: &str)

Step information

pub fn progress(&self, message: &str)

Progress information

pub fn progress_done(&self)

Progress completion

pub fn detail(&self, message: &str)

Detailed information (only shown in verbose mode)

pub fn summary(&self, title: &str, items: &[String])

pub fn summary_kv(&self, title: &str, items: &[(&str, String)])

Key-value pair summary display

pub fn list(&self, title: &str, items: &[String])

pub fn format_size(&self, bytes: u64) -> String

Format file size in human-readable units

pub fn format_duration(&self, duration: Duration) -> String

Format duration in human-readable format

pub fn format_speed(&self, bytes_per_sec: u64) -> String

Format transfer speed in human-readable format

pub fn display_live_progress(&self, progress: &ProgressState)

显示实时进度状态

pub fn display_detailed_progress(&self, progress: &ProgressState)

Display detailed parallel task status

pub fn notify_concurrency_adjustment( &self, old_value: usize, new_value: usize, reason: &str, )

Display concurrency adjustment notification

pub fn notify_task_start( &self, task_type: &str, layer_index: usize, size: u64, priority: u64, )

Display task start notification

pub fn notify_task_complete( &self, task_type: &str, layer_index: usize, duration: Duration, size: u64, )

Display task completion notification

pub fn display_simple_progress( &self, completed: usize, total: usize, message: &str, )

Display simple progress information

Trait Implementations

impl Clone for Logger

fn clone(&self) -> Logger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Logger

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

Formats the value using the given formatter.