msy 0.4.6

Modern musl rsync alternative - Fast, parallel file synchronization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261

use std::sync::Arc;
/// SSH remote→local progress tests (requires fedora)
///
/// These tests verify that progress callbacks work correctly when downloading
/// files from remote servers via SSH transport.
///
/// **Scope**: Remote→Local transfers only
/// **Local→Remote**: Tested via manual CLI testing (see ssh_per_file_progress_test.rs)
///
/// Run with: cargo test --test ssh_remote_to_local_progress_test -- --ignored
///
/// Prerequisites:
/// - fedora accessible via SSH
/// - SSH keys configured for passwordless login
///
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use tempfile::TempDir;

const FEDORA_HOST: &str = "fedora";
const FEDORA_USER: &str = "nick";

/// Helper to create SSH config for fedora
fn create_fedora_config() -> msy::ssh::config::SshConfig {
	use msy::ssh::config::SshConfig;

	let mut config = SshConfig::new(FEDORA_HOST);
	config.user = FEDORA_USER.to_string();
	config.port = 22;
	config
}

/// Helper to create a remote file via SSH command
fn create_remote_file(path: &str, size_mb: usize) {
	let create_cmd = format!("ssh {} 'dd if=/dev/zero of={} bs=1M count={} 2>/dev/null'", FEDORA_HOST, path, size_mb);
	std::process::Command::new("sh").arg("-c").arg(&create_cmd).output().expect("Failed to create remote file");
}

/// Helper to cleanup remote file
fn cleanup_remote_file(path: &str) {
	let cleanup_cmd = format!("ssh {} 'rm -f {}'", FEDORA_HOST, path);
	let _ = std::process::Command::new("sh").arg("-c").arg(&cleanup_cmd).output();
}

#[tokio::test]
#[ignore]
async fn test_remote_to_local_with_progress() {
	use msy::transport::Transport;
	use msy::transport::ssh::SshTransport;

	let remote_source = format!("/tmp/sy_test_{}_2mb.dat", std::process::id());
	create_remote_file(&remote_source, 2);

	let config = create_fedora_config();
	let transport = SshTransport::new(&config).await.expect("Failed to connect to fedora");

	let dest_dir = TempDir::new().unwrap();
	let local_dest = dest_dir.path().join("downloaded.dat");

	// Track progress
	let updates = Arc::new(AtomicU64::new(0));
	let updates_clone = updates.clone();
	let last_bytes = Arc::new(AtomicU64::new(0));
	let last_bytes_clone = last_bytes.clone();

	let progress_callback = Arc::new(move |bytes: u64, total: u64| {
		updates_clone.fetch_add(1, Ordering::SeqCst);
		last_bytes_clone.store(bytes, Ordering::SeqCst);
		assert!(bytes <= total, "bytes should not exceed total");
	});

	// Download with progress
	let result = transport
		.copy_file_streaming(std::path::Path::new(&remote_source), &local_dest, Some(progress_callback))
		.await
		.expect("Download failed");

	// Verify
	assert_eq!(result.bytes_written, 2 * 1024 * 1024);
	assert!(local_dest.exists());

	let update_count = updates.load(Ordering::SeqCst);
	assert!(update_count >= 3, "Expected progress updates, got {}", update_count);

	let final_bytes = last_bytes.load(Ordering::SeqCst);
	assert_eq!(final_bytes, 2 * 1024 * 1024);

	cleanup_remote_file(&remote_source);

	println!("✅ Remote→Local (2MB) with progress: PASS");
}

#[tokio::test]
#[ignore]
async fn test_remote_to_local_large_file() {
	use msy::transport::Transport;
	use msy::transport::ssh::SshTransport;

	let remote_source = format!("/tmp/sy_test_{}_10mb.dat", std::process::id());
	create_remote_file(&remote_source, 10);

	let config = create_fedora_config();
	let transport = SshTransport::new(&config).await.expect("Failed to connect");

	let dest_dir = TempDir::new().unwrap();
	let local_dest = dest_dir.path().join("large.dat");

	let updates = Arc::new(AtomicU64::new(0));
	let updates_clone = updates.clone();

	let progress_callback = Arc::new(move |_bytes: u64, _total: u64| {
		updates_clone.fetch_add(1, Ordering::SeqCst);
	});

	let result = transport
		.copy_file_streaming(std::path::Path::new(&remote_source), &local_dest, Some(progress_callback))
		.await
		.expect("Large file download failed");

	assert_eq!(result.bytes_written, 10 * 1024 * 1024);

	let update_count = updates.load(Ordering::SeqCst);
	assert!(update_count >= 10, "Expected >= 10 updates for 10MB, got {}", update_count);

	cleanup_remote_file(&remote_source);

	println!("✅ Remote→Local (10MB) with progress: PASS");
}

#[tokio::test]
#[ignore]
async fn test_remote_to_local_progress_monotonic() {
	use msy::transport::Transport;
	use msy::transport::ssh::SshTransport;

	let remote_source = format!("/tmp/sy_test_{}_5mb.dat", std::process::id());
	create_remote_file(&remote_source, 5);

	let config = create_fedora_config();
	let transport = SshTransport::new(&config).await.expect("Failed to connect");

	let dest_dir = TempDir::new().unwrap();
	let local_dest = dest_dir.path().join("mono.dat");

	let last_bytes = Arc::new(AtomicU64::new(0));
	let last_bytes_clone = last_bytes.clone();
	let monotonic = Arc::new(AtomicBool::new(true));
	let monotonic_clone = monotonic.clone();

	let progress_callback = Arc::new(move |bytes: u64, _total: u64| {
		let prev = last_bytes_clone.load(Ordering::SeqCst);
		if bytes < prev {
			monotonic_clone.store(false, Ordering::SeqCst);
		}
		last_bytes_clone.store(bytes, Ordering::SeqCst);
	});

	let _ = transport
		.copy_file_streaming(std::path::Path::new(&remote_source), &local_dest, Some(progress_callback))
		.await
		.expect("Monotonic test failed");

	assert!(monotonic.load(Ordering::SeqCst), "Progress must increase monotonically");

	cleanup_remote_file(&remote_source);

	println!("✅ Remote→Local progress monotonic: PASS");
}

#[tokio::test]
#[ignore]
async fn test_remote_to_local_connection_pool() {
	use msy::transport::Transport;
	use msy::transport::ssh::SshTransport;

	// Create 2 remote files
	let remote1 = format!("/tmp/sy_test_{}_pool1.dat", std::process::id());
	let remote2 = format!("/tmp/sy_test_{}_pool2.dat", std::process::id());
	create_remote_file(&remote1, 3);
	create_remote_file(&remote2, 3);

	let config = create_fedora_config();
	let transport = Arc::new(SshTransport::with_pool_size(&config, 2).await.expect("Failed to create pool"));

	assert_eq!(transport.pool_size(), 2);

	let dest_dir = TempDir::new().unwrap();

	// Download files concurrently
	let t1 = transport.clone();
	let t2 = transport.clone();
	let dest_path = dest_dir.path().to_path_buf();
	let remote1_clone = remote1.clone();
	let remote2_clone = remote2.clone();

	let h1 = tokio::spawn(async move {
		let local_dest = dest_path.join("pool1.dat");
		let updates = Arc::new(AtomicU64::new(0));
		let updates_clone = updates.clone();

		let progress_callback = Arc::new(move |_: u64, _: u64| {
			updates_clone.fetch_add(1, Ordering::SeqCst);
		});

		let result = t1.copy_file_streaming(std::path::Path::new(&remote1_clone), &local_dest, Some(progress_callback)).await.unwrap();

		(result, updates.load(Ordering::SeqCst))
	});

	let dest_path2 = dest_dir.path().to_path_buf();
	let h2 = tokio::spawn(async move {
		let local_dest = dest_path2.join("pool2.dat");
		let updates = Arc::new(AtomicU64::new(0));
		let updates_clone = updates.clone();

		let progress_callback = Arc::new(move |_: u64, _: u64| {
			updates_clone.fetch_add(1, Ordering::SeqCst);
		});

		let result = t2.copy_file_streaming(std::path::Path::new(&remote2_clone), &local_dest, Some(progress_callback)).await.unwrap();

		(result, updates.load(Ordering::SeqCst))
	});

	let (result1, updates1) = h1.await.unwrap();
	let (result2, updates2) = h2.await.unwrap();

	assert_eq!(result1.bytes_written, 3 * 1024 * 1024);
	assert_eq!(result2.bytes_written, 3 * 1024 * 1024);
	assert!(updates1 >= 3, "Pool transfer 1 should have progress");
	assert!(updates2 >= 3, "Pool transfer 2 should have progress");

	cleanup_remote_file(&remote1);
	cleanup_remote_file(&remote2);

	println!("✅ Remote→Local connection pool with progress: PASS");
}

/// Note: Local→Remote testing
///
/// Local→Remote transfers use DualTransport (not SshTransport directly).
/// These should be tested via:
///
/// 1. Manual CLI testing with --per-file-progress:
///    ```
///    sy /local/file nick@fedora:/remote/dest --per-file-progress
///    ```
///
/// 2. The manual test script generator in ssh_per_file_progress_test.rs:
///    ```
///    cargo test --test ssh_per_file_progress_test generate_manual_test_script -- --ignored --nocapture > manual_test.sh
///    bash manual_test.sh
///    ```
///
/// DualTransport testing would require more complex setup and is better
/// validated through end-to-end CLI testing.
#[test]
#[ignore]
fn note_local_to_remote_testing() {
	println!("Local→Remote transfers require DualTransport.");
	println!("Test via CLI: sy /local nick@fedora:/remote --per-file-progress");
}