public void handleDownstream(final ChannelHandlerContext context, final ChannelEvent evt)
throws Exception {
if (evt instanceof ChannelStateEvent) {
ChannelStateEvent e = (ChannelStateEvent) evt;
switch (e.getState()) {
case OPEN:
case CONNECTED:
case BOUND:
if (Boolean.FALSE.equals(e.getValue()) || e.getValue() == null) {
closeOutboundAndChannel(context, e);
return;
}
}
}
if (!(evt instanceof MessageEvent)) {
context.sendDownstream(evt);
return;
}
MessageEvent e = (MessageEvent) evt;
if (!(e.getMessage() instanceof ChannelBuffer)) {
context.sendDownstream(evt);
return;
}
// Do not encrypt the first write request if this handler is
// created with startTLS flag turned on.
if (startTls && sentFirstMessage.compareAndSet(false, true)) {
context.sendDownstream(evt);
return;
}
// Otherwise, all messages are encrypted.
ChannelBuffer msg = (ChannelBuffer) e.getMessage();
PendingWrite pendingWrite;
if (msg.readable()) {
pendingWrite =
new PendingWrite(
evt.getFuture(), msg.toByteBuffer(msg.readerIndex(), msg.readableBytes()));
} else {
pendingWrite = new PendingWrite(evt.getFuture(), null);
}
synchronized (pendingUnencryptedWrites) {
boolean offered = pendingUnencryptedWrites.offer(pendingWrite);
assert offered;
}
wrap(context, evt.getChannel());
}
@Override
public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
if (_encodeCipher != null) {
MessageEvent m = Util.code(_encodeCipher, e, false);
ctx.sendDownstream(m);
}
}
private void handleApplicationShutdown(ChannelHandlerContext ctx, MessageEvent me) {
synchronized (monitor) {
this.shutdown = true;
emptyAcknowledgementSchedule.clear();
ongoingMessageExchanges.clear();
}
ctx.sendDownstream(me);
}
@Override
public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent channelEvent)
throws Exception {
if (channelEvent instanceof MessageEvent) {
final MessageEvent msgEvent = (MessageEvent) channelEvent;
this.outgoingMessage(ctx, msgEvent);
}
ctx.sendDownstream(channelEvent);
}
/**
* If the message to be written is a {@link CoapResponse} this method decides whether the message
* type is {@link MessageType.Name#ACK} (if there wasn't an empty acknowledgement sent yet) or
* {@link MessageType.Name#CON} (if there was already an empty acknowledgement sent). In the
* latter case it additionally cancels the sending of an empty acknowledgement (which was
* scheduled by the <code>messageReceived</code> method when the request was received).
*
* @param ctx The {@link ChannelHandlerContext} connecting relating this class (which implements
* the {@link ChannelUpstreamHandler} interface) to the datagramChannel that received the
* message.
* @param me the {@link MessageEvent} containing the actual message
* @throws Exception if an error occurred
*/
@Override
public void writeRequested(ChannelHandlerContext ctx, MessageEvent me) throws Exception {
if (isShutdown()) return;
if (me.getMessage() instanceof CoapResponse) handleOutgoingCoapResponse(ctx, me);
else if (me.getMessage() instanceof InternalApplicationShutdownMessage)
handleApplicationShutdown(ctx, me);
else ctx.sendDownstream(me);
}
private void closeOutboundAndChannel(
final ChannelHandlerContext context, final ChannelStateEvent e) throws SSLException {
if (!e.getChannel().isConnected()) {
context.sendDownstream(e);
return;
}
unwrap(context, e.getChannel(), ChannelBuffers.EMPTY_BUFFER, 0, 0);
if (!engine.isInboundDone()) {
if (sentCloseNotify.compareAndSet(false, true)) {
engine.closeOutbound();
ChannelFuture closeNotifyFuture = wrapNonAppData(context, e.getChannel());
closeNotifyFuture.addListener(new ClosingChannelFutureListener(context, e));
return;
}
}
context.sendDownstream(e);
}
@Override
public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
// Log all channel state changes.
if (e instanceof ChannelStateEvent) {
// logger.trace("server : channel state changed: " + e);
}
// Sending the event downstream (outbound)
ctx.sendDownstream(e);
// super.handleDownstream(ctx, e);
}
@Override
public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent evt) throws Exception {
if (!(evt instanceof MessageEvent)) {
ctx.sendDownstream(evt);
return;
}
MessageEvent e = (MessageEvent) evt;
Object originalMessage = e.getMessage();
if (originalMessage instanceof ChannelBuffer) {
// 对于ChannelBuffer不尝试编码
ctx.sendDownstream(evt);
} else {
ChannelBuffer encodedMessage = encode(ctx, e.getChannel(), originalMessage);
if (encodedMessage != null) {
Channels.write(ctx, e.getFuture(), encodedMessage, e.getRemoteAddress());
}
}
}
private void sendHeader(ChannelHandlerContext ctx) throws IOException {
headerSent = true;
logger.info(
"Authenticating with Found Elasticsearch at [{}] on connection [{}]",
ctx.getChannel().getRemoteAddress(),
ctx.getChannel().getLocalAddress());
ChannelBuffer message = new FoundTransportHeader(clusterName.value(), apiKey).getHeaderBuffer();
ctx.sendDownstream(
new DownstreamMessageEvent(
ctx.getChannel(),
Channels.succeededFuture(ctx.getChannel()),
message,
ctx.getChannel().getRemoteAddress()));
}
private void flushPendingEncryptedWrites(ChannelHandlerContext ctx) {
// Avoid possible dead lock and data integrity issue
// which is caused by cross communication between more than one channel
// in the same VM.
if (!pendingEncryptedWritesLock.tryLock()) {
return;
}
try {
MessageEvent e;
while ((e = pendingEncryptedWrites.poll()) != null) {
ctx.sendDownstream(e);
}
} finally {
pendingEncryptedWritesLock.unlock();
}
}
/* (non-Javadoc)
* @see org.jboss.netty.channel.SimpleChannelHandler#writeRequested(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.MessageEvent)
*/
@Override
public void writeRequested(final ChannelHandlerContext context, final MessageEvent e)
throws Exception {
// extract the string from the message event
final Object message = e.getMessage();
if (!(message instanceof String)) {
context.sendDownstream(e);
return;
}
String string = (String) message;
// encode the string into a buffer
ByteOrder byteOrder = context.getChannel().getConfig().getBufferFactory().getDefaultOrder();
ChannelBuffer buffer = copiedBuffer(byteOrder, string, Charset.forName("utf-8"));
// send the buffer downstream
Channels.write(context, e.getFuture(), buffer, e.getRemoteAddress());
}
@Override
public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
if (e instanceof MessageEvent) {
MessageEvent event = (MessageEvent) e;
ChannelBuffer buffer = (ChannelBuffer) event.getMessage();
while (buffer.readableBytes() > 0) {
ChannelBuffer newBuffer = ChannelBuffers.dynamicBuffer();
if (buffer.readableBytes() >= chunkSize) {
newBuffer.writeBytes(buffer.readBytes(chunkSize));
} else {
newBuffer.writeBytes(buffer.readBytes(buffer.readableBytes()));
}
Thread.sleep(latency);
write(ctx, e.getFuture(), newBuffer, event.getRemoteAddress());
}
} else {
ctx.sendDownstream(e);
}
}
private void handleOutgoingCoapResponse(ChannelHandlerContext ctx, MessageEvent me) {
CoapResponse coapResponse = (CoapResponse) me.getMessage();
InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
IncomingMessageExchange messageExchange;
synchronized (monitor) {
messageExchange = ongoingMessageExchanges.remove(remoteEndpoint, coapResponse.getMessageID());
}
if (messageExchange instanceof IncomingReliableMessageExchange) {
// if the ongoing message exchange is reliable and the empty ACK was not yet sent make
// response piggy-
// backed and suppress scheduled empty ACK
if (!((IncomingReliableMessageExchange) messageExchange).isAcknowledgementSent()) {
coapResponse.setMessageType(MessageType.Name.ACK.getNumber());
((IncomingReliableMessageExchange) messageExchange).setAcknowledgementSent();
}
}
ctx.sendDownstream(me);
}
@Override
public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
ctx.sendDownstream(e);
}
@Override
public void writeRequested(ChannelHandlerContext ctx, MessageEvent me) {
log.info("Message to be sent to {}", me.getRemoteAddress());
ctx.sendDownstream(me);
}