001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.camel.spring.handler;
018    
019    import java.util.HashMap;
020    import java.util.HashSet;
021    import java.util.Map;
022    import java.util.Set;
023    
024    import javax.xml.bind.Binder;
025    import javax.xml.bind.JAXBContext;
026    import javax.xml.bind.JAXBException;
027    import org.w3c.dom.Element;
028    import org.w3c.dom.Node;
029    import org.w3c.dom.NodeList;
030    
031    import org.apache.camel.ExchangePattern;
032    import org.apache.camel.builder.xml.Namespaces;
033    import org.apache.camel.model.FromDefinition;
034    import org.apache.camel.model.SendDefinition;
035    import org.apache.camel.model.config.PropertiesDefinition;
036    import org.apache.camel.model.dataformat.ArtixDSDataFormat;
037    import org.apache.camel.model.dataformat.JaxbDataFormat;
038    import org.apache.camel.model.dataformat.SerializationDataFormat;
039    import org.apache.camel.model.dataformat.XMLBeansDataFormat;
040    import org.apache.camel.model.loadbalancer.RandomLoadBalanceStrategy;
041    import org.apache.camel.model.loadbalancer.RoundRobinLoadBalanceStrategy;
042    import org.apache.camel.model.loadbalancer.StickyLoadBalanceStrategy;
043    import org.apache.camel.model.loadbalancer.TopicLoadBalanceStrategy;
044    import org.apache.camel.spi.NamespaceAware;
045    import org.apache.camel.spring.CamelBeanPostProcessor;
046    import org.apache.camel.spring.CamelContextFactoryBean;
047    import org.apache.camel.spring.CamelJMXAgentDefinition;
048    import org.apache.camel.spring.CamelTemplateFactoryBean;
049    import org.apache.camel.spring.EndpointFactoryBean;
050    import org.apache.camel.spring.remoting.CamelProxyFactoryBean;
051    import org.apache.camel.spring.remoting.CamelServiceExporter;
052    import org.apache.camel.util.ObjectHelper;
053    import org.apache.camel.view.ModelFileGenerator;
054    import org.springframework.beans.factory.BeanDefinitionStoreException;
055    import org.springframework.beans.factory.config.BeanDefinition;
056    import org.springframework.beans.factory.config.RuntimeBeanReference;
057    import org.springframework.beans.factory.parsing.BeanComponentDefinition;
058    import org.springframework.beans.factory.support.BeanDefinitionBuilder;
059    import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
060    import org.springframework.beans.factory.xml.ParserContext;
061    
062    /**
063     * Camel namespace for the spring XML configuration file.
064     */
065    public class CamelNamespaceHandler extends NamespaceHandlerSupport {
066    
067        protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(EndpointFactoryBean.class);
068        protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class);
069        protected Set<String> parserElementNames = new HashSet<String>();
070        protected Binder<Node> binder;
071        private JAXBContext jaxbContext;
072        private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>();
073    
074        public ModelFileGenerator createModelFileGenerator() throws JAXBException {
075            return new ModelFileGenerator(getJaxbContext());
076        }
077    
078        public void init() {
079            // remoting
080            addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class);
081            addBeanDefinitionParser("template", CamelTemplateFactoryBean.class);
082            addBeanDefinitionParser("export", CamelServiceExporter.class);
083    
084            // data types
085            addBeanDefinitionParser("artixDS", ArtixDSDataFormat.class);
086            addBeanDefinitionParser("jaxb", JaxbDataFormat.class);
087            addBeanDefinitionParser("serialization", SerializationDataFormat.class);
088            addBeanDefinitionParser("xmlBeans", XMLBeansDataFormat.class);
089    
090            // load balancers
091            addBeanDefinitionParser("roundRobin", RoundRobinLoadBalanceStrategy.class);
092            addBeanDefinitionParser("random", RandomLoadBalanceStrategy.class);
093            addBeanDefinitionParser("sticky", StickyLoadBalanceStrategy.class);
094            addBeanDefinitionParser("topic", TopicLoadBalanceStrategy.class);
095    
096            // jmx agent
097            addBeanDefinitionParser("jmxAgent", CamelJMXAgentDefinition.class);
098    
099            // endpoint
100            addBeanDefinitionParser("endpoint", EndpointFactoryBean.class);
101    
102            // camel context
103            Class cl = CamelContextFactoryBean.class;
104            try {
105                cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean");
106            } catch (Throwable t) {
107                // not running with camel-osgi so we fallback to the regular factory bean
108            }
109            registerParser("camelContext", new CamelContextBeanDefinitionParser(cl));
110        }
111    
112        private void addBeanDefinitionParser(String elementName, Class<?> type) {
113            BeanDefinitionParser parser = new BeanDefinitionParser(type);
114            registerParser(elementName, parser);
115            parserMap.put(elementName, parser);
116        }
117    
118        protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement, BeanDefinitionBuilder parentBuilder) {
119            String beanPostProcessorId = contextId + ":beanPostProcessor";
120            childElement.setAttribute("id", beanPostProcessorId);
121            BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext);
122            definition.getPropertyValues().addPropertyValue("camelContext", new RuntimeBeanReference(contextId));
123            parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId);
124        }
125    
126        protected void registerScriptParser(String elementName, String engineName) {
127            registerParser(elementName, new ScriptDefinitionParser(engineName));
128        }
129    
130        protected void registerParser(String name, org.springframework.beans.factory.xml.BeanDefinitionParser parser) {
131            parserElementNames.add(name);
132            registerBeanDefinitionParser(name, parser);
133        }
134    
135        public Set<String> getParserElementNames() {
136            return parserElementNames;
137        }
138    
139        protected Object parseUsingJaxb(Element element, ParserContext parserContext) {
140            try {
141                binder = getJaxbContext().createBinder();
142                return binder.unmarshal(element);
143            } catch (JAXBException e) {
144                throw new BeanDefinitionStoreException("Failed to parse JAXB element: " + e, e);
145            }
146        }
147    
148        public JAXBContext getJaxbContext() throws JAXBException {
149            if (jaxbContext == null) {
150                jaxbContext = createJaxbContext();
151            }
152            return jaxbContext;
153        }
154    
155        protected JAXBContext createJaxbContext() throws JAXBException {
156            StringBuilder packages = new StringBuilder();
157            for (Class cl : getJaxbPackages()) {
158                if (packages.length() > 0) {
159                    packages.append(":");
160                }
161                packages.append(cl.getName().substring(0, cl.getName().lastIndexOf('.')));
162            }
163            return JAXBContext.newInstance(packages.toString(), getClass().getClassLoader());
164        }
165    
166        protected Set<Class> getJaxbPackages() {
167            Set<Class> classes = new HashSet<Class>();
168            classes.add(org.apache.camel.spring.CamelContextFactoryBean.class);
169            classes.add(ExchangePattern.class);
170            classes.add(org.apache.camel.model.RouteDefinition.class);
171            classes.add(org.apache.camel.model.config.StreamResequencerConfig.class);     
172            classes.add(org.apache.camel.model.dataformat.DataFormatDefinition.class);
173            classes.add(org.apache.camel.model.language.ExpressionDefinition.class);
174            classes.add(org.apache.camel.model.loadbalancer.LoadBalancerDefinition.class);
175            return classes;
176        }
177    
178        protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser {
179            public CamelContextBeanDefinitionParser(Class type) {
180                super(type);
181            }
182    
183            @Override
184            protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
185                super.doParse(element, parserContext, builder);
186    
187                String contextId = element.getAttribute("id");
188    
189                // lets avoid folks having to explicitly give an ID to a camel context
190                if (ObjectHelper.isEmpty(contextId)) {
191                    contextId = "camelContext";
192                    element.setAttribute("id", contextId);
193                }
194    
195                // now lets parse the routes
196                Object value = parseUsingJaxb(element, parserContext);
197                if (value instanceof CamelContextFactoryBean) {
198                    CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value;
199                    builder.addPropertyValue("id", contextId);
200                    builder.addPropertyValue("routes", factoryBean.getRoutes());
201                    builder.addPropertyValue("intercepts", factoryBean.getIntercepts());
202                    builder.addPropertyValue("dataFormats", factoryBean.getDataFormats());
203                    builder.addPropertyValue("exceptionClauses", factoryBean.getExceptionClauses());
204                    builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs());
205                    builder.addPropertyValue("properties", factoryBean.getProperties());
206    
207                    if (factoryBean.getPackages().length > 0) {
208                        builder.addPropertyValue("packages", factoryBean.getPackages());
209                    }
210                }
211    
212                boolean createdBeanPostProcessor = false;
213                NodeList list = element.getChildNodes();
214                int size = list.getLength();
215                for (int i = 0; i < size; i++) {
216                    Node child = list.item(i);
217                    if (child instanceof Element) {
218                        Element childElement = (Element)child;
219                        String localName = child.getLocalName();
220                        if (localName.equals("beanPostProcessor")) {
221                            createBeanPostProcessor(parserContext, contextId, childElement, builder);
222                            createdBeanPostProcessor = true;
223                        } else if (localName.equals("endpoint")) {
224                            registerEndpoint(childElement, parserContext, contextId);
225                        } else {
226                            BeanDefinitionParser parser = parserMap.get(localName);
227                            if (parser != null) {
228                                BeanDefinition definition = parser.parse(childElement, parserContext);
229                                String id = childElement.getAttribute("id");
230                                if (ObjectHelper.isNotEmpty(id)) {
231                                    parserContext.registerComponent(new BeanComponentDefinition(definition, id));
232                                    if (localName.equals("jmxAgent")) {
233                                        builder.addPropertyReference("camelJMXAgent", id);
234                                    }
235                                }
236                            }
237    
238                        }
239                    }
240                }
241    
242                // register as endpoint defined indirectly in the routes by from/to types having id explict set
243                registerEndpointsWithIdsDefinedInFromToTypes(element, parserContext, contextId);
244    
245                // lets inject the namespaces into any namespace aware POJOs
246                injectNamespaces(element);
247                if (!createdBeanPostProcessor) {
248                    // no bean processor element so lets create it by ourself
249                    Element childElement = element.getOwnerDocument().createElement("beanPostProcessor");
250                    element.appendChild(childElement);
251                    createBeanPostProcessor(parserContext, contextId, childElement, builder);
252                }
253            }
254        }
255    
256        protected void injectNamespaces(Element element) {
257            NodeList list = element.getChildNodes();
258            Namespaces namespaces = null;
259            int size = list.getLength();
260            for (int i = 0; i < size; i++) {
261                Node child = list.item(i);
262                if (child instanceof Element) {
263                    Element childElement = (Element)child;
264                    Object object = binder.getJAXBNode(child);
265                    if (object instanceof NamespaceAware) {
266                        NamespaceAware namespaceAware = (NamespaceAware)object;
267                        if (namespaces == null) {
268                            namespaces = new Namespaces(element);
269                        }
270                        namespaces.configure(namespaceAware);
271                    }
272                    injectNamespaces(childElement);
273                }
274            }
275        }
276    
277        protected void registerEndpointsWithIdsDefinedInFromToTypes(Element element, ParserContext parserContext, String contextId) {
278            NodeList list = element.getChildNodes();
279            int size = list.getLength();
280            for (int i = 0; i < size; i++) {
281                Node child = list.item(i);
282                if (child instanceof Element) {
283                    Element childElement = (Element)child;
284                    Object object = binder.getJAXBNode(child);
285                    // we only want from/to types to be registered as endpoints
286                    if (object instanceof FromDefinition || object instanceof SendDefinition) {
287                        registerEndpoint(childElement, parserContext, contextId);
288                    }
289                    // recursive
290                    registerEndpointsWithIdsDefinedInFromToTypes(childElement, parserContext, contextId);
291                }
292            }
293        }
294    
295        private void registerEndpoint(Element childElement, ParserContext parserContext, String contextId) {
296            String id = childElement.getAttribute("id");
297            // must have an id to be registered
298            if (ObjectHelper.isNotEmpty(id)) {
299                BeanDefinition definition = endpointParser.parse(childElement, parserContext);
300                definition.getPropertyValues().addPropertyValue("camelContext", new RuntimeBeanReference(contextId));
301                parserContext.registerComponent(new BeanComponentDefinition(definition, id));
302            }
303        }
304        
305    }