26 | * The most common use case of this interface is to intercept an I/O request 27 | * such as {@link Channel#write(Object)} and {@link Channel#close()}. 28 | * 29 | *
31 | * In most cases, you will get to use a {@link SimpleChannelDownstreamHandler} 32 | * to implement a downstream handler because it provides an individual handler 33 | * method for each event type. You might want to implement this interface 34 | * directly though if you want to handle various types of events in more 35 | * generic way. 36 | * 37 | *
39 | * You can forward the received event downstream or upstream. In most cases, 40 | * {@link ChannelDownstreamHandler} will send the event downstream 41 | * (i.e. outbound) although it is legal to send the event upstream (i.e. inbound): 42 | * 43 | *
44 | * // Sending the event downstream (outbound)
45 | * void handleDownstream({@link ChannelHandlerContext} ctx, {@link ChannelEvent} e) throws Exception {
46 | * ...
47 | * ctx.sendDownstream(e);
48 | * ...
49 | * }
50 | *
51 | * // Sending the event upstream (inbound)
52 | * void handleDownstream({@link ChannelHandlerContext} ctx, {@link ChannelEvent} e) throws Exception {
53 | * ...
54 | * ctx.sendUpstream(new {@link UpstreamChannelStateEvent}(...));
55 | * ...
56 | * }
57 | *
58 | *
59 | * 61 | * You will also find various helper methods in {@link Channels} to be useful 62 | * to generate and send an artificial or manipulated event. 63 | *
64 | * Caution: 65 | *
66 | * Use the *Later(..) methods of the {@link Channels} class if you want to send an upstream event 67 | * from a {@link ChannelDownstreamHandler} otherwise you may run into threading issues. 68 | * 69 | *
75 | * {@link #handleDownstream(ChannelHandlerContext, ChannelEvent) handleDownstream} 76 | * may be invoked by more than one thread simultaneously. If the handler 77 | * accesses a shared resource or stores stateful information, you might need 78 | * proper synchronization in the handler implementation. 79 | * 80 | * @apiviz.exclude ^org\.jboss\.netty\.handler\..*$ 81 | */ 82 | public interface ChannelDownstreamHandler extends ChannelHandler { 83 | 84 | /** 85 | * Handles the specified downstream event. 86 | * 87 | * @param ctx the context object for this handler 88 | * @param e the downstream event to process or intercept 89 | */ 90 | void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception; 91 | } 92 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/ChannelFactory.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | import java.util.concurrent.Executor; 19 | 20 | import org.jboss.netty.channel.event.ChannelEvent; 21 | import org.jboss.netty.channel.socket.nio.server.NioServerSocketChannelFactory; 22 | import org.jboss.netty.util.ExternalResourceReleasable; 23 | 24 | 25 | /** 26 | * The main interface to a transport that creates a {@link Channel} associated 27 | * with a certain communication entity such as a network socket. For example, 28 | * the {@link NioServerSocketChannelFactory} creates a channel which has a 29 | * NIO-based server socket as its underlying communication entity. 30 | *
31 | * Once a new {@link Channel} is created, the {@link ChannelPipeline} which 32 | * was specified as a parameter in the {@link #newChannel(ChannelPipeline)} 33 | * is attached to the new {@link Channel}, and starts to handle all associated 34 | * {@link ChannelEvent}s. 35 | * 36 | *
38 | * To shut down a network application service which is managed by a factory. 39 | * you should follow the following steps: 40 | *
46 | * For detailed transport-specific information on shutting down a factory, 47 | * please refer to the Javadoc of {@link ChannelFactory}'s subtypes, such as 48 | * {@link NioServerSocketChannelFactory}. 49 | * 50 | * @apiviz.landmark 51 | * @apiviz.has org.jboss.netty.channel.skeleton.Channel oneway - - creates 52 | * 53 | * @apiviz.exclude ^org\.jboss\.netty\.channel\.([a-z]+\.)+.*ChannelFactory$ 54 | */ 55 | public interface ChannelFactory extends ExternalResourceReleasable { 56 | 57 | /** 58 | * Creates and opens a new {@link Channel} and attaches the specified 59 | * {@link ChannelPipeline} to the new {@link Channel}. 60 | * 61 | * @param pipeline the {@link ChannelPipeline} which is going to be 62 | * attached to the new {@link Channel} 63 | * 64 | * @return the newly open channel 65 | * 66 | * @throws org.jboss.netty.channel.exception.ChannelException if failed to create and open a new channel 67 | */ 68 | Channel newChannel(ChannelPipeline pipeline); 69 | 70 | /** 71 | * Shudown the ChannelFactory and all the resource it created internal. 72 | */ 73 | void shutdown(); 74 | 75 | /** 76 | * Releases the external resources that this factory depends on to function. 77 | * An external resource is a resource that this factory didn't create by 78 | * itself. For example, {@link Executor}s that you specified in the factory 79 | * constructor are external resources. You can call this method to release 80 | * all external resources conveniently when the resources are not used by 81 | * this factory or any other part of your application. An unexpected 82 | * behavior will be resulted in if the resources are released when there's 83 | * an open channel which is managed by this factory. 84 | * 85 | * This will also call {@link #shutdown()} before do any action 86 | */ 87 | void releaseExternalResources(); 88 | } 89 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/ChannelPipelineFactory.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | import org.jboss.netty.bootstrap.Bootstrap; 19 | import org.jboss.netty.bootstrap.ClientBootstrap; 20 | 21 | /** 22 | * Creates a new {@link ChannelPipeline} for a new {@link Channel}. 23 | *
24 | * When a {@linkplain ServerChannel server-side channel} accepts a new incoming 25 | * connection, a new child channel is created for each newly accepted connection. 26 | * A new child channel uses a new {@link ChannelPipeline}, which is created by 27 | * the {@link ChannelPipelineFactory} specified in the server-side channel's 28 | * {@link ChannelConfig#getPipelineFactory() "pipelineFactory"} option. 29 | *
30 | * Also, when a {@link ClientBootstrap} or {@link ConnectionlessBootstrap} 31 | * creates a new channel, it uses the {@link Bootstrap#getPipelineFactory() "pipelineFactory"} 32 | * property to create a new {@link ChannelPipeline} for each new channel. 33 | * 34 | * @apiviz.has org.jboss.netty.channel.skeleton.ChannelPipeline oneway - - creates 35 | */ 36 | public interface ChannelPipelineFactory { 37 | 38 | /** 39 | * Returns a newly created {@link ChannelPipeline}. 40 | */ 41 | ChannelPipeline getPipeline() throws Exception; 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/ChannelSink.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | 19 | import org.jboss.netty.channel.event.ChannelEvent; 20 | import org.jboss.netty.channel.exception.ChannelPipelineException; 21 | import org.jboss.netty.channel.future.ChannelFuture; 22 | 23 | /** 24 | * Receives and processes the terminal downstream {@link ChannelEvent}s. 25 | *
26 | * A {@link ChannelSink} is an internal component which is supposed to be 27 | * implemented by a transport provider. Most users will not see this type 28 | * in their code. 29 | * 30 | * @apiviz.uses org.jboss.netty.channel.skeleton.ChannelPipeline - - sends events upstream 31 | */ 32 | public interface ChannelSink { 33 | 34 | /** 35 | * Invoked by {@link ChannelPipeline} when a downstream {@link ChannelEvent} 36 | * has reached its terminal (the head of the pipeline). 37 | */ 38 | void eventSunk(ChannelPipeline pipeline, ChannelEvent e) throws Exception; 39 | 40 | /** 41 | * Invoked by {@link ChannelPipeline} when an exception was raised while 42 | * one of its {@link ChannelHandler}s process a {@link ChannelEvent}. 43 | */ 44 | void exceptionCaught(ChannelPipeline pipeline, ChannelEvent e, ChannelPipelineException cause) throws Exception; 45 | 46 | /** 47 | * Execute the given {@link Runnable} later in the io-thread. 48 | * Some implementation may not support this and just execute it directly. 49 | */ 50 | ChannelFuture execute(ChannelPipeline pipeline, Runnable task); 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/FileRegion.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | import java.io.IOException; 19 | import java.nio.channels.FileChannel; 20 | import java.nio.channels.WritableByteChannel; 21 | 22 | import org.jboss.netty.util.ExternalResourceReleasable; 23 | 24 | /** 25 | * A region of a file that is sent via a {@link Channel} which supports 26 | * zero-copy file transfer. 27 | * 28 | *
24 | * It calculates the close-to-optimal capacity of the {@link ChannelBuffer} 25 | * for the next read operation depending on the actual number of read bytes 26 | * in the previous read operation. More accurate the prediction is, more 27 | * effective the memory utilization will be. 28 | *
29 | * Once a read operation is performed and the actual number of read bytes is 30 | * known, an I/O thread will call {@link #previousReceiveBufferSize(int)} to 31 | * update the predictor so it can predict more accurately next time. 32 | */ 33 | public interface ReceiveBufferSizePredictor { 34 | 35 | /** 36 | * Predicts the capacity of the {@link ChannelBuffer} for the next 37 | * read operation depending on the actual number of read bytes in the 38 | * previous read operation. 39 | * 40 | * @return the expected number of readable bytes this time 41 | */ 42 | int nextReceiveBufferSize(); 43 | 44 | /** 45 | * Updates this predictor by specifying the actual number of read bytes 46 | * in the previous read operation. 47 | * 48 | * @param previousReceiveBufferSize 49 | * the actual number of read bytes in the previous read operation 50 | */ 51 | void previousReceiveBufferSize(int previousReceiveBufferSize); 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/ReceiveBufferSizePredictorFactory.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | /** 19 | * Creates a new {@link ReceiveBufferSizePredictor}. 20 | * 21 | * @apiviz.has org.jboss.netty.channel.skeleton.ReceiveBufferSizePredictor oneway - - creates 22 | */ 23 | public interface ReceiveBufferSizePredictorFactory { 24 | 25 | /** 26 | * Returns a newly created {@link ReceiveBufferSizePredictor}. 27 | */ 28 | ReceiveBufferSizePredictor getPredictor() throws Exception; 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/ServerChannel.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | import org.jboss.netty.channel.socket.ServerSocketChannel; 19 | 20 | /** 21 | * A {@link Channel} that accepts an incoming connection attempt and creates 22 | * its child {@link Channel}s by accepting them. {@link ServerSocketChannel} is 23 | * a good example. 24 | */ 25 | public interface ServerChannel extends Channel { 26 | // This is a tag interface. 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/ServerChannelFactory.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core; 17 | 18 | /** 19 | * A {@link ChannelFactory} that creates a {@link ServerChannel}. 20 | * 21 | * @apiviz.has org.jboss.netty.channel.skeleton.ServerChannel oneway - - creates 22 | */ 23 | public interface ServerChannelFactory extends ChannelFactory { 24 | ServerChannel newChannel(ChannelPipeline pipeline); 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/impl/AbstractChannelSink.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core.impl; 17 | 18 | import org.jboss.netty.channel.event.ChannelEvent; 19 | import org.jboss.netty.channel.exception.ChannelPipelineException; 20 | import org.jboss.netty.channel.future.ChannelFuture; 21 | import org.jboss.netty.channel.core.ChannelHandler; 22 | import org.jboss.netty.channel.core.ChannelPipeline; 23 | import org.jboss.netty.channel.core.ChannelSink; 24 | import org.jboss.netty.channel.core.Channels; 25 | 26 | /** 27 | * A skeletal {@link ChannelSink} implementation. 28 | */ 29 | public abstract class AbstractChannelSink implements ChannelSink { 30 | 31 | /** 32 | * Creates a new instance. 33 | */ 34 | protected AbstractChannelSink() { 35 | } 36 | 37 | /** 38 | * Sends an {@link org.jboss.netty.channel.event.ExceptionEvent} upstream with the specified 39 | * {@code cause}. 40 | * 41 | * @param event the {@link ChannelEvent} which caused a 42 | * {@link ChannelHandler} to raise an exception 43 | * @param cause the exception raised by a {@link ChannelHandler} 44 | */ 45 | public void exceptionCaught(ChannelPipeline pipeline, 46 | ChannelEvent event, ChannelPipelineException cause) throws Exception { 47 | Throwable actualCause = cause.getCause(); 48 | if (actualCause == null) { 49 | actualCause = cause; 50 | } 51 | if (isFireExceptionCaughtLater(event, actualCause)) { 52 | Channels.fireExceptionCaughtLater(event.getChannel(), actualCause); 53 | } else { 54 | Channels.fireExceptionCaught(event.getChannel(), actualCause); 55 | } 56 | } 57 | 58 | /** 59 | * Returns {@code true} if and only if the specified {@code actualCause}, which was raised while 60 | * handling the specified {@code event}, must trigger an {@code exceptionCaught()} event in 61 | * an I/O thread. 62 | * 63 | * @param event the event which raised exception 64 | * @param actualCause the raised exception 65 | */ 66 | protected boolean isFireExceptionCaughtLater(ChannelEvent event, Throwable actualCause) { 67 | return false; 68 | } 69 | 70 | /** 71 | * This implementation just directly call {@link Runnable#run()}. 72 | * Sub-classes should override this if they can handle it in a better way 73 | */ 74 | public ChannelFuture execute(ChannelPipeline pipeline, Runnable task) { 75 | try { 76 | task.run(); 77 | return Channels.succeededFuture(pipeline.getChannel()); 78 | } catch (Throwable t) { 79 | return Channels.failedFuture(pipeline.getChannel(), t); 80 | } 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /src/main/java/org/jboss/netty/channel/core/impl/AbstractServerChannel.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2012 The Netty Project 3 | * 4 | * The Netty Project licenses this file to you under the Apache License, 5 | * version 2.0 (the "License"); you may not use this file except in compliance 6 | * with the License. You may obtain a copy of the License at: 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 13 | * License for the specific language governing permissions and limitations 14 | * under the License. 15 | */ 16 | package org.jboss.netty.channel.core.impl; 17 | 18 | import org.jboss.netty.channel.future.ChannelFuture; 19 | import org.jboss.netty.channel.core.Channel; 20 | import org.jboss.netty.channel.core.ChannelFactory; 21 | import org.jboss.netty.channel.core.ChannelPipeline; 22 | import org.jboss.netty.channel.core.ChannelSink; 23 | import org.jboss.netty.channel.core.ServerChannel; 24 | 25 | import java.net.SocketAddress; 26 | 27 | /** 28 | * A skeletal server-side {@link Channel} implementation. A server-side 29 | * {@link Channel} does not allow the following operations: 30 | *
| Name | Associated setter method | 35 | *
|---|---|
| {@code "backlog"} | {@link #setBacklog(int)} | 37 | *
| {@code "reuseAddress"} | {@link #setReuseAddress(boolean)} | 39 | *
| {@code "receiveBufferSize"} | {@link #setReceiveBufferSize(int)} | 41 | *
25 | * {@link InternalLoggerFactory}.setDefaultFactory(new {@link Log4JLoggerFactory}());
26 | *
27 | * Please note that the new default factory is effective only for the classes
28 | * which were loaded after the default factory is changed. Therefore,
29 | * {@link #setDefaultFactory(InternalLoggerFactory)} should be called as early
30 | * as possible and shouldn't be called more than once.
31 | *
32 | * @apiviz.landmark
33 | * @apiviz.has org.jboss.netty.logging.InternalLogger oneway - - creates
34 | */
35 | public abstract class InternalLoggerFactory {
36 | private static volatile InternalLoggerFactory defaultFactory = new JdkLoggerFactory();
37 |
38 | /**
39 | * Returns the default factory. The initial default factory is
40 | * {@link JdkLoggerFactory}.
41 | */
42 | public static InternalLoggerFactory getDefaultFactory() {
43 | return defaultFactory;
44 | }
45 |
46 | /**
47 | * Changes the default factory.
48 | */
49 | public static void setDefaultFactory(InternalLoggerFactory defaultFactory) {
50 | if (defaultFactory == null) {
51 | throw new NullPointerException("defaultFactory");
52 | }
53 | InternalLoggerFactory.defaultFactory = defaultFactory;
54 | }
55 |
56 | /**
57 | * Creates a new logger instance with the name of the specified class.
58 | */
59 | public static InternalLogger getInstance(Class clazz) {
60 | return getInstance(clazz.getName());
61 | }
62 |
63 | /**
64 | * Creates a new logger instance with the specified name.
65 | */
66 | public static InternalLogger getInstance(String name) {
67 | return getDefaultFactory().newInstance(name);
68 | }
69 |
70 | /**
71 | * Creates a new logger instance with the specified name.
72 | */
73 | public abstract InternalLogger newInstance(String name);
74 | }
75 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/logging/JdkLogger.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.logging;
17 |
18 | import java.util.logging.Level;
19 | import java.util.logging.Logger;
20 |
21 | /**
22 | * java.util.logging
23 | * logger.
24 | */
25 | class JdkLogger extends AbstractInternalLogger {
26 |
27 | private final Logger logger;
28 | private final String loggerName;
29 |
30 | JdkLogger(Logger logger, String loggerName) {
31 | this.logger = logger;
32 | this.loggerName = loggerName;
33 | }
34 |
35 | public void debug(String msg) {
36 | logger.logp(Level.FINE, loggerName, null, msg);
37 | }
38 |
39 | public void debug(String msg, Throwable cause) {
40 | logger.logp(Level.FINE, loggerName, null, msg, cause);
41 | }
42 |
43 | public void error(String msg) {
44 | logger.logp(Level.SEVERE, loggerName, null, msg);
45 | }
46 |
47 | public void error(String msg, Throwable cause) {
48 | logger.logp(Level.SEVERE, loggerName, null, msg, cause);
49 | }
50 |
51 | public void info(String msg) {
52 | logger.logp(Level.INFO, loggerName, null, msg);
53 | }
54 |
55 | public void info(String msg, Throwable cause) {
56 | logger.logp(Level.INFO, loggerName, null, msg, cause);
57 | }
58 |
59 | public boolean isDebugEnabled() {
60 | return logger.isLoggable(Level.FINE);
61 | }
62 |
63 | public boolean isErrorEnabled() {
64 | return logger.isLoggable(Level.SEVERE);
65 | }
66 |
67 | public boolean isInfoEnabled() {
68 | return logger.isLoggable(Level.INFO);
69 | }
70 |
71 | public boolean isWarnEnabled() {
72 | return logger.isLoggable(Level.WARNING);
73 | }
74 |
75 | public void warn(String msg) {
76 | logger.logp(Level.WARNING, loggerName, null, msg);
77 | }
78 |
79 | public void warn(String msg, Throwable cause) {
80 | logger.logp(Level.WARNING, loggerName, null, msg, cause);
81 | }
82 |
83 | @Override
84 | public String toString() {
85 | return loggerName;
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/logging/JdkLoggerFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.logging;
17 |
18 |
19 | import java.util.logging.Logger;
20 |
21 | /**
22 | * Logger factory which creates a
23 | * java.util.logging
24 | * logger.
25 | */
26 | public class JdkLoggerFactory extends InternalLoggerFactory {
27 |
28 | @Override
29 | public InternalLogger newInstance(String name) {
30 | final Logger logger =
31 | Logger.getLogger(name);
32 | return new JdkLogger(logger, name);
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/util/DebugUtil.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.util;
17 |
18 | import org.jboss.netty.channel.core.ChannelPipeline;
19 | import org.jboss.netty.channel.core.ChannelSink;
20 | import org.jboss.netty.util.internal.SystemPropertyUtil;
21 |
22 | /**
23 | * Determines if Netty is running in a debug mode or not. Please note that
24 | * this is not a Java debug mode. You can enable Netty debug mode by
25 | * specifying the {@code "org.jboss.netty.debug"} system property (e.g.
26 | * {@code java -Dorg.jboss.netty.debug ...})
27 | * 28 | * If debug mode is disabled (default), the stack trace of the exceptions are 29 | * compressed to help debugging a user application. 30 | *
31 | * If debug mode is enabled, the stack trace of the exceptions raised in
32 | * {@link ChannelPipeline} or {@link ChannelSink} are retained as it is to help
33 | * debugging Netty.
34 | */
35 | public final class DebugUtil {
36 |
37 | private static final boolean DEBUG_ENABLED =
38 | SystemPropertyUtil.getBoolean("org.jboss.netty.debug", false);
39 |
40 | /**
41 | * Returns {@code true} if and only if Netty debug mode is enabled.
42 | */
43 | public static boolean isDebugEnabled() {
44 | return DEBUG_ENABLED;
45 | }
46 |
47 | private DebugUtil() {
48 | // Unused
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/util/EstimatableObjectWrapper.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.util;
17 |
18 | /**
19 | * Represents an object which contains another object that needs to be taken
20 | * into account by {@link ObjectSizeEstimator} for more accurate object size
21 | * estimation.
22 | */
23 | public interface EstimatableObjectWrapper {
24 |
25 | /**
26 | * Returns the underlying object that needs to be taken into account
27 | * by {@link ObjectSizeEstimator} for more accurate object size estimation.
28 | */
29 | Object unwrap();
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/util/ExternalResourceReleasable.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.util;
17 |
18 | /**
19 | * A common interface for a class which depends on external resources that
20 | * need explicit release or shutdown.
21 | * @apiviz.landmark
22 | */
23 | public interface ExternalResourceReleasable {
24 |
25 | /**
26 | * Releases the external resources that this object depends on. You should
27 | * not call this method if the external resources (e.g. thread pool) are
28 | * in use by other objects.
29 | */
30 | void releaseExternalResources();
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/util/ExternalResourceUtil.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.util;
17 |
18 | /**
19 | * A utility class that provides the convenient shutdown of
20 | * {@link ExternalResourceReleasable}s.
21 | */
22 | public final class ExternalResourceUtil {
23 |
24 | /**
25 | * Releases the specified {@link ExternalResourceReleasable}s.
26 | */
27 | public static void release(ExternalResourceReleasable... releasables) {
28 | ExternalResourceReleasable[] releasablesCopy =
29 | new ExternalResourceReleasable[releasables.length];
30 |
31 | for (int i = 0; i < releasables.length; i ++) {
32 | if (releasables[i] == null) {
33 | throw new NullPointerException("releasables[" + i + ']');
34 | }
35 | releasablesCopy[i] = releasables[i];
36 | }
37 |
38 | for (ExternalResourceReleasable e: releasablesCopy) {
39 | e.releaseExternalResources();
40 | }
41 | }
42 |
43 | private ExternalResourceUtil() {
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/main/java/org/jboss/netty/util/MapBackedSet.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 The Netty Project
3 | *
4 | * The Netty Project licenses this file to you under the Apache License,
5 | * version 2.0 (the "License"); you may not use this file except in compliance
6 | * with the License. You may obtain a copy of the License at:
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations
14 | * under the License.
15 | */
16 | package org.jboss.netty.util;
17 |
18 | import java.io.Serializable;
19 | import java.util.AbstractSet;
20 | import java.util.Iterator;
21 | import java.util.Map;
22 | import java.util.Set;
23 |
24 | /**
25 | * A {@link Map}-backed {@link Set}.
26 | */
27 | final class MapBackedSet