com.rabbitmq.client.impl

Class AMQChannel

java.lang.Object

com.rabbitmq.client.impl.ShutdownNotifierComponent

com.rabbitmq.client.impl.AMQChannel

All Implemented Interfaces:

ShutdownNotifier

Direct Known Subclasses:

ChannelN

public abstract class AMQChannel
extends ShutdownNotifierComponent

Base class modelling an AMQ channel. Subclasses implement Channel.close() and processAsync(), and may choose to override processShutdownSignal() and rpc().

See Also:

ChannelN, Connection

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AMQChannel.BlockingRpcContinuation<T>
static interface	AMQChannel.RpcContinuation
static class	AMQChannel.SimpleBlockingRpcContinuation

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	_blockContent Whether transmission of content-bearing methods should be blocked
protected Object	_channelMutex Protected; used instead of synchronizing on the channel itself, so that clients can themselves use the channel to synchronize on.
protected int	_rpcTimeout Timeout for RPC calls
protected static int	NO_RPC_TIMEOUT

Constructor Summary

Constructors

Constructor and Description
AMQChannel(AMQConnection connection, int channelNumber) Construct a channel on the given connection, with the given channel number.

Method Summary

Modifier and Type	Method and Description
void	asyncRpc(Method m, CompletableFuture<Command> future)
void	enqueueAsyncRpc(Method method, CompletableFuture<Command> future)
void	enqueueRpc(AMQChannel.RpcContinuation k)
void	ensureIsOpen()
CompletableFuture<Command>	exnWrappingAsyncRpc(Method m)
AMQCommand	exnWrappingRpc(Method m) Placeholder until we address bug 15786 (implementing a proper exception hierarchy).
int	getChannelNumber() Public API - Retrieves this channel's channel number.
AMQConnection	getConnection()
void	handleCompleteInboundCommand(AMQCommand command) Private API - handle a command which has been assembled
void	handleFrame(Frame frame) Private API - When the Connection receives a Frame for this channel, it passes it to this method.
boolean	isOutstandingRpc()
protected void	markRpcFinished()
RpcWrapper	nextOutstandingRpc()
void	notifyOutstandingRpc(ShutdownSignalException signal)
abstract boolean	processAsync(Command command) Protected API - called by nextCommand to check possibly handle an incoming Command before it is returned to the caller of nextCommand.
void	processShutdownSignal(ShutdownSignalException signal, boolean ignoreClosed, boolean notifyRpc) Protected API - respond, in the driver thread, to a ShutdownSignalException.
void	quiescingAsyncRpc(Method m, CompletableFuture<Command> future)
void	quiescingRpc(Method m, AMQChannel.RpcContinuation k)
void	quiescingTransmit(AMQCommand c)
void	quiescingTransmit(Method m)
AMQCommand	rpc(Method m) Protected API - sends a Method to the broker and waits for the next in-bound Command from the broker: only for use from non-connection-MainLoop threads!
void	rpc(Method m, AMQChannel.RpcContinuation k)
AMQCommand	rpc(Method m, int timeout)
String	toString()
void	transmit(AMQCommand c)
void	transmit(Method m)
static IOException	wrap(ShutdownSignalException ex) Placeholder until we address bug 15786 (implementing a proper exception hierarchy).
static IOException	wrap(ShutdownSignalException ex, String message)
protected ChannelContinuationTimeoutException	wrapTimeoutException(Method m, TimeoutException e) Cleans RPC channel state after a timeout and wraps the TimeoutException in a ChannelContinuationTimeoutException

Methods inherited from class com.rabbitmq.client.impl.ShutdownNotifierComponent

addShutdownListener, getCloseReason, isOpen, notifyListeners, removeShutdownListener, setShutdownCauseIfOpen

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

NO_RPC_TIMEOUT

protected static final int NO_RPC_TIMEOUT

See Also:

Constant Field Values

_channelMutex

protected final Object _channelMutex

Protected; used instead of synchronizing on the channel itself, so that clients can themselves use the channel to synchronize on.

_blockContent

protected volatile boolean _blockContent

Whether transmission of content-bearing methods should be blocked

_rpcTimeout

protected final int _rpcTimeout

Timeout for RPC calls

Constructor Detail

AMQChannel

public AMQChannel(AMQConnection connection,
                  int channelNumber)

Construct a channel on the given connection, with the given channel number.

Parameters:

connection - the underlying connection for this channel

channelNumber - the allocated reference number for this channel

Method Detail

getChannelNumber

public int getChannelNumber()

Public API - Retrieves this channel's channel number.

Returns:

the channel number

handleFrame

public void handleFrame(Frame frame)
                 throws IOException

Private API - When the Connection receives a Frame for this channel, it passes it to this method.

Parameters:

frame - the incoming frame

Throws:

IOException - if an error is encountered

wrap

public static IOException wrap(ShutdownSignalException ex)

Placeholder until we address bug 15786 (implementing a proper exception hierarchy). In the meantime, this at least won't throw away any information from the wrapped exception.

Parameters:

ex - the exception to wrap

Returns:

the wrapped exception

wrap

public static IOException wrap(ShutdownSignalException ex,
                               String message)

exnWrappingRpc

public AMQCommand exnWrappingRpc(Method m)
                          throws IOException

Placeholder until we address bug 15786 (implementing a proper exception hierarchy).

Throws:

IOException

exnWrappingAsyncRpc

public CompletableFuture<Command> exnWrappingAsyncRpc(Method m)
                                               throws IOException

Throws:

IOException

handleCompleteInboundCommand

public void handleCompleteInboundCommand(AMQCommand command)
                                  throws IOException

Private API - handle a command which has been assembled

Parameters:

command - the incoming command

Throws:

IOException - if there's any problem

IOException

enqueueRpc

public void enqueueRpc(AMQChannel.RpcContinuation k)

enqueueAsyncRpc

public void enqueueAsyncRpc(Method method,
                            CompletableFuture<Command> future)

isOutstandingRpc

public boolean isOutstandingRpc()

nextOutstandingRpc

public RpcWrapper nextOutstandingRpc()

markRpcFinished

protected void markRpcFinished()

ensureIsOpen

public void ensureIsOpen()
                  throws AlreadyClosedException

Throws:

AlreadyClosedException

rpc

public AMQCommand rpc(Method m)
               throws IOException,
                      ShutdownSignalException

Protected API - sends a Method to the broker and waits for the next in-bound Command from the broker: only for use from non-connection-MainLoop threads!

Throws:

IOException

ShutdownSignalException

rpc

public AMQCommand rpc(Method m,
                      int timeout)
               throws IOException,
                      ShutdownSignalException,
                      TimeoutException

Throws:

IOException

ShutdownSignalException

TimeoutException

wrapTimeoutException

protected ChannelContinuationTimeoutException wrapTimeoutException(Method m,
                                                                   TimeoutException e)

Cleans RPC channel state after a timeout and wraps the TimeoutException in a ChannelContinuationTimeoutException

rpc

public void rpc(Method m,
                AMQChannel.RpcContinuation k)
         throws IOException

Throws:

IOException

quiescingRpc

public void quiescingRpc(Method m,
                         AMQChannel.RpcContinuation k)
                  throws IOException

Throws:

IOException

asyncRpc

public void asyncRpc(Method m,
                     CompletableFuture<Command> future)
              throws IOException

Throws:

IOException

quiescingAsyncRpc

public void quiescingAsyncRpc(Method m,
                              CompletableFuture<Command> future)
                       throws IOException

Throws:

IOException

processAsync

public abstract boolean processAsync(Command command)
                              throws IOException

Protected API - called by nextCommand to check possibly handle an incoming Command before it is returned to the caller of nextCommand. If this method returns true, the command is considered handled and is not passed back to nextCommand's caller; if it returns false, nextCommand returns the command as usual. This is used in subclasses to implement handling of Basic.Return and Basic.Deliver messages, as well as Channel.Close and Connection.Close.

Parameters:

command - the command to handle asynchronously

Returns:

true if we handled the command; otherwise the caller should consider it "unhandled"

Throws:

IOException

toString

public String toString()

Overrides:

toString in class Object

processShutdownSignal

public void processShutdownSignal(ShutdownSignalException signal,
                                  boolean ignoreClosed,
                                  boolean notifyRpc)

Protected API - respond, in the driver thread, to a ShutdownSignalException.

Parameters:

signal - the signal to handle

ignoreClosed - the flag indicating whether to ignore the AlreadyClosedException thrown when the channel is already closed

notifyRpc - the flag indicating whether any remaining rpc continuation should be notified with the given signal

notifyOutstandingRpc

public void notifyOutstandingRpc(ShutdownSignalException signal)

transmit

public void transmit(Method m)
              throws IOException

Throws:

IOException

transmit

public void transmit(AMQCommand c)
              throws IOException

Throws:

IOException

quiescingTransmit

public void quiescingTransmit(Method m)
                       throws IOException

Throws:

IOException

quiescingTransmit

public void quiescingTransmit(AMQCommand c)
                       throws IOException

Throws:

IOException

getConnection

public AMQConnection getConnection()