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