Struct ImageManager

pub struct ImageManager { /* private fields */ }

综合镜像管理器 - 4种操作模式的统一入口

Implementations

impl ImageManager

pub fn new(cache_dir: Option<&str>, verbose: bool) -> Result<Self>

创建新的镜像管理器

Examples found in repository

examples/optimized_upload_demo.rs (line 14)

async fn main() -> Result<()> {
    println!("Docker Image Pusher - Optimized Upload Demo");

    // Create image manager with optimizations enabled (default)
    let mut manager = ImageManager::new(None, true)?;

    // Configure pipeline for demonstration
    let config = PipelineConfig {
        max_concurrent: 8,
        buffer_size: 1024,
        small_blob_threshold: 10 * 1024 * 1024,   // 10MB
        medium_blob_threshold: 100 * 1024 * 1024, // 100MB
        large_blob_threshold: 500 * 1024 * 1024,  // 500MB
        timeout_seconds: 7200,
        retry_attempts: 3,
        memory_limit_mb: 512,
        enable_compression: true,
        enable_streaming: true,
    };
    manager.configure_pipeline(config);

    // Verify configuration
    let (optimized, pipeline_config) = manager.get_config();
    println!("Optimized mode: {}", optimized);
    println!("Pipeline config: {:?}", pipeline_config);

    // Example registry client (would need real registry URL)
    let client = RegistryClientBuilder::new("https://registry.example.com".to_string())
        .with_verbose(true)
        .build()?;

    // Test connectivity (this would fail with example URL)
    println!("Testing registry connectivity...");
    match client.test_connectivity().await {
        Ok(_) => println!("✓ Registry connectivity successful"),
        Err(e) => println!(
            "✗ Registry connectivity failed: {} (expected with example URL)",
            e
        ),
    }

    // Example operation mode for pushing from tar
    let mode = OperationMode::PushFromTar {
        tar_file: "example-image.tar".to_string(),
        repository: "myapp".to_string(),
        reference: "latest".to_string(),
    };

    println!("Operation mode: {}", mode.description());

    // In a real scenario, you would call:
    // manager.execute_operation(&mode, Some(&client), None).await?;

    println!("Demo completed successfully!");
    println!("\nKey benefits of optimized mode:");
    println!("• Priority-based upload scheduling (small blobs first)");
    println!("• Streaming TAR processing with parallel uploads");
    println!("• Memory-efficient processing of large files");
    println!("• Configurable pipeline parameters");

    Ok(())
}

examples/extract_and_cache_demo.rs (line 46)

async fn main() -> Result<()> {
    println!("📦 Docker Image Pusher - Extract and Cache Demo");
    println!("===================================================");

    // 配置参数
    let tar_file = get_tar_file_path();
    let cache_dir = ".cache_extract_demo";

    // 从tar文件名推导repository和reference
    let file_stem = Path::new(&tar_file)
        .file_stem()
        .and_then(|s| s.to_str())
        .unwrap_or("extracted-image");
    let repository = format!("local/{}", file_stem);
    let reference = "latest";

    println!("📥 Configuration:");
    println!("  Tar File: {}", tar_file);
    println!("  Repository: {}", repository);
    println!("  Reference: {}", reference);
    println!("  Cache Directory: {}", cache_dir);
    println!();

    // 1. 验证tar文件存在
    if !Path::new(&tar_file).exists() {
        eprintln!("❌ Tar file not found: {}", tar_file);
        eprintln!("💡 Please ensure the dufs.tar file exists in the examples/ directory");
        return Err(docker_image_pusher::error::RegistryError::Validation(
            format!("Tar file does not exist: {}", tar_file),
        ));
    }

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 定义操作模式
    let mode = OperationMode::ExtractAndCache {
        tar_file: tar_file.clone(),
        repository: repository.clone(),
        reference: reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 4. 执行提取和缓存操作
    println!("🔄 Starting extract and cache operation...");
    match image_manager.execute_operation(&mode, None, None).await {
        Ok(()) => {
            println!("✅ Extract and cache operation completed successfully!");
            println!();
            println!("📂 Image extracted and cached to: {}", cache_dir);
            println!("🔍 You can now inspect the cache contents:");
            println!(
                "   - Manifests: {}/manifests/{}/{}",
                cache_dir, repository, reference
            );
            println!("   - Blobs: {}/blobs/sha256/", cache_dir);
            println!("   - Index: {}/index.json", cache_dir);
        }
        Err(e) => {
            eprintln!("❌ Extract and cache operation failed: {}", e);
            std::process::exit(1);
        }
    }

    // 5. 显示提取统计
    show_extraction_stats(&tar_file, cache_dir).await;

    Ok(())
}

examples/pull_and_cache_demo.rs (line 33)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Pull and Cache Demo");
    println!("==================================================");

    // 配置参数 - 支持环境变量
    let registry = env::var("DOCKER_REGISTRY")
        .unwrap_or_else(|_| "https://registry.cn-beijing.aliyuncs.com".to_string());
    let repository = env::var("DOCKER_REPOSITORY").unwrap_or_else(|_| "yoce/cblt".to_string());
    let reference = env::var("DOCKER_REFERENCE").unwrap_or_else(|_| "yoce".to_string());
    let cache_dir = ".cache_demo";

    println!("📥 Configuration:");
    println!("  Registry: {}", registry);
    println!("  Repository: {}", repository);
    println!("  Reference: {}", reference);
    println!("  Cache Directory: {}", cache_dir);
    println!();

    // 1. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 2. 构建 Registry Client
    println!("🌐 Building Registry Client...");
    let client = RegistryClientBuilder::new(registry.to_string())
        .with_timeout(3600)
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 3. 获取认证（总是尝试，支持匿名token）
    println!("🔐 Attempting authentication...");
    let auth_token = if let (Ok(username), Ok(password)) =
        (env::var("DOCKER_USERNAME"), env::var("DOCKER_PASSWORD"))
    {
        println!("  Using provided credentials for user: {}", username);
        let auth_config = AuthConfig::new(username, password);
        client
            .authenticate_for_repository(&auth_config, &repository)
            .await?
    } else {
        println!("  No credentials provided, trying anonymous authentication...");
        // 使用直接认证方法尝试获取匿名token
        let auth = docker_image_pusher::registry::auth::Auth::new();
        let output = docker_image_pusher::logging::Logger::new(true);
        auth.authenticate_with_registry(&registry, &repository, None, None, &output)
            .await?
    };

    if auth_token.is_some() {
        println!("✅ Authentication successful");
    } else {
        println!("ℹ️  No authentication required");
    }

    // 4. 定义操作模式
    let mode = OperationMode::PullAndCache {
        repository: repository.to_string(),
        reference: reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 5. 执行拉取和缓存操作
    println!("🔄 Starting pull and cache operation...");
    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Pull and cache operation completed successfully!");
            println!();
            println!("📂 Image cached to: {}", cache_dir);
            println!("🔍 You can now inspect the cache contents:");
            println!(
                "   - Manifests: {}/manifests/{}/{}",
                cache_dir, repository, reference
            );
            println!("   - Blobs: {}/blobs/sha256/", cache_dir);
            println!("   - Index: {}/index.json", cache_dir);
        }
        Err(e) => {
            eprintln!("❌ Pull and cache operation failed: {}", e);
            std::process::exit(1);
        }
    }

    // 6. 显示缓存统计
    show_cache_stats(cache_dir).await;

    Ok(())
}

