Struct RegistryClientBuilder

pub struct RegistryClientBuilder { /* private fields */ }

Implementations

impl RegistryClientBuilder

pub fn new(address: String) -> Self

Examples found in repository

examples/optimized_upload_demo.rs (line 37)

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/pull_and_cache_demo.rs (line 38)

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/auth_test_demo.rs (line 25)

async fn main() -> Result<()> {
    println!("🔐 Docker Registry API v2 Authentication Test");
    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());

    println!("📋 Configuration:");
    println!("  Registry: {}", registry);
    println!("  Repository: {}", repository);
    println!();

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

    // 测试无凭据的情况
    println!();
    println!("🔍 Test 1: Testing registry authentication challenge...");
    let auth = docker_image_pusher::registry::auth::Auth::new();
    let output = docker_image_pusher::logging::Logger::new(true);

    // 直接调用新的认证方法
    match auth
        .authenticate_with_registry(&registry, &repository, None, None, &output)
        .await
    {
        Ok(token) => {
            if let Some(token) = token {
                println!(
                    "✅ Received authentication token: {}...",
                    &token[..20.min(token.len())]
                );
            } else {
                println!("ℹ️  Registry does not require authentication");
            }
        }
        Err(e) => {
            println!("❌ Authentication test failed: {}", e);
            println!("   This is expected if the registry requires credentials");
        }
    }

    // 测试有凭据的情况（如果提供）
    if let (Ok(username), Ok(password)) = (env::var("DOCKER_USERNAME"), env::var("DOCKER_PASSWORD"))
    {
        println!();
        println!("🔍 Test 2: Testing with provided credentials...");
        println!("  Username: {}", username);

        match auth
            .authenticate_with_registry(
                &registry,
                &repository,
                Some(&username),
                Some(&password),
                &output,
            )
            .await
        {
            Ok(token) => {
                if let Some(token) = token {
                    println!("✅ Successfully authenticated with credentials");
                    println!("  Token: {}...", &token[..50.min(token.len())]);

                    // 测试token是否能用于访问manifest
                    println!();
                    println!("🔍 Test 3: Testing token with manifest access...");
                    match client
                        .pull_manifest(&repository, "yoce", &Some(token))
                        .await
                    {
                        Ok(manifest) => {
                            println!("✅ Successfully pulled manifest using token");
                            println!("  Manifest size: {} bytes", manifest.len());
                        }
                        Err(e) => {
                            println!("❌ Failed to pull manifest with token: {}", e);
                        }
                    }
                } else {
                    println!("ℹ️  Authentication successful but no token required");
                }
            }
            Err(e) => {
                println!("❌ Authentication with credentials failed: {}", e);
            }
        }
    } else {
        println!();
        println!("ℹ️  No credentials provided via DOCKER_USERNAME/DOCKER_PASSWORD");
        println!("   Set these environment variables to test credential-based authentication");
    }

    println!();
    println!("🏁 Authentication test completed");

    Ok(())
}

examples/push_to_aliyun_demo.rs (line 63)

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 46)

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 47)

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/check_aliyun_namespace.rs
• examples/large_image_test_demo.rs

pub fn with_auth(self, auth_config: Option<AuthConfig>) -> Self

pub fn with_timeout(self, timeout: u64) -> Self

Examples found in repository

examples/pull_and_cache_demo.rs (line 39)

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/auth_test_demo.rs (line 26)

async fn main() -> Result<()> {
    println!("🔐 Docker Registry API v2 Authentication Test");
    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());

    println!("📋 Configuration:");
    println!("  Registry: {}", registry);
    println!("  Repository: {}", repository);
    println!();

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

    // 测试无凭据的情况
    println!();
    println!("🔍 Test 1: Testing registry authentication challenge...");
    let auth = docker_image_pusher::registry::auth::Auth::new();
    let output = docker_image_pusher::logging::Logger::new(true);

    // 直接调用新的认证方法
    match auth
        .authenticate_with_registry(&registry, &repository, None, None, &output)
        .await
    {
        Ok(token) => {
            if let Some(token) = token {
                println!(
                    "✅ Received authentication token: {}...",
                    &token[..20.min(token.len())]
                );
            } else {
                println!("ℹ️  Registry does not require authentication");
            }
        }
        Err(e) => {
            println!("❌ Authentication test failed: {}", e);
            println!("   This is expected if the registry requires credentials");
        }
    }

    // 测试有凭据的情况（如果提供）
    if let (Ok(username), Ok(password)) = (env::var("DOCKER_USERNAME"), env::var("DOCKER_PASSWORD"))
    {
        println!();
        println!("🔍 Test 2: Testing with provided credentials...");
        println!("  Username: {}", username);

        match auth
            .authenticate_with_registry(
                &registry,
                &repository,
                Some(&username),
                Some(&password),
                &output,
            )
            .await
        {
            Ok(token) => {
                if let Some(token) = token {
                    println!("✅ Successfully authenticated with credentials");
                    println!("  Token: {}...", &token[..50.min(token.len())]);

                    // 测试token是否能用于访问manifest
                    println!();
                    println!("🔍 Test 3: Testing token with manifest access...");
                    match client
                        .pull_manifest(&repository, "yoce", &Some(token))
                        .await
                    {
                        Ok(manifest) => {
                            println!("✅ Successfully pulled manifest using token");
                            println!("  Manifest size: {} bytes", manifest.len());
                        }
                        Err(e) => {
                            println!("❌ Failed to pull manifest with token: {}", e);
                        }
                    }
                } else {
                    println!("ℹ️  Authentication successful but no token required");
                }
            }
            Err(e) => {
                println!("❌ Authentication with credentials failed: {}", e);
            }
        }
    } else {
        println!();
        println!("ℹ️  No credentials provided via DOCKER_USERNAME/DOCKER_PASSWORD");
        println!("   Set these environment variables to test credential-based authentication");
    }

    println!();
    println!("🏁 Authentication test completed");

    Ok(())
}

examples/push_to_aliyun_demo.rs (line 64)

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 47)

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 48)

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 70)

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/check_aliyun_namespace.rs
• examples/large_image_test_demo.rs

pub fn with_skip_tls(self, skip_tls: bool) -> Self

Examples found in repository

examples/push_to_aliyun_demo.rs (line 65)

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 48)

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 49)

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 128)

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(())
}

examples/check_aliyun_namespace.rs (line 32)

async fn main() -> Result<()> {
    println!("🔍 Aliyun Registry Namespace Checker");
    println!("=====================================");

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

    // 要检查的namespace/repository
    let namespace = "canny_best";
    let repository = "canny_best/test-repo";

    println!("📊 Configuration:");
    println!("  Registry: {}", aliyun_registry);
    println!("  Username: {}", aliyun_username);
    println!("  Namespace: {}", namespace);
    println!("  Repository: {}", repository);
    println!();

    // 构建客户端
    println!("🌐 Building Registry Client...");
    let client = RegistryClientBuilder::new(format!("https://{}", aliyun_registry))
        .with_timeout(3600)
        .with_skip_tls(false)
        .with_verbose(true)
        .build()?;

    // 测试连接性
    println!("🔗 Testing registry connectivity...");
    match client.test_connectivity().await {
        Ok(_) => println!("✅ Registry is accessible"),
        Err(e) => {
            println!("⚠️  Registry connectivity test failed: {}", e);
            println!("   This may be normal for some registries");
        }
    }

    // 认证
    println!("🔐 Authenticating...");
    let auth_config = AuthConfig::new(aliyun_username.to_string(), aliyun_password.to_string());

    match client.authenticate(&auth_config).await {
        Ok(Some(token)) => {
            println!("✅ Authentication successful (token received)");

            // 尝试访问repository
            println!("📦 Checking repository access...");
            match client.list_tags(repository, &Some(token.clone())).await {
                Ok(tags) => {
                    println!("✅ Repository {} is accessible", repository);
                    println!("🏷️  Available tags: {:?}", tags);
                }
                Err(e) => {
                    println!("❌ Repository {} is not accessible: {}", repository, e);

                    println!("\n💡 To fix this issue:");
                    println!("   1. Login to Aliyun Console: https://cr.console.aliyun.com/");
                    println!("   2. Create namespace '{}' if it doesn't exist", namespace);
                    println!(
                        "   3. Create repository '{}' in the namespace",
                        repository.split('/').nth(1).unwrap_or("unknown")
                    );
                    println!("   4. Ensure your account has push/pull permissions");

                    return Ok(());
                }
            }

            // 尝试检查认证的repository访问
            println!("🔐 Testing repository-specific authentication...");
            match client
                .authenticate_for_repository(&auth_config, repository)
                .await
            {
                Ok(Some(repo_token)) => {
                    println!("✅ Repository-specific authentication successful");

                    // 检查一个不存在的镜像
                    println!("🔍 Testing image existence check...");
                    match client
                        .check_image_exists(repository, "non-existent-tag", &Some(repo_token))
                        .await
                    {
                        Ok(exists) => {
                            if exists {
                                println!("⚠️  Image unexpectedly exists");
                            } else {
                                println!(
                                    "✅ Image existence check works (image doesn't exist as expected)"
                                );
                            }
                        }
                        Err(e) => {
                            println!("⚠️  Image existence check failed: {}", e);
                        }
                    }
                }
                Ok(None) => {
                    println!("✅ Repository-specific authentication successful (no token)");
                }
                Err(e) => {
                    println!("❌ Repository-specific authentication failed: {}", e);
                }
            }
        }
        Ok(None) => {
            println!("✅ Authentication successful (no token required)");
        }
        Err(e) => {
            println!("❌ Authentication failed: {}", e);
            println!("\n💡 Please check:");
            println!("   - Username: {}", aliyun_username);
            println!("   - Password is correct");
            println!("   - Account has access to Aliyun Container Registry");
            return Ok(());
        }
    }

    println!("\n🎉 All checks completed!");
    println!(
        "   Repository {} appears to be ready for push operations",
        repository
    );

    Ok(())
}

pub fn with_verbose(self, verbose: bool) -> Self

Examples found in repository

examples/optimized_upload_demo.rs (line 38)

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/pull_and_cache_demo.rs (line 40)

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/auth_test_demo.rs (line 27)

async fn main() -> Result<()> {
    println!("🔐 Docker Registry API v2 Authentication Test");
    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());

    println!("📋 Configuration:");
    println!("  Registry: {}", registry);
    println!("  Repository: {}", repository);
    println!();

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

    // 测试无凭据的情况
    println!();
    println!("🔍 Test 1: Testing registry authentication challenge...");
    let auth = docker_image_pusher::registry::auth::Auth::new();
    let output = docker_image_pusher::logging::Logger::new(true);

    // 直接调用新的认证方法
    match auth
        .authenticate_with_registry(&registry, &repository, None, None, &output)
        .await
    {
        Ok(token) => {
            if let Some(token) = token {
                println!(
                    "✅ Received authentication token: {}...",
                    &token[..20.min(token.len())]
                );
            } else {
                println!("ℹ️  Registry does not require authentication");
            }
        }
        Err(e) => {
            println!("❌ Authentication test failed: {}", e);
            println!("   This is expected if the registry requires credentials");
        }
    }

    // 测试有凭据的情况（如果提供）
    if let (Ok(username), Ok(password)) = (env::var("DOCKER_USERNAME"), env::var("DOCKER_PASSWORD"))
    {
        println!();
        println!("🔍 Test 2: Testing with provided credentials...");
        println!("  Username: {}", username);

        match auth
            .authenticate_with_registry(
                &registry,
                &repository,
                Some(&username),
                Some(&password),
                &output,
            )
            .await
        {
            Ok(token) => {
                if let Some(token) = token {
                    println!("✅ Successfully authenticated with credentials");
                    println!("  Token: {}...", &token[..50.min(token.len())]);

                    // 测试token是否能用于访问manifest
                    println!();
                    println!("🔍 Test 3: Testing token with manifest access...");
                    match client
                        .pull_manifest(&repository, "yoce", &Some(token))
                        .await
                    {
                        Ok(manifest) => {
                            println!("✅ Successfully pulled manifest using token");
                            println!("  Manifest size: {} bytes", manifest.len());
                        }
                        Err(e) => {
                            println!("❌ Failed to pull manifest with token: {}", e);
                        }
                    }
                } else {
                    println!("ℹ️  Authentication successful but no token required");
                }
            }
            Err(e) => {
                println!("❌ Authentication with credentials failed: {}", e);
            }
        }
    } else {
        println!();
        println!("ℹ️  No credentials provided via DOCKER_USERNAME/DOCKER_PASSWORD");
        println!("   Set these environment variables to test credential-based authentication");
    }

    println!();
    println!("🏁 Authentication test completed");

    Ok(())
}

examples/push_to_aliyun_demo.rs (line 66)

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 49)

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 50)

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/check_aliyun_namespace.rs
• examples/large_image_test_demo.rs

pub fn build(self) -> Result<RegistryClient>

Examples found in repository

examples/optimized_upload_demo.rs (line 39)

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/pull_and_cache_demo.rs (line 41)

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/auth_test_demo.rs (line 28)

async fn main() -> Result<()> {
    println!("🔐 Docker Registry API v2 Authentication Test");
    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());

    println!("📋 Configuration:");
    println!("  Registry: {}", registry);
    println!("  Repository: {}", repository);
    println!();

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

    // 测试无凭据的情况
    println!();
    println!("🔍 Test 1: Testing registry authentication challenge...");
    let auth = docker_image_pusher::registry::auth::Auth::new();
    let output = docker_image_pusher::logging::Logger::new(true);

    // 直接调用新的认证方法
    match auth
        .authenticate_with_registry(&registry, &repository, None, None, &output)
        .await
    {
        Ok(token) => {
            if let Some(token) = token {
                println!(
                    "✅ Received authentication token: {}...",
                    &token[..20.min(token.len())]
                );
            } else {
                println!("ℹ️  Registry does not require authentication");
            }
        }
        Err(e) => {
            println!("❌ Authentication test failed: {}", e);
            println!("   This is expected if the registry requires credentials");
        }
    }

    // 测试有凭据的情况（如果提供）
    if let (Ok(username), Ok(password)) = (env::var("DOCKER_USERNAME"), env::var("DOCKER_PASSWORD"))
    {
        println!();
        println!("🔍 Test 2: Testing with provided credentials...");
        println!("  Username: {}", username);

        match auth
            .authenticate_with_registry(
                &registry,
                &repository,
                Some(&username),
                Some(&password),
                &output,
            )
            .await
        {
            Ok(token) => {
                if let Some(token) = token {
                    println!("✅ Successfully authenticated with credentials");
                    println!("  Token: {}...", &token[..50.min(token.len())]);

                    // 测试token是否能用于访问manifest
                    println!();
                    println!("🔍 Test 3: Testing token with manifest access...");
                    match client
                        .pull_manifest(&repository, "yoce", &Some(token))
                        .await
                    {
                        Ok(manifest) => {
                            println!("✅ Successfully pulled manifest using token");
                            println!("  Manifest size: {} bytes", manifest.len());
                        }
                        Err(e) => {
                            println!("❌ Failed to pull manifest with token: {}", e);
                        }
                    }
                } else {
                    println!("ℹ️  Authentication successful but no token required");
                }
            }
            Err(e) => {
                println!("❌ Authentication with credentials failed: {}", e);
            }
        }
    } else {
        println!();
        println!("ℹ️  No credentials provided via DOCKER_USERNAME/DOCKER_PASSWORD");
        println!("   Set these environment variables to test credential-based authentication");
    }

    println!();
    println!("🏁 Authentication test completed");

    Ok(())
}

examples/push_to_aliyun_demo.rs (line 67)

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 50)

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 51)

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/check_aliyun_namespace.rs
• examples/large_image_test_demo.rs

Trait Implementations

impl Debug for RegistryClientBuilder

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

Formats the value using the given formatter.