Volumes

let volume = volume_manager.volume_for_path(&path).await;
println!("Volume: {} ({})", volume.name, volume.fingerprint);

s3://my-bucket/photos/vacation.jpg       ← Amazon S3
gdrive://My Drive/Documents/report.pdf   ← Google Drive
onedrive://Documents/budget.xlsx         ← OneDrive
azblob://container/data/export.csv       ← Azure Blob
gcs://bucket/logs/app.log                ← Google Cloud Storage

// Find volume for a path
let volume = volume_manager.volume_for_path("/Users/data").await;

// List all volumes
let volumes = volume_manager.get_all_volumes().await;

// Check available space
let available = volume.total_bytes_available;

volume_manager.track_volume(
    &volume.fingerprint,
    &library_context,
    Some("My Backup Drive".to_string())
).await?;

use sd_core::ops::volumes::add_cloud::{CloudStorageConfig, VolumeAddCloudInput};

// Add S3 bucket via action
let input = VolumeAddCloudInput {
    service: CloudServiceType::S3,
    display_name: "My S3 Bucket".to_string(),
    config: CloudStorageConfig::S3 {
        bucket: "my-bucket".to_string(),
        region: "us-west-2".to_string(),
        access_key_id: "AKIAXXXX".to_string(),
        secret_access_key: "secret".to_string(),
        endpoint: None, // Optional: for S3-compatible services
    },
};

let output = action_manager.execute(input, library, context).await?;

# Amazon S3
sd volume add-cloud "My S3 Bucket" \
  --service s3 \
  --bucket my-bucket \
  --region us-west-2 \
  --access-key-id AKIAXXXX \
  --secret-access-key secret123

# Cloudflare R2
sd volume add-cloud "R2 Storage" \
  --service s3 \
  --bucket my-r2-bucket \
  --region auto \
  --access-key-id xxx \
  --secret-access-key yyy \
  --endpoint https://account.r2.cloudflarestorage.com

# MinIO (self-hosted)
sd volume add-cloud "MinIO Local" \
  --service s3 \
  --bucket test \
  --region us-east-1 \
  --access-key-id minioadmin \
  --secret-access-key minioadmin \
  --endpoint http://localhost:9000

# Remove cloud volume
sd volume remove-cloud <fingerprint> -y

let mut events = event_bus.subscribe();

while let Ok(event) = events.recv().await {
    match event {
        Event::VolumeAdded(volume) => {
            // New volume connected
        }
        Event::VolumeRemoved { fingerprint } => {
            // Volume disconnected
        }
        _ => {}
    }
}

if volume.supports_cow() {
    // Use fast COW copy (APFS, Btrfs, ZFS, ReFS)
    perform_cow_copy(&src, &dst).await?;
} else if volume.supports_server_side_copy() {
    // Cloud server-side copy (S3, GCS, Azure)
    perform_server_side_copy(&src, &dst).await?;
} else {
    // Standard streaming copy
    perform_regular_copy(&src, &dst).await?;
}

// Check if paths are on same volume
let same_volume = volume_manager.same_volume(&src, &dst).await;

if same_volume {
    // Fast move operation (local) or server-side rename (cloud)
    fs::rename(&src, &dst).await?;
} else {
    // Cross-volume copy required
    copy_cross_volume(&src, &dst).await?;
}

let (read_mbps, write_mbps) = volume_manager
    .run_speed_test(&fingerprint).await?;

let config = VolumeDetectionConfig {
    include_system: false,     // Skip system volumes
    include_virtual: false,    // Skip virtual filesystems
    refresh_interval_secs: 30, // Monitor interval
};

let volume_manager = VolumeManager::new(device_id, config, event_bus);

// S3-compatible services
CloudStorageConfig::S3 {
    bucket: "bucket-name".to_string(),
    region: "us-west-2".to_string(),
    access_key_id: "key".to_string(),
    secret_access_key: "secret".to_string(),
    endpoint: Some("https://custom-endpoint.com".to_string()), // Optional
}

match volume_manager.track_volume(&library, &fingerprint, None).await {
    Ok(tracked) => {
        println!("Volume tracked: {}", tracked.display_name.unwrap_or_default());
    }
    Err(VolumeError::NotFound(fp)) => {
        // Volume no longer available
    }
    Err(VolumeError::Platform(msg)) => {
        // Platform-specific error
    }
    Err(VolumeError::Database(msg)) => {
        // Database operation failed
    }
}

use sd_core::crypto::cloud_credentials::CloudCredentialError;

match credential_manager.get_credential(library_id, &fingerprint) {
    Ok(cred) => { /* Use credentials */ }
    Err(CloudCredentialError::NotFound(lib_id, fp)) => {
        // Credentials not found - volume may have been removed
    }
    Err(CloudCredentialError::Keyring(e)) => {
        // OS keyring access failed
    }
    Err(CloudCredentialError::Decryption(e)) => {
        // Credential decryption failed - may need re-authentication
    }
}

if let Some(volume) = volume_manager.volume_for_path(&location_path).await {
    if !volume_manager.is_volume_tracked(&volume.fingerprint).await? {
        // Prompt: "Track this volume for better performance?"
    }
}

let required_bytes = calculate_operation_size();
let volumes = volume_manager.volumes_with_space(required_bytes).await;

if volumes.is_empty() {
    return Err("Insufficient space on any volume");
}

// Same file gets same content hash regardless of location
let local_hash = hash_file("/local/photo.jpg").await?;
let cloud_hash = hash_file("s3://bucket/photo.jpg").await?;

assert_eq!(local_hash, cloud_hash); // Same content = same hash