From b9a3033ac83b539a9f02ad22f7843f438dbe98a9 Mon Sep 17 00:00:00 2001 From: snold Date: Wed, 29 Jan 2014 14:53:21 +0100 Subject: [PATCH] Satisfying Diff --- .../model/RouteContextRefDefinition.java | 10 ++- .../RouteContextRefDefinitionHelper.java | 34 +++++++++- .../apache/camel/spi/CamelRouteContext.java | 33 ++++++++++ .../xml/AbstractCamelContextFactoryBean.java | 64 +++++++++++++------ .../spring/CamelRouteContextFactoryBean.java | 35 ++++++++-- .../spring/handler/CamelNamespaceHandler.java | 22 ++++--- 6 files changed, 158 insertions(+), 40 deletions(-) create mode 100644 camel-core/src/main/java/org/apache/camel/spi/CamelRouteContext.java diff --git a/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinition.java b/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinition.java index 87667a3527026..4d8aeb8bee684 100644 --- a/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinition.java +++ b/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinition.java @@ -27,7 +27,7 @@ /** * Represents an XML <routeContextRef/> element * - * @version + * @version */ @XmlRootElement(name = "routeContextRef") @XmlAccessorType(XmlAccessType.FIELD) @@ -51,9 +51,15 @@ public void setRef(String ref) { this.ref = ref; } - @SuppressWarnings({"unchecked", "rawtypes"}) public List lookupRoutes(CamelContext camelContext) { return RouteContextRefDefinitionHelper.lookupRoutes(camelContext, ref); } + public List lookupRouteBuilders(CamelContext camelContext) { + return RouteContextRefDefinitionHelper.lookupRouteBuilders(camelContext, ref); + } + + public List lookupRouteContextRefs(CamelContext camelContext) { + return RouteContextRefDefinitionHelper.lookupRouteContextRefs(camelContext, ref); + } } diff --git a/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinitionHelper.java b/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinitionHelper.java index 500aca918e89b..5abb7733e7adb 100644 --- a/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinitionHelper.java +++ b/camel-core/src/main/java/org/apache/camel/model/RouteContextRefDefinitionHelper.java @@ -61,18 +61,22 @@ public static synchronized List lookupRoutes(CamelContext camel ObjectHelper.notNull(camelContext, "camelContext"); ObjectHelper.notNull(ref, "ref"); - List answer = CamelContextHelper.lookup(camelContext, ref, List.class); + CamelRouteContext answer = CamelContextHelper.lookup(camelContext, ref, CamelRouteContext.class); if (answer == null) { throw new IllegalArgumentException("Cannot find RouteContext with id " + ref); } + if ( answer.getRoutes() == null ) { + return Collections.emptyList(); + } + // must clone the route definitions as they can be reused with multiple CamelContexts // and they would need their own instances of the definitions to not have side effects among // the CamelContext - for example property placeholder resolutions etc. - List clones = new ArrayList(answer.size()); + List clones = new ArrayList(answer.getRoutes().size()); try { JAXBContext jaxb = getOrCreateJAXBContext(); - for (RouteDefinition def : answer) { + for (RouteDefinition def : answer.getRoutes()) { RouteDefinition clone = cloneRouteDefinition(jaxb, def); if (clone != null) { clones.add(clone); @@ -85,6 +89,30 @@ public static synchronized List lookupRoutes(CamelContext camel return clones; } + public static synchronized List lookupRouteBuilders(CamelContext camelContext, String ref) { + ObjectHelper.notNull(camelContext, "camelContext"); + ObjectHelper.notNull(ref, "ref"); + + CamelRouteContext answer = CamelContextHelper.lookup(camelContext, ref, CamelRouteContext.class); + if (answer == null) { + throw new IllegalArgumentException("Cannot find RouteContext with id " + ref); + } + + return answer.getBuilderRefs(); + } + + public static synchronized List lookupRouteContextRefs(CamelContext camelContext, String ref) { + ObjectHelper.notNull(camelContext, "camelContext"); + ObjectHelper.notNull(ref, "ref"); + + CamelRouteContext answer = CamelContextHelper.lookup(camelContext, ref, CamelRouteContext.class); + if (answer == null) { + throw new IllegalArgumentException("Cannot find RouteContext with id " + ref); + } + + return answer.getRouteRefs(); + } + private static synchronized JAXBContext getOrCreateJAXBContext() throws JAXBException { if (jaxbContext == null) { // must use classloader from CamelContext to have JAXB working diff --git a/camel-core/src/main/java/org/apache/camel/spi/CamelRouteContext.java b/camel-core/src/main/java/org/apache/camel/spi/CamelRouteContext.java new file mode 100644 index 0000000000000..988c8f5268f73 --- /dev/null +++ b/camel-core/src/main/java/org/apache/camel/spi/CamelRouteContext.java @@ -0,0 +1,33 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.spi; + +import java.util.List; + +import org.apache.camel.model.RouteBuilderDefinition; +import org.apache.camel.model.RouteContextRefDefinition; +import org.apache.camel.model.RouteDefinition; + +public interface CamelRouteContext { + + public List getRoutes(); + + public List getBuilderRefs(); + + public List getRouteRefs(); + +} \ No newline at end of file diff --git a/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java b/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java index f2ee007c6e7a6..ff3eae9686de7 100644 --- a/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java +++ b/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java @@ -17,6 +17,7 @@ package org.apache.camel.core.xml; import java.util.ArrayList; +import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; @@ -98,16 +99,16 @@ * or found by searching the classpath for Java classes which extend * {@link org.apache.camel.builder.RouteBuilder}. * - * @version + * @version */ @XmlAccessorType(XmlAccessType.FIELD) public abstract class AbstractCamelContextFactoryBean extends IdentifiedType implements RouteContainer { - + /** * JVM system property to control lazy loading of type converters. */ public static final String LAZY_LOAD_TYPE_CONVERTERS = "CamelLazyLoadTypeConverters"; - + private static final Logger LOG = LoggerFactory.getLogger(AbstractCamelContextFactoryBean.class); @XmlTransient @@ -326,7 +327,7 @@ private void prepareRoutes() { } protected abstract void initCustomRegistry(T context); - + @SuppressWarnings("deprecation") protected void initLazyLoadTypeConverters() { if (getLazyLoadTypeConverters() != null) { @@ -481,14 +482,14 @@ protected void initPropertyPlaceholder() throws Exception { PropertiesParser.class); pc.setPropertiesParser(parser); } - + pc.setPropertyPrefix(def.getPropertyPrefix()); pc.setPropertySuffix(def.getPropertySuffix()); - + if (def.isFallbackToUnaugmentedProperty() != null) { pc.setFallbackToUnaugmentedProperty(def.isFallbackToUnaugmentedProperty()); } - + pc.setPrefixToken(def.getPrefixToken()); pc.setSuffixToken(def.getSuffixToken()); @@ -498,18 +499,43 @@ protected void initPropertyPlaceholder() throws Exception { } protected void initRouteRefs() throws Exception { - // add route refs to existing routes - if (getRouteRefs() != null) { - for (RouteContextRefDefinition ref : getRouteRefs()) { - List defs = ref.lookupRoutes(getContext()); - for (RouteDefinition def : defs) { - LOG.debug("Adding route from {} -> {}", ref, def); - // add in top as they are most likely to be common/shared - // which you may want to start first - getRoutes().add(0, def); - } - } - } + // add route refs to existing routes + if (getRouteRefs() != null) { + Map flattenedRouteRefs = new HashMap(); + for (RouteContextRefDefinition ref : getRouteRefs()) { + flattenedRouteRefs.putAll(flattenRouteRefs(ref, flattenedRouteRefs)); + } + for (RouteContextRefDefinition ref : flattenedRouteRefs.values() ) { + LOG.debug("Adding RouteContextRef {} items", ref); + addingRouteRefItems(ref); + } + } + } + + protected Map flattenRouteRefs(RouteContextRefDefinition ref, final Map routeRefMap) throws Exception { + Map currentRouteRefsMap = new HashMap(routeRefMap); + if (!currentRouteRefsMap.containsKey(ref.getRef())) { + currentRouteRefsMap.put(ref.getRef(), ref); + for (RouteContextRefDefinition it : ref.lookupRouteContextRefs(getContext())) { + currentRouteRefsMap.putAll(flattenRouteRefs(it, currentRouteRefsMap)); + } + } else { + LOG.warn("Ignoring circular reference ", ref); + } + return currentRouteRefsMap; + } + + protected void addingRouteRefItems(RouteContextRefDefinition ref) throws Exception { + for (final RouteBuilderDefinition builderRef : ref.lookupRouteBuilders(getContext())) { + LOG.debug("Adding BuilderRef {} ", builderRef); + getBuilderRefs().add(builderRef); + } + for (RouteDefinition def : ref.lookupRoutes(getContext())) { + LOG.debug("Adding route from {} -> {}", ref, def); + // add in top as they are most likely to be common/shared + // which you may want to start first + getRoutes().add(0, def); + } } protected abstract S getBeanForType(Class clazz); diff --git a/components/camel-spring/src/main/java/org/apache/camel/spring/CamelRouteContextFactoryBean.java b/components/camel-spring/src/main/java/org/apache/camel/spring/CamelRouteContextFactoryBean.java index 621cced61a744..74ec8ad3ffe08 100644 --- a/components/camel-spring/src/main/java/org/apache/camel/spring/CamelRouteContextFactoryBean.java +++ b/components/camel-spring/src/main/java/org/apache/camel/spring/CamelRouteContextFactoryBean.java @@ -24,21 +24,28 @@ import javax.xml.bind.annotation.XmlRootElement; import org.apache.camel.model.IdentifiedType; +import org.apache.camel.model.RouteBuilderDefinition; +import org.apache.camel.model.RouteContextRefDefinition; import org.apache.camel.model.RouteDefinition; +import org.apache.camel.spi.CamelRouteContext; import org.springframework.beans.factory.FactoryBean; /** - * @version + * @version */ @XmlRootElement(name = "routeContext") @XmlAccessorType(XmlAccessType.FIELD) -public class CamelRouteContextFactoryBean extends IdentifiedType implements FactoryBean> { +public class CamelRouteContextFactoryBean extends IdentifiedType implements CamelRouteContext, FactoryBean { - @XmlElement(name = "route", required = true) + @XmlElement(name = "route", required = false) private List routes = new ArrayList(); + @XmlElement(name = "routeBuilder", required = false) + private List builderRefs = new ArrayList(); + @XmlElement(name = "routeContextRef", required = false) + private List routeRefs = new ArrayList(); - public List getObject() throws Exception { - return routes; + public CamelRouteContext getObject() throws Exception { + return this; } public Class getObjectType() { @@ -56,5 +63,21 @@ public List getRoutes() { public void setRoutes(List routes) { this.routes = routes; } - + + public List getBuilderRefs() { + return builderRefs; + } + + public void setBuilderRefs(List builderRefs) { + this.builderRefs = builderRefs; + } + + public List getRouteRefs() { + return routeRefs; + } + + public void setRouteRefs(List routeRefs) { + this.routeRefs = routeRefs; + } + } diff --git a/components/camel-spring/src/main/java/org/apache/camel/spring/handler/CamelNamespaceHandler.java b/components/camel-spring/src/main/java/org/apache/camel/spring/handler/CamelNamespaceHandler.java index 957c792c226bc..9c60bd416776f 100644 --- a/components/camel-spring/src/main/java/org/apache/camel/spring/handler/CamelNamespaceHandler.java +++ b/components/camel-spring/src/main/java/org/apache/camel/spring/handler/CamelNamespaceHandler.java @@ -76,7 +76,7 @@ public class CamelNamespaceHandler extends NamespaceHandlerSupport { protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class, false); protected Set parserElementNames = new HashSet(); protected Map parserMap = new HashMap(); - + private JAXBContext jaxbContext; private Map autoRegisterMap = new HashMap(); @@ -100,7 +100,7 @@ public ModelFileGenerator createModelFileGenerator() throws JAXBException { public void init() { // register routeContext parser registerParser("routeContext", new RouteContextDefinitionParser()); - + addBeanDefinitionParser("keyStoreParameters", KeyStoreParametersFactoryBean.class, true, true); addBeanDefinitionParser("secureRandomParameters", SecureRandomParametersFactoryBean.class, true, true); registerBeanDefinitionParser("sslContextParameters", new SSLContextParametersFactoryBeanBeanDefinitionParser()); @@ -144,7 +144,7 @@ public void init() { } if (osgi) { LOG.info("OSGi environment detected."); - } + } LOG.debug("Using {} as CamelContextBeanDefinitionParser", cl.getCanonicalName()); registerParser("camelContext", new CamelContextBeanDefinitionParser(cl)); } @@ -201,7 +201,7 @@ protected Set> getJaxbPackages() { classes.add(org.apache.camel.util.spring.SSLContextParametersFactoryBean.class); return classes; } - + protected class SSLContextParametersFactoryBeanBeanDefinitionParser extends BeanDefinitionParser { public SSLContextParametersFactoryBeanBeanDefinitionParser() { @@ -211,8 +211,8 @@ public SSLContextParametersFactoryBeanBeanDefinitionParser() { @Override protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { super.doParse(element, builder); - - // Note: prefer to use doParse from parent and postProcess; however, parseUsingJaxb requires + + // Note: prefer to use doParse from parent and postProcess; however, parseUsingJaxb requires // parserContext for no apparent reason. Binder binder; try { @@ -220,12 +220,12 @@ protected void doParse(Element element, ParserContext parserContext, BeanDefinit } catch (JAXBException e) { throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e); } - + Object value = parseUsingJaxb(element, parserContext, binder); - + if (value instanceof SSLContextParametersFactoryBean) { SSLContextParametersFactoryBean bean = (SSLContextParametersFactoryBean)value; - + builder.addPropertyValue("cipherSuites", bean.getCipherSuites()); builder.addPropertyValue("cipherSuitesFilter", bean.getCipherSuitesFilter()); builder.addPropertyValue("secureSocketProtocols", bean.getSecureSocketProtocols()); @@ -233,7 +233,7 @@ protected void doParse(Element element, ParserContext parserContext, BeanDefinit builder.addPropertyValue("keyManagers", bean.getKeyManagers()); builder.addPropertyValue("trustManagers", bean.getTrustManagers()); builder.addPropertyValue("secureRandom", bean.getSecureRandom()); - + builder.addPropertyValue("clientParameters", bean.getClientParameters()); builder.addPropertyValue("serverParameters", bean.getServerParameters()); } else { @@ -267,6 +267,8 @@ protected void doParse(Element element, ParserContext parserContext, BeanDefinit if (value instanceof CamelRouteContextFactoryBean) { CamelRouteContextFactoryBean factoryBean = (CamelRouteContextFactoryBean) value; builder.addPropertyValue("routes", factoryBean.getRoutes()); + builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs()); + builder.addPropertyValue("routeRefs", factoryBean.getRouteRefs()); } // lets inject the namespaces into any namespace aware POJOs