andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove BlockingReadHandler from master

Browse Source 
- As mentioned in the developer group:
  - https://groups.google.com/d/topic/netty/ZT0zaZ56eoU/discussion
This commit is contained in:
Trustin Lee 2012-06-12 17:42:36 +09:00
parent 660e4548a6
commit 61e357049e
3 changed files with 0 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

227
handler/src/main/java/io/netty/handler/queue/BlockingReadHandler.java
View File

@ -1,227 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.queue;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.MessageBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.BlockingOperationException;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundMessageHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.util.internal.QueueFactory;
import java.io.IOException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* Emulates blocking read operation. This handler stores all received messages
* into a {@link BlockingQueue} and returns the received messages when
* {@link #read()}, {@link #read(long, TimeUnit)}, {@link #readEvent()}, or
* {@link #readEvent(long, TimeUnit)} method is called.
* <p>
* Please note that this handler is only useful for the cases where there are
* very small number of connections, such as testing and simple client-side
* application development.
* <p>
* Also, any handler placed after this handler will never receive
* {@code messageReceived}, {@code exceptionCaught}, and {@code channelClosed}
* events, hence it should be placed in the last place in a pipeline.
* <p>
* Here is an example that demonstrates the usage:
* <pre>
* {@link BlockingReadHandler}&lt;{@link ByteBuf}&gt; reader =
* new {@link BlockingReadHandler}&lt;{@link ByteBuf}&gt;();
* {@link ChannelPipeline} p = ...;
* p.addLast("reader", reader);
*
* ...
*
* // Read a message from a channel in a blocking manner.
* try {
* {@link ByteBuf} buf = reader.read(60, TimeUnit.SECONDS);
* if (buf == null) {
* // Connection closed.
* } else {
* // Handle the received message here.
* }
* } catch ({@link BlockingReadTimeoutException} e) {
* // Read timed out.
* } catch (IOException e) {
* // Other read errors
* }
* </pre>
*
* @param <E> the type of the received messages
*/
public class BlockingReadHandler<E> extends ChannelInboundMessageHandlerAdapter<Object> {
private static final Object INACTIVE = new Object();
private volatile ChannelHandlerContext ctx;
private final BlockingQueue<Object> queue;
private volatile boolean closed;
/**
* Creates a new instance with the default unbounded {@link BlockingQueue}
* implementation.
*/
public BlockingReadHandler() {
this(QueueFactory.createQueue());
}
/**
* Creates a new instance with the specified {@link BlockingQueue}.
*/
public BlockingReadHandler(BlockingQueue<Object> queue) {
if (queue == null) {
throw new NullPointerException("queue");
}
this.queue = queue;
}
@Override
public MessageBuf<Object> newInboundBuffer(
ChannelHandlerContext ctx) throws Exception {
this.ctx = ctx;
return Unpooled.wrappedBuffer(queue);
}
/**
* Returns {@code true} if and only if the {@link Channel} associated with
* this handler has been closed.
*/
public boolean isClosed() {
return closed;
}
/**
* Waits until a new message is received or the associated {@link Channel}
* is closed.
*
* @return the received message or {@code null} if the associated
* {@link Channel} has been closed
* @throws IOException
* if failed to receive a new message
* @throws InterruptedException
* if the operation has been interrupted
*/
public E read() throws IOException, InterruptedException {
return filter(readEvent());
}
/**
* Waits until a new message is received or the associated {@link Channel}
* is closed.
*
* @param timeout
* the amount time to wait until a new message is received.
* If no message is received within the timeout,
* {@link BlockingReadTimeoutException} is thrown.
* @param unit
* the unit of {@code timeout}
*
* @return the received message or {@code null} if the associated
* {@link Channel} has been closed
* @throws BlockingReadTimeoutException
* if no message was received within the specified timeout
* @throws IOException
* if failed to receive a new message
* @throws InterruptedException
* if the operation has been interrupted
*/
public E read(long timeout, TimeUnit unit) throws IOException, InterruptedException {
return filter(readEvent(timeout, unit));
}
@SuppressWarnings("unchecked")
private E filter(Object e) throws IOException {
if (e == null || e == INACTIVE) {
return null;
}
if (e instanceof IOException) {
throw (IOException) e;
}
if (e instanceof Throwable) {
throw (IOException) new IOException().initCause((Throwable) e);
}
return (E) e;
}
private Object readEvent() throws InterruptedException {
detectDeadLock();
if (isClosed()) {
return null;
}
return queue.take();
}
private Object readEvent(long timeout, TimeUnit unit) throws InterruptedException, BlockingReadTimeoutException {
detectDeadLock();
if (isClosed()) {
return null;
}
Object o = queue.poll(timeout, unit);
if (o == null) {
throw new BlockingReadTimeoutException();
} else {
return o;
}
}
private void detectDeadLock() {
if (ctx.executor().inEventLoop()) {
throw new BlockingOperationException();
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
addEvent(INACTIVE);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx,
Throwable cause) throws Exception {
addEvent(cause);
}
@Override
public void afterRemove(ChannelHandlerContext ctx) throws Exception {
addEvent(INACTIVE);
}
private void addEvent(Object e) {
if (!closed) {
if (e == INACTIVE) {
closed = true;
}
queue.add(e);
}
}
@Override
public void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
// TODO Auto-generated method stub
}
}

56
handler/src/main/java/io/netty/handler/queue/BlockingReadTimeoutException.java
View File

@ -1,56 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.queue;
import java.io.IOException;
import java.io.InterruptedIOException;
/**
* A {@link IOException} raised by {@link BlockingReadHandler} when no data
* was read within a certain period of time.
*/
public class BlockingReadTimeoutException extends InterruptedIOException {
private static final long serialVersionUID = 356009226872649493L;
/**
* Creates a new instance.
*/
public BlockingReadTimeoutException() {
}
/**
* Creates a new instance.
*/
public BlockingReadTimeoutException(String message, Throwable cause) {
super(message);
initCause(cause);
}
/**
* Creates a new instance.
*/
public BlockingReadTimeoutException(String message) {
super(message);
}
/**
* Creates a new instance.
*/
public BlockingReadTimeoutException(Throwable cause) {
initCause(cause);
}
}

24
handler/src/main/java/io/netty/handler/queue/package-info.java
View File

@ -1,24 +0,0 @@
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
/**
* The special-purpose handlers that store an event into an internal queue
* instead of propagating the event immediately.
*
* @apiviz.exclude \.channel\.
* @apiviz.exclude Exception$
*/
package io.netty.handler.queue;