examples/push_to_aliyun_demo.rs (line 46)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Push to Aliyun Registry Demo");
    println!("=======================================================");

    // 阿里云配置
    let aliyun_registry = "registry.cn-beijing.aliyuncs.com";
    let aliyun_username = "canny_best@163.com";
    let aliyun_password = "ra201222";

    // 源镜像（从缓存）
    let source_repository = "yoce/cblt";
    let source_reference = "yoce";

    // 目标镜像（推送到阿里云）- 推送回同一个仓库，不同tag
    let target_repository = "yoce/cblt";
    let target_reference = "push-test";
    let cache_dir = ".cache_demo";

    println!("📥 Configuration:");
    println!(
        "  Source (Cache): {}/{}",
        source_repository, source_reference
    );
    println!("  Target Registry: {}", aliyun_registry);
    println!("  Target Repository: {}", target_repository);
    println!("  Target Reference: {}", target_reference);
    println!("  Cache Directory: {}", cache_dir);
    println!("  Username: {}", aliyun_username);
    println!();

    // 1. 检查缓存是否存在
    check_cache_exists(cache_dir, source_repository, source_reference).await?;

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 复制缓存中的镜像到目标仓库名称
    println!("📋 Copying cached image to target repository name...");
    copy_image_in_cache(
        cache_dir,
        source_repository,
        source_reference,
        target_repository,
        target_reference,
    )
    .await?;
    println!("✅ Image copied in cache");

    // 4. 构建 Registry Client for 阿里云
    println!("🌐 Building Registry Client for Aliyun...");
    let client = RegistryClientBuilder::new(format!("https://{}", aliyun_registry))
        .with_timeout(3600)
        .with_skip_tls(false)
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 4. 认证到阿里云
    println!("🔐 Authenticating with Aliyun registry...");
    let auth_config = AuthConfig::new(aliyun_username.to_string(), aliyun_password.to_string());
    let auth_token = client
        .authenticate_for_repository(&auth_config, target_repository)
        .await?;
    println!("✅ Authentication successful");

    // 5. 定义操作模式 - 推送缓存中的镜像到阿里云
    let mode = OperationMode::PushFromCacheUsingManifest {
        repository: target_repository.to_string(),
        reference: target_reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 6. 执行推送操作
    println!("🔄 Starting push to Aliyun operation...");
    println!(
        "🎯 Target: {}/{}/{}",
        aliyun_registry, target_repository, target_reference
    );

    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Push to Aliyun operation completed successfully!");
            println!(
                "🎯 Image pushed to: {}/{}/{}",
                aliyun_registry, target_repository, target_reference
            );
            println!("🔍 You can verify the upload in Aliyun Console:");
            println!("   https://cr.console.aliyun.com");

            // 验证推送结果
            verify_push_result(&client, target_repository, target_reference, &auth_token).await;
        }
        Err(e) => {
            eprintln!("❌ Push to Aliyun operation failed: {}", e);
            eprintln!("💡 Possible solutions:");
            eprintln!("   - Check Aliyun credentials and permissions");
            eprintln!("   - Verify repository name format (namespace/repo)");
            eprintln!("   - Check network connectivity to Aliyun registry");
            eprintln!("   - Ensure the repository exists in Aliyun console");
            eprintln!("   - Check if the namespace 'yoce' exists");
            std::process::exit(1);
        }
    }

    Ok(())
}

examples/push_from_cache_manifest_demo.rs (line 41)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Push from Cache (Manifest) Demo");
    println!("============================================================");

    // 配置参数 - 使用Aliyun registry，推送到已存在的repository
    let source_repository = "yoce/cblt"; // 从缓存中读取
    let source_reference = "yoce";
    let target_registry = "registry.cn-beijing.aliyuncs.com";
    let target_repository = "yoce/cblt"; // 推送回同一个repository
    let target_reference = "test-push"; // 使用新的tag
    let cache_dir = ".cache_demo";

    println!("📥 Configuration:");
    println!(
        "  Source (Cache): {}/{}",
        source_repository, source_reference
    );
    println!("  Target Registry: {}", target_registry);
    println!("  Target Repository: {}", target_repository);
    println!("  Target Reference: {}", target_reference);
    println!("  Cache Directory: {}", cache_dir);
    println!();

    // 1. 检查缓存是否存在
    check_cache_exists(cache_dir, source_repository, source_reference).await?;

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 构建 Registry Client - 配置为Aliyun registry
    println!("🌐 Building Registry Client for Aliyun registry...");
    let client = RegistryClientBuilder::new(format!("https://{}", target_registry))
        .with_timeout(3600)
        .with_skip_tls(false) // Aliyun registry使用TLS
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 4. 获取认证 - 使用Aliyun registry凭据
    println!("🔐 Authenticating with Aliyun registry...");
    let username = env::var("ALIYUN_USERNAME").unwrap_or_else(|_| "canny_best@163.com".to_string());
    let password = env::var("ALIYUN_PASSWORD").unwrap_or_else(|_| "ra201222".to_string());

    let auth_config = AuthConfig::new(username.clone(), password.clone());
    let auth_token = client
        .authenticate_for_repository(&auth_config, target_repository)
        .await?;
    println!("✅ Authentication successful with user: {}", username);
    println!("🔑 Token scope: repository:{}:pull,push", target_repository);

    // 5. 定义操作模式 - 使用 manifest 方式推送
    let mode = OperationMode::PushFromCacheUsingManifest {
        repository: target_repository.to_string(),
        reference: target_reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 6. 执行推送操作
    println!("🔄 Starting push from cache operation...");
    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Push from cache operation completed successfully!");
            println!();
            println!(
                "🎯 Image pushed to: {}/{}/{}",
                target_registry, target_repository, target_reference
            );
            println!("🔍 You can now verify the upload:");
            println!(
                "   curl -H \"Authorization: Bearer <token>\" https://{}/v2/{}/manifests/{}",
                target_registry, target_repository, target_reference
            );
            println!(
                "   curl -H \"Authorization: Bearer <token>\" https://{}/v2/{}/tags/list",
                target_registry, target_repository
            );
        }
        Err(e) => {
            eprintln!("❌ Push from cache operation failed: {}", e);
            eprintln!("💡 Possible solutions:");
            eprintln!(
                "   - Check if source image exists in cache: {}/{}",
                source_repository, source_reference
            );
            eprintln!("   - Verify Aliyun registry credentials");
            eprintln!("   - Check network connectivity to Aliyun registry");
            std::process::exit(1);
        }
    }

    // 7. 验证推送结果
    verify_push_result(&client, target_repository, target_reference, &auth_token).await;

    Ok(())
}

examples/push_from_cache_tar_demo.rs (line 42)

async fn main() -> Result<()> {
    println!("📦 Docker Image Pusher - Push from Cache (Tar Reference) Demo");
    println!("================================================================");

    // 配置参数
    let target_registry = "registry.cn-beijing.aliyuncs.com";
    let target_repository = "yoce/cblt"; // 推送到相同的repository
    let target_reference = "yoce"; // 推送到相同的reference
    let cache_dir = ".cache_demo"; // 使用已有的缓存

    println!("📥 Configuration:");
    println!("  Cache Directory: {}", cache_dir);
    println!("  Target Registry: {}", target_registry);
    println!("  Target Repository: {}", target_repository);
    println!("  Target Reference: {}", target_reference);
    println!();

    println!(
        "ℹ️  Note: This mode pushes cached image {}/{} to target registry",
        target_repository, target_reference
    );
    println!("   The implementation is identical to manifest-based push");
    println!();

    // 1. 检查缓存是否存在
    check_cache_exists(cache_dir, target_repository, target_reference).await?;

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 构建 Registry Client
    println!("🌐 Building Registry Client for Aliyun registry...");
    let client = RegistryClientBuilder::new(format!("https://{}", target_registry))
        .with_timeout(3600)
        .with_skip_tls(false) // Aliyun uses TLS
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 4. 获取认证（Aliyun credentials）
    println!("🔐 Authenticating with Aliyun registry...");
    let auth_config = AuthConfig::new("canny_best@163.com".to_string(), "ra201222".to_string());
    let auth_token = client
        .authenticate_for_repository(&auth_config, target_repository)
        .await?;
    println!(
        "✅ Authentication successful with user: {}",
        auth_config.username
    );
    println!("🔑 Token scope: repository:{}:pull,push", target_repository);

    // 5. 定义操作模式 - 使用 tar 引用方式推送（实际上与manifest模式相同）
    let mode = OperationMode::PushFromCacheUsingTar {
        repository: target_repository.to_string(),
        reference: target_reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!("🔄 Internal Process: Reading from unified cache format (same as manifest mode)");
    println!();

    // 6. 执行推送操作
    println!("🔄 Starting push from cache operation...");
    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Push from cache (tar reference) operation completed successfully!");
            println!();
            println!(
                "🎯 Image pushed to: {}/{}/{}",
                target_registry, target_repository, target_reference
            );
            println!("🔍 You can now verify the upload:");
            println!(
                "   curl http://{}/v2/{}/manifests/{}",
                target_registry, target_repository, target_reference
            );
            println!(
                "   curl http://{}/v2/{}/tags/list",
                target_registry, target_repository
            );

            // 显示模式差异说明
            show_mode_explanation();
        }
        Err(e) => {
            eprintln!("❌ Push from cache (tar reference) operation failed: {}", e);
            eprintln!("💡 Possible solutions:");
            eprintln!(
                "   - Check if target registry is running: docker run -d -p 5000:5000 registry:2"
            );
            eprintln!("   - Verify cache contains the source image");
            eprintln!("   - Check network connectivity to target registry");
            std::process::exit(1);
        }
    }

    // 7. 验证推送结果并对比两种模式
    verify_push_result_and_compare(&client, target_repository, target_reference, &auth_token).await;

    Ok(())
}

Additional examples can be found in:

• examples/comprehensive_demo.rs
• examples/large_image_test_demo.rs

pub fn with_config( cache_dir: Option<&str>, verbose: bool, use_optimized_upload: bool, ) -> Result<Self>

创建镜像管理器，并允许配置优化选项

pub async fn execute_operation( &mut self, mode: &OperationMode, client: Option<&RegistryClient>, auth_token: Option<&str>, ) -> Result<()>

执行指定的操作模式 - 统一入口点

Examples found in repository

examples/extract_and_cache_demo.rs (line 61)

async fn main() -> Result<()> {
    println!("📦 Docker Image Pusher - Extract and Cache Demo");
    println!("===================================================");

    // 配置参数
    let tar_file = get_tar_file_path();
    let cache_dir = ".cache_extract_demo";

    // 从tar文件名推导repository和reference
    let file_stem = Path::new(&tar_file)
        .file_stem()
        .and_then(|s| s.to_str())
        .unwrap_or("extracted-image");
    let repository = format!("local/{}", file_stem);
    let reference = "latest";

    println!("📥 Configuration:");
    println!("  Tar File: {}", tar_file);
    println!("  Repository: {}", repository);
    println!("  Reference: {}", reference);
    println!("  Cache Directory: {}", cache_dir);
    println!();

    // 1. 验证tar文件存在
    if !Path::new(&tar_file).exists() {
        eprintln!("❌ Tar file not found: {}", tar_file);
        eprintln!("💡 Please ensure the dufs.tar file exists in the examples/ directory");
        return Err(docker_image_pusher::error::RegistryError::Validation(
            format!("Tar file does not exist: {}", tar_file),
        ));
    }

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 定义操作模式
    let mode = OperationMode::ExtractAndCache {
        tar_file: tar_file.clone(),
        repository: repository.clone(),
        reference: reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 4. 执行提取和缓存操作
    println!("🔄 Starting extract and cache operation...");
    match image_manager.execute_operation(&mode, None, None).await {
        Ok(()) => {
            println!("✅ Extract and cache operation completed successfully!");
            println!();
            println!("📂 Image extracted and cached to: {}", cache_dir);
            println!("🔍 You can now inspect the cache contents:");
            println!(
                "   - Manifests: {}/manifests/{}/{}",
                cache_dir, repository, reference
            );
            println!("   - Blobs: {}/blobs/sha256/", cache_dir);
            println!("   - Index: {}/index.json", cache_dir);
        }
        Err(e) => {
            eprintln!("❌ Extract and cache operation failed: {}", e);
            std::process::exit(1);
        }
    }

    // 5. 显示提取统计
    show_extraction_stats(&tar_file, cache_dir).await;

    Ok(())
}

examples/pull_and_cache_demo.rs (line 81)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Pull and Cache Demo");
    println!("==================================================");

    // 配置参数 - 支持环境变量
    let registry = env::var("DOCKER_REGISTRY")
        .unwrap_or_else(|_| "https://registry.cn-beijing.aliyuncs.com".to_string());
    let repository = env::var("DOCKER_REPOSITORY").unwrap_or_else(|_| "yoce/cblt".to_string());
    let reference = env::var("DOCKER_REFERENCE").unwrap_or_else(|_| "yoce".to_string());
    let cache_dir = ".cache_demo";

    println!("📥 Configuration:");
    println!("  Registry: {}", registry);
    println!("  Repository: {}", repository);
    println!("  Reference: {}", reference);
    println!("  Cache Directory: {}", cache_dir);
    println!();

    // 1. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 2. 构建 Registry Client
    println!("🌐 Building Registry Client...");
    let client = RegistryClientBuilder::new(registry.to_string())
        .with_timeout(3600)
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 3. 获取认证（总是尝试，支持匿名token）
    println!("🔐 Attempting authentication...");
    let auth_token = if let (Ok(username), Ok(password)) =
        (env::var("DOCKER_USERNAME"), env::var("DOCKER_PASSWORD"))
    {
        println!("  Using provided credentials for user: {}", username);
        let auth_config = AuthConfig::new(username, password);
        client
            .authenticate_for_repository(&auth_config, &repository)
            .await?
    } else {
        println!("  No credentials provided, trying anonymous authentication...");
        // 使用直接认证方法尝试获取匿名token
        let auth = docker_image_pusher::registry::auth::Auth::new();
        let output = docker_image_pusher::logging::Logger::new(true);
        auth.authenticate_with_registry(&registry, &repository, None, None, &output)
            .await?
    };

    if auth_token.is_some() {
        println!("✅ Authentication successful");
    } else {
        println!("ℹ️  No authentication required");
    }

    // 4. 定义操作模式
    let mode = OperationMode::PullAndCache {
        repository: repository.to_string(),
        reference: reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 5. 执行拉取和缓存操作
    println!("🔄 Starting pull and cache operation...");
    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Pull and cache operation completed successfully!");
            println!();
            println!("📂 Image cached to: {}", cache_dir);
            println!("🔍 You can now inspect the cache contents:");
            println!(
                "   - Manifests: {}/manifests/{}/{}",
                cache_dir, repository, reference
            );
            println!("   - Blobs: {}/blobs/sha256/", cache_dir);
            println!("   - Index: {}/index.json", cache_dir);
        }
        Err(e) => {
            eprintln!("❌ Pull and cache operation failed: {}", e);
            std::process::exit(1);
        }
    }

    // 6. 显示缓存统计
    show_cache_stats(cache_dir).await;

    Ok(())
}

examples/push_to_aliyun_demo.rs (line 95)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Push to Aliyun Registry Demo");
    println!("=======================================================");

    // 阿里云配置
    let aliyun_registry = "registry.cn-beijing.aliyuncs.com";
    let aliyun_username = "canny_best@163.com";
    let aliyun_password = "ra201222";

    // 源镜像（从缓存）
    let source_repository = "yoce/cblt";
    let source_reference = "yoce";

    // 目标镜像（推送到阿里云）- 推送回同一个仓库，不同tag
    let target_repository = "yoce/cblt";
    let target_reference = "push-test";
    let cache_dir = ".cache_demo";

    println!("📥 Configuration:");
    println!(
        "  Source (Cache): {}/{}",
        source_repository, source_reference
    );
    println!("  Target Registry: {}", aliyun_registry);
    println!("  Target Repository: {}", target_repository);
    println!("  Target Reference: {}", target_reference);
    println!("  Cache Directory: {}", cache_dir);
    println!("  Username: {}", aliyun_username);
    println!();

    // 1. 检查缓存是否存在
    check_cache_exists(cache_dir, source_repository, source_reference).await?;

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 复制缓存中的镜像到目标仓库名称
    println!("📋 Copying cached image to target repository name...");
    copy_image_in_cache(
        cache_dir,
        source_repository,
        source_reference,
        target_repository,
        target_reference,
    )
    .await?;
    println!("✅ Image copied in cache");

    // 4. 构建 Registry Client for 阿里云
    println!("🌐 Building Registry Client for Aliyun...");
    let client = RegistryClientBuilder::new(format!("https://{}", aliyun_registry))
        .with_timeout(3600)
        .with_skip_tls(false)
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 4. 认证到阿里云
    println!("🔐 Authenticating with Aliyun registry...");
    let auth_config = AuthConfig::new(aliyun_username.to_string(), aliyun_password.to_string());
    let auth_token = client
        .authenticate_for_repository(&auth_config, target_repository)
        .await?;
    println!("✅ Authentication successful");

    // 5. 定义操作模式 - 推送缓存中的镜像到阿里云
    let mode = OperationMode::PushFromCacheUsingManifest {
        repository: target_repository.to_string(),
        reference: target_reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 6. 执行推送操作
    println!("🔄 Starting push to Aliyun operation...");
    println!(
        "🎯 Target: {}/{}/{}",
        aliyun_registry, target_repository, target_reference
    );

    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Push to Aliyun operation completed successfully!");
            println!(
                "🎯 Image pushed to: {}/{}/{}",
                aliyun_registry, target_repository, target_reference
            );
            println!("🔍 You can verify the upload in Aliyun Console:");
            println!("   https://cr.console.aliyun.com");

            // 验证推送结果
            verify_push_result(&client, target_repository, target_reference, &auth_token).await;
        }
        Err(e) => {
            eprintln!("❌ Push to Aliyun operation failed: {}", e);
            eprintln!("💡 Possible solutions:");
            eprintln!("   - Check Aliyun credentials and permissions");
            eprintln!("   - Verify repository name format (namespace/repo)");
            eprintln!("   - Check network connectivity to Aliyun registry");
            eprintln!("   - Ensure the repository exists in Aliyun console");
            eprintln!("   - Check if the namespace 'yoce' exists");
            std::process::exit(1);
        }
    }

    Ok(())
}

examples/push_from_cache_manifest_demo.rs (line 77)

async fn main() -> Result<()> {
    println!("🚀 Docker Image Pusher - Push from Cache (Manifest) Demo");
    println!("============================================================");

    // 配置参数 - 使用Aliyun registry，推送到已存在的repository
    let source_repository = "yoce/cblt"; // 从缓存中读取
    let source_reference = "yoce";
    let target_registry = "registry.cn-beijing.aliyuncs.com";
    let target_repository = "yoce/cblt"; // 推送回同一个repository
    let target_reference = "test-push"; // 使用新的tag
    let cache_dir = ".cache_demo";

    println!("📥 Configuration:");
    println!(
        "  Source (Cache): {}/{}",
        source_repository, source_reference
    );
    println!("  Target Registry: {}", target_registry);
    println!("  Target Repository: {}", target_repository);
    println!("  Target Reference: {}", target_reference);
    println!("  Cache Directory: {}", cache_dir);
    println!();

    // 1. 检查缓存是否存在
    check_cache_exists(cache_dir, source_repository, source_reference).await?;

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 构建 Registry Client - 配置为Aliyun registry
    println!("🌐 Building Registry Client for Aliyun registry...");
    let client = RegistryClientBuilder::new(format!("https://{}", target_registry))
        .with_timeout(3600)
        .with_skip_tls(false) // Aliyun registry使用TLS
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 4. 获取认证 - 使用Aliyun registry凭据
    println!("🔐 Authenticating with Aliyun registry...");
    let username = env::var("ALIYUN_USERNAME").unwrap_or_else(|_| "canny_best@163.com".to_string());
    let password = env::var("ALIYUN_PASSWORD").unwrap_or_else(|_| "ra201222".to_string());

    let auth_config = AuthConfig::new(username.clone(), password.clone());
    let auth_token = client
        .authenticate_for_repository(&auth_config, target_repository)
        .await?;
    println!("✅ Authentication successful with user: {}", username);
    println!("🔑 Token scope: repository:{}:pull,push", target_repository);

    // 5. 定义操作模式 - 使用 manifest 方式推送
    let mode = OperationMode::PushFromCacheUsingManifest {
        repository: target_repository.to_string(),
        reference: target_reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!();

    // 6. 执行推送操作
    println!("🔄 Starting push from cache operation...");
    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Push from cache operation completed successfully!");
            println!();
            println!(
                "🎯 Image pushed to: {}/{}/{}",
                target_registry, target_repository, target_reference
            );
            println!("🔍 You can now verify the upload:");
            println!(
                "   curl -H \"Authorization: Bearer <token>\" https://{}/v2/{}/manifests/{}",
                target_registry, target_repository, target_reference
            );
            println!(
                "   curl -H \"Authorization: Bearer <token>\" https://{}/v2/{}/tags/list",
                target_registry, target_repository
            );
        }
        Err(e) => {
            eprintln!("❌ Push from cache operation failed: {}", e);
            eprintln!("💡 Possible solutions:");
            eprintln!(
                "   - Check if source image exists in cache: {}/{}",
                source_repository, source_reference
            );
            eprintln!("   - Verify Aliyun registry credentials");
            eprintln!("   - Check network connectivity to Aliyun registry");
            std::process::exit(1);
        }
    }

    // 7. 验证推送结果
    verify_push_result(&client, target_repository, target_reference, &auth_token).await;

    Ok(())
}

examples/push_from_cache_tar_demo.rs (line 79)

async fn main() -> Result<()> {
    println!("📦 Docker Image Pusher - Push from Cache (Tar Reference) Demo");
    println!("================================================================");

    // 配置参数
    let target_registry = "registry.cn-beijing.aliyuncs.com";
    let target_repository = "yoce/cblt"; // 推送到相同的repository
    let target_reference = "yoce"; // 推送到相同的reference
    let cache_dir = ".cache_demo"; // 使用已有的缓存

    println!("📥 Configuration:");
    println!("  Cache Directory: {}", cache_dir);
    println!("  Target Registry: {}", target_registry);
    println!("  Target Repository: {}", target_repository);
    println!("  Target Reference: {}", target_reference);
    println!();

    println!(
        "ℹ️  Note: This mode pushes cached image {}/{} to target registry",
        target_repository, target_reference
    );
    println!("   The implementation is identical to manifest-based push");
    println!();

    // 1. 检查缓存是否存在
    check_cache_exists(cache_dir, target_repository, target_reference).await?;

    // 2. 创建 ImageManager
    println!("🔧 Creating ImageManager...");
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;
    println!("✅ ImageManager created successfully");

    // 3. 构建 Registry Client
    println!("🌐 Building Registry Client for Aliyun registry...");
    let client = RegistryClientBuilder::new(format!("https://{}", target_registry))
        .with_timeout(3600)
        .with_skip_tls(false) // Aliyun uses TLS
        .with_verbose(true)
        .build()?;
    println!("✅ Registry Client built successfully");

    // 4. 获取认证（Aliyun credentials）
    println!("🔐 Authenticating with Aliyun registry...");
    let auth_config = AuthConfig::new("canny_best@163.com".to_string(), "ra201222".to_string());
    let auth_token = client
        .authenticate_for_repository(&auth_config, target_repository)
        .await?;
    println!(
        "✅ Authentication successful with user: {}",
        auth_config.username
    );
    println!("🔑 Token scope: repository:{}:pull,push", target_repository);

    // 5. 定义操作模式 - 使用 tar 引用方式推送（实际上与manifest模式相同）
    let mode = OperationMode::PushFromCacheUsingTar {
        repository: target_repository.to_string(),
        reference: target_reference.to_string(),
    };

    println!("📋 Operation Mode: {}", mode.description());
    println!("🔄 Internal Process: Reading from unified cache format (same as manifest mode)");
    println!();

    // 6. 执行推送操作
    println!("🔄 Starting push from cache operation...");
    match image_manager
        .execute_operation(&mode, Some(&client), auth_token.as_deref())
        .await
    {
        Ok(()) => {
            println!("✅ Push from cache (tar reference) operation completed successfully!");
            println!();
            println!(
                "🎯 Image pushed to: {}/{}/{}",
                target_registry, target_repository, target_reference
            );
            println!("🔍 You can now verify the upload:");
            println!(
                "   curl http://{}/v2/{}/manifests/{}",
                target_registry, target_repository, target_reference
            );
            println!(
                "   curl http://{}/v2/{}/tags/list",
                target_registry, target_repository
            );

            // 显示模式差异说明
            show_mode_explanation();
        }
        Err(e) => {
            eprintln!("❌ Push from cache (tar reference) operation failed: {}", e);
            eprintln!("💡 Possible solutions:");
            eprintln!(
                "   - Check if target registry is running: docker run -d -p 5000:5000 registry:2"
            );
            eprintln!("   - Verify cache contains the source image");
            eprintln!("   - Check network connectivity to target registry");
            std::process::exit(1);
        }
    }

    // 7. 验证推送结果并对比两种模式
    verify_push_result_and_compare(&client, target_repository, target_reference, &auth_token).await;

    Ok(())
}

examples/comprehensive_demo.rs (line 82)

async fn run_comprehensive_demo(cache_dir: &str, target_registry: &str) -> Result<()> {
    // =========================================================================
    // 模式1: PullAndCache - 从registry拉取并缓存
    // =========================================================================
    println!("📥 MODE 1: Pull and Cache from Registry");
    println!("========================================");

    let pull_start = Instant::now();

    // 创建ImageManager
    let mut image_manager = ImageManager::new(Some(cache_dir), true)?;

    // 构建registry client
    let source_client = RegistryClientBuilder::new("https://registry-1.docker.io".to_string())
        .with_timeout(3600)
        .with_verbose(true)
        .build()?;

    // 定义拉取操作
    let pull_mode = OperationMode::PullAndCache {
        repository: "library/hello-world".to_string(),
        reference: "latest".to_string(),
    };

    println!("🔄 Executing: {}", pull_mode.description());
    image_manager
        .execute_operation(&pull_mode, Some(&source_client), None)
        .await?;

    let pull_duration = pull_start.elapsed();
    println!("✅ Mode 1 completed in {:.2}s", pull_duration.as_secs_f64());
    println!();

    // =========================================================================
    // 模式2: ExtractAndCache - 从tar文件提取并缓存
    // =========================================================================
    println!("📦 MODE 2: Extract and Cache from Tar File");
    println!("===========================================");

    let extract_start = Instant::now();

    // 创建示例tar文件
    let tar_file = "nginx-demo.tar";
    create_demo_tar_file(tar_file, "nginx:alpine").await?;

    // 定义提取操作
    let extract_mode = OperationMode::ExtractAndCache {
        tar_file: tar_file.to_string(),
        repository: "local/nginx".to_string(),
        reference: "alpine".to_string(),
    };

    println!("🔄 Executing: {}", extract_mode.description());
    image_manager
        .execute_operation(&extract_mode, None, None)
        .await?;

    let extract_duration = extract_start.elapsed();
    println!(
        "✅ Mode 2 completed in {:.2}s",
        extract_duration.as_secs_f64()
    );
    println!();

    // =========================================================================
    // 准备目标registry客户端
    // =========================================================================
    println!("🌐 Setting up target registry...");
    ensure_target_registry_running(target_registry).await;

    let target_client = RegistryClientBuilder::new(format!("http://{}", target_registry))
        .with_timeout(3600)
        .with_skip_tls(true)
        .with_verbose(true)
        .build()?;

    // =========================================================================
    // 模式3: PushFromCacheUsingManifest - 从缓存推送（manifest方式）
    // =========================================================================
    println!("🚀 MODE 3: Push from Cache using Manifest");
    println!("==========================================");

    let push_manifest_start = Instant::now();

    // 定义推送操作（manifest方式）
    let push_manifest_mode = OperationMode::PushFromCacheUsingManifest {
        repository: "demo/hello-world-manifest".to_string(),
        reference: "v1.0".to_string(),
    };

    println!("🔄 Executing: {}", push_manifest_mode.description());
    image_manager
        .execute_operation(&push_manifest_mode, Some(&target_client), None)
        .await?;

    let push_manifest_duration = push_manifest_start.elapsed();
    println!(
        "✅ Mode 3 completed in {:.2}s",
        push_manifest_duration.as_secs_f64()
    );
    println!();

    // =========================================================================
    // 模式4: PushFromCacheUsingTar - 从缓存推送（tar引用方式）
    // =========================================================================
    println!("📦 MODE 4: Push from Cache using Tar Reference");
    println!("===============================================");

    let push_tar_start = Instant::now();

    // 定义推送操作（tar引用方式）
    let push_tar_mode = OperationMode::PushFromCacheUsingTar {
        repository: "demo/nginx-tar-ref".to_string(),
        reference: "alpine".to_string(),
    };

    println!("🔄 Executing: {}", push_tar_mode.description());
    image_manager
        .execute_operation(&push_tar_mode, Some(&target_client), None)
        .await?;

    let push_tar_duration = push_tar_start.elapsed();
    println!(
        "✅ Mode 4 completed in {:.2}s",
        push_tar_duration.as_secs_f64()
    );
    println!();

    // 验证所有推送结果
    verify_all_pushes(&target_client, target_registry).await;

    Ok(())
}

Additional examples can be found in:

• examples/large_image_test_demo.rs

pub fn get_cache_stats(&self) -> Result<CacheStats>

获取缓存统计信息

pub fn list_cached_images(&self) -> Vec<(String, String)>

列出缓存中的所有镜像

pub fn is_image_cached(&self, repository: &str, reference: &str) -> Result<bool>

检查镜像是否在缓存中

pub fn configure_pipeline(&mut self, config: PipelineConfig)

配置流式处理管道参数

Examples found in repository

examples/optimized_upload_demo.rs (line 29)

async fn main() -> Result<()> {
    println!("Docker Image Pusher - Optimized Upload Demo");

    // Create image manager with optimizations enabled (default)
    let mut manager = ImageManager::new(None, true)?;

    // Configure pipeline for demonstration
    let config = PipelineConfig {
        max_concurrent: 8,
        buffer_size: 1024,
        small_blob_threshold: 10 * 1024 * 1024,   // 10MB
        medium_blob_threshold: 100 * 1024 * 1024, // 100MB
        large_blob_threshold: 500 * 1024 * 1024,  // 500MB
        timeout_seconds: 7200,
        retry_attempts: 3,
        memory_limit_mb: 512,
        enable_compression: true,
        enable_streaming: true,
    };
    manager.configure_pipeline(config);

    // Verify configuration
    let (optimized, pipeline_config) = manager.get_config();
    println!("Optimized mode: {}", optimized);
    println!("Pipeline config: {:?}", pipeline_config);

    // Example registry client (would need real registry URL)
    let client = RegistryClientBuilder::new("https://registry.example.com".to_string())
        .with_verbose(true)
        .build()?;

    // Test connectivity (this would fail with example URL)
    println!("Testing registry connectivity...");
    match client.test_connectivity().await {
        Ok(_) => println!("✓ Registry connectivity successful"),
        Err(e) => println!(
            "✗ Registry connectivity failed: {} (expected with example URL)",
            e
        ),
    }

    // Example operation mode for pushing from tar
    let mode = OperationMode::PushFromTar {
        tar_file: "example-image.tar".to_string(),
        repository: "myapp".to_string(),
        reference: "latest".to_string(),
    };

    println!("Operation mode: {}", mode.description());

    // In a real scenario, you would call:
    // manager.execute_operation(&mode, Some(&client), None).await?;

    println!("Demo completed successfully!");
    println!("\nKey benefits of optimized mode:");
    println!("• Priority-based upload scheduling (small blobs first)");
    println!("• Streaming TAR processing with parallel uploads");
    println!("• Memory-efficient processing of large files");
    println!("• Configurable pipeline parameters");

    Ok(())
}

pub fn set_optimized_upload(&mut self, enabled: bool)

设置是否使用优化的上传模式

pub fn get_config(&self) -> (bool, &PipelineConfig)

获取当前配置状态

Examples found in repository

examples/optimized_upload_demo.rs (line 32)

async fn main() -> Result<()> {
    println!("Docker Image Pusher - Optimized Upload Demo");

    // Create image manager with optimizations enabled (default)
    let mut manager = ImageManager::new(None, true)?;

    // Configure pipeline for demonstration
    let config = PipelineConfig {
        max_concurrent: 8,
        buffer_size: 1024,
        small_blob_threshold: 10 * 1024 * 1024,   // 10MB
        medium_blob_threshold: 100 * 1024 * 1024, // 100MB
        large_blob_threshold: 500 * 1024 * 1024,  // 500MB
        timeout_seconds: 7200,
        retry_attempts: 3,
        memory_limit_mb: 512,
        enable_compression: true,
        enable_streaming: true,
    };
    manager.configure_pipeline(config);

    // Verify configuration
    let (optimized, pipeline_config) = manager.get_config();
    println!("Optimized mode: {}", optimized);
    println!("Pipeline config: {:?}", pipeline_config);

    // Example registry client (would need real registry URL)
    let client = RegistryClientBuilder::new("https://registry.example.com".to_string())
        .with_verbose(true)
        .build()?;

    // Test connectivity (this would fail with example URL)
    println!("Testing registry connectivity...");
    match client.test_connectivity().await {
        Ok(_) => println!("✓ Registry connectivity successful"),
        Err(e) => println!(
            "✗ Registry connectivity failed: {} (expected with example URL)",
            e
        ),
    }

    // Example operation mode for pushing from tar
    let mode = OperationMode::PushFromTar {
        tar_file: "example-image.tar".to_string(),
        repository: "myapp".to_string(),
        reference: "latest".to_string(),
    };

    println!("Operation mode: {}", mode.description());

    // In a real scenario, you would call:
    // manager.execute_operation(&mode, Some(&client), None).await?;

    println!("Demo completed successfully!");
    println!("\nKey benefits of optimized mode:");
    println!("• Priority-based upload scheduling (small blobs first)");
    println!("• Streaming TAR processing with parallel uploads");
    println!("• Memory-efficient processing of large files");
    println!("• Configurable pipeline parameters");

    Ok(())
}