You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hugegraph.apache.org by ji...@apache.org on 2026/10/12 08:59:51 UTC

(hugegraph-toolchain) branch master updated: fix(loader): warn for legacy file options (#809)

This is an automated email from the ASF dual-hosted git repository.

imbajin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/hugegraph-toolchain.git


The following commit(s) were added to refs/heads/master by this push:
     new e23a93be0 fix(loader): warn for legacy file options (#809)
e23a93be0 is described below

commit e23a93be061a0e523e4374753f6e2dd0a7dd5088
Author: imbajin <ji...@apache.org>
AuthorDate: Mon Oct 12 16:59:41 2026 +0800

    fix(loader): warn for legacy file options (#809)
    
    - record deprecated aliases during option validation
    - retain positive checks and post-validation warnings
    - cover direct and file inputs with help and errors
    - document argument-file warning behavior
---
 hugegraph-loader/README.md                         |  3 ++
 .../hugegraph/loader/executor/LoadOptions.java     | 19 ++++++--
 .../loader/test/unit/LoadOptionsTest.java          | 54 +++++++++++++++++-----
 3 files changed, 62 insertions(+), 14 deletions(-)

diff --git a/hugegraph-loader/README.md b/hugegraph-loader/README.md
index e3254db3e..decc2b3a9 100644
--- a/hugegraph-loader/README.md
+++ b/hugegraph-loader/README.md
@@ -126,6 +126,9 @@ example/file/schema.groovy
 bash bin/hugegraph-loader.sh @loader.args
 ```
 
+Use `--parser-threads` to set read pipelines. The deprecated `--parallel-count` alias also works in argument files
+and emits one warning after successful option validation.
+
 Paths in the argument file resolve from the working directory. Protect files containing credentials with mode `0600`;
 the credentials can then stay out of the process arguments. The mapping directory must be writable for progress output,
 so copy a mapping mounted from a read-only Kubernetes ConfigMap to a writable volume before running Loader.
diff --git a/hugegraph-loader/src/main/java/org/apache/hugegraph/loader/executor/LoadOptions.java b/hugegraph-loader/src/main/java/org/apache/hugegraph/loader/executor/LoadOptions.java
index 7c0042f9d..b779ed1ac 100644
--- a/hugegraph-loader/src/main/java/org/apache/hugegraph/loader/executor/LoadOptions.java
+++ b/hugegraph-loader/src/main/java/org/apache/hugegraph/loader/executor/LoadOptions.java
@@ -20,7 +20,6 @@ package org.apache.hugegraph.loader.executor;
 import java.io.File;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
 
@@ -34,8 +33,10 @@ import org.apache.hugegraph.loader.filter.util.ShortIdConfig;
 import org.apache.hugegraph.util.E;
 import org.apache.hugegraph.util.Log;
 import com.beust.jcommander.IParameterValidator;
+import com.beust.jcommander.IParameterValidator2;
 import com.beust.jcommander.JCommander;
 import com.beust.jcommander.Parameter;
+import com.beust.jcommander.ParameterDescription;
 import com.beust.jcommander.ParameterException;
 import com.google.common.collect.ImmutableSet;
 
@@ -186,11 +187,13 @@ public final class LoadOptions implements Cloneable {
     public int batchSize = 500;
 
     @Parameter(names = {"--parallel-count", "--parser-threads"}, arity = 1,
-               validateWith = {PositiveValidator.class},
+               validateWith = {ParseThreadsValidator.class},
                description = "Parallel read pipelines (default: max(2, CPUS/2); " +
                              "--parallel-count is deprecated)")
     public int parseThreads = Math.max(2, CPUS / 2);
 
+    private boolean deprecatedParallelCount;
+
     @Parameter(names = {"--start-file"}, arity = 1,
             description = "start file index for partial loading")
     public int startFile = 0;
@@ -421,7 +424,7 @@ public final class LoadOptions implements Cloneable {
             options.maxParseErrors = Constants.NO_LIMIT;
             options.maxInsertErrors = Constants.NO_LIMIT;
         }
-        if (Arrays.asList(args).contains("--parallel-count")) {
+        if (options.deprecatedParallelCount) {
             LOG.warn("Parameter --parallel-count is deprecated, " +
                      "please use --parser-threads instead");
         }
@@ -534,6 +537,16 @@ public final class LoadOptions implements Cloneable {
         }
     }
 
+    public static class ParseThreadsValidator extends PositiveValidator implements IParameterValidator2 {
+
+        @Override
+        public void validate(String name, String value, ParameterDescription parameter) {
+            if ("--parallel-count".equals(name)) {
+                ((LoadOptions) parameter.getObject()).deprecatedParallelCount = true;
+            }
+        }
+    }
+
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
diff --git a/hugegraph-loader/src/test/java/org/apache/hugegraph/loader/test/unit/LoadOptionsTest.java b/hugegraph-loader/src/test/java/org/apache/hugegraph/loader/test/unit/LoadOptionsTest.java
index aa16276e8..4711c7cdf 100644
--- a/hugegraph-loader/src/test/java/org/apache/hugegraph/loader/test/unit/LoadOptionsTest.java
+++ b/hugegraph-loader/src/test/java/org/apache/hugegraph/loader/test/unit/LoadOptionsTest.java
@@ -131,6 +131,7 @@ public class LoadOptionsTest {
             String usage = new String(Files.readAllBytes(output.toPath()), StandardCharsets.UTF_8);
             if (expectUsage) {
                 Assert.assertTrue(usage, usage.contains("Usage:") && usage.contains("--file"));
+                Assert.assertFalse(usage, usage.contains("Parameter --parallel-count is deprecated"));
             } else {
                 Assert.assertFalse(usage, usage.contains("Usage:"));
             }
@@ -148,6 +149,7 @@ public class LoadOptionsTest {
     public static class ParserProcess {
 
         public static void main(String[] args) {
+            org.apache.log4j.BasicConfigurator.configure();
             LoadOptions.parseOptions(args);
         }
     }
@@ -233,20 +235,50 @@ public class LoadOptionsTest {
     @Test
     public void testDeprecatedParallelCountParameter() throws Exception {
         File mapping = createTempMapping();
-        String[] args = new String[]{
-                "-f", mapping.getPath(),
-                "-g", "g",
-                "-h", "localhost",
-                "--parallel-count", "4"
-        };
+        File arguments = File.createTempFile("loader-alias-", ".args", new File("."));
+        try {
+            for (boolean responseFile : new boolean[]{false, true}) {
+                for (String name : new String[]{"--parallel-count", "--parser-threads"}) {
+                    String[] args = new String[]{"--file", mapping.getPath(), name, "4"};
+                    if (responseFile) {
+                        Files.write(arguments.toPath(), Arrays.asList(args), StandardCharsets.UTF_8);
+                        args = new String[]{"@" + arguments.getPath()};
+                    }
+                    CapturingAppender appender = attachAppender();
+                    try {
+                        LoadOptions options = LoadOptions.parseOptions(args);
+                        Assert.assertEquals(4, options.parseThreads);
+                        int warnings = appender.buffer.toString().split("deprecated", -1).length - 1;
+                        Assert.assertEquals("--parallel-count".equals(name) ? 1 : 0, warnings);
+                    } finally {
+                        detachAppender(appender);
+                    }
+                }
+            }
+        } finally {
+            arguments.delete();
+            mapping.delete();
+        }
+    }
 
-        CapturingAppender appender = attachAppender();
+    @Test
+    public void testDeprecatedParameterDoesNotWarnOnInvalidInputOrHelp() throws Exception {
+        File mapping = createTempMapping();
+        File arguments = File.createTempFile("loader-alias-exit-", ".args", new File("."));
         try {
-            LoadOptions options = LoadOptions.parseOptions(args);
-            Assert.assertEquals(4, options.parseThreads);
-            Assert.assertTrue(appender.contains("deprecated"));
+            assertParserExit(false, "--file", mapping.getPath(), "--parallel-count", "0");
+            assertParserExit(false, "--file", mapping.getPath(),
+                             "--parallel-count", "4", "--port", "0");
+            assertParserExit(true, "--help", "--parallel-count", "4");
+            Files.write(arguments.toPath(), Arrays.asList("--file", mapping.getPath(),
+                                                         "--parallel-count", "0"),
+                        StandardCharsets.UTF_8);
+            assertParserExit(false, "@" + arguments.getPath());
+            Files.write(arguments.toPath(), Arrays.asList("--help", "--parallel-count", "4"),
+                        StandardCharsets.UTF_8);
+            assertParserExit(true, "@" + arguments.getPath());
         } finally {
-            detachAppender(appender);
+            arguments.delete();
             mapping.delete();
         }
     }