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    
028    import org.w3c.dom.Element;
029    import org.w3c.dom.Node;
030    import org.w3c.dom.NodeList;
031    
032    import org.apache.camel.ExchangePattern;
033    import org.apache.camel.builder.xml.Namespaces;
034    import org.apache.camel.spi.NamespaceAware;
035    import org.apache.camel.spring.CamelBeanPostProcessor;
036    import org.apache.camel.spring.CamelContextFactoryBean;
037    import org.apache.camel.spring.CamelJMXAgentType;
038    import org.apache.camel.spring.CamelTemplateFactoryBean;
039    import org.apache.camel.spring.EndpointFactoryBean;
040    import org.apache.camel.spring.remoting.CamelProxyFactoryBean;
041    import org.apache.camel.spring.remoting.CamelServiceExporter;
042    import org.apache.camel.util.ObjectHelper;
043    import org.apache.camel.view.ModelFileGenerator;
044    import org.apache.commons.logging.Log;
045    import org.apache.commons.logging.LogFactory;
046    import org.springframework.beans.factory.BeanDefinitionStoreException;
047    import org.springframework.beans.factory.config.BeanDefinition;
048    import org.springframework.beans.factory.config.RuntimeBeanReference;
049    import org.springframework.beans.factory.parsing.BeanComponentDefinition;
050    import org.springframework.beans.factory.support.BeanDefinitionBuilder;
051    import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
052    import org.springframework.beans.factory.xml.ParserContext;
053    
054    /**
055     * Camel namespace for the spring XML configuration file.
056     */
057    public class CamelNamespaceHandler extends NamespaceHandlerSupport {
058    
059        private static final transient Log LOG = LogFactory.getLog(CamelNamespaceHandler.class);
060        protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(EndpointFactoryBean.class);
061        protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class);
062        protected Set<String> parserElementNames = new HashSet<String>();
063        protected Binder<Node> binder;
064        private JAXBContext jaxbContext;
065        private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>();
066    
067        public ModelFileGenerator createModelFileGenerator() throws JAXBException {
068            return new ModelFileGenerator(getJaxbContext());
069        }
070    
071        public void init() {
072            // remoting
073            addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class);
074            addBeanDefinitionParser("template", CamelTemplateFactoryBean.class);
075            addBeanDefinitionParser("export", CamelServiceExporter.class);
076    
077            // jmx agent
078            addBeanDefinitionParser("jmxAgent", CamelJMXAgentType.class);
079    
080            // TODO switch to use the above mechanism?
081            registerParser("endpoint", endpointParser);
082    
083            boolean osgi = false;
084            Class cl = CamelContextFactoryBean.class;
085            try {
086                cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean");
087                osgi = true;
088            } catch (Throwable t) {
089                LOG.trace("Cannot find class so assuming not running in OSGI container: " + t.getMessage());
090            }
091    
092            if (osgi) {
093                LOG.info("camel-osgi.jar detected in classpath");
094            } else {
095                LOG.info("camel-osgi.jar not detected in classpath");
096            }
097    
098            if (LOG.isDebugEnabled()) {
099                LOG.debug("Using " + cl.getCanonicalName() + " as CamelContextBeanDefinitionParser");
100            }
101            registerParser("camelContext", new CamelContextBeanDefinitionParser(cl));
102        }
103    
104        private void addBeanDefinitionParser(String elementName, Class<?> type) {
105            BeanDefinitionParser parser = new BeanDefinitionParser(type);
106            registerParser(elementName, parser);
107            parserMap.put(elementName, parser);
108        }
109    
110        protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement, BeanDefinitionBuilder parentBuilder) {
111            String beanPostProcessorId = contextId + ":beanPostProcessor";
112            childElement.setAttribute("id", beanPostProcessorId);
113            BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext);
114            // only register to camel context id as a String. Then we can look it up later
115            // otherwise we get a circular reference in spring and it will not allow custom bean post processing
116            // see more at CAMEL-1663
117            definition.getPropertyValues().addPropertyValue("camelId", contextId);
118            parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId);
119        }
120    
121        protected void registerScriptParser(String elementName, String engineName) {
122            registerParser(elementName, new ScriptDefinitionParser(engineName));
123        }
124    
125        protected void registerParser(String name,
126                                      org.springframework.beans.factory.xml.BeanDefinitionParser parser) {
127            parserElementNames.add(name);
128            registerBeanDefinitionParser(name, parser);
129        }
130    
131        public Set<String> getParserElementNames() {
132            return parserElementNames;
133        }
134    
135        protected Object parseUsingJaxb(Element element, ParserContext parserContext) {
136            try {
137                binder = getJaxbContext().createBinder();
138                return binder.unmarshal(element);
139                /*
140                 * Unmarshaller unmarshaller =
141                 * getJaxbContext().createUnmarshaller(); return
142                 * unmarshaller.unmarshal(element);
143                 */
144            } catch (JAXBException e) {
145                throw new BeanDefinitionStoreException("Failed to parse JAXB element: " + e, e);
146            }
147        }
148    
149        public JAXBContext getJaxbContext() throws JAXBException {
150            if (jaxbContext == null) {
151                jaxbContext = createJaxbContext();
152            }
153            return jaxbContext;
154        }
155    
156        protected JAXBContext createJaxbContext() throws JAXBException {
157            StringBuilder packages = new StringBuilder();
158            for (Class cl : getJaxbPackages()) {
159                if (packages.length() > 0) {
160                    packages.append(":");
161                }
162                packages.append(cl.getName().substring(0, cl.getName().lastIndexOf('.')));
163            }
164            return JAXBContext.newInstance(packages.toString(), getClass().getClassLoader());
165        }
166    
167        protected Set<Class> getJaxbPackages() {
168            Set<Class> classes = new HashSet<Class>();
169            classes.add(org.apache.camel.spring.CamelContextFactoryBean.class);
170            classes.add(ExchangePattern.class);
171            classes.add(org.apache.camel.model.RouteType.class);
172            classes.add(org.apache.camel.model.config.StreamResequencerConfig.class);     
173            classes.add(org.apache.camel.model.dataformat.DataFormatType.class);
174            classes.add(org.apache.camel.model.language.ExpressionType.class);
175            classes.add(org.apache.camel.model.loadbalancer.LoadBalancerType.class);
176            return classes;
177        }
178    
179        protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser {
180            public CamelContextBeanDefinitionParser(Class type) {
181                super(type);
182            }
183    
184            @Override
185            protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
186                super.doParse(element, parserContext, builder);
187    
188                String contextId = element.getAttribute("id");
189    
190                // lets avoid folks having to explicitly give an ID to a camel
191                // context
192                if (ObjectHelper.isNullOrBlank(contextId)) {
193                    contextId = "camelContext";
194                    element.setAttribute("id", contextId);
195                }
196    
197                // now lets parse the routes with JAXB
198                Object value = parseUsingJaxb(element, parserContext);
199                
200                if (value instanceof CamelContextFactoryBean) {
201                    // set the property value with the JAXB parsed value
202                    CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value;
203                    builder.addPropertyValue("id", contextId);
204                    builder.addPropertyValue("routes", factoryBean.getRoutes());
205                    builder.addPropertyValue("intercepts", factoryBean.getIntercepts());
206                    builder.addPropertyValue("dataFormats", factoryBean.getDataFormats());
207                    builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs());
208                    builder.addPropertyValue("properties", factoryBean.getProperties());
209                    if (factoryBean.getPackages().length > 0) {
210                        builder.addPropertyValue("packages", factoryBean.getPackages());
211                    }
212                }
213    
214                boolean createdBeanPostProcessor = false;
215                NodeList list = element.getChildNodes();
216                int size = list.getLength();
217                for (int i = 0; i < size; i++) {
218                    Node child = list.item(i);
219                    if (child instanceof Element) {
220                        Element childElement = (Element)child;
221                        String localName = child.getLocalName();
222                        if (localName.equals("beanPostProcessor")) {
223                            createBeanPostProcessor(parserContext, contextId, childElement, builder);
224                            createdBeanPostProcessor = true;
225                        } else if (localName.equals("endpoint")) {
226                            BeanDefinition definition = endpointParser.parse(childElement, parserContext);
227                            String id = childElement.getAttribute("id");
228                            if (ObjectHelper.isNotNullAndNonEmpty(id)) {
229                                // TODO we can zap this?
230                                definition.getPropertyValues()
231                                    .addPropertyValue("camelContext", new RuntimeBeanReference(contextId));
232                                // definition.getPropertyValues().addPropertyValue("context",
233                                // builder.getBeanDefinition());
234                                parserContext.registerComponent(new BeanComponentDefinition(definition, id));
235                            }
236                        } else {
237                            BeanDefinitionParser parser = parserMap.get(localName);
238                            if (parser != null) {
239                                BeanDefinition definition = parser.parse(childElement, parserContext);
240                                String id = childElement.getAttribute("id");
241                                if (ObjectHelper.isNotNullAndNonEmpty(id)) {
242                                    parserContext.registerComponent(new BeanComponentDefinition(definition, id));
243                                    if (localName.equals("jmxAgent")) {
244                                        builder.addPropertyReference("camelJMXAgent", id);
245                                    }
246                                }
247                            }
248    
249                        }
250                    }
251                }
252                // lets inject the namespaces into any namespace aware POJOs
253                injectNamespaces(element);
254                if (!createdBeanPostProcessor) {
255                    // no bean processor element so lets create it by ourself
256                    Element childElement = element.getOwnerDocument().createElement("beanPostProcessor");
257                    element.appendChild(childElement);
258                    createBeanPostProcessor(parserContext, contextId, childElement, builder);
259                }
260            }
261        }
262    
263        protected void injectNamespaces(Element element) {
264            NodeList list = element.getChildNodes();
265            Namespaces namespaces = null;
266            int size = list.getLength();
267            for (int i = 0; i < size; i++) {
268                Node child = list.item(i);
269                if (child instanceof Element) {
270                    Element childElement = (Element)child;
271                    Object object = binder.getJAXBNode(child);
272                    if (object instanceof NamespaceAware) {
273                        NamespaceAware namespaceAware = (NamespaceAware)object;
274                        if (namespaces == null) {
275                            namespaces = new Namespaces(element);
276                        }
277                        namespaces.configure(namespaceAware);
278                    }
279                    injectNamespaces(childElement);
280                }
281            }
282        }
283    }