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.component.netty;
018
019 import java.io.File;
020 import java.net.URI;
021 import java.util.ArrayList;
022 import java.util.List;
023 import java.util.Map;
024
025 import org.apache.camel.LoggingLevel;
026 import org.apache.camel.RuntimeCamelException;
027 import org.apache.camel.util.URISupport;
028 import org.jboss.netty.channel.ChannelDownstreamHandler;
029 import org.jboss.netty.channel.ChannelHandler;
030 import org.jboss.netty.channel.ChannelUpstreamHandler;
031 import org.jboss.netty.channel.SimpleChannelHandler;
032 import org.jboss.netty.handler.codec.serialization.ObjectDecoder;
033 import org.jboss.netty.handler.codec.serialization.ObjectEncoder;
034 import org.jboss.netty.handler.ssl.SslHandler;
035
036 @SuppressWarnings("unchecked")
037 public class NettyConfiguration implements Cloneable {
038 private String protocol;
039 private String host;
040 private int port;
041 private boolean keepAlive = true;
042 private boolean tcpNoDelay = true;
043 private boolean broadcast;
044 private long connectTimeout = 10000;
045 private long timeout = 30000;
046 private boolean reuseAddress = true;
047 private boolean sync = true;
048 private String passphrase;
049 private File keyStoreFile;
050 private File trustStoreFile;
051 private SslHandler sslHandler;
052 private List<ChannelDownstreamHandler> encoders = new ArrayList<ChannelDownstreamHandler>();
053 private List<ChannelUpstreamHandler> decoders = new ArrayList<ChannelUpstreamHandler>();
054 private ChannelHandler handler;
055 private boolean ssl;
056 private long sendBufferSize = 65536;
057 private long receiveBufferSize = 65536;
058 private int corePoolSize = 10;
059 private int maxPoolSize = 100;
060 private String keyStoreFormat;
061 private String securityProvider;
062 private boolean disconnect;
063 private boolean lazyChannelCreation = true;
064 private boolean transferExchange;
065 private boolean disconnectOnNoReply = true;
066 private LoggingLevel noReplyLogLevel = LoggingLevel.WARN;
067
068 /**
069 * Returns a copy of this configuration
070 */
071 public NettyConfiguration copy() {
072 try {
073 NettyConfiguration answer = (NettyConfiguration) clone();
074 // make sure the lists is copied in its own instance
075 List<ChannelDownstreamHandler> encodersCopy = new ArrayList<ChannelDownstreamHandler>(encoders);
076 answer.setEncoders(encodersCopy);
077 List<ChannelUpstreamHandler> decodersCopy = new ArrayList<ChannelUpstreamHandler>(decoders);
078 answer.setDecoders(decodersCopy);
079 return answer;
080 } catch (CloneNotSupportedException e) {
081 throw new RuntimeCamelException(e);
082 }
083 }
084
085 public void parseURI(URI uri, Map<String, Object> parameters, NettyComponent component) throws Exception {
086 protocol = uri.getScheme();
087
088 if ((!protocol.equalsIgnoreCase("tcp")) && (!protocol.equalsIgnoreCase("udp"))) {
089 throw new IllegalArgumentException("Unrecognized Netty protocol: " + protocol + " for uri: " + uri);
090 }
091
092 setHost(uri.getHost());
093 setPort(uri.getPort());
094
095 sslHandler = component.resolveAndRemoveReferenceParameter(parameters, "sslHandler", SslHandler.class, null);
096 passphrase = component.resolveAndRemoveReferenceParameter(parameters, "passphrase", String.class, null);
097 keyStoreFormat = component.getAndRemoveParameter(parameters, "keyStoreFormat", String.class, "JKS");
098 securityProvider = component.getAndRemoveParameter(parameters, "securityProvider", String.class, "SunX509");
099 keyStoreFile = component.resolveAndRemoveReferenceParameter(parameters, "keyStoreFile", File.class, null);
100 trustStoreFile = component.resolveAndRemoveReferenceParameter(parameters, "trustStoreFile", File.class, null);
101
102 List<ChannelDownstreamHandler> referencedEncoders = component.resolveAndRemoveReferenceListParameter(parameters, "encoders", ChannelDownstreamHandler.class, null);
103 addToHandlersList(encoders, referencedEncoders, ChannelDownstreamHandler.class);
104 List<ChannelUpstreamHandler> referencedDecoders = component.resolveAndRemoveReferenceListParameter(parameters, "decoders", ChannelUpstreamHandler.class, null);
105 addToHandlersList(decoders, referencedDecoders, ChannelUpstreamHandler.class);
106
107 if (encoders.isEmpty() && decoders.isEmpty()) {
108 encoders.add(component.resolveAndRemoveReferenceParameter(parameters, "encoder", ChannelDownstreamHandler.class, new ObjectEncoder()));
109 decoders.add(component.resolveAndRemoveReferenceParameter(parameters, "decoder", ChannelUpstreamHandler.class, new ObjectDecoder()));
110 }
111
112 handler = component.resolveAndRemoveReferenceParameter(parameters, "handler", SimpleChannelHandler.class, null);
113
114 Map<String, Object> settings = URISupport.parseParameters(uri);
115 if (settings.containsKey("keepAlive")) {
116 setKeepAlive(Boolean.valueOf((String) settings.get("keepAlive")));
117 }
118 if (settings.containsKey("tcpNoDelay")) {
119 setTcpNoDelay(Boolean.valueOf((String) settings.get("tcpNoDelay")));
120 }
121 if (settings.containsKey("broadcast")) {
122 setBroadcast(Boolean.valueOf((String) settings.get("broadcast")));
123 }
124 if (settings.containsKey("reuseAddress")) {
125 setReuseAddress(Boolean.valueOf((String) settings.get("reuseAddress")));
126 }
127 if (settings.containsKey("connectTimeoutMillis")) {
128 setConnectTimeout(Long.valueOf((String) settings.get("connectTimeoutMillis")));
129 }
130 if (settings.containsKey("sync")) {
131 setTcpNoDelay(Boolean.valueOf((String) settings.get("sync")));
132 }
133 if (settings.containsKey("receiveTimeoutMillis")) {
134 setTimeout(Long.valueOf((String) settings.get("receiveTimeoutMillis")));
135 }
136 if (settings.containsKey("sendBufferSize")) {
137 setSendBufferSize(Long.valueOf((String) settings.get("sendBufferSize")));
138 }
139 if (settings.containsKey("receiveBufferSize")) {
140 setReceiveBufferSize(Long.valueOf((String) settings.get("receiveBufferSize")));
141 }
142 if (settings.containsKey("ssl")) {
143 setTcpNoDelay(Boolean.valueOf((String) settings.get("ssl")));
144 }
145 if (settings.containsKey("corePoolSize")) {
146 setCorePoolSize(Integer.valueOf((String) settings.get("corePoolSize")));
147 }
148 if (settings.containsKey("maxPoolSize")) {
149 setMaxPoolSize(Integer.valueOf((String) settings.get("maxPoolSize")));
150 }
151 if (settings.containsKey("disconnect")) {
152 setDisconnect(Boolean.valueOf((String) settings.get("disconnect")));
153 }
154 if (settings.containsKey("lazyChannelCreation")) {
155 setLazyChannelCreation(Boolean.valueOf((String) settings.get("lazyChannelCreation")));
156 }
157 if (settings.containsKey("transferExchange")) {
158 setTransferExchange(Boolean.valueOf((String) settings.get("transferExchange")));
159 }
160 if (settings.containsKey("disconnectOnNoReply")) {
161 setDisconnectOnNoReply(Boolean.valueOf((String) settings.get("disconnectOnNoReply")));
162 }
163 if (settings.containsKey("noReplyLogLevel")) {
164 setNoReplyLogLevel(LoggingLevel.valueOf((String) settings.get("noReplyLogLevel")));
165 }
166 }
167
168 public String getProtocol() {
169 return protocol;
170 }
171
172 public void setProtocol(String protocol) {
173 this.protocol = protocol;
174 }
175
176 public String getHost() {
177 return host;
178 }
179
180 public void setHost(String host) {
181 this.host = host;
182 }
183
184 public int getPort() {
185 return port;
186 }
187
188 public void setPort(int port) {
189 this.port = port;
190 }
191
192 public boolean isKeepAlive() {
193 return keepAlive;
194 }
195
196 public void setKeepAlive(boolean keepAlive) {
197 this.keepAlive = keepAlive;
198 }
199
200 public boolean isTcpNoDelay() {
201 return tcpNoDelay;
202 }
203
204 public void setTcpNoDelay(boolean tcpNoDelay) {
205 this.tcpNoDelay = tcpNoDelay;
206 }
207
208 public boolean isBroadcast() {
209 return broadcast;
210 }
211
212 public void setBroadcast(boolean broadcast) {
213 this.broadcast = broadcast;
214 }
215
216 public long getConnectTimeout() {
217 return connectTimeout;
218 }
219
220 public void setConnectTimeout(long connectTimeout) {
221 this.connectTimeout = connectTimeout;
222 }
223
224 public boolean isReuseAddress() {
225 return reuseAddress;
226 }
227
228 public void setReuseAddress(boolean reuseAddress) {
229 this.reuseAddress = reuseAddress;
230 }
231
232 public boolean isSync() {
233 return sync;
234 }
235
236 public void setSync(boolean sync) {
237 this.sync = sync;
238 }
239
240 public SslHandler getSslHandler() {
241 return sslHandler;
242 }
243
244 public void setSslHandler(SslHandler sslHandler) {
245 this.sslHandler = sslHandler;
246 }
247
248 public List<ChannelDownstreamHandler> getEncoders() {
249 return encoders;
250 }
251
252 public List<ChannelUpstreamHandler> getDecoders() {
253 return decoders;
254 }
255
256 public ChannelDownstreamHandler getEncoder() {
257 return encoders.isEmpty() ? null : encoders.get(0);
258 }
259
260 public void setEncoder(ChannelDownstreamHandler encoder) {
261 if (!encoders.contains(encoder)) {
262 encoders.add(encoder);
263 }
264 }
265
266 public void setEncoders(List<ChannelDownstreamHandler> encoders) {
267 this.encoders = encoders;
268 }
269
270 public ChannelUpstreamHandler getDecoder() {
271 return decoders.isEmpty() ? null : decoders.get(0);
272 }
273
274 public void setDecoder(ChannelUpstreamHandler decoder) {
275 if (!decoders.contains(decoder)) {
276 decoders.add(decoder);
277 }
278 }
279
280 public void setDecoders(List<ChannelUpstreamHandler> decoders) {
281 this.decoders = decoders;
282 }
283
284 public ChannelHandler getHandler() {
285 return handler;
286 }
287
288 public void setHandler(ChannelHandler handler) {
289 this.handler = handler;
290 }
291
292 public long getTimeout() {
293 return timeout;
294 }
295
296 public void setTimeout(long timeout) {
297 this.timeout = timeout;
298 }
299
300 public long getSendBufferSize() {
301 return sendBufferSize;
302 }
303
304 public void setSendBufferSize(long sendBufferSize) {
305 this.sendBufferSize = sendBufferSize;
306 }
307
308 public boolean isSsl() {
309 return ssl;
310 }
311
312 public void setSsl(boolean ssl) {
313 this.ssl = ssl;
314 }
315
316 public long getReceiveBufferSize() {
317 return receiveBufferSize;
318 }
319
320 public void setReceiveBufferSize(long receiveBufferSize) {
321 this.receiveBufferSize = receiveBufferSize;
322 }
323
324 public String getPassphrase() {
325 return passphrase;
326 }
327
328 public void setPassphrase(String passphrase) {
329 this.passphrase = passphrase;
330 }
331
332 public File getKeyStoreFile() {
333 return keyStoreFile;
334 }
335
336 public void setKeyStoreFile(File keyStoreFile) {
337 this.keyStoreFile = keyStoreFile;
338 }
339
340 public File getTrustStoreFile() {
341 return trustStoreFile;
342 }
343
344 public void setTrustStoreFile(File trustStoreFile) {
345 this.trustStoreFile = trustStoreFile;
346 }
347
348 public int getCorePoolSize() {
349 return corePoolSize;
350 }
351
352 public void setCorePoolSize(int corePoolSize) {
353 this.corePoolSize = corePoolSize;
354 }
355
356 public int getMaxPoolSize() {
357 return maxPoolSize;
358 }
359
360 public void setMaxPoolSize(int maxPoolSize) {
361 this.maxPoolSize = maxPoolSize;
362 }
363
364 public String getKeyStoreFormat() {
365 return keyStoreFormat;
366 }
367
368 public void setKeyStoreFormat(String keyStoreFormat) {
369 this.keyStoreFormat = keyStoreFormat;
370 }
371
372 public String getSecurityProvider() {
373 return securityProvider;
374 }
375
376 public void setSecurityProvider(String securityProvider) {
377 this.securityProvider = securityProvider;
378 }
379
380 public boolean isDisconnect() {
381 return disconnect;
382 }
383
384 public void setDisconnect(boolean disconnect) {
385 this.disconnect = disconnect;
386 }
387
388 public boolean isLazyChannelCreation() {
389 return lazyChannelCreation;
390 }
391
392 public void setLazyChannelCreation(boolean lazyChannelCreation) {
393 this.lazyChannelCreation = lazyChannelCreation;
394 }
395
396 public boolean isTransferExchange() {
397 return transferExchange;
398 }
399
400 public void setTransferExchange(boolean transferExchange) {
401 this.transferExchange = transferExchange;
402 }
403
404 public boolean isDisconnectOnNoReply() {
405 return disconnectOnNoReply;
406 }
407
408 public void setDisconnectOnNoReply(boolean disconnectOnNoReply) {
409 this.disconnectOnNoReply = disconnectOnNoReply;
410 }
411
412 public LoggingLevel getNoReplyLogLevel() {
413 return noReplyLogLevel;
414 }
415
416 public void setNoReplyLogLevel(LoggingLevel noReplyLogLevel) {
417 this.noReplyLogLevel = noReplyLogLevel;
418 }
419
420 public String getAddress() {
421 return host + ":" + port;
422 }
423
424 private <T> void addToHandlersList(List configured, List handlers, Class<? extends T> handlerType) {
425 if (handlers != null) {
426 for (int x = 0; x < handlers.size(); x++) {
427 Object handler = handlers.get(x);
428 if (handlerType.isInstance(handler)) {
429 configured.add(handler);
430 }
431 }
432 }
433 }
434
435 }