Examples with LifecycleStrategy org.apache.camel.spi.LifecycleStrategy used on opensource projects

Example 16 with LifecycleStrategy

use of org.apache.camel.spi.LifecycleStrategy in project camel by apache.

the class DefaultCamelContext method addEndpoint.

public Endpoint addEndpoint(String uri, Endpoint endpoint) throws Exception {
    Endpoint oldEndpoint;
    startService(endpoint);
    oldEndpoint = endpoints.remove(getEndpointKey(uri));
    for (LifecycleStrategy strategy : lifecycleStrategies) {
        strategy.onEndpointAdd(endpoint);
    }
    addEndpointToRegistry(uri, endpoint);
    if (oldEndpoint != null) {
        stopServices(oldEndpoint);
    }
    return oldEndpoint;
}

Example 17 with LifecycleStrategy

use of org.apache.camel.spi.LifecycleStrategy in project camel by apache.

the class DefaultCamelContext method doStartOrResumeRouteConsumers.

private void doStartOrResumeRouteConsumers(Map<Integer, DefaultRouteStartupOrder> inputs, boolean resumeOnly, boolean addingRoute) throws Exception {
    List<Endpoint> routeInputs = new ArrayList<Endpoint>();
    for (Map.Entry<Integer, DefaultRouteStartupOrder> entry : inputs.entrySet()) {
        Integer order = entry.getKey();
        Route route = entry.getValue().getRoute();
        RouteService routeService = entry.getValue().getRouteService();
        // if we are starting camel, then skip routes which are configured to not be auto started
        boolean autoStartup = routeService.getRouteDefinition().isAutoStartup(this) && this.isAutoStartup();
        if (addingRoute && !autoStartup) {
            log.info("Skipping starting of route " + routeService.getId() + " as its configured with autoStartup=false");
            continue;
        }
        // start the service
        for (Consumer consumer : routeService.getInputs().values()) {
            Endpoint endpoint = consumer.getEndpoint();
            // check multiple consumer violation, with the other routes to be started
            if (!doCheckMultipleConsumerSupportClash(endpoint, routeInputs)) {
                throw new FailedToStartRouteException(routeService.getId(), "Multiple consumers for the same endpoint is not allowed: " + endpoint);
            }
            // check for multiple consumer violations with existing routes which
            // have already been started, or is currently starting
            List<Endpoint> existingEndpoints = new ArrayList<Endpoint>();
            for (Route existingRoute : getRoutes()) {
                if (route.getId().equals(existingRoute.getId())) {
                    // skip ourselves
                    continue;
                }
                Endpoint existing = existingRoute.getEndpoint();
                ServiceStatus status = getRouteStatus(existingRoute.getId());
                if (status != null && (status.isStarted() || status.isStarting())) {
                    existingEndpoints.add(existing);
                }
            }
            if (!doCheckMultipleConsumerSupportClash(endpoint, existingEndpoints)) {
                throw new FailedToStartRouteException(routeService.getId(), "Multiple consumers for the same endpoint is not allowed: " + endpoint);
            }
            // start the consumer on the route
            log.debug("Route: {} >>> {}", route.getId(), route);
            if (resumeOnly) {
                log.debug("Resuming consumer (order: {}) on route: {}", order, route.getId());
            } else {
                log.debug("Starting consumer (order: {}) on route: {}", order, route.getId());
            }
            if (resumeOnly && route.supportsSuspension()) {
                // if we are resuming and the route can be resumed
                ServiceHelper.resumeService(consumer);
                log.info("Route: " + route.getId() + " resumed and consuming from: " + endpoint);
            } else {
                // when starting we should invoke the lifecycle strategies
                for (LifecycleStrategy strategy : lifecycleStrategies) {
                    strategy.onServiceAdd(this, consumer, route);
                }
                startService(consumer);
                log.info("Route: " + route.getId() + " started and consuming from: " + endpoint);
            }
            routeInputs.add(endpoint);
            // add to the order which they was started, so we know how to stop them in reverse order
            // but only add if we haven't already registered it before (we dont want to double add when restarting)
            boolean found = false;
            for (RouteStartupOrder other : routeStartupOrder) {
                if (other.getRoute().getId().equals(route.getId())) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                routeStartupOrder.add(entry.getValue());
            }
        }
        if (resumeOnly) {
            routeService.resume();
        } else {
            // and start the route service (no need to start children as they are already warmed up)
            routeService.start(false);
        }
    }
}

Example 18 with LifecycleStrategy

use of org.apache.camel.spi.LifecycleStrategy in project camel by apache.

the class DefaultCamelContext method doAddService.

private void doAddService(Object object, boolean stopOnShutdown, boolean forceStart) throws Exception {
    // inject CamelContext
    if (object instanceof CamelContextAware) {
        CamelContextAware aware = (CamelContextAware) object;
        aware.setCamelContext(this);
    }
    if (object instanceof Service) {
        Service service = (Service) object;
        for (LifecycleStrategy strategy : lifecycleStrategies) {
            if (service instanceof Endpoint) {
                // use specialized endpoint add
                strategy.onEndpointAdd((Endpoint) service);
            } else {
                strategy.onServiceAdd(this, service, null);
            }
        }
        if (!forceStart) {
            // now start the service (and defer starting if CamelContext is starting up itself)
            deferStartService(object, stopOnShutdown);
        } else {
            // only add to services to close if its a singleton
            // otherwise we could for example end up with a lot of prototype scope endpoints
            // assume singleton by default
            boolean singleton = true;
            if (object instanceof IsSingleton) {
                singleton = ((IsSingleton) service).isSingleton();
            }
            // do not add endpoints as they have their own list
            if (singleton && !(service instanceof Endpoint)) {
                // only add to list of services to stop if its not already there
                if (stopOnShutdown && !hasService(service)) {
                    servicesToStop.add(service);
                }
            }
            ServiceHelper.startService(service);
        }
    }
}

Example 19 with LifecycleStrategy

use of org.apache.camel.spi.LifecycleStrategy in project camel by apache.

the class DefaultExecutorServiceManager method doShutdownNow.

private List<Runnable> doShutdownNow(ExecutorService executorService, boolean failSafe) {
    ObjectHelper.notNull(executorService, "executorService");
    List<Runnable> answer = null;
    if (!executorService.isShutdown()) {
        if (failSafe) {
            // log as warn, as we shutdown as fail-safe, so end user should see more details in the log.
            LOG.warn("Forcing shutdown of ExecutorService: {}", executorService);
        } else {
            LOG.debug("Forcing shutdown of ExecutorService: {}", executorService);
        }
        answer = executorService.shutdownNow();
        if (LOG.isTraceEnabled()) {
            LOG.trace("Shutdown of ExecutorService: {} is shutdown: {} and terminated: {}.", executorService, executorService.isShutdown(), executorService.isTerminated());
        }
    }
    // let lifecycle strategy be notified as well which can let it be managed in JMX as well
    ThreadPoolExecutor threadPool = null;
    if (executorService instanceof ThreadPoolExecutor) {
        threadPool = (ThreadPoolExecutor) executorService;
    } else if (executorService instanceof SizedScheduledExecutorService) {
        threadPool = ((SizedScheduledExecutorService) executorService).getScheduledThreadPoolExecutor();
    }
    if (threadPool != null) {
        for (LifecycleStrategy lifecycle : camelContext.getLifecycleStrategies()) {
            lifecycle.onThreadPoolRemove(camelContext, threadPool);
        }
    }
    // remove reference as its shutdown (do not remove if fail-safe)
    if (!failSafe) {
        executorServices.remove(executorService);
    }
    return answer;
}

Example 20 with LifecycleStrategy

use of org.apache.camel.spi.LifecycleStrategy in project camel by apache.

the class AbstractCamelContextFactoryBean method afterPropertiesSet.

public void afterPropertiesSet() throws Exception {
    if (ObjectHelper.isEmpty(getId())) {
        throw new IllegalArgumentException("Id must be set");
    }
    // set the package scan resolver as soon as possible
    PackageScanClassResolver packageResolver = getBeanForType(PackageScanClassResolver.class);
    if (packageResolver != null) {
        LOG.info("Using custom PackageScanClassResolver: {}", packageResolver);
        getContext().setPackageScanClassResolver(packageResolver);
    }
    // then set custom properties
    Map<String, String> mergedOptions = new HashMap<>();
    if (getProperties() != null) {
        mergedOptions.putAll(getProperties().asMap());
    }
    if (getGlobalOptions() != null) {
        mergedOptions.putAll(getGlobalOptions().asMap());
    }
    getContext().setGlobalOptions(mergedOptions);
    // and enable lazy loading of type converters if applicable
    initLazyLoadTypeConverters();
    setupCustomServices();
    // set the custom registry if defined
    initCustomRegistry(getContext());
    // setup property placeholder so we got it as early as possible
    initPropertyPlaceholder();
    // setup JMX agent at first
    initJMXAgent();
    Tracer tracer = getBeanForType(Tracer.class);
    if (tracer != null) {
        // use formatter if there is a TraceFormatter bean defined
        TraceFormatter formatter = getBeanForType(TraceFormatter.class);
        if (formatter != null) {
            tracer.setFormatter(formatter);
        }
        LOG.info("Using custom Tracer: {}", tracer);
        getContext().addInterceptStrategy(tracer);
    }
    BacklogTracer backlogTracer = getBeanForType(BacklogTracer.class);
    if (backlogTracer != null) {
        LOG.info("Using custom BacklogTracer: {}", backlogTracer);
        getContext().addInterceptStrategy(backlogTracer);
    }
    HandleFault handleFault = getBeanForType(HandleFault.class);
    if (handleFault != null) {
        LOG.info("Using custom HandleFault: {}", handleFault);
        getContext().addInterceptStrategy(handleFault);
    }
    @SuppressWarnings("deprecation") org.apache.camel.processor.interceptor.Delayer delayer = getBeanForType(org.apache.camel.processor.interceptor.Delayer.class);
    if (delayer != null) {
        LOG.info("Using custom Delayer: {}", delayer);
        getContext().addInterceptStrategy(delayer);
    }
    InflightRepository inflightRepository = getBeanForType(InflightRepository.class);
    if (inflightRepository != null) {
        LOG.info("Using custom InflightRepository: {}", inflightRepository);
        getContext().setInflightRepository(inflightRepository);
    }
    AsyncProcessorAwaitManager asyncProcessorAwaitManager = getBeanForType(AsyncProcessorAwaitManager.class);
    if (asyncProcessorAwaitManager != null) {
        LOG.info("Using custom AsyncProcessorAwaitManager: {}", asyncProcessorAwaitManager);
        getContext().setAsyncProcessorAwaitManager(asyncProcessorAwaitManager);
    }
    ManagementStrategy managementStrategy = getBeanForType(ManagementStrategy.class);
    if (managementStrategy != null) {
        LOG.info("Using custom ManagementStrategy: {}", managementStrategy);
        getContext().setManagementStrategy(managementStrategy);
    }
    ManagementNamingStrategy managementNamingStrategy = getBeanForType(ManagementNamingStrategy.class);
    if (managementNamingStrategy != null) {
        LOG.info("Using custom ManagementNamingStrategy: {}", managementNamingStrategy);
        getContext().getManagementStrategy().setManagementNamingStrategy(managementNamingStrategy);
    }
    EventFactory eventFactory = getBeanForType(EventFactory.class);
    if (eventFactory != null) {
        LOG.info("Using custom EventFactory: {}", eventFactory);
        getContext().getManagementStrategy().setEventFactory(eventFactory);
    }
    UnitOfWorkFactory unitOfWorkFactory = getBeanForType(UnitOfWorkFactory.class);
    if (unitOfWorkFactory != null) {
        LOG.info("Using custom UnitOfWorkFactory: {}", unitOfWorkFactory);
        getContext().setUnitOfWorkFactory(unitOfWorkFactory);
    }
    RuntimeEndpointRegistry runtimeEndpointRegistry = getBeanForType(RuntimeEndpointRegistry.class);
    if (runtimeEndpointRegistry != null) {
        LOG.info("Using custom RuntimeEndpointRegistry: {}", runtimeEndpointRegistry);
        getContext().setRuntimeEndpointRegistry(runtimeEndpointRegistry);
    }
    // custom type converters defined as <bean>s
    Map<String, TypeConverters> typeConverters = getContext().getRegistry().findByTypeWithName(TypeConverters.class);
    if (typeConverters != null && !typeConverters.isEmpty()) {
        for (Entry<String, TypeConverters> entry : typeConverters.entrySet()) {
            TypeConverters converter = entry.getValue();
            LOG.info("Adding custom TypeConverters with id: {} and implementation: {}", entry.getKey(), converter);
            getContext().getTypeConverterRegistry().addTypeConverters(converter);
        }
    }
    // set the event notifier strategies if defined
    Map<String, EventNotifier> eventNotifiers = getContext().getRegistry().findByTypeWithName(EventNotifier.class);
    if (eventNotifiers != null && !eventNotifiers.isEmpty()) {
        for (Entry<String, EventNotifier> entry : eventNotifiers.entrySet()) {
            EventNotifier notifier = entry.getValue();
            // do not add if already added, for instance a tracer that is also an InterceptStrategy class
            if (!getContext().getManagementStrategy().getEventNotifiers().contains(notifier)) {
                LOG.info("Using custom EventNotifier with id: {} and implementation: {}", entry.getKey(), notifier);
                getContext().getManagementStrategy().addEventNotifier(notifier);
            }
        }
    }
    // set endpoint strategies if defined
    Map<String, EndpointStrategy> endpointStrategies = getContext().getRegistry().findByTypeWithName(EndpointStrategy.class);
    if (endpointStrategies != null && !endpointStrategies.isEmpty()) {
        for (Entry<String, EndpointStrategy> entry : endpointStrategies.entrySet()) {
            EndpointStrategy strategy = entry.getValue();
            LOG.info("Using custom EndpointStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
            getContext().addRegisterEndpointCallback(strategy);
        }
    }
    // shutdown
    ShutdownStrategy shutdownStrategy = getBeanForType(ShutdownStrategy.class);
    if (shutdownStrategy != null) {
        LOG.info("Using custom ShutdownStrategy: " + shutdownStrategy);
        getContext().setShutdownStrategy(shutdownStrategy);
    }
    // add global interceptors
    Map<String, InterceptStrategy> interceptStrategies = getContext().getRegistry().findByTypeWithName(InterceptStrategy.class);
    if (interceptStrategies != null && !interceptStrategies.isEmpty()) {
        for (Entry<String, InterceptStrategy> entry : interceptStrategies.entrySet()) {
            InterceptStrategy strategy = entry.getValue();
            // do not add if already added, for instance a tracer that is also an InterceptStrategy class
            if (!getContext().getInterceptStrategies().contains(strategy)) {
                LOG.info("Using custom InterceptStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
                getContext().addInterceptStrategy(strategy);
            }
        }
    }
    // set the lifecycle strategy if defined
    Map<String, LifecycleStrategy> lifecycleStrategies = getContext().getRegistry().findByTypeWithName(LifecycleStrategy.class);
    if (lifecycleStrategies != null && !lifecycleStrategies.isEmpty()) {
        for (Entry<String, LifecycleStrategy> entry : lifecycleStrategies.entrySet()) {
            LifecycleStrategy strategy = entry.getValue();
            // do not add if already added, for instance a tracer that is also an InterceptStrategy class
            if (!getContext().getLifecycleStrategies().contains(strategy)) {
                LOG.info("Using custom LifecycleStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
                getContext().addLifecycleStrategy(strategy);
            }
        }
    }
    // add route policy factories
    Map<String, RoutePolicyFactory> routePolicyFactories = getContext().getRegistry().findByTypeWithName(RoutePolicyFactory.class);
    if (routePolicyFactories != null && !routePolicyFactories.isEmpty()) {
        for (Entry<String, RoutePolicyFactory> entry : routePolicyFactories.entrySet()) {
            RoutePolicyFactory factory = entry.getValue();
            LOG.info("Using custom RoutePolicyFactory with id: {} and implementation: {}", entry.getKey(), factory);
            getContext().addRoutePolicyFactory(factory);
        }
    }
    // set the default thread pool profile if defined
    initThreadPoolProfiles(getContext());
    // Set the application context and camelContext for the beanPostProcessor
    initBeanPostProcessor(getContext());
    // init camel context
    initCamelContext(getContext());
    // init stream caching strategy
    initStreamCachingStrategy();
}