diff --git a/README.md b/README.md index 4ff3647..ffdb2da 100644 --- a/README.md +++ b/README.md @@ -343,6 +343,8 @@ features without changing the meaning of ordinary compatibility options. | `-m` | Enable the multithreaded scanner/loader/sender pipeline. | | `-c [level]`, `-z [level]` | Enable streaming zstd compression, levels 1-22. | | `--compress-level ` | Set the zstd compression level. | +| `--zc ` | Alias for `--compress-choice`. FastSync supports `zstd` and `none`. | +| `--zl ` | Alias for `--compress-level`. | | `--chunk-size ` | Set the transfer chunk size. | | `-s` | Enable FastSync chunk serialization. | | `-f`, `--sendfile` | Use TCP `sendfile()` zero-copy transfer. Incompatible with compression and chunk serialization. | diff --git a/RSYNC_COMPAT.md b/RSYNC_COMPAT.md index 02679d8..f5c7586 100644 --- a/RSYNC_COMPAT.md +++ b/RSYNC_COMPAT.md @@ -172,8 +172,8 @@ This document maps rsync's full feature set to FastSync's current implementation | Flag | Rsync Description | FastSync Status | Notes | |------|-------------------|-----------------|-------| | `-z`, `--compress` | Compress file data | 🔀 Alt Arg | Always uses zstd (rsync supports multiple algorithms) | -| `--compress-choice=STR` | Choose compression algorithm | ❌ Not Implemented | Removed because it had no effect; FastSync always uses zstd | -| `--compress-level=NUM` | Set compression level | ✅ Implemented | 1-22, default 5 | +| `--compress-choice=STR`, `--zc=STR` | Choose compression algorithm | ✅ Implemented | FastSync supports `zstd` and `none` | +| `--compress-level=NUM`, `--zl=NUM` | Set compression level | ✅ Implemented | 1-22, default 5 | | `--compress-threads=NUM` | Set compression threads | ❌ Not Implemented | | | `--skip-compress=LIST` | Skip compress for suffixes | ❌ Not Implemented | Internal skip for hardcoded types; not user-configurable | diff --git a/src/client/client_cli.c b/src/client/client_cli.c index 571c685..e0fb20c 100644 --- a/src/client/client_cli.c +++ b/src/client/client_cli.c @@ -78,6 +78,18 @@ static int set_positive_int_option(int* dest, const char* value, const char* opt return 0; } +/* Set and validate the compression algorithm selected by the client. */ +static int set_compression_choice(Config* config, const char* value) { + if (strcmp(value, "zstd") != 0 && strcmp(value, "none") != 0) { + log_message(LOG_LEVEL_ERROR, "--compress-choice must be zstd or none"); + return -1; + } + if (set_string_option(&config->compress_choice, value, "--compress-choice") != 0) + return -1; + config->use_compression = strcmp(value, "zstd") == 0; + return 0; +} + /* Parse a string as a non-negative integer into *dest. Returns true on success, false on error. */ static int set_nonneg_int_option(int* dest, const char* value, const char* option_name) { if (!parse_nonneg_int(value, dest)) { @@ -244,6 +256,8 @@ static const OptionEntry OPTION_TABLE[] = { {"--fastsync-server-path", NULL, OPT_STRING, offsetof(Config, fastsync_server_path)}, {"--partial-dir", NULL, OPT_STRING, offsetof(Config, partial_dir)}, {"--suffix", NULL, OPT_STRING, offsetof(Config, suffix)}, + {"--compress-choice", "--zc", OPT_STRING, offsetof(Config, compress_choice)}, + {"--compress-level", "--zl", OPT_POS_INT, offsetof(Config, compression_level)}, {"--timeout", NULL, OPT_POS_INT, offsetof(Config, timeout)}, {"--contimeout", NULL, OPT_POS_INT, offsetof(Config, contimeout)}, @@ -264,6 +278,26 @@ static const OptionEntry* find_table_option(const char* arg) { return NULL; } +static const OptionEntry* find_table_option_with_equals(const char* arg, const char** value) { + const char* equals = strchr(arg, '='); + if (!equals || equals == arg) + return NULL; + size_t name_len = (size_t)(equals - arg); + for (size_t i = 0; i < sizeof(OPTION_TABLE) / sizeof(OPTION_TABLE[0]); i++) { + const OptionEntry* entry = &OPTION_TABLE[i]; + if ((strlen(entry->name) == name_len && strncmp(arg, entry->name, name_len) == 0) || + (entry->alias && strlen(entry->alias) == name_len && + strncmp(arg, entry->alias, name_len) == 0)) { + if (strcmp(entry->name, "--compress-choice") == 0 || + strcmp(entry->name, "--compress-level") == 0) { + *value = equals + 1; + return entry; + } + } + } + return NULL; +} + static int apply_table_option(Config* config, const OptionEntry* entry, const char* value) { if (entry->kind == OPT_NOOP) return 0; @@ -313,21 +347,37 @@ int parse_args(Config* config, int argc, char* argv[], int* positional_args, continue; } const OptionEntry* entry = find_table_option(argv[i]); + const char* inline_value = NULL; + if (!entry) + entry = find_table_option_with_equals(argv[i], &inline_value); if (entry) { if (entry->kind != OPT_FLAG) { - if (i + 1 >= argc) { + const char* value = inline_value; + if (!value && i + 1 < argc) + value = argv[++i]; + if (!value) { log_message(LOG_LEVEL_ERROR, "missing argument for %s", entry->name); return -1; } - if (apply_table_option(config, entry, argv[++i]) != 0) - return -1; - if (entry->offset == offsetof(Config, chmod_spec)) { - mode_t ignored; - if (!chmod_apply(0, config->chmod_spec, &ignored)) { - log_message(LOG_LEVEL_ERROR, "--chmod has invalid permission changes"); + if (strcmp(entry->name, "--compress-choice") == 0) { + if (set_compression_choice(config, value) != 0) + return -1; + } else { + if (apply_table_option(config, entry, value) != 0) + return -1; + if (strcmp(entry->name, "--compress-level") == 0 && + (config->compression_level < 1 || config->compression_level > 22)) { + log_message(LOG_LEVEL_ERROR, "--compress-level must be between 1 and 22"); return -1; } - config->use_metadata = true; + if (entry->offset == offsetof(Config, chmod_spec)) { + mode_t ignored; + if (!chmod_apply(0, config->chmod_spec, &ignored)) { + log_message(LOG_LEVEL_ERROR, "--chmod has invalid permission changes"); + return -1; + } + config->use_metadata = true; + } } } else if (apply_table_option(config, entry, NULL) != 0) { return -1; @@ -356,7 +406,8 @@ int parse_args(Config* config, int argc, char* argv[], int* positional_args, printf("fastsync version %s\n", PROTOCOL_VERSION); return 1; } else if (opt_is(argv[i], "-a", "--archive")) { - config->use_compression = true; + config->use_compression = + !config->compress_choice || strcmp(config->compress_choice, "zstd") == 0; config->use_multithreading = true; config->use_metadata = true; log_message(LOG_LEVEL_INFO, "Enabled archive mode (-c -m -M)"); @@ -392,7 +443,8 @@ int parse_args(Config* config, int argc, char* argv[], int* positional_args, else log_message(LOG_LEVEL_WARNING, "--delta-max value %llu too small, using default", val); } else if (opt_is(argv[i], "-c", "-z")) { - config->use_compression = true; + config->use_compression = + !config->compress_choice || strcmp(config->compress_choice, "zstd") == 0; log_message(LOG_LEVEL_INFO, "Enabled Compression"); if (i + 1 < argc) { char* end_ptr; @@ -505,13 +557,6 @@ int parse_args(Config* config, int argc, char* argv[], int* positional_args, } else if (opt_is(argv[i], "-T", NULL) && i + 1 < argc) { if (set_positive_int_option(&config->timeout, argv[++i], "-T") != 0) return -1; - } else if (opt_is(argv[i], "--compress-level", NULL) && i + 1 < argc) { - if (set_positive_int_option(&config->compression_level, argv[++i], "--compress-level") != 0) - return -1; - if (config->compression_level < 1 || config->compression_level > 22) { - log_message(LOG_LEVEL_ERROR, "--compress-level must be between 1 and 22"); - return -1; - } } else if (argv[i][0] == '-') { char* escaped = output_escape(argv[i], false); fprintf(stderr, "Unknown option: %s\n", escaped ? escaped : ""); @@ -531,6 +576,8 @@ int parse_args(Config* config, int argc, char* argv[], int* positional_args, } } set_log_level(config->quiet ? LOG_LEVEL_ERROR : (verbose ? LOG_LEVEL_DEBUG : LOG_LEVEL_WARNING)); + if (config->compress_choice) + config->use_compression = strcmp(config->compress_choice, "zstd") == 0; return 0; } diff --git a/src/client/usage.c b/src/client/usage.c index 35e8a2f..c6a6e40 100644 --- a/src/client/usage.c +++ b/src/client/usage.c @@ -46,6 +46,8 @@ void print_usage(void) { printf(" -s Enable chunk serialization\n"); printf(" --secluded-args Accept rsync compatibility option (no effect)\n"); printf(" -f Enable sendfile (TCP only, not with -c or -s)\n"); + printf(" --compress-choice Compression algorithm (default: zstd)\n"); + printf(" --zc Alias for --compress-choice\n"); printf(" -v, --verbose Enable debug logging\n"); printf(" -q, --quiet Suppress non-error output\n"); printf(" --debug=FLAGS Fine-grained debug logging (use --debug=help for flags)\n"); @@ -86,6 +88,7 @@ void print_usage(void) { printf(" --inplace Update files in-place (no temp+rename)\n"); printf(" --fsync Fsync every written file before publication\n"); printf(" --compress-level Compression level (default: 5)\n"); + printf(" --zl Alias for --compress-level\n"); printf(" --help Show this help\n"); printf(" -V, --version Show version\n"); } diff --git a/tests/integration/test_features.py b/tests/integration/test_features.py index ec1e6d5..0be9f35 100644 --- a/tests/integration/test_features.py +++ b/tests/integration/test_features.py @@ -206,6 +206,28 @@ class TestChmod: assert (os.stat(os.path.join(received, "small.txt")).st_mode & 0o777) == 0o644 +class TestCompressionChoice: + def test_zstd_choice_compresses(self, shared_server): + clean_dir(DEST_DIR) + result, _ = run_client(SOURCE_DIR, DEST_DIR, flags=["--zc", "zstd"], + port=shared_server.port) + assert result.returncode == 0, f"zstd sync failed: {(result.stderr or result.stdout)[:200]}" + received = get_dest_received_dir(DEST_DIR, SOURCE_DIR) + mismatches, missing = verify_transfer(SOURCE_DIR, received) + assert not missing, f"Missing: {missing}" + assert not mismatches, f"Mismatch: {mismatches}" + + def test_none_choice_disables_compression(self, shared_server): + clean_dir(DEST_DIR) + result, _ = run_client(SOURCE_DIR, DEST_DIR, flags=["-z", "--compress-choice", "none"], + port=shared_server.port) + assert result.returncode == 0, f"none sync failed: {(result.stderr or result.stdout)[:200]}" + received = get_dest_received_dir(DEST_DIR, SOURCE_DIR) + mismatches, missing = verify_transfer(SOURCE_DIR, received) + assert not missing, f"Missing: {missing}" + assert not mismatches, f"Mismatch: {mismatches}" + + class TestExclude: def test_exclude_single(self, shared_server): clean_dir(DEST_DIR) diff --git a/tests/test_client_cli.c b/tests/test_client_cli.c index 218f538..be0cb20 100644 --- a/tests/test_client_cli.c +++ b/tests/test_client_cli.c @@ -5,6 +5,7 @@ #include "log.h" #include "test_utils.h" #include "utils.h" +#include #include #include #include @@ -481,7 +482,7 @@ static void test_parse_args_rejects_unimplemented_options() { "--daemon", "--config", "--server", - "--compress-choice"}; + "--checksum-choice"}; for (size_t i = 0; i < sizeof(options) / sizeof(options[0]); i++) { Config* cfg = config_create(); @@ -688,6 +689,93 @@ static void test_parse_args_whole_file() { config_delete(cfg); } +/* Test rsync-compatible compression-choice and compression-level aliases. */ +static void test_parse_args_compression_aliases() { + Config* cfg = config_create(); + char* argv[] = {"fastsync", "--zc", "zstd", "--zl", "10", "/src", "/dst"}; + int positional_args[2]; + int positional_count = 0; + + int ret = parse_args(cfg, 7, argv, positional_args, &positional_count); + EXPECT_EQ_INT(ret, 0); + EXPECT_EQ_STR(cfg->compress_choice, "zstd"); + EXPECT_EQ_INT(cfg->compression_level, 10); + EXPECT_TRUE(cfg->use_compression); + EXPECT_EQ_INT(positional_count, 2); + + config_delete(cfg); +} + +static void test_parse_args_compression_equals_and_none() { + Config* cfg = config_create(); + char* argv[] = {"fastsync", "-z", "--zc=none", "--zl=7", "/src", "/dst"}; + int positional_args[2]; + int positional_count = 0; + + int ret = parse_args(cfg, 6, argv, positional_args, &positional_count); + EXPECT_EQ_INT(ret, 0); + EXPECT_EQ_STR(cfg->compress_choice, "none"); + EXPECT_EQ_INT(cfg->compression_level, 7); + EXPECT_FALSE(cfg->use_compression); + config_delete(cfg); +} + +static void test_parse_args_compression_canonical_equals() { + Config* cfg = config_create(); + char* argv[] = {"fastsync", "--compress-choice=zstd", "--compress-level=7", "/src", "/dst"}; + int positional_args[2]; + int positional_count = 0; + + EXPECT_EQ_INT(parse_args(cfg, 5, argv, positional_args, &positional_count), 0); + EXPECT_EQ_STR(cfg->compress_choice, "zstd"); + EXPECT_EQ_INT(cfg->compression_level, 7); + EXPECT_TRUE(cfg->use_compression); + EXPECT_EQ_INT(positional_count, 2); + + config_delete(cfg); +} + +static void test_parse_args_compression_alias_equals() { + Config* cfg = config_create(); + char* argv[] = {"fastsync", "--zc=zstd", "--zl=7", "/src", "/dst"}; + int positional_args[2]; + int positional_count = 0; + + EXPECT_EQ_INT(parse_args(cfg, 5, argv, positional_args, &positional_count), 0); + EXPECT_EQ_STR(cfg->compress_choice, "zstd"); + EXPECT_EQ_INT(cfg->compression_level, 7); + EXPECT_TRUE(cfg->use_compression); + EXPECT_EQ_INT(positional_count, 2); + + config_delete(cfg); +} + +static void test_parse_args_rejects_invalid_compression_level_equals() { + static const char* const values[] = {"0", "23", "invalid"}; + + for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); i++) { + Config* cfg = config_create(); + char option[32]; + snprintf(option, sizeof(option), "--compress-level=%s", values[i]); + char* argv[] = {"fastsync", option, "/src", "/dst"}; + int positional_args[2]; + int positional_count = 0; + + EXPECT_EQ_INT(parse_args(cfg, 4, argv, positional_args, &positional_count), -1); + config_delete(cfg); + } +} + +static void test_parse_args_rejects_invalid_compression_choice() { + Config* cfg = config_create(); + char* argv[] = {"fastsync", "--compress-choice=bogus", "/src", "/dst"}; + int positional_args[2]; + int positional_count = 0; + + EXPECT_EQ_INT(parse_args(cfg, 4, argv, positional_args, &positional_count), -1); + config_delete(cfg); +} + void test_client_cli() { test_validate_config_required_paths(); test_validate_config_incompatible_options(); @@ -734,4 +822,10 @@ void test_client_cli() { test_parse_args_secluded_args(); test_parse_args_short_s_remains_chunk_serialization(); test_parse_args_whole_file(); + test_parse_args_compression_aliases(); + test_parse_args_compression_equals_and_none(); + test_parse_args_compression_canonical_equals(); + test_parse_args_compression_alias_equals(); + test_parse_args_rejects_invalid_compression_level_equals(); + test_parse_args_rejects_invalid_compression_choice(); }