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 <[email protected]> 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");
