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.impl;
018    
019    import java.lang.reflect.ParameterizedType;
020    import java.lang.reflect.Type;
021    import java.util.Map;
022    import java.util.concurrent.ExecutorService;
023    import java.util.concurrent.ScheduledExecutorService;
024    
025    import org.apache.camel.CamelContext;
026    import org.apache.camel.CamelContextAware;
027    import org.apache.camel.Component;
028    import org.apache.camel.Endpoint;
029    import org.apache.camel.Exchange;
030    import org.apache.camel.ExchangePattern;
031    import org.apache.camel.PollingConsumer;
032    import org.apache.camel.util.ObjectHelper;
033    import org.apache.camel.util.concurrent.ExecutorServiceHelper;
034    
035    /**
036     * A default endpoint useful for implementation inheritance
037     *
038     * @version $Revision: 772501 $
039     */
040    public abstract class DefaultEndpoint implements Endpoint, CamelContextAware {
041        private static final int DEFAULT_THREADPOOL_SIZE = 5;
042    
043        private String endpointUri;
044        private CamelContext camelContext;
045        private Component component;
046        private ExecutorService executorService;
047        private ExchangePattern exchangePattern = ExchangePattern.InOnly;
048    
049        protected DefaultEndpoint(String endpointUri, Component component) {
050            this(endpointUri, component.getCamelContext());
051            this.component = component;
052        }
053    
054        protected DefaultEndpoint(String endpointUri, CamelContext camelContext) {
055            this(endpointUri);
056            this.camelContext = camelContext;
057        }
058    
059        protected DefaultEndpoint(String endpointUri) {
060            this.setEndpointUri(endpointUri);
061        }
062    
063        protected DefaultEndpoint() {
064        }
065    
066        public int hashCode() {
067            return getEndpointUri().hashCode() * 37 + 1;
068        }
069    
070        @Override
071        public boolean equals(Object object) {
072            if (object instanceof DefaultEndpoint) {
073                DefaultEndpoint that = (DefaultEndpoint) object;
074                return ObjectHelper.equal(this.getEndpointUri(), that.getEndpointUri());
075            }
076            return false;
077        }
078    
079        @Override
080        public String toString() {
081            return "Endpoint[" + getEndpointUri() + "]";
082        }
083    
084        public String getEndpointUri() {
085            if (endpointUri == null) {
086                endpointUri = createEndpointUri();
087                if (endpointUri == null) {
088                    throw new IllegalArgumentException("endpointUri is not specified and " + getClass().getName()
089                            + " does not implement createEndpointUri() to create a default value");
090                }
091            }
092            return endpointUri;
093        }
094    
095        public CamelContext getCamelContext() {
096            return camelContext;
097        }
098    
099        public Component getComponent() {
100            return component;
101        }
102    
103        public void setCamelContext(CamelContext camelContext) {
104            this.camelContext = camelContext;
105        }
106    
107        public synchronized ExecutorService getExecutorService() {
108            if (executorService == null) {
109                Component c = getComponent();
110                if (c instanceof DefaultComponent) {
111                    DefaultComponent dc = (DefaultComponent) c;
112                    executorService = dc.getExecutorService();
113                }
114                if (executorService == null) {
115                    executorService = createScheduledExecutorService();
116                }
117            }
118            return executorService;
119        }
120        
121        public synchronized ScheduledExecutorService getScheduledExecutorService() {
122            ExecutorService executor = getExecutorService();
123            if (executor instanceof ScheduledExecutorService) {
124                return (ScheduledExecutorService) executor;
125            } else {
126                return createScheduledExecutorService();
127            }
128        }
129    
130        public synchronized void setExecutorService(ExecutorService executorService) {
131            this.executorService = executorService;
132        }
133    
134        public PollingConsumer createPollingConsumer() throws Exception {
135            return new EventDrivenPollingConsumer(this);
136        }
137    
138        /**
139         * Converts the given exchange to the specified exchange type
140         */
141        public Exchange convertTo(Class<Exchange> type, Exchange exchange) {
142            if (type.isInstance(exchange)) {
143                return type.cast(exchange);
144            }
145            return getCamelContext().getExchangeConverter().convertTo(type, exchange);
146        }
147    
148        public Exchange createExchange(Exchange exchange) {
149            Class<Exchange> exchangeType = getExchangeType();
150            if (exchangeType != null) {
151                if (exchangeType.isInstance(exchange)) {
152                    return exchangeType.cast(exchange);
153                }
154            }
155            Exchange answer = createExchange();
156            answer.copyFrom(exchange);
157            return answer;
158        }
159    
160        /**
161         * Returns the type of the exchange which is generated by this component
162         */
163        @SuppressWarnings("unchecked")
164        public Class<Exchange> getExchangeType() {
165            Type type = getClass().getGenericSuperclass();
166            if (type instanceof ParameterizedType) {
167                ParameterizedType parameterizedType = (ParameterizedType) type;
168                Type[] arguments = parameterizedType.getActualTypeArguments();
169                if (arguments.length > 0) {
170                    Type argumentType = arguments[0];
171                    if (argumentType instanceof Class) {
172                        return (Class<Exchange>) argumentType;
173                    }
174                }
175            }
176            return null;
177        }
178    
179        public Exchange createExchange() {
180            return createExchange(getExchangePattern());
181        }
182    
183        public Exchange createExchange(ExchangePattern pattern) {
184            return new DefaultExchange(this, pattern);
185        }
186    
187        public ExchangePattern getExchangePattern() {
188            return exchangePattern;
189        }
190    
191        public void setExchangePattern(ExchangePattern exchangePattern) {
192            this.exchangePattern = exchangePattern;
193        }
194    
195        protected ScheduledExecutorService createScheduledExecutorService() {
196            return ExecutorServiceHelper.newScheduledThreadPool(DEFAULT_THREADPOOL_SIZE, getEndpointUri(), true);
197        }
198    
199        public void configureProperties(Map options) {
200        }
201    
202        /**
203         * A factory method to lazily create the endpointUri if none is specified 
204         */
205        protected String createEndpointUri() {
206            return null;
207        }
208    
209        /**
210         * Sets the endpointUri if it has not been specified yet via some kind of dependency injection mechanism.
211         * This allows dependency injection frameworks such as Spring or Guice to set the default endpoint URI in cases
212         * where it has not been explicitly configured using the name/context in which an Endpoint is created.
213         */
214        public void setEndpointUriIfNotSpecified(String value) {
215            if (endpointUri == null) {
216                setEndpointUri(value);
217            }
218        }
219        protected void setEndpointUri(String endpointUri) {
220            this.endpointUri = endpointUri;
221        }
222    
223        public boolean isLenientProperties() {
224            // default should be false for most components
225            return false;
226        }
227    
228    }