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.model;
018    
019    import java.util.ArrayList;
020    import java.util.List;
021    import java.util.concurrent.BlockingQueue;
022    import java.util.concurrent.ThreadPoolExecutor;
023    
024    import javax.xml.bind.annotation.XmlAccessType;
025    import javax.xml.bind.annotation.XmlAccessorType;
026    import javax.xml.bind.annotation.XmlAttribute;
027    import javax.xml.bind.annotation.XmlElementRef;
028    import javax.xml.bind.annotation.XmlRootElement;
029    import javax.xml.bind.annotation.XmlTransient;
030    
031    import org.apache.camel.Processor;
032    import org.apache.camel.impl.RouteContext;
033    import org.apache.camel.processor.Pipeline;
034    import org.apache.camel.processor.ThreadProcessor;
035    
036    /**
037     * Represents an XML <thread/> element
038     *
039     * @version $Revision: 36865 $
040     */
041    @XmlRootElement(name = "thread")
042    @XmlAccessorType(XmlAccessType.FIELD)
043    public class ThreadType extends ProcessorType<ProcessorType> {
044        @XmlAttribute(required = false)
045        private Integer coreSize = 1;
046        @XmlAttribute(required = false)
047        private Boolean daemon = Boolean.TRUE;
048        @XmlAttribute(required = false)
049        private Long keepAliveTime;
050        @XmlAttribute(required = false)
051        private Integer maxSize = 1;
052        @XmlAttribute(required = false)
053        private String name = "Thread Processor";
054        @XmlAttribute(required = false)
055        private Integer priority = Thread.NORM_PRIORITY;
056        @XmlAttribute(required = false)
057        private Long stackSize;
058        @XmlElementRef
059        private List<ProcessorType<?>> outputs = new ArrayList<ProcessorType<?>>();
060        @XmlTransient
061        private BlockingQueue<Runnable> taskQueue;
062        @XmlTransient
063        private ThreadGroup threadGroup;
064        @XmlTransient
065        private ThreadPoolExecutor executor;
066    
067        public ThreadType() {
068        }
069    
070        public ThreadType(int coreSize) {
071            this.coreSize = coreSize;
072            this.maxSize = coreSize;
073        }
074    
075        public ThreadType(ThreadPoolExecutor executor) {
076            this.executor = executor;
077        }
078    
079        @Override
080        public List<ProcessorType<?>> getOutputs() {
081            return outputs;
082        }
083    
084        @Override
085        public String toString() {
086            return "Thread[" + getLabel() + "]";
087        }
088    
089        @Override
090        public String getLabel() {
091            return "coreSize=" + coreSize;
092        }
093    
094        @Override
095        public Processor createProcessor(RouteContext routeContext) throws Exception {
096    
097            ThreadProcessor thread = new ThreadProcessor();
098            thread.setExecutor(executor);
099            if (coreSize != null) {
100                thread.setCoreSize(coreSize);
101            }
102            if (daemon != null) {
103                thread.setDaemon(daemon);
104            }
105            if (keepAliveTime != null) {
106                thread.setKeepAliveTime(keepAliveTime);
107            }
108            if (maxSize != null) {
109                thread.setMaxSize(maxSize);
110            }
111            thread.setName(name);
112            thread.setPriority(priority);
113            if (stackSize != null) {
114                thread.setStackSize(stackSize);
115            }
116            thread.setTaskQueue(taskQueue);
117            thread.setThreadGroup(threadGroup);
118    
119            // TODO: see if we can avoid creating so many nested pipelines
120    
121            ArrayList<Processor> pipe = new ArrayList<Processor>(2);
122            pipe.add(thread);
123            pipe.add(createOutputsProcessor(routeContext, outputs));
124            return new Pipeline(pipe);
125        }
126    
127        ///////////////////////////////////////////////////////////////////
128        //
129        // Fluent Methods
130        //
131        ///////////////////////////////////////////////////////////////////
132        public ThreadType coreSize(int coreSize) {
133            setCoreSize(coreSize);
134            return this;
135        }
136    
137        public ThreadType daemon(boolean daemon) {
138            setDaemon(daemon);
139            return this;
140        }
141    
142        public ThreadType keepAliveTime(long keepAliveTime) {
143            setKeepAliveTime(keepAliveTime);
144            return this;
145        }
146    
147        public ThreadType maxSize(int maxSize) {
148            setMaxSize(maxSize);
149            return this;
150        }
151    
152        public ThreadType name(String name) {
153            setName(name);
154            return this;
155        }
156    
157        public ThreadType priority(int priority) {
158            setPriority(priority);
159            return this;
160        }
161    
162        public ThreadType stackSize(long stackSize) {
163            setStackSize(stackSize);
164            return this;
165        }
166    
167        public ThreadType taskQueue(BlockingQueue<Runnable> taskQueue) {
168            setTaskQueue(taskQueue);
169            return this;
170        }
171    
172        public ThreadType threadGroup(ThreadGroup threadGroup) {
173            setThreadGroup(threadGroup);
174            return this;
175        }
176    
177        public ThreadType executor(ThreadPoolExecutor executor) {
178            setExecutor(executor);
179            return this;
180        }
181    
182        ///////////////////////////////////////////////////////////////////
183        //
184        // Property Accessors
185        //
186        ///////////////////////////////////////////////////////////////////
187    
188        public void setCoreSize(int coreSize) {
189            this.coreSize = coreSize;
190        }
191    
192        public void setDaemon(boolean daemon) {
193            this.daemon = daemon;
194        }
195    
196        public void setKeepAliveTime(long keepAliveTime) {
197            this.keepAliveTime = keepAliveTime;
198        }
199    
200        public void setMaxSize(int maxSize) {
201            this.maxSize = maxSize;
202        }
203    
204        public void setName(String name) {
205            this.name = name;
206        }
207    
208        public void setPriority(int priority) {
209            this.priority = priority;
210        }
211    
212        public void setStackSize(long stackSize) {
213            this.stackSize = stackSize;
214        }
215    
216        public void setTaskQueue(BlockingQueue<Runnable> taskQueue) {
217            this.taskQueue = taskQueue;
218        }
219    
220        public void setThreadGroup(ThreadGroup threadGroup) {
221            this.threadGroup = threadGroup;
222        }
223    
224        public ThreadPoolExecutor getExecutor() {
225            return executor;
226        }
227    
228        public void setExecutor(ThreadPoolExecutor executor) {
229            this.executor = executor;
230        }
231    }