You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2022/04/27 15:04:45 UTC
[camel] 01/04: CAMEL-18081: camel-main/camel-java-dsl - Add option to compile to disk to pre-load on next run
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
commit 8cfbee8c9b71ad2612431c8f4401e8d072d61d4f
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Wed Apr 27 15:42:14 2022 +0200
CAMEL-18081: camel-main/camel-java-dsl - Add option to compile to disk to pre-load on next run
---
.../apache/camel/spi}/CompilePostProcessor.java | 2 +-
.../MainConfigurationPropertiesConfigurer.java | 6 ++
.../camel-main-configuration-metadata.json | 1 +
core/camel-main/src/main/docs/main.adoc | 3 +-
.../org/apache/camel/main/BaseMainSupport.java | 106 ++++++++++++++++++++-
.../camel/main/MainConfigurationProperties.java | 26 +++++
.../apache/camel/main/RouteDslPostCompiler.java | 36 +++----
.../dsl/support/RouteBuilderLoaderSupport.java | 1 +
.../dsl/java/joor/ClassRoutesBuilderLoader.java | 3 +-
.../dsl/java/joor/JavaRoutesBuilderLoader.java | 2 +-
.../dsl/java/joor/JavaJoorCaptureByteCodeTest.java | 2 +-
.../camel/dsl/jbang/core/commands/FatJar.java | 3 +
.../apache/camel/dsl/jbang/core/commands/Run.java | 5 +-
.../camel/main/AnnotationDependencyInjection.java | 2 +-
.../java/org/apache/camel/main/KameletMain.java | 5 -
15 files changed, 171 insertions(+), 32 deletions(-)
diff --git a/dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/CompilePostProcessor.java b/core/camel-api/src/main/java/org/apache/camel/spi/CompilePostProcessor.java
similarity index 97%
rename from dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/CompilePostProcessor.java
rename to core/camel-api/src/main/java/org/apache/camel/spi/CompilePostProcessor.java
index 16d6d960522..0f58bc2a75b 100644
--- a/dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/CompilePostProcessor.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/CompilePostProcessor.java
@@ -14,7 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.dsl.support;
+package org.apache.camel.spi;
import org.apache.camel.CamelContext;
diff --git a/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java b/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
index e1fb5a110db..cb4088fdca4 100644
--- a/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
+++ b/core/camel-main/src/generated/java/org/apache/camel/main/MainConfigurationPropertiesConfigurer.java
@@ -159,6 +159,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "RoutesBuilders": target.setRoutesBuilders(property(camelContext, java.util.List.class, value)); return true;
case "routescollectorenabled":
case "RoutesCollectorEnabled": target.setRoutesCollectorEnabled(property(camelContext, boolean.class, value)); return true;
+ case "routescompiledirectory":
+ case "RoutesCompileDirectory": target.setRoutesCompileDirectory(property(camelContext, java.lang.String.class, value)); return true;
case "routesexcludepattern":
case "RoutesExcludePattern": target.setRoutesExcludePattern(property(camelContext, java.lang.String.class, value)); return true;
case "routesincludepattern":
@@ -384,6 +386,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "RoutesBuilders": return java.util.List.class;
case "routescollectorenabled":
case "RoutesCollectorEnabled": return boolean.class;
+ case "routescompiledirectory":
+ case "RoutesCompileDirectory": return java.lang.String.class;
case "routesexcludepattern":
case "RoutesExcludePattern": return java.lang.String.class;
case "routesincludepattern":
@@ -610,6 +614,8 @@ public class MainConfigurationPropertiesConfigurer extends org.apache.camel.supp
case "RoutesBuilders": return target.getRoutesBuilders();
case "routescollectorenabled":
case "RoutesCollectorEnabled": return target.isRoutesCollectorEnabled();
+ case "routescompiledirectory":
+ case "RoutesCompileDirectory": return target.getRoutesCompileDirectory();
case "routesexcludepattern":
case "RoutesExcludePattern": return target.getRoutesExcludePattern();
case "routesincludepattern":
diff --git a/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json b/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
index 5c24cc107de..f9372e40e51 100644
--- a/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
+++ b/core/camel-main/src/generated/resources/META-INF/camel-main-configuration-metadata.json
@@ -82,6 +82,7 @@
{ "name": "camel.main.routesBuilderClasses", "description": "Sets classes names that implement RoutesBuilder .", "sourceType": "org.apache.camel.main.MainConfigurationProperties", "type": "string", "javaType": "java.lang.String" },
{ "name": "camel.main.routesBuilders", "description": "Sets the RoutesBuilder instances.", "sourceType": "org.apache.camel.main.MainConfigurationProperties", "type": "object", "javaType": "java.util.List" },
{ "name": "camel.main.routesCollectorEnabled", "description": "Whether the routes collector is enabled or not. When enabled Camel will auto-discover routes (RouteBuilder instances from the registry and also load additional routes from the file system). The routes collector is default enabled.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "boolean", "javaType": "boolean", "defaultValue": true },
+ { "name": "camel.main.routesCompileDirectory", "description": "Directory to use for saving runtime compiled Camel routes to class files, when using camel-java-joor-dsl as Java DSL (such as when using Camel K with Java source routes). Camel will compile to in-memory only by default. Specifying this option, allows Camel to persist the compiled class to disk. And when starting the application again the routes are loaded from the pre-compiled class files instead of re-compiling again.", [...]
{ "name": "camel.main.routesExcludePattern", "description": "Used for exclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to exclude all the routes from a directory whose name contains foo use: **\/foo.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "string", "javaType": [...]
{ "name": "camel.main.routesIncludePattern", "description": "Used for inclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to include all the routes from a directory whose name contains foo use: **\/foo.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "string", "javaType": [...]
{ "name": "camel.main.routesReloadDirectory", "description": "Directory to scan for route changes. Camel cannot scan the classpath, so this must be configured to a file directory. Development with Maven as build tool, you can configure the directory to be src\/main\/resources to scan for Camel routes in XML or YAML files.", "sourceType": "org.apache.camel.main.DefaultConfigurationProperties", "type": "string", "javaType": "java.lang.String", "defaultValue": "src\/main\/resources\/camel" },
diff --git a/core/camel-main/src/main/docs/main.adoc b/core/camel-main/src/main/docs/main.adoc
index 749164dbd82..34f1eb15c27 100644
--- a/core/camel-main/src/main/docs/main.adoc
+++ b/core/camel-main/src/main/docs/main.adoc
@@ -18,7 +18,7 @@ The following tables lists all the options:
// main options: START
=== Camel Main configurations
-The camel.main supports 109 options, which are listed below.
+The camel.main supports 110 options, which are listed below.
[width="100%",cols="2,5,^1,2",options="header"]
|===
@@ -92,6 +92,7 @@ The camel.main supports 109 options, which are listed below.
| *camel.main.routesBuilder{zwsp}Classes* | Sets classes names that implement RoutesBuilder . | | String
| *camel.main.routesBuilders* | Sets the RoutesBuilder instances. | | List
| *camel.main.routesCollector{zwsp}Enabled* | Whether the routes collector is enabled or not. When enabled Camel will auto-discover routes (RouteBuilder instances from the registry and also load additional routes from the file system). The routes collector is default enabled. | true | boolean
+| *camel.main.routesCompile{zwsp}Directory* | Directory to use for saving runtime compiled Camel routes to class files, when using camel-java-joor-dsl as Java DSL (such as when using Camel K with Java source routes). Camel will compile to in-memory only by default. Specifying this option, allows Camel to persist the compiled class to disk. And when starting the application again the routes are loaded from the pre-compiled class files instead of re-compiling again. | | String
| *camel.main.routesExclude{zwsp}Pattern* | Used for exclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to exclude all the routes from a directory whose name contains foo use: **/foo. | | String
| *camel.main.routesInclude{zwsp}Pattern* | Used for inclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to include all the routes from a directory whose name contains foo use: **/foo. | classpath:camel/*,classpath:camel-template/*,classpath:camel-rest/* | String
| *camel.main.routesReload{zwsp}Directory* | Directory to scan for route changes. Camel cannot scan the classpath, so this must be configured to a file directory. Development with Maven as build tool, you can configure the directory to be src/main/resources to scan for Camel routes in XML or YAML files. | src/main/resources/camel | String
diff --git a/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java b/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java
index f17f366ba32..f5cf5a8568f 100644
--- a/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/BaseMainSupport.java
@@ -158,6 +158,9 @@ public abstract class BaseMainSupport extends BaseService {
}
public Properties getInitialProperties() {
+ if (initialProperties == null) {
+ initialProperties = new OrderedProperties();
+ }
return initialProperties;
}
@@ -387,10 +390,14 @@ public abstract class BaseMainSupport extends BaseService {
if (mainConfigurationProperties.isAutoConfigurationEnabled()) {
autoConfigurationFailFast(camelContext, autoConfiguredProperties);
autoConfigurationPropertiesComponent(camelContext, autoConfiguredProperties);
+ autoConfigurationRoutesIncludePattern(camelContext, autoConfiguredProperties);
+
+ // eager configure dsl compiler as we may load routes when doing modeline scanning
+ autoConfigurationRoutesCompileDirectory(camelContext, autoConfiguredProperties);
+ configureDslCompiler(camelContext);
// eager load properties from modeline by scanning DSL sources and gather properties for auto configuration
if (camelContext.isModeline() || mainConfigurationProperties.isModeline()) {
- autoConfigurationRoutesIncludePattern(camelContext, autoConfiguredProperties);
modelineRoutes(camelContext);
}
@@ -510,6 +517,14 @@ public abstract class BaseMainSupport extends BaseService {
}
}
+ protected void configureDslCompiler(CamelContext camelContext) {
+ if (mainConfigurationProperties.getRoutesCompileDirectory() != null) {
+ RouteDslPostCompiler pc = new RouteDslPostCompiler(mainConfigurationProperties.getRoutesCompileDirectory());
+ camelContext.getRegistry().bind("RouteDslPostCompiler", pc);
+ LOG.debug("Compiling Camel DSL to directory: {}", mainConfigurationProperties.getRoutesCompileDirectory());
+ }
+ }
+
protected void modelineRoutes(CamelContext camelContext) throws Exception {
// then configure and add the routes
RoutesConfigurer configurer = new RoutesConfigurer();
@@ -573,6 +588,8 @@ public abstract class BaseMainSupport extends BaseService {
configureStartupRecorder(camelContext);
// setup package scan
configurePackageScan(camelContext);
+ // configure DSL post compiler
+ configureDslCompiler(camelContext);
// ensure camel context is build
camelContext.build();
@@ -813,6 +830,93 @@ public abstract class BaseMainSupport extends BaseService {
}
}
+ protected void autoConfigurationRoutesCompileDirectory(
+ CamelContext camelContext, OrderedLocationProperties autoConfiguredProperties) {
+
+ Object dir = getInitialProperties().getProperty("camel.main.routesCompileDirectory");
+ if (ObjectHelper.isNotEmpty(dir)) {
+ mainConfigurationProperties
+ .setRoutesCompileDirectory(CamelContextHelper.parseText(camelContext, dir.toString()));
+ autoConfiguredProperties.put("initial", "camel.main.routesCompileDirectory", dir.toString());
+ }
+
+ // load properties
+ OrderedLocationProperties prop = (OrderedLocationProperties) camelContext.getPropertiesComponent()
+ .loadProperties(name -> name.startsWith("camel."), MainHelper::optionKey);
+ LOG.debug("Properties from Camel properties component:");
+ for (String key : prop.stringPropertyNames()) {
+ LOG.debug(" {}={}", key, prop.getProperty(key));
+ }
+
+ // special for environment-variable-enabled as we need to know this early before we set all the other options
+ String loc = prop.getLocation("camel.main.routesCompileDirectory");
+ dir = prop.remove("camel.main.routesCompileDirectory");
+ if (ObjectHelper.isNotEmpty(dir)) {
+ mainConfigurationProperties.setRoutesCompileDirectory(
+ CamelContextHelper.parseText(camelContext, dir.toString()));
+ autoConfiguredProperties.put(loc, "camel.main.routesCompileDirectory",
+ dir.toString());
+ }
+ // special for system-properties-enabled as we need to know this early before we set all the other options
+ loc = prop.getLocation("camel.main.routesCompileDirectory");
+ Object jvmEnabled = prop.remove("camel.main.routesCompileDirectory");
+ if (ObjectHelper.isNotEmpty(jvmEnabled)) {
+ mainConfigurationProperties.setRoutesIncludePattern(
+ CamelContextHelper.parseText(camelContext, jvmEnabled.toString()));
+ autoConfiguredProperties.put(loc, "camel.main.routesCompileDirectory",
+ jvmEnabled.toString());
+ }
+
+ // load properties from ENV (override existing)
+ Properties propENV = null;
+ if (mainConfigurationProperties.isAutoConfigurationEnvironmentVariablesEnabled()) {
+ propENV = helper.loadEnvironmentVariablesAsProperties(new String[] { "camel.main." });
+ if (!propENV.isEmpty()) {
+ prop.putAll("ENV", propENV);
+ LOG.debug("Properties from OS environment variables:");
+ for (String key : propENV.stringPropertyNames()) {
+ LOG.debug(" {}={}", key, propENV.getProperty(key));
+ }
+ }
+ }
+ // load properties from JVM (override existing)
+ Properties propJVM = null;
+ if (mainConfigurationProperties.isAutoConfigurationSystemPropertiesEnabled()) {
+ propJVM = helper.loadJvmSystemPropertiesAsProperties(new String[] { "camel.main." });
+ if (!propJVM.isEmpty()) {
+ prop.putAll("SYS", propJVM);
+ LOG.debug("Properties from JVM system properties:");
+ for (String key : propJVM.stringPropertyNames()) {
+ LOG.debug(" {}={}", key, propJVM.getProperty(key));
+ }
+ }
+ }
+
+ // special for fail-fast as we need to know this early before we set all the other options
+ loc = "ENV";
+ dir = propENV != null ? propENV.remove("camel.main.routesCompileDirectory") : null;
+ if (ObjectHelper.isNotEmpty(propJVM)) {
+ Object val = propJVM.remove("camel.main.routesCompileDirectory");
+ if (ObjectHelper.isNotEmpty(val)) {
+ loc = "SYS";
+ dir = val;
+ }
+ }
+ if (ObjectHelper.isNotEmpty(dir)) {
+ mainConfigurationProperties
+ .setRoutesCompileDirectory(CamelContextHelper.parseText(camelContext, dir.toString()));
+ autoConfiguredProperties.put(loc, "camel.main.routesCompileDirectory", dir.toString());
+ } else {
+ loc = prop.getLocation("camel.main.routesCompileDirectory");
+ dir = prop.remove("camel.main.routesCompileDirectory");
+ if (ObjectHelper.isNotEmpty(dir)) {
+ mainConfigurationProperties
+ .setRoutesCompileDirectory(CamelContextHelper.parseText(camelContext, dir.toString()));
+ autoConfiguredProperties.put(loc, "camel.main.routesCompileDirectory", dir.toString());
+ }
+ }
+ }
+
/**
* Configures CamelContext from the {@link MainConfigurationProperties} properties.
*/
diff --git a/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java b/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
index 59b1cd4aae4..0e33e5d2248 100644
--- a/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/MainConfigurationProperties.java
@@ -41,6 +41,7 @@ public class MainConfigurationProperties extends DefaultConfigurationProperties<
private int durationHitExitCode;
private String basePackageScan;
private boolean basePackageScanEnabled = true;
+ private String routesCompileDirectory;
private String routesBuilderClasses;
private String configurationClasses;
@@ -353,6 +354,20 @@ public class MainConfigurationProperties extends DefaultConfigurationProperties<
this.basePackageScanEnabled = basePackageScanEnabled;
}
+ public String getRoutesCompileDirectory() {
+ return routesCompileDirectory;
+ }
+
+ /**
+ * Directory to use for saving runtime compiled Camel routes to class files, when using camel-java-joor-dsl as Java
+ * DSL (such as when using Camel K with Java source routes). Camel will compile to in-memory only by default.
+ * Specifying this option, allows Camel to persist the compiled class to disk. And when starting the application
+ * again the routes are loaded from the pre-compiled class files instead of re-compiling again.
+ */
+ public void setRoutesCompileDirectory(String routesCompileDirectory) {
+ this.routesCompileDirectory = routesCompileDirectory;
+ }
+
public int getDurationHitExitCode() {
return durationHitExitCode;
}
@@ -587,6 +602,17 @@ public class MainConfigurationProperties extends DefaultConfigurationProperties<
return this;
}
+ /**
+ * Directory to use for saving runtime compiled Camel routes to class files, when using camel-java-joor-dsl as Java
+ * DSL (such as when using Camel K with Java source routes). Camel will compile to in-memory only by default.
+ * Specifying this option, allows Camel to persist the compiled class to disk. And when starting the application
+ * again the routes are loaded from the pre-compiled class files instead of re-compiling again.
+ */
+ public MainConfigurationProperties withRoutesCompileDirectory(String routeCompileDirectory) {
+ this.routesCompileDirectory = routeCompileDirectory;
+ return this;
+ }
+
// fluent builders - configurations
// --------------------------------------------------------------
diff --git a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/JavaJoorPostCompiler.java b/core/camel-main/src/main/java/org/apache/camel/main/RouteDslPostCompiler.java
similarity index 57%
rename from dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/JavaJoorPostCompiler.java
rename to core/camel-main/src/main/java/org/apache/camel/main/RouteDslPostCompiler.java
index ab6fbbead17..2b385ad7b26 100644
--- a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/JavaJoorPostCompiler.java
+++ b/core/camel-main/src/main/java/org/apache/camel/main/RouteDslPostCompiler.java
@@ -20,38 +20,38 @@ import java.io.File;
import java.io.FileOutputStream;
import org.apache.camel.CamelContext;
-import org.apache.camel.dsl.support.CompilePostProcessor;
+import org.apache.camel.spi.CompilePostProcessor;
import org.apache.camel.util.IOHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Post compiler for java-joor-dsl that stores the compiled .java sources as .class files to disk.
*/
-public class JavaJoorPostCompiler {
+public class RouteDslPostCompiler implements CompilePostProcessor {
- public static void initJavaJoorPostCompiler(CamelContext context, String outputDirectory) {
- context.getRegistry().bind("JavaJoorDslPostCompiler", new ByteCodeCompilePostProcessor(outputDirectory));
- }
-
- private static class ByteCodeCompilePostProcessor implements CompilePostProcessor {
+ private static final Logger LOG = LoggerFactory.getLogger(RouteDslPostCompiler.class);
- private final String outputDirectory;
+ private final String outputDirectory;
- public ByteCodeCompilePostProcessor(String outputDirectory) {
- this.outputDirectory = outputDirectory;
- }
+ public RouteDslPostCompiler(String outputDirectory) {
+ this.outputDirectory = outputDirectory;
+ }
- @Override
- public void postCompile(CamelContext camelContext, String name, Class<?> clazz, byte[] byteCode, Object instance)
- throws Exception {
- if (byteCode != null) {
+ @Override
+ public void postCompile(CamelContext camelContext, String name, Class<?> clazz, byte[] byteCode, Object instance)
+ throws Exception {
+ if (byteCode != null) {
+ // write to disk (can be triggered multiple times so only write once)
+ File target = new File(outputDirectory + "/" + name + ".class");
+ if (!target.exists()) {
// create work-dir if needed
new File(outputDirectory).mkdirs();
- // write to disk
- FileOutputStream fos = new FileOutputStream(outputDirectory + "/" + name + ".class", false);
+ FileOutputStream fos = new FileOutputStream(target);
+ LOG.debug("Writing compiled class: {} as bytecode to file: {}", name, target);
fos.write(byteCode);
IOHelper.close(fos);
}
}
}
-
}
diff --git a/dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/RouteBuilderLoaderSupport.java b/dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/RouteBuilderLoaderSupport.java
index c9618679cf2..fe67a37cfa7 100644
--- a/dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/RouteBuilderLoaderSupport.java
+++ b/dsl/camel-dsl-support/src/main/java/org/apache/camel/dsl/support/RouteBuilderLoaderSupport.java
@@ -27,6 +27,7 @@ import org.apache.camel.StartupStep;
import org.apache.camel.api.management.ManagedAttribute;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.builder.RouteBuilderLifecycleStrategy;
+import org.apache.camel.spi.CompilePostProcessor;
import org.apache.camel.spi.Resource;
import org.apache.camel.spi.RoutesBuilderLoader;
import org.apache.camel.spi.StartupStepRecorder;
diff --git a/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/ClassRoutesBuilderLoader.java b/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/ClassRoutesBuilderLoader.java
index 29075318e78..4ee1488b429 100644
--- a/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/ClassRoutesBuilderLoader.java
+++ b/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/ClassRoutesBuilderLoader.java
@@ -26,8 +26,8 @@ import org.apache.camel.CamelContextAware;
import org.apache.camel.RoutesBuilder;
import org.apache.camel.api.management.ManagedResource;
import org.apache.camel.builder.RouteBuilder;
-import org.apache.camel.dsl.support.CompilePostProcessor;
import org.apache.camel.dsl.support.ExtendedRouteBuilderLoaderSupport;
+import org.apache.camel.spi.CompilePostProcessor;
import org.apache.camel.spi.Resource;
import org.apache.camel.spi.ResourceAware;
import org.apache.camel.spi.annotations.RoutesLoader;
@@ -85,6 +85,7 @@ public class ClassRoutesBuilderLoader extends ExtendedRouteBuilderLoaderSupport
// support custom annotation scanning post compilation
// such as to register custom beans, type converters, etc.
for (CompilePostProcessor pre : getCompilePostProcessors()) {
+ // do not pass in byte code as we do not need to write to disk again
pre.postCompile(getCamelContext(), className, clazz, null, obj);
}
diff --git a/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/JavaRoutesBuilderLoader.java b/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/JavaRoutesBuilderLoader.java
index b679be54486..8ec2c8c5e9f 100644
--- a/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/JavaRoutesBuilderLoader.java
+++ b/dsl/camel-java-joor-dsl/src/main/java/org/apache/camel/dsl/java/joor/JavaRoutesBuilderLoader.java
@@ -29,8 +29,8 @@ import org.apache.camel.CamelContextAware;
import org.apache.camel.RoutesBuilder;
import org.apache.camel.api.management.ManagedResource;
import org.apache.camel.builder.RouteBuilder;
-import org.apache.camel.dsl.support.CompilePostProcessor;
import org.apache.camel.dsl.support.ExtendedRouteBuilderLoaderSupport;
+import org.apache.camel.spi.CompilePostProcessor;
import org.apache.camel.spi.Resource;
import org.apache.camel.spi.ResourceAware;
import org.apache.camel.spi.annotations.RoutesLoader;
diff --git a/dsl/camel-java-joor-dsl/src/test/java/org/apache/camel/dsl/java/joor/JavaJoorCaptureByteCodeTest.java b/dsl/camel-java-joor-dsl/src/test/java/org/apache/camel/dsl/java/joor/JavaJoorCaptureByteCodeTest.java
index 12c91100328..f7ed873a806 100644
--- a/dsl/camel-java-joor-dsl/src/test/java/org/apache/camel/dsl/java/joor/JavaJoorCaptureByteCodeTest.java
+++ b/dsl/camel-java-joor-dsl/src/test/java/org/apache/camel/dsl/java/joor/JavaJoorCaptureByteCodeTest.java
@@ -26,8 +26,8 @@ import org.apache.camel.ProducerTemplate;
import org.apache.camel.RoutesBuilder;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.mock.MockEndpoint;
-import org.apache.camel.dsl.support.CompilePostProcessor;
import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.spi.CompilePostProcessor;
import org.apache.camel.spi.Resource;
import org.apache.camel.support.ResourceSupport;
import org.junit.jupiter.api.Test;
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/FatJar.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/FatJar.java
index a1d7ac13d95..94c4960bf18 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/FatJar.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/FatJar.java
@@ -159,6 +159,9 @@ class FatJar implements Callable<Integer> {
List<String> lines = Files.readAllLines(settings.toPath());
FileOutputStream fos = new FileOutputStream(target, false);
for (String line : lines) {
+ if (line.startsWith("camel.main.routesCompileDirectory")) {
+ continue; // skip as fat-jar should not compile to disk
+ }
for (String k : SETTINGS_PROP_SOURCE_KEYS) {
line = fileToClasspath(line, k);
}
diff --git a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/Run.java b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/Run.java
index 7527fb299f6..35fa604948f 100644
--- a/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/Run.java
+++ b/dsl/camel-jbang/camel-jbang-core/src/main/java/org/apache/camel/dsl/jbang/core/commands/Run.java
@@ -214,8 +214,9 @@ class Run implements Callable<Integer> {
writeSettings("camel.main.tracing", trace ? "true" : "false");
main.addInitialProperty("camel.main.modeline", modeline ? "true" : "false");
writeSettings("camel.main.modeline", modeline ? "true" : "false");
- main.addInitialProperty("camel.jbang.work-directory", WORK_DIR);
- writeSettings("camel.jbang.work-directory", WORK_DIR);
+ // allow java-dsl to compile to .class which we need in fat-jar mode
+ main.addInitialProperty("camel.main.routesCompileDirectory", WORK_DIR);
+ writeSettings("camel.main.routesCompileDirectory", WORK_DIR);
// command line arguments
if (property != null) {
diff --git a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/AnnotationDependencyInjection.java b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/AnnotationDependencyInjection.java
index 368b7abafea..449fae07577 100644
--- a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/AnnotationDependencyInjection.java
+++ b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/AnnotationDependencyInjection.java
@@ -35,10 +35,10 @@ import org.apache.camel.LoggingLevel;
import org.apache.camel.NoSuchBeanException;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.TypeConverterExists;
-import org.apache.camel.dsl.support.CompilePostProcessor;
import org.apache.camel.impl.engine.CamelPostProcessorHelper;
import org.apache.camel.spi.CamelBeanPostProcessor;
import org.apache.camel.spi.CamelBeanPostProcessorInjector;
+import org.apache.camel.spi.CompilePostProcessor;
import org.apache.camel.spi.Registry;
import org.apache.camel.spi.TypeConverterRegistry;
import org.apache.camel.util.ObjectHelper;
diff --git a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java
index 00418848231..be6e9247e6b 100644
--- a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java
+++ b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java
@@ -198,11 +198,6 @@ public class KameletMain extends MainCommandLineSupport {
answer.setLoadHealthChecks(true);
// annotation based dependency injection for camel/spring/quarkus annotations in DSLs and Java beans
AnnotationDependencyInjection.initAnnotationBasedDependencyInjection(answer);
- // java-dsl post compiler to save compilation to disk
- String dir = (String) getInitialProperties().get("camel.jbang.work-directory");
- if (dir != null) {
- JavaJoorPostCompiler.initJavaJoorPostCompiler(answer, dir);
- }
// embed HTTP server if port is specified
Object port = getInitialProperties().get("camel.jbang.platform-http.port");