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

Example 1 with TransactedPolicy

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

the class TransactionErrorHandlerBuilder method createErrorHandler.

public Processor createErrorHandler(RouteContext routeContext, Processor processor) throws Exception {
    if (transactionTemplate == null) {
        // lookup in context if no transaction template has been configured
        LOG.debug("No TransactionTemplate configured on TransactionErrorHandlerBuilder. Will try find it in the registry.");
        Map<String, TransactedPolicy> mapPolicy = routeContext.lookupByType(TransactedPolicy.class);
        if (mapPolicy != null && mapPolicy.size() == 1) {
            TransactedPolicy policy = mapPolicy.values().iterator().next();
            if (policy != null && policy instanceof SpringTransactionPolicy) {
                transactionTemplate = ((SpringTransactionPolicy) policy).getTransactionTemplate();
            }
        }
        if (transactionTemplate == null) {
            TransactedPolicy policy = routeContext.lookup(PROPAGATION_REQUIRED, TransactedPolicy.class);
            if (policy != null && policy instanceof SpringTransactionPolicy) {
                transactionTemplate = ((SpringTransactionPolicy) policy).getTransactionTemplate();
            }
        }
        if (transactionTemplate == null) {
            Map<String, TransactionTemplate> mapTemplate = routeContext.lookupByType(TransactionTemplate.class);
            if (mapTemplate == null || mapTemplate.isEmpty()) {
                LOG.trace("No TransactionTemplate found in registry.");
            } else if (mapTemplate.size() == 1) {
                transactionTemplate = mapTemplate.values().iterator().next();
            } else {
                LOG.debug("Found {} TransactionTemplate in registry. Cannot determine which one to use. " + "Please configure a TransactionTemplate on the TransactionErrorHandlerBuilder", mapTemplate.size());
            }
        }
        if (transactionTemplate == null) {
            Map<String, PlatformTransactionManager> mapManager = routeContext.lookupByType(PlatformTransactionManager.class);
            if (mapManager == null || mapManager.isEmpty()) {
                LOG.trace("No PlatformTransactionManager found in registry.");
            } else if (mapManager.size() == 1) {
                transactionTemplate = new TransactionTemplate(mapManager.values().iterator().next());
            } else {
                LOG.debug("Found {} PlatformTransactionManager in registry. Cannot determine which one to use for TransactionTemplate. " + "Please configure a TransactionTemplate on the TransactionErrorHandlerBuilder", mapManager.size());
            }
        }
        if (transactionTemplate != null) {
            LOG.debug("Found TransactionTemplate in registry to use: " + transactionTemplate);
        }
    }
    ObjectHelper.notNull(transactionTemplate, "transactionTemplate", this);
    TransactionErrorHandler answer = new TransactionErrorHandler(routeContext.getCamelContext(), processor, getLogger(), getOnRedelivery(), getRedeliveryPolicy(), getExceptionPolicyStrategy(), transactionTemplate, getRetryWhilePolicy(routeContext.getCamelContext()), getExecutorService(routeContext.getCamelContext()), getRollbackLoggingLevel(), getOnExceptionOccurred());
    // configure error handler before we can use it
    configure(routeContext, answer);
    return answer;
}

Example 2 with TransactedPolicy

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

the class TransactedDefinition method doResolvePolicy.

protected static Policy doResolvePolicy(RouteContext routeContext, String ref, Class<? extends Policy> type) {
    // explicit ref given so lookup by it
    if (ObjectHelper.isNotEmpty(ref)) {
        return CamelContextHelper.mandatoryLookup(routeContext.getCamelContext(), ref, Policy.class);
    }
    // no explicit reference given from user so we can use some convention over configuration here
    // try to lookup by scoped type
    Policy answer = null;
    if (type != null) {
        // try find by type, note that this method is not supported by all registry
        Map<String, ?> types = routeContext.lookupByType(type);
        if (types.size() == 1) {
            // only one policy defined so use it
            Object found = types.values().iterator().next();
            if (type.isInstance(found)) {
                return type.cast(found);
            }
        }
    }
    // for transacted routing try the default REQUIRED name
    if (type == TransactedPolicy.class) {
        // still not found try with the default name PROPAGATION_REQUIRED
        answer = routeContext.lookup(PROPAGATION_REQUIRED, TransactedPolicy.class);
    }
    // still no policy found then try lookup the platform transaction manager and use it as policy
    if (answer == null && type == TransactedPolicy.class) {
        Class<?> tmClazz = routeContext.getCamelContext().getClassResolver().resolveClass("org.springframework.transaction.PlatformTransactionManager");
        if (tmClazz != null) {
            // see if we can find the platform transaction manager in the registry
            Map<String, ?> maps = routeContext.lookupByType(tmClazz);
            if (maps.size() == 1) {
                // only one platform manager then use it as default and create a transacted
                // policy with it and default to required
                // as we do not want dependency on spring jars in the camel-core we use
                // reflection to lookup classes and create new objects and call methods
                // as this is only done during route building it does not matter that we
                // use reflection as performance is no a concern during route building
                Object transactionManager = maps.values().iterator().next();
                LOG.debug("One instance of PlatformTransactionManager found in registry: {}", transactionManager);
                Class<?> txClazz = routeContext.getCamelContext().getClassResolver().resolveClass("org.apache.camel.spring.spi.SpringTransactionPolicy");
                if (txClazz != null) {
                    LOG.debug("Creating a new temporary SpringTransactionPolicy using the PlatformTransactionManager: {}", transactionManager);
                    TransactedPolicy txPolicy = ObjectHelper.newInstance(txClazz, TransactedPolicy.class);
                    Method method;
                    try {
                        method = txClazz.getMethod("setTransactionManager", tmClazz);
                    } catch (NoSuchMethodException e) {
                        throw new RuntimeCamelException("Cannot get method setTransactionManager(PlatformTransactionManager) on class: " + txClazz);
                    }
                    ObjectHelper.invokeMethod(method, txPolicy, transactionManager);
                    return txPolicy;
                } else {
                    // camel-spring is missing on the classpath
                    throw new RuntimeCamelException("Cannot create a transacted policy as camel-spring.jar is not on the classpath!");
                }
            } else {
                if (maps.isEmpty()) {
                    throw new NoSuchBeanException(null, "PlatformTransactionManager");
                } else {
                    throw new IllegalArgumentException("Found " + maps.size() + " PlatformTransactionManager in registry. " + "Cannot determine which one to use. Please configure a TransactionTemplate on the transacted policy.");
                }
            }
        }
    }
    return answer;
}