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

davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new 5cec1d0df1a CAMEL-18406: camel-jbang - Add commands to control routes 
(start and stop)
5cec1d0df1a is described below

commit 5cec1d0df1a15d3a91e489a3a1990dcdfbb7e04e
Author: Claus Ibsen <[email protected]>
AuthorDate: Tue Aug 30 09:40:27 2022 +0200

    CAMEL-18406: camel-jbang - Add commands to control routes (start and stop)
---
 .../main/java/org/apache/camel/util/TimeUtils.java |   5 +
 .../camel/cli/connector/LocalCliConnector.java     |  95 ++++++++-
 .../dsl/jbang/core/commands/CamelCommand.java      |   7 +
 .../dsl/jbang/core/commands/CamelJBangMain.java    |   6 +
 .../core/commands/action/ActionBaseCommand.java    | 229 +++++++++++++++++++++
 .../{CamelCommand.java => action/CamelAction.java} |  36 +---
 .../core/commands/action/CamelRouteAction.java     |  67 ++++++
 .../CamelRouteStartAction.java}                    |  35 +---
 .../CamelRouteStopAction.java}                     |  35 +---
 9 files changed, 440 insertions(+), 75 deletions(-)

diff --git a/core/camel-util/src/main/java/org/apache/camel/util/TimeUtils.java 
b/core/camel-util/src/main/java/org/apache/camel/util/TimeUtils.java
index 723a864aa23..4fda283a9f0 100644
--- a/core/camel-util/src/main/java/org/apache/camel/util/TimeUtils.java
+++ b/core/camel-util/src/main/java/org/apache/camel/util/TimeUtils.java
@@ -157,8 +157,13 @@ public final class TimeUtils {
      * Converts to milliseconds.
      *
      * @param source duration which can be in text format such as 15s
+     * @return time in millis, will return 0 if the input is null or empty
      */
     public static long toMilliSeconds(String source) {
+        if (source == null || source.isEmpty()) {
+            return 0;
+        }
+
         // quick conversion if its only digits
         boolean digit = true;
         for (int i = 0; i < source.length(); i++) {
diff --git 
a/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
 
b/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
index f26d00b5afd..ded9845fe3b 100644
--- 
a/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
+++ 
b/dsl/camel-cli-connector/src/main/java/org/apache/camel/cli/connector/LocalCliConnector.java
@@ -17,6 +17,7 @@
 package org.apache.camel.cli.connector;
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.lang.management.ClassLoadingMXBean;
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
@@ -31,21 +32,25 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
 
 import org.apache.camel.CamelContext;
 import org.apache.camel.CamelContextAware;
 import org.apache.camel.ExtendedCamelContext;
+import org.apache.camel.Route;
 import org.apache.camel.console.DevConsole;
 import org.apache.camel.health.HealthCheck;
 import org.apache.camel.health.HealthCheckHelper;
 import org.apache.camel.spi.CliConnector;
 import org.apache.camel.spi.CliConnectorFactory;
+import org.apache.camel.support.PatternHelper;
 import org.apache.camel.support.service.ServiceHelper;
 import org.apache.camel.support.service.ServiceSupport;
 import org.apache.camel.util.FileUtil;
 import org.apache.camel.util.IOHelper;
 import org.apache.camel.util.concurrent.ThreadHelper;
 import org.apache.camel.util.json.JsonObject;
+import org.apache.camel.util.json.Jsoner;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -67,6 +72,7 @@ public class LocalCliConnector extends ServiceSupport 
implements CliConnector, C
     private volatile ExecutorService terminateExecutor;
     private File lockFile;
     private File statusFile;
+    private File actionFile;
 
     public LocalCliConnector(CliConnectorFactory cliConnectorFactory) {
         this.cliConnectorFactory = cliConnectorFactory;
@@ -123,7 +129,8 @@ public class LocalCliConnector extends ServiceSupport 
implements CliConnector, C
         lockFile = createLockFile(getPid());
         if (lockFile != null) {
             statusFile = createLockFile(lockFile.getName() + "-status.json");
-            executor.scheduleWithFixedDelay(this::statusTask, 0, delay, 
TimeUnit.MILLISECONDS);
+            actionFile = createLockFile(lockFile.getName() + "-action.json");
+            executor.scheduleWithFixedDelay(this::task, 0, delay, 
TimeUnit.MILLISECONDS);
             LOG.info("Camel CLI enabled (local)");
         } else {
             LOG.warn("Cannot create PID file: {}. This integration cannot be 
managed by Camel CLI.", getPid());
@@ -153,7 +160,7 @@ public class LocalCliConnector extends ServiceSupport 
implements CliConnector, C
         });
     }
 
-    protected void statusTask() {
+    protected void task() {
         if (!lockFile.exists() && terminating.compareAndSet(false, true)) {
             // if the lock file is deleted then trigger termination
             sigterm();
@@ -162,6 +169,87 @@ public class LocalCliConnector extends ServiceSupport 
implements CliConnector, C
         if (!statusFile.exists()) {
             return;
         }
+
+        actionTask();
+        statusTask();
+    }
+
+    protected void actionTask() {
+        try {
+            JsonObject root = loadAction();
+            if (root.isEmpty()) {
+                return;
+            }
+
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("Action: {}", root);
+            }
+
+            String action = root.getString("action");
+            if ("route".equals(action)) {
+                // id is a pattern
+                String pattern = root.getString("id");
+                // find matching IDs
+                List<String> ids = camelContext.getRoutes()
+                        .stream().map(Route::getRouteId)
+                        .filter(routeId -> PatternHelper.matchPattern(routeId, 
pattern))
+                        .collect(Collectors.toList());
+                for (String id : ids) {
+                    try {
+                        String command = root.getString("command");
+                        if ("start".equals(command)) {
+                            if ("*".equals(id)) {
+                                
camelContext.getRouteController().startAllRoutes();
+                            } else {
+                                
camelContext.getRouteController().startRoute(id);
+                            }
+                        } else if ("stop".equals(command)) {
+                            if ("*".equals(id)) {
+                                
camelContext.getRouteController().stopAllRoutes();
+                            } else {
+                                
camelContext.getRouteController().stopRoute(id);
+                            }
+                        } else if ("suspend".equals(command)) {
+                            camelContext.getRouteController().suspendRoute(id);
+                        } else if ("resume".equals(command)) {
+                            camelContext.getRouteController().resumeRoute(id);
+                        }
+                    } catch (Exception e) {
+                        // ignore
+                    }
+                }
+            }
+
+            // action done so delete file
+            FileUtil.deleteFile(actionFile);
+
+        } catch (Throwable e) {
+            // ignore
+            LOG.trace(
+                    "Error executing action file: " + actionFile + " due to: " 
+ e.getMessage()
+                      + ". This exception is ignored.",
+                    e);
+        }
+    }
+
+    JsonObject loadAction() {
+        try {
+            if (actionFile != null && actionFile.exists()) {
+                FileInputStream fis = new FileInputStream(actionFile);
+                String text = IOHelper.loadText(fis);
+                IOHelper.close(fis);
+                if (!text.isEmpty()) {
+                    return (JsonObject) Jsoner.deserialize(text);
+                }
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+            // ignore
+        }
+        return null;
+    }
+
+    protected void statusTask() {
         try {
             // even during termination then collect status as we want to see 
status changes during stopping
             JsonObject root = new JsonObject();
@@ -304,6 +392,9 @@ public class LocalCliConnector extends ServiceSupport 
implements CliConnector, C
         if (statusFile != null) {
             FileUtil.deleteFile(statusFile);
         }
+        if (actionFile != null) {
+            FileUtil.deleteFile(actionFile);
+        }
         if (executor != null) {
             camelContext.getExecutorServiceManager().shutdown(executor);
             executor = null;
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
index d89a4446a24..02e43eb9710 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
@@ -46,4 +46,11 @@ public abstract class CamelCommand implements 
Callable<Integer> {
         return new File(camelDir, pid + "-status.json");
     }
 
+    public File getActionFile(String pid) {
+        if (camelDir == null) {
+            camelDir = new File(System.getProperty("user.home"), ".camel");
+        }
+        return new File(camelDir, pid + "-action.json");
+    }
+
 }
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
index 32448d38b62..65b10637e28 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelJBangMain.java
@@ -20,6 +20,9 @@ import java.util.concurrent.Callable;
 
 import org.apache.camel.catalog.CamelCatalog;
 import org.apache.camel.catalog.DefaultCamelCatalog;
+import org.apache.camel.dsl.jbang.core.commands.action.CamelAction;
+import org.apache.camel.dsl.jbang.core.commands.action.CamelRouteStartAction;
+import org.apache.camel.dsl.jbang.core.commands.action.CamelRouteStopAction;
 import org.apache.camel.dsl.jbang.core.commands.process.CamelContextStatus;
 import org.apache.camel.dsl.jbang.core.commands.process.CamelContextTop;
 import org.apache.camel.dsl.jbang.core.commands.process.CamelRouteStatus;
@@ -50,6 +53,9 @@ public class CamelJBangMain implements Callable<Integer> {
                 .addSubcommand("top", new CommandLine(new CamelTop(main))
                         .addSubcommand("context", new CommandLine(new 
CamelContextTop(main)))
                         .addSubcommand("route", new CommandLine(new 
CamelRouteTop(main))))
+                .addSubcommand("cmd", new CommandLine(new CamelAction(main))
+                        .addSubcommand("start-route", new CommandLine(new 
CamelRouteStartAction(main)))
+                        .addSubcommand("stop-route", new CommandLine(new 
CamelRouteStopAction(main))))
                 .addSubcommand("generate", new CommandLine(new 
CodeGenerator(main))
                         .addSubcommand("rest", new CommandLine(new 
CodeRestGenerator(main))))
                 .addSubcommand("jolokia", new CommandLine(new Jolokia(main)))
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/ActionBaseCommand.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/ActionBaseCommand.java
new file mode 100644
index 00000000000..3ec1257fb32
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/ActionBaseCommand.java
@@ -0,0 +1,229 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.jbang.core.commands.action;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringJoiner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.camel.dsl.jbang.core.commands.CamelCommand;
+import org.apache.camel.dsl.jbang.core.commands.CamelJBangMain;
+import org.apache.camel.support.PatternHelper;
+import org.apache.camel.util.FileUtil;
+import org.apache.camel.util.IOHelper;
+import org.apache.camel.util.StringHelper;
+import org.apache.camel.util.json.JsonObject;
+import org.apache.camel.util.json.Jsoner;
+
+abstract class ActionBaseCommand extends CamelCommand {
+
+    private static final String[] DSL_EXT = new String[] { "groovy", "java", 
"js", "jsh", "kts", "xml", "yaml" };
+    private static final Pattern PATTERN = Pattern.compile("([\\w|\\-.])+");
+
+    public ActionBaseCommand(CamelJBangMain main) {
+        super(main);
+    }
+
+    List<Long> findPids(String name) {
+        List<Long> pids = new ArrayList<>();
+
+        // we need to know the pids of the running camel integrations
+        if (name.matches("\\d+")) {
+            return List.of(Long.parseLong(name));
+        } else {
+            // lets be open and match all that starts with this pattern
+            if (!name.endsWith("*")) {
+                name = name + "*";
+            }
+        }
+
+        final long cur = ProcessHandle.current().pid();
+        final String pattern = name;
+        ProcessHandle.allProcesses()
+                .filter(ph -> ph.pid() != cur)
+                .forEach(ph -> {
+                    JsonObject root = loadStatus(ph.pid());
+                    // there must be a status file for the running Camel 
integration
+                    if (root != null) {
+                        String pName = extractName(root, ph);
+                        // ignore file extension, so it is easier to match by 
name
+                        pName = FileUtil.onlyName(pName);
+                        if (pName != null && !pName.isEmpty() && 
PatternHelper.matchPattern(pName, pattern)) {
+                            pids.add(ph.pid());
+                        }
+                    }
+                });
+
+        return pids;
+    }
+
+    static String extractMainClass(JsonObject root) {
+        JsonObject runtime = (JsonObject) root.get("runtime");
+        return runtime != null ? runtime.getString("mainClass") : null;
+    }
+
+    static String extractName(JsonObject root, ProcessHandle ph) {
+        String name = doExtractName(root, ph);
+        return FileUtil.stripPath(name);
+    }
+
+    static String doExtractName(JsonObject root, ProcessHandle ph) {
+        // favour main class if known
+        if (root != null) {
+            String mc = extractMainClass(root);
+            if (mc != null) {
+                return mc;
+            }
+        }
+        String cl = ph.info().commandLine().orElse("");
+
+        // this may be a maven plugin run that spawns a child process where 
Camel actually runs (link to child)
+        String mvn = extractMavenPluginName(cl);
+        if (mvn != null) {
+            // is camel running in any of the children?
+            boolean camel = ph.children().anyMatch(ch -> !extractName(root, 
ch).isEmpty());
+            if (camel) {
+                return ""; // skip parent as we want only the child process 
with camel
+            }
+        }
+
+        // try first camel-jbang
+        String name = extractCamelJBangName(cl);
+        if (name != null) {
+            return name;
+        }
+
+        // this may be a maven plugin run that spawns a child process where 
Camel actually runs (link to parent)
+        mvn = extractMavenPluginName(cl);
+        if (mvn == null && ph.parent().isPresent()) {
+            // try parent as it may spawn a sub process
+            String clp = ph.parent().get().info().commandLine().orElse("");
+            mvn = extractMavenPluginName(clp);
+        }
+
+        name = extractCamelName(cl, mvn);
+        return name == null ? "" : name;
+    }
+
+    private static String extractMavenPluginName(String cl) {
+        String name = StringHelper.after(cl, 
"org.codehaus.plexus.classworlds.launcher.Launcher");
+        if (name != null) {
+            return name.trim();
+        }
+        return null;
+    }
+
+    private static String extractCamelName(String cl, String mvn) {
+        if (cl != null) {
+            if (cl.contains("camel-spring-boot") && mvn != null) {
+                int pos = cl.lastIndexOf(" ");
+                if (pos != -1) {
+                    String after = cl.substring(pos);
+                    after = after.trim();
+                    if (after.matches("[\\w|.]+")) {
+                        return after;
+                    }
+                }
+                return mvn;
+            } else if (cl.contains("camel-quarkus") && mvn != null) {
+                return mvn;
+            } else {
+                int pos = cl.lastIndexOf(" ");
+                if (pos != -1) {
+                    String after = cl.substring(pos);
+                    after = after.trim();
+                    if (after.matches("[\\w|.]+")) {
+                        return after;
+                    }
+                }
+                if (mvn != null) {
+                    return mvn;
+                }
+                return cl.contains("camel-main") ? "camel-main" : "camel-core";
+            }
+        }
+
+        return null;
+    }
+
+    static String extractCamelJBangName(String cl) {
+        String name = StringHelper.after(cl, "main.CamelJBang run");
+        if (name != null) {
+            name = name.trim();
+            StringJoiner js = new StringJoiner(" ");
+            // focus only on the route files supported (to skip such as readme 
files)
+            Matcher matcher = PATTERN.matcher(name);
+            while (matcher.find()) {
+                String part = matcher.group();
+                String ext = FileUtil.onlyExt(part, true);
+                if (ext != null && Arrays.asList(DSL_EXT).contains(ext)) {
+                    js.add(part);
+                }
+            }
+            return js.toString();
+        }
+
+        return null;
+    }
+
+    static long extractSince(ProcessHandle ph) {
+        long since = 0;
+        if (ph.info().startInstant().isPresent()) {
+            since = ph.info().startInstant().get().toEpochMilli();
+        }
+        return since;
+    }
+
+    static String extractState(int status) {
+        if (status <= 4) {
+            return "Starting";
+        } else if (status == 5) {
+            return "Running";
+        } else if (status == 6) {
+            return "Suspending";
+        } else if (status == 7) {
+            return "Suspended";
+        } else if (status == 8) {
+            return "Terminating";
+        } else if (status == 9) {
+            return "Terminated";
+        } else {
+            return "Terminated";
+        }
+    }
+
+    JsonObject loadStatus(long pid) {
+        try {
+            File f = getStatusFile("" + pid);
+            if (f != null) {
+                FileInputStream fis = new FileInputStream(f);
+                String text = IOHelper.loadText(fis);
+                IOHelper.close(fis);
+                return (JsonObject) Jsoner.deserialize(text);
+            }
+        } catch (Throwable e) {
+            // ignore
+        }
+        return null;
+    }
+
+}
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelAction.java
similarity index 51%
copy from 
dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
copy to 
dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelAction.java
index d89a4446a24..550b798d067 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelAction.java
@@ -14,36 +14,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.camel.dsl.jbang.core.commands;
-
-import java.io.File;
-import java.util.concurrent.Callable;
+package org.apache.camel.dsl.jbang.core.commands.action;
 
+import org.apache.camel.dsl.jbang.core.commands.CamelJBangMain;
 import picocli.CommandLine;
 
-public abstract class CamelCommand implements Callable<Integer> {
-
-    private final CamelJBangMain main;
-    private File camelDir;
-
-    //CHECKSTYLE:OFF
-    @CommandLine.Option(names = { "-h", "--help" }, usageHelp = true, 
description = "Display the help and sub-commands")
-    private boolean helpRequested = false;
-    //CHECKSTYLE:ON
[email protected](name = "cmd",
+                     description = "Performs commands in the running Camel 
integrations, such as start or stop route. (use --help to see sub commands)")
+public class CamelAction extends ActionBaseCommand {
 
-    public CamelCommand(CamelJBangMain main) {
-        this.main = main;
+    public CamelAction(CamelJBangMain main) {
+        super(main);
     }
 
-    public CamelJBangMain getMain() {
-        return main;
+    @Override
+    public Integer call() throws Exception {
+        new CommandLine(this).execute("--help");
+        return 0;
     }
-
-    public File getStatusFile(String pid) {
-        if (camelDir == null) {
-            camelDir = new File(System.getProperty("user.home"), ".camel");
-        }
-        return new File(camelDir, pid + "-status.json");
-    }
-
 }
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteAction.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteAction.java
new file mode 100644
index 00000000000..d9a89696ecc
--- /dev/null
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteAction.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.jbang.core.commands.action;
+
+import java.io.File;
+import java.util.List;
+
+import org.apache.camel.dsl.jbang.core.commands.CamelJBangMain;
+import org.apache.camel.util.IOHelper;
+import org.apache.camel.util.json.JsonObject;
+import picocli.CommandLine;
+
+public abstract class CamelRouteAction extends ActionBaseCommand {
+
+    @CommandLine.Parameters(description = "Name or pid of running Camel 
integration", arity = "0..1")
+    String name;
+
+    @CommandLine.Option(names = { "--all" },
+                        description = "To select all running Camel 
integrations")
+    boolean all;
+
+    @CommandLine.Option(names = { "--id" },
+                        description = "Route ids (supports wildcards)", 
defaultValue = "*")
+    String id = "*";
+
+    public CamelRouteAction(CamelJBangMain main) {
+        super(main);
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        if (!all && name == null) {
+            return 0;
+        } else if (all) {
+            name = "*";
+        }
+
+        List<Long> pids = findPids(name);
+
+        for (long pid : pids) {
+            JsonObject root = new JsonObject();
+            root.put("action", "route");
+            root.put("id", id);
+            File f = getActionFile("" + pid);
+            onAction(root);
+            IOHelper.writeText(root.toJson(), f);
+        }
+
+        return 0;
+    }
+
+    protected abstract void onAction(JsonObject root);
+}
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteStartAction.java
similarity index 51%
copy from 
dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
copy to 
dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteStartAction.java
index d89a4446a24..50b8076671d 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteStartAction.java
@@ -14,36 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.camel.dsl.jbang.core.commands;
-
-import java.io.File;
-import java.util.concurrent.Callable;
+package org.apache.camel.dsl.jbang.core.commands.action;
 
+import org.apache.camel.dsl.jbang.core.commands.CamelJBangMain;
+import org.apache.camel.util.json.JsonObject;
 import picocli.CommandLine;
 
-public abstract class CamelCommand implements Callable<Integer> {
-
-    private final CamelJBangMain main;
-    private File camelDir;
-
-    //CHECKSTYLE:OFF
-    @CommandLine.Option(names = { "-h", "--help" }, usageHelp = true, 
description = "Display the help and sub-commands")
-    private boolean helpRequested = false;
-    //CHECKSTYLE:ON
-
-    public CamelCommand(CamelJBangMain main) {
-        this.main = main;
-    }
[email protected](name = "start-route",
+                     description = "Start Camel routes")
+public class CamelRouteStartAction extends CamelRouteAction {
 
-    public CamelJBangMain getMain() {
-        return main;
+    public CamelRouteStartAction(CamelJBangMain main) {
+        super(main);
     }
 
-    public File getStatusFile(String pid) {
-        if (camelDir == null) {
-            camelDir = new File(System.getProperty("user.home"), ".camel");
-        }
-        return new File(camelDir, pid + "-status.json");
+    @Override
+    protected void onAction(JsonObject root) {
+        root.put("command", "start");
     }
 
 }
diff --git 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteStopAction.java
similarity index 51%
copy from 
dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
copy to 
dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteStopAction.java
index d89a4446a24..6c63d889974 100644
--- 
a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/CamelCommand.java
+++ 
b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/action/CamelRouteStopAction.java
@@ -14,36 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.camel.dsl.jbang.core.commands;
-
-import java.io.File;
-import java.util.concurrent.Callable;
+package org.apache.camel.dsl.jbang.core.commands.action;
 
+import org.apache.camel.dsl.jbang.core.commands.CamelJBangMain;
+import org.apache.camel.util.json.JsonObject;
 import picocli.CommandLine;
 
-public abstract class CamelCommand implements Callable<Integer> {
-
-    private final CamelJBangMain main;
-    private File camelDir;
-
-    //CHECKSTYLE:OFF
-    @CommandLine.Option(names = { "-h", "--help" }, usageHelp = true, 
description = "Display the help and sub-commands")
-    private boolean helpRequested = false;
-    //CHECKSTYLE:ON
-
-    public CamelCommand(CamelJBangMain main) {
-        this.main = main;
-    }
[email protected](name = "stop-route",
+                     description = "Stop Camel routes")
+public class CamelRouteStopAction extends CamelRouteAction {
 
-    public CamelJBangMain getMain() {
-        return main;
+    public CamelRouteStopAction(CamelJBangMain main) {
+        super(main);
     }
 
-    public File getStatusFile(String pid) {
-        if (camelDir == null) {
-            camelDir = new File(System.getProperty("user.home"), ".camel");
-        }
-        return new File(camelDir, pid + "-status.json");
+    @Override
+    protected void onAction(JsonObject root) {
+        root.put("command", "stop");
     }
 
 }

Reply via email to