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 */ 017package org.apache.camel.model; 018 019import java.util.concurrent.RejectedExecutionHandler; 020import java.util.concurrent.TimeUnit; 021 022import javax.xml.bind.annotation.XmlAccessType; 023import javax.xml.bind.annotation.XmlAccessorType; 024import javax.xml.bind.annotation.XmlAttribute; 025import javax.xml.bind.annotation.XmlRootElement; 026import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 027 028import org.apache.camel.spi.Metadata; 029import org.apache.camel.util.concurrent.ThreadPoolRejectedPolicy; 030 031/** 032 * To configure thread pools 033 */ 034@Metadata(label = "configuration") 035@XmlRootElement(name = "threadPoolProfile") 036@XmlAccessorType(XmlAccessType.FIELD) 037public class ThreadPoolProfileDefinition extends OptionalIdentifiedDefinition<ThreadPoolProfileDefinition> { 038 @XmlAttribute 039 private Boolean defaultProfile; 040 @XmlAttribute 041 private String poolSize; 042 @XmlAttribute 043 private String maxPoolSize; 044 @XmlAttribute 045 private String keepAliveTime; 046 @XmlAttribute 047 @XmlJavaTypeAdapter(TimeUnitAdapter.class) 048 private TimeUnit timeUnit; 049 @XmlAttribute 050 private String maxQueueSize; 051 @XmlAttribute 052 private String allowCoreThreadTimeOut; 053 @XmlAttribute 054 private ThreadPoolRejectedPolicy rejectedPolicy; 055 056 public ThreadPoolProfileDefinition() { 057 } 058 059 @Override 060 public String getShortName() { 061 return "threadPoolProfile"; 062 } 063 064 @Override 065 public String getLabel() { 066 return "ThreadPoolProfile " + getId(); 067 } 068 069 public ThreadPoolProfileDefinition poolSize(int poolSize) { 070 return poolSize("" + poolSize); 071 } 072 073 public ThreadPoolProfileDefinition poolSize(String poolSize) { 074 setPoolSize(poolSize); 075 return this; 076 } 077 078 public ThreadPoolProfileDefinition maxPoolSize(int maxPoolSize) { 079 return maxPoolSize("" + maxQueueSize); 080 } 081 082 public ThreadPoolProfileDefinition maxPoolSize(String maxPoolSize) { 083 setMaxPoolSize("" + maxPoolSize); 084 return this; 085 } 086 087 public ThreadPoolProfileDefinition keepAliveTime(long keepAliveTime) { 088 return keepAliveTime("" + keepAliveTime); 089 } 090 091 public ThreadPoolProfileDefinition keepAliveTime(String keepAliveTime) { 092 setKeepAliveTime("" + keepAliveTime); 093 return this; 094 } 095 096 public ThreadPoolProfileDefinition timeUnit(TimeUnit timeUnit) { 097 setTimeUnit(timeUnit); 098 return this; 099 } 100 101 public ThreadPoolProfileDefinition maxQueueSize(int maxQueueSize) { 102 return maxQueueSize("" + maxQueueSize); 103 } 104 105 public ThreadPoolProfileDefinition maxQueueSize(String maxQueueSize) { 106 setMaxQueueSize("" + maxQueueSize); 107 return this; 108 } 109 110 public ThreadPoolProfileDefinition rejectedPolicy(ThreadPoolRejectedPolicy rejectedPolicy) { 111 setRejectedPolicy(rejectedPolicy); 112 return this; 113 } 114 115 public ThreadPoolProfileDefinition allowCoreThreadTimeOut(boolean allowCoreThreadTimeOut) { 116 setAllowCoreThreadTimeOut("" + allowCoreThreadTimeOut); 117 return this; 118 } 119 120 public Boolean getDefaultProfile() { 121 return defaultProfile; 122 } 123 124 /** 125 * Whether this profile is the default thread pool profile 126 */ 127 public void setDefaultProfile(Boolean defaultProfile) { 128 this.defaultProfile = defaultProfile; 129 } 130 131 public Boolean isDefaultProfile() { 132 return defaultProfile != null && defaultProfile; 133 } 134 135 public String getPoolSize() { 136 return poolSize; 137 } 138 139 /** 140 * Sets the core pool size 141 */ 142 public void setPoolSize(String poolSize) { 143 this.poolSize = poolSize; 144 } 145 146 public String getMaxPoolSize() { 147 return maxPoolSize; 148 } 149 150 /** 151 * Sets the maximum pool size 152 */ 153 public void setMaxPoolSize(String maxPoolSize) { 154 this.maxPoolSize = maxPoolSize; 155 } 156 157 public String getKeepAliveTime() { 158 return keepAliveTime; 159 } 160 161 /** 162 * Sets the keep alive time for idle threads in the pool 163 */ 164 public void setKeepAliveTime(String keepAliveTime) { 165 this.keepAliveTime = keepAliveTime; 166 } 167 168 public String getMaxQueueSize() { 169 return maxQueueSize; 170 } 171 172 /** 173 * Sets the maximum number of tasks in the work queue. 174 * <p/> 175 * Use <tt>-1</tt> or <tt>Integer.MAX_VALUE</tt> for an unbounded queue 176 */ 177 public void setMaxQueueSize(String maxQueueSize) { 178 this.maxQueueSize = maxQueueSize; 179 } 180 181 public String getAllowCoreThreadTimeOut() { 182 return allowCoreThreadTimeOut; 183 } 184 185 /** 186 * Whether idle core threads is allowed to timeout and therefore can shrink 187 * the pool size below the core pool size 188 * <p/> 189 * Is by default <tt>false</tt> 190 */ 191 public void setAllowCoreThreadTimeOut(String allowCoreThreadTimeOut) { 192 this.allowCoreThreadTimeOut = allowCoreThreadTimeOut; 193 } 194 195 public TimeUnit getTimeUnit() { 196 return timeUnit; 197 } 198 199 /** 200 * Sets the time unit to use for keep alive time By default SECONDS is used. 201 */ 202 public void setTimeUnit(TimeUnit timeUnit) { 203 this.timeUnit = timeUnit; 204 } 205 206 public ThreadPoolRejectedPolicy getRejectedPolicy() { 207 return rejectedPolicy; 208 } 209 210 public RejectedExecutionHandler getRejectedExecutionHandler() { 211 if (rejectedPolicy != null) { 212 return rejectedPolicy.asRejectedExecutionHandler(); 213 } 214 return null; 215 } 216 217 /** 218 * Sets the handler for tasks which cannot be executed by the thread pool. 219 */ 220 public void setRejectedPolicy(ThreadPoolRejectedPolicy rejectedPolicy) { 221 this.rejectedPolicy = rejectedPolicy; 222 } 223 224}