You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by or...@apache.org on 2023/10/17 11:20:48 UTC
[camel] branch main updated (4fce7339c98 -> 29566baad54)
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
from 4fce7339c98 Upgrade Kubernetes Client to version 6.9.0 (#11737)
new f2f084c9407 CAMEL-19998: cleanup type converter APIs
new 998c8fa4152 CAMEL-19998: use the wrapper method to stop the registry
new 194c7f6ae87 CAMEL-19998: cleanup injector API
new 76db106418e CAMEL-19998: cleanup route controller API
new 8504874a173 CAMEL-19998: cleanup shutdown strategy API
new 29566baad54 CAMEL-19998: cleanup executor service manager API
The 6 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../camel/impl/engine/AbstractCamelContext.java | 118 ++++++-----------
.../impl/engine/DefaultCamelContextExtension.java | 142 +++++++++++++++++++++
2 files changed, 180 insertions(+), 80 deletions(-)
[camel] 05/06: CAMEL-19998: cleanup shutdown strategy API
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 8504874a173846225a57509a42b34eb8b84132a5
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Tue Oct 17 09:33:36 2023 +0200
CAMEL-19998: cleanup shutdown strategy API
---
.../camel/impl/engine/AbstractCamelContext.java | 19 ++++++++-----------
.../impl/engine/DefaultCamelContextExtension.java | 17 +++++++++++++++++
2 files changed, 25 insertions(+), 11 deletions(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index e4f86be0781..38423b8f153 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -261,7 +261,6 @@ public abstract class AbstractCamelContext extends BaseService
private Boolean autowiredEnabled = Boolean.TRUE;
private Long delay;
private Map<String, String> globalOptions = new HashMap<>();
- private volatile ShutdownStrategy shutdownStrategy;
private volatile ExecutorServiceManager executorServiceManager;
private EndpointRegistry<NormalizedUri> endpoints;
private RuntimeEndpointRegistry runtimeEndpointRegistry;
@@ -1077,6 +1076,8 @@ public abstract class AbstractCamelContext extends BaseService
// stop all routes in reverse order that they were started
Comparator<RouteStartupOrder> comparator = Comparator.comparingInt(RouteStartupOrder::getStartupOrder);
+
+ final ShutdownStrategy shutdownStrategy = camelContextExtension.getShutdownStrategy();
if (shutdownStrategy == null || shutdownStrategy.isShutdownRoutesInReverseOrder()) {
comparator = comparator.reversed();
}
@@ -1091,6 +1092,7 @@ public abstract class AbstractCamelContext extends BaseService
public void removeAllRoutes() throws Exception {
// stop all routes in reverse order that they were started
Comparator<RouteStartupOrder> comparator = Comparator.comparingInt(RouteStartupOrder::getStartupOrder);
+ final ShutdownStrategy shutdownStrategy = getShutdownStrategy();
if (shutdownStrategy == null || shutdownStrategy.isShutdownRoutesInReverseOrder()) {
comparator = comparator.reversed();
}
@@ -2131,7 +2133,7 @@ public abstract class AbstractCamelContext extends BaseService
}
// init the shutdown strategy
- this.shutdownStrategy = getShutdownStrategy();
+ final ShutdownStrategy shutdownStrategy = getShutdownStrategy();
if (startupSummaryLevel == StartupSummaryLevel.Verbose) {
// verbose startup should let route controller do the route shutdown logging
if (shutdownStrategy != null && shutdownStrategy.getLoggingLevel().ordinal() < LoggingLevel.INFO.ordinal()) {
@@ -2734,6 +2736,7 @@ public abstract class AbstractCamelContext extends BaseService
@Override
protected void doStop() throws Exception {
stopWatch.restart();
+ final ShutdownStrategy shutdownStrategy = getShutdownStrategy();
if (startupSummaryLevel != StartupSummaryLevel.Oneline && startupSummaryLevel != StartupSummaryLevel.Off) {
if (shutdownStrategy != null && shutdownStrategy.getTimeUnit() != null) {
@@ -2908,6 +2911,7 @@ public abstract class AbstractCamelContext extends BaseService
int forced = 0;
List<String> lines = new ArrayList<>();
+ final ShutdownStrategy shutdownStrategy = camelContextExtension.getShutdownStrategy();
if (shutdownStrategy != null && shutdownStrategy.isShutdownRoutesInReverseOrder()) {
routeStartupOrder.sort(Comparator.comparingInt(RouteStartupOrder::getStartupOrder).reversed());
} else {
@@ -3487,19 +3491,12 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public ShutdownStrategy getShutdownStrategy() {
- if (shutdownStrategy == null) {
- synchronized (lock) {
- if (shutdownStrategy == null) {
- setShutdownStrategy(createShutdownStrategy());
- }
- }
- }
- return shutdownStrategy;
+ return camelContextExtension.getShutdownStrategy();
}
@Override
public void setShutdownStrategy(ShutdownStrategy shutdownStrategy) {
- this.shutdownStrategy = internalServiceManager.addService(shutdownStrategy);
+ camelContextExtension.setShutdownStrategy(shutdownStrategy);
}
@Override
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index 7fe9c766e05..c9206743d5b 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -70,6 +70,7 @@ import org.apache.camel.spi.RestRegistry;
import org.apache.camel.spi.RestRegistryFactory;
import org.apache.camel.spi.RouteController;
import org.apache.camel.spi.RouteStartupOrder;
+import org.apache.camel.spi.ShutdownStrategy;
import org.apache.camel.spi.StartupStepRecorder;
import org.apache.camel.spi.StreamCachingStrategy;
import org.apache.camel.spi.Tracer;
@@ -125,6 +126,7 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
private volatile TypeConverterRegistry typeConverterRegistry;
private volatile TypeConverter typeConverter;
private volatile RouteController routeController;
+ private volatile ShutdownStrategy shutdownStrategy;
private volatile Injector injector;
@@ -872,6 +874,21 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
this.routeController = camelContext.getInternalServiceManager().addService(routeController);
}
+ ShutdownStrategy getShutdownStrategy() {
+ if (shutdownStrategy == null) {
+ synchronized (lock) {
+ if (shutdownStrategy == null) {
+ setShutdownStrategy(camelContext.createShutdownStrategy());
+ }
+ }
+ }
+ return shutdownStrategy;
+ }
+
+ void setShutdownStrategy(ShutdownStrategy shutdownStrategy) {
+ this.shutdownStrategy = camelContext.getInternalServiceManager().addService(shutdownStrategy);
+ }
+
@Override
public RouteController getInternalRouteController() {
return internalRouteController;
[camel] 03/06: CAMEL-19998: cleanup injector API
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 194c7f6ae8707b8094eb16ad7e7252a17f1abb03
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Tue Oct 17 09:01:11 2023 +0200
CAMEL-19998: cleanup injector API
---
.../camel/impl/engine/AbstractCamelContext.java | 14 +++-----------
.../impl/engine/DefaultCamelContextExtension.java | 22 ++++++++++++++++++++++
2 files changed, 25 insertions(+), 11 deletions(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index 2ab1485665c..db0c9e47f0a 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -261,7 +261,6 @@ public abstract class AbstractCamelContext extends BaseService
private Boolean autowiredEnabled = Boolean.TRUE;
private Long delay;
private Map<String, String> globalOptions = new HashMap<>();
- private volatile Injector injector;
private volatile ShutdownStrategy shutdownStrategy;
private volatile ExecutorServiceManager executorServiceManager;
private volatile RouteController routeController;
@@ -1583,19 +1582,12 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public Injector getInjector() {
- if (injector == null) {
- synchronized (lock) {
- if (injector == null) {
- setInjector(createInjector());
- }
- }
- }
- return injector;
+ return camelContextExtension.getInjector();
}
@Override
public void setInjector(Injector injector) {
- this.injector = internalServiceManager.addService(injector);
+ camelContextExtension.setInjector(injector);
}
@Override
@@ -3167,7 +3159,7 @@ public abstract class AbstractCamelContext extends BaseService
* Force clear lazy initialization so they can be re-created on restart
*/
protected void forceStopLazyInitialization() {
- injector = null;
+ camelContextExtension.resetInjector();
camelContextExtension.resetTypeConverterRegistry();
camelContextExtension.resetTypeConverter();
}
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index d3a0bc2cfc0..f7ff8da84d4 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -50,6 +50,7 @@ import org.apache.camel.spi.ExchangeFactoryManager;
import org.apache.camel.spi.FactoryFinder;
import org.apache.camel.spi.HeadersMapFactory;
import org.apache.camel.spi.InflightRepository;
+import org.apache.camel.spi.Injector;
import org.apache.camel.spi.InterceptStrategy;
import org.apache.camel.spi.LifecycleStrategy;
import org.apache.camel.spi.LogListener;
@@ -124,6 +125,8 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
private volatile TypeConverterRegistry typeConverterRegistry;
private volatile TypeConverter typeConverter;
+ private volatile Injector injector;
+
@Deprecated
private ErrorHandlerFactory errorHandlerFactory;
private String basePackageScan;
@@ -830,6 +833,25 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
return typeConverter;
}
+ void resetInjector() {
+ injector = null;
+ }
+
+ Injector getInjector() {
+ if (injector == null) {
+ synchronized (lock) {
+ if (injector == null) {
+ setInjector(camelContext.createInjector());
+ }
+ }
+ }
+ return injector;
+ }
+
+ void setInjector(Injector injector) {
+ this.injector = camelContext.getInternalServiceManager().addService(injector);
+ }
+
@Override
public RouteController getInternalRouteController() {
return internalRouteController;
[camel] 01/06: CAMEL-19998: cleanup type converter APIs
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit f2f084c9407cfc6bc890c1d31ff9b04ad718a429
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Tue Oct 17 08:09:39 2023 +0200
CAMEL-19998: cleanup type converter APIs
- cleanup type converter APIs
- cleanup type converter registry APIs
---
.../camel/impl/engine/AbstractCamelContext.java | 48 +++++++----------
.../impl/engine/DefaultCamelContextExtension.java | 60 ++++++++++++++++++++++
2 files changed, 78 insertions(+), 30 deletions(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index b7f6ac58ab1..e730dab51da 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -261,8 +261,6 @@ public abstract class AbstractCamelContext extends BaseService
private Boolean autowiredEnabled = Boolean.TRUE;
private Long delay;
private Map<String, String> globalOptions = new HashMap<>();
- private volatile TypeConverter typeConverter;
- private volatile TypeConverterRegistry typeConverterRegistry;
private volatile Injector injector;
private volatile ShutdownStrategy shutdownStrategy;
private volatile ExecutorServiceManager executorServiceManager;
@@ -1555,43 +1553,32 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public TypeConverter getTypeConverter() {
- return typeConverter;
+ return camelContextExtension.getTypeConverter();
}
public void setTypeConverter(TypeConverter typeConverter) {
- this.typeConverter = internalServiceManager.addService(typeConverter);
+ camelContextExtension.setTypeConverter(typeConverter);
}
+ /**
+ * Get a type converter or create a new one if unset
+ *
+ * @deprecated use DefaultCamelContextExtension#getOrCreateTypeConverter()
+ * @return A type converter instance
+ */
+ @Deprecated(since = "4.2.0")
protected TypeConverter getOrCreateTypeConverter() {
- if (typeConverter == null) {
- synchronized (lock) {
- if (typeConverter == null) {
- setTypeConverter(createTypeConverter());
- }
- }
- }
- return typeConverter;
+ return camelContextExtension.getOrCreateTypeConverter();
}
@Override
public TypeConverterRegistry getTypeConverterRegistry() {
- if (typeConverterRegistry == null) {
- synchronized (lock) {
- if (typeConverterRegistry == null) {
- setTypeConverterRegistry(createTypeConverterRegistry());
- }
- }
- }
- return typeConverterRegistry;
+ return camelContextExtension.getTypeConverterRegistry();
}
@Override
public void setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry) {
- this.typeConverterRegistry = internalServiceManager.addService(typeConverterRegistry);
- // some registries are also a type converter implementation
- if (typeConverterRegistry instanceof TypeConverter) {
- this.typeConverter = (TypeConverter) typeConverterRegistry;
- }
+ camelContextExtension.setTypeConverterRegistry(typeConverterRegistry);
}
@Override
@@ -2124,7 +2111,7 @@ public abstract class AbstractCamelContext extends BaseService
// Setup type converter eager as its highly in use and should not be lazy initialized
if (eagerCreateTypeConverter()) {
StartupStep step5 = startupStepRecorder.beginStep(CamelContext.class, null, "Setting up TypeConverter");
- getOrCreateTypeConverter();
+ camelContextExtension.getOrCreateTypeConverter();
startupStepRecorder.endStep(step5);
}
@@ -2173,6 +2160,7 @@ public abstract class AbstractCamelContext extends BaseService
// ensure additional type converters is loaded (either if enabled or we should use package scanning from the base)
boolean load = loadTypeConverters || camelContextExtension.getBasePackageScan() != null;
+ final TypeConverter typeConverter = camelContextExtension.getTypeConverter();
if (load && typeConverter instanceof AnnotationScanTypeConverters) {
StartupStep step2 = startupStepRecorder.beginStep(CamelContext.class, null, "Scan TypeConverters");
((AnnotationScanTypeConverters) typeConverter).scanTypeConverters();
@@ -2889,8 +2877,8 @@ public abstract class AbstractCamelContext extends BaseService
InternalServiceManager.shutdownServices(this, camelContextExtension.getReactiveExecutor());
// shutdown type converter and registry as late as possible
- ServiceHelper.stopService(typeConverter);
- ServiceHelper.stopService(typeConverterRegistry);
+ camelContextExtension.stopTypeConverter();
+ camelContextExtension.stopTypeConverterRegistry();
ServiceHelper.stopService(camelContextExtension.getRegistry());
// stop the lazy created so they can be re-created on restart
@@ -3180,8 +3168,8 @@ public abstract class AbstractCamelContext extends BaseService
*/
protected void forceStopLazyInitialization() {
injector = null;
- typeConverterRegistry = null;
- typeConverter = null;
+ camelContextExtension.resetTypeConverterRegistry();
+ camelContextExtension.resetTypeConverter();
}
/**
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index e01231b5f12..7c157f921de 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -36,6 +36,7 @@ import org.apache.camel.ResolveEndpointFailedException;
import org.apache.camel.Route;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.Service;
+import org.apache.camel.TypeConverter;
import org.apache.camel.spi.BootstrapCloseable;
import org.apache.camel.spi.CamelContextNameStrategy;
import org.apache.camel.spi.ClassResolver;
@@ -72,11 +73,13 @@ import org.apache.camel.spi.StartupStepRecorder;
import org.apache.camel.spi.StreamCachingStrategy;
import org.apache.camel.spi.Tracer;
import org.apache.camel.spi.TransformerRegistry;
+import org.apache.camel.spi.TypeConverterRegistry;
import org.apache.camel.spi.UuidGenerator;
import org.apache.camel.spi.ValidatorRegistry;
import org.apache.camel.support.EndpointHelper;
import org.apache.camel.support.NormalizedUri;
import org.apache.camel.support.PluginHelper;
+import org.apache.camel.support.service.ServiceHelper;
import org.apache.camel.util.StringHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -118,6 +121,8 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
private volatile Tracer tracer;
private volatile TransformerRegistry<TransformerKey> transformerRegistry;
private volatile ValidatorRegistry<ValidatorKey> validatorRegistry;
+ private volatile TypeConverterRegistry typeConverterRegistry;
+ private volatile TypeConverter typeConverter;
@Deprecated
private ErrorHandlerFactory errorHandlerFactory;
@@ -766,6 +771,61 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
this.validatorRegistry = camelContext.getInternalServiceManager().addService(validatorRegistry);
}
+ void stopTypeConverterRegistry() {
+ ServiceHelper.stopService(typeConverterRegistry);
+ }
+
+ void resetTypeConverterRegistry() {
+ typeConverterRegistry = null;
+ }
+
+ TypeConverterRegistry getTypeConverterRegistry() {
+ if (typeConverterRegistry == null) {
+ synchronized (lock) {
+ if (typeConverterRegistry == null) {
+ setTypeConverterRegistry(camelContext.createTypeConverterRegistry());
+
+ // some registries are also a type converter implementation
+ if (typeConverterRegistry instanceof TypeConverter newTypeConverter) {
+ setTypeConverter(newTypeConverter);
+ }
+ }
+ }
+ }
+ return typeConverterRegistry;
+ }
+
+ void setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry) {
+ this.typeConverterRegistry = camelContext.getInternalServiceManager().addService(typeConverterRegistry);
+ }
+
+ void stopTypeConverter() {
+ ServiceHelper.stopService(typeConverter);
+ }
+
+ void resetTypeConverter() {
+ typeConverter = null;
+ }
+
+ TypeConverter getTypeConverter() {
+ return typeConverter;
+ }
+
+ void setTypeConverter(TypeConverter typeConverter) {
+ this.typeConverter = camelContext.getInternalServiceManager().addService(typeConverter);
+ }
+
+ TypeConverter getOrCreateTypeConverter() {
+ if (typeConverter == null) {
+ synchronized (lock) {
+ if (typeConverter == null) {
+ setTypeConverter(camelContext.createTypeConverter());
+ }
+ }
+ }
+ return typeConverter;
+ }
+
@Override
public RouteController getInternalRouteController() {
return internalRouteController;
[camel] 04/06: CAMEL-19998: cleanup route controller API
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 76db106418efec4b9a5fc3cd1d4a261daac1b25f
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Tue Oct 17 09:15:55 2023 +0200
CAMEL-19998: cleanup route controller API
---
.../camel/impl/engine/AbstractCamelContext.java | 18 +++++-------------
.../impl/engine/DefaultCamelContextExtension.java | 20 ++++++++++++++++++++
2 files changed, 25 insertions(+), 13 deletions(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index db0c9e47f0a..e4f86be0781 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -263,7 +263,6 @@ public abstract class AbstractCamelContext extends BaseService
private Map<String, String> globalOptions = new HashMap<>();
private volatile ShutdownStrategy shutdownStrategy;
private volatile ExecutorServiceManager executorServiceManager;
- private volatile RouteController routeController;
private EndpointRegistry<NormalizedUri> endpoints;
private RuntimeEndpointRegistry runtimeEndpointRegistry;
private ShutdownRoute shutdownRoute = ShutdownRoute.Default;
@@ -922,19 +921,12 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public RouteController getRouteController() {
- if (routeController == null) {
- synchronized (lock) {
- if (routeController == null) {
- setRouteController(createRouteController());
- }
- }
- }
- return routeController;
+ return camelContextExtension.getRouteController();
}
@Override
public void setRouteController(RouteController routeController) {
- this.routeController = internalServiceManager.addService(routeController);
+ camelContextExtension.setRouteController(routeController);
}
@Override
@@ -2130,7 +2122,7 @@ public abstract class AbstractCamelContext extends BaseService
StartupStep step = startupStepRecorder.beginStep(CamelContext.class, null, "Init CamelContext");
// init the route controller
- this.routeController = getRouteController();
+ final RouteController routeController = getRouteController();
if (startupSummaryLevel == StartupSummaryLevel.Verbose) {
// verbose startup should let route controller do the route startup logging
if (routeController.getLoggingLevel().ordinal() < LoggingLevel.INFO.ordinal()) {
@@ -2372,7 +2364,7 @@ public abstract class AbstractCamelContext extends BaseService
stopWatch.restart();
// Start the route controller
- startService(this.routeController);
+ startService(camelContextExtension.getRouteController());
doNotStartRoutesOnFirstStart = !firstStartDone && !isAutoStartup();
@@ -2759,7 +2751,7 @@ public abstract class AbstractCamelContext extends BaseService
EventHelper.notifyCamelContextRoutesStopping(this);
// Stop the route controller
- ServiceHelper.stopAndShutdownService(this.routeController);
+ camelContextExtension.stopAndShutdownRouteController();
// stop route inputs in the same order as they were started, so we stop
// the very first inputs at first
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index f7ff8da84d4..7fe9c766e05 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -124,6 +124,7 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
private volatile ValidatorRegistry<ValidatorKey> validatorRegistry;
private volatile TypeConverterRegistry typeConverterRegistry;
private volatile TypeConverter typeConverter;
+ private volatile RouteController routeController;
private volatile Injector injector;
@@ -852,6 +853,25 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
this.injector = camelContext.getInternalServiceManager().addService(injector);
}
+ void stopAndShutdownRouteController() {
+ ServiceHelper.stopAndShutdownService(this.routeController);
+ }
+
+ RouteController getRouteController() {
+ if (routeController == null) {
+ synchronized (lock) {
+ if (routeController == null) {
+ setRouteController(camelContext.createRouteController());
+ }
+ }
+ }
+ return routeController;
+ }
+
+ void setRouteController(RouteController routeController) {
+ this.routeController = camelContext.getInternalServiceManager().addService(routeController);
+ }
+
@Override
public RouteController getInternalRouteController() {
return internalRouteController;
[camel] 02/06: CAMEL-19998: use the wrapper method to stop the registry
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 998c8fa41523ead5301cb2ab133e6a56a02cd6a6
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Tue Oct 17 08:11:51 2023 +0200
CAMEL-19998: use the wrapper method to stop the registry
---
.../main/java/org/apache/camel/impl/engine/AbstractCamelContext.java | 2 +-
.../org/apache/camel/impl/engine/DefaultCamelContextExtension.java | 4 ++++
2 files changed, 5 insertions(+), 1 deletion(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index e730dab51da..2ab1485665c 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -2879,7 +2879,7 @@ public abstract class AbstractCamelContext extends BaseService
// shutdown type converter and registry as late as possible
camelContextExtension.stopTypeConverter();
camelContextExtension.stopTypeConverterRegistry();
- ServiceHelper.stopService(camelContextExtension.getRegistry());
+ camelContextExtension.stopRegistry();
// stop the lazy created so they can be re-created on restart
forceStopLazyInitialization();
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index 7c157f921de..d3a0bc2cfc0 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -334,6 +334,10 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
this.managementMBeanAssembler = camelContext.getInternalServiceManager().addService(managementMBeanAssembler, false);
}
+ void stopRegistry() {
+ ServiceHelper.stopService(registry);
+ }
+
@Override
public Registry getRegistry() {
if (registry == null) {
[camel] 06/06: CAMEL-19998: cleanup executor service manager API
Posted by or...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 29566baad543eff2ca69b69b10b31589cf186dfc
Author: Otavio Rodolfo Piske <an...@gmail.com>
AuthorDate: Tue Oct 17 09:44:28 2023 +0200
CAMEL-19998: cleanup executor service manager API
---
.../camel/impl/engine/AbstractCamelContext.java | 17 +++--------------
.../impl/engine/DefaultCamelContextExtension.java | 19 +++++++++++++++++++
2 files changed, 22 insertions(+), 14 deletions(-)
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index 38423b8f153..21546e539e2 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -201,7 +201,6 @@ public abstract class AbstractCamelContext extends BaseService
volatile StartupStepRecorder startupStepRecorder = new DefaultStartupStepRecorder();
int defaultRouteStartupOrder = 1000;
- private final Object lock = new Object();
private final DefaultCamelContextExtension camelContextExtension = new DefaultCamelContextExtension(this);
private final AtomicInteger endpointKeyCounter = new AtomicInteger();
private final List<EndpointStrategy> endpointStrategies = new ArrayList<>();
@@ -261,7 +260,6 @@ public abstract class AbstractCamelContext extends BaseService
private Boolean autowiredEnabled = Boolean.TRUE;
private Long delay;
private Map<String, String> globalOptions = new HashMap<>();
- private volatile ExecutorServiceManager executorServiceManager;
private EndpointRegistry<NormalizedUri> endpoints;
private RuntimeEndpointRegistry runtimeEndpointRegistry;
private ShutdownRoute shutdownRoute = ShutdownRoute.Default;
@@ -2860,7 +2858,7 @@ public abstract class AbstractCamelContext extends BaseService
// the route back as before
// shutdown executor service, reactive executor last
- InternalServiceManager.shutdownServices(this, executorServiceManager);
+ InternalServiceManager.shutdownServices(this, camelContextExtension.getExecutorServiceManager());
InternalServiceManager.shutdownServices(this, camelContextExtension.getReactiveExecutor());
// shutdown type converter and registry as late as possible
@@ -3551,21 +3549,12 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public ExecutorServiceManager getExecutorServiceManager() {
- if (executorServiceManager == null) {
- synchronized (lock) {
- if (executorServiceManager == null) {
- setExecutorServiceManager(createExecutorServiceManager());
- }
- }
- }
- return this.executorServiceManager;
+ return camelContextExtension.getExecutorServiceManager();
}
@Override
public void setExecutorServiceManager(ExecutorServiceManager executorServiceManager) {
- // special for executorServiceManager as want to stop it manually so
- // false in stopOnShutdown
- this.executorServiceManager = internalServiceManager.addService(executorServiceManager, false);
+ camelContextExtension.setExecutorServiceManager(executorServiceManager);
}
@Override
diff --git a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index c9206743d5b..208c56d61d6 100644
--- a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++ b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -47,6 +47,7 @@ import org.apache.camel.spi.EndpointUriFactory;
import org.apache.camel.spi.EventNotifier;
import org.apache.camel.spi.ExchangeFactory;
import org.apache.camel.spi.ExchangeFactoryManager;
+import org.apache.camel.spi.ExecutorServiceManager;
import org.apache.camel.spi.FactoryFinder;
import org.apache.camel.spi.HeadersMapFactory;
import org.apache.camel.spi.InflightRepository;
@@ -127,6 +128,7 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
private volatile TypeConverter typeConverter;
private volatile RouteController routeController;
private volatile ShutdownStrategy shutdownStrategy;
+ private volatile ExecutorServiceManager executorServiceManager;
private volatile Injector injector;
@@ -889,6 +891,23 @@ class DefaultCamelContextExtension implements ExtendedCamelContext {
this.shutdownStrategy = camelContext.getInternalServiceManager().addService(shutdownStrategy);
}
+ ExecutorServiceManager getExecutorServiceManager() {
+ if (executorServiceManager == null) {
+ synchronized (lock) {
+ if (executorServiceManager == null) {
+ setExecutorServiceManager(camelContext.createExecutorServiceManager());
+ }
+ }
+ }
+ return this.executorServiceManager;
+ }
+
+ void setExecutorServiceManager(ExecutorServiceManager executorServiceManager) {
+ // special for executorServiceManager as want to stop it manually so
+ // false in stopOnShutdown
+ this.executorServiceManager = camelContext.getInternalServiceManager().addService(executorServiceManager, false);
+ }
+
@Override
public RouteController getInternalRouteController() {
return internalRouteController;