@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
Object m = e.getMessage();
if (!(m instanceof ChannelBuffer)) {
ctx.sendUpstream(e);
return;
}
ChannelBuffer input = (ChannelBuffer) m;
if (!input.readable()) {
return;
}
ChannelBuffer cumulation = cumulation(ctx);
if (cumulation.readable()) {
cumulation.discardReadBytes();
cumulation.writeBytes(input);
callDecode(ctx, e.getChannel(), cumulation, e.getRemoteAddress());
} else {
callDecode(ctx, e.getChannel(), input, e.getRemoteAddress());
if (input.readable()) {
cumulation.writeBytes(input);
}
}
}
public static void send(MessageEvent event, Integer transactionId, Long connectionId)
throws Exception {
logger.debug("ConnectionResponse::send to " + event.getRemoteAddress());
ChannelBuffer responseBuffer = ChannelBuffers.buffer(4 + 4 + 8);
responseBuffer.writeInt(Action.CONNECT.getId());
responseBuffer.writeInt(transactionId);
responseBuffer.writeLong(connectionId);
logger.debug("ConnectionResponse DUMP: " + Utils.getHexString(responseBuffer.array()));
event.getChannel().write(responseBuffer, event.getRemoteAddress());
}
/* (non-Javadoc)
* @see org.jboss.netty.channel.SimpleChannelHandler#messageReceived(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.MessageEvent)
*/
@Override
public void messageReceived(final ChannelHandlerContext context, final MessageEvent e)
throws Exception {
String decoded;
synchronized (stringWriter) {
// extract the buffer from the message event
final Object message = e.getMessage();
if (!(message instanceof ChannelBuffer)) {
context.sendUpstream(e);
return;
}
final ChannelBuffer buffer = (ChannelBuffer) message;
if (!buffer.readable()) {
return;
}
// read all bytes from the buffer to the decoder stream
final byte[] bytes = new byte[buffer.readableBytes()];
buffer.readBytes(bytes);
writerOutputStream.write(bytes);
writerOutputStream.flush();
decoded = stringWriter.toString();
stringWriter.getBuffer().setLength(0);
}
// push all successfully decoded characters upstream
Channels.fireMessageReceived(context, decoded, e.getRemoteAddress());
}
/**
* {@inheritDoc}
*
* @see
* org.jboss.netty.channel.SimpleChannelUpstreamHandler#messageReceived(org.jboss.netty.channel.ChannelHandlerContext,
* org.jboss.netty.channel.MessageEvent)
*/
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
final SocketAddress remote = e.getRemoteAddress();
ChannelBuffer buff = (ChannelBuffer) e.getMessage();
if (buff.equals(BYE_BUFF)) {
e.getChannel()
.write(BYE_MSG, remote)
.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
future.getChannel().close();
}
});
return;
}
e.getChannel()
.write(e.getMessage(), remote)
.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isSuccess()) {
logger.info(" S:OK");
} else {
logger.info(" S:FAILED");
}
}
});
}
private void handleIncomingConfirmableCoapResponse(ChannelHandlerContext ctx, MessageEvent me) {
InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
CoapResponse coapResponse = (CoapResponse) me.getMessage();
writeEmptyAcknowledgement(remoteEndpoint, coapResponse.getMessageID());
ctx.sendUpstream(me);
}
public static void send(
MessageEvent event, Integer transactionId, List<TorrentStats> torrentStatsList)
throws Exception {
logger.debug("ScrapeResponse::send to " + event.getRemoteAddress());
ChannelBuffer responseBuffer = ChannelBuffers.buffer(4 + 4 + torrentStatsList.size() * 12);
responseBuffer.writeInt(Action.SCRAPE.getId());
responseBuffer.writeInt(transactionId);
for (TorrentStats torrentStats : torrentStatsList) {
responseBuffer.writeInt(torrentStats.seeders);
responseBuffer.writeInt(torrentStats.completed);
responseBuffer.writeInt(torrentStats.leechers);
}
logger.debug("ScrapeResponse DUMP: " + Utils.getHexString(responseBuffer.array()));
event.getChannel().write(responseBuffer, event.getRemoteAddress());
}
private void handleIncomingConfirmableCoapRequest(ChannelHandlerContext ctx, MessageEvent me) {
InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
CoapMessage coapMessage = (CoapMessage) me.getMessage();
IncomingReliableMessageExchange newMessageExchange =
new IncomingReliableMessageExchange(remoteEndpoint, coapMessage.getMessageID());
IncomingMessageExchange oldMessageExchange =
ongoingMessageExchanges.get(remoteEndpoint, coapMessage.getMessageID());
// Check if there is an ongoing
if (oldMessageExchange != null) {
if (oldMessageExchange instanceof IncomingReliableMessageExchange) {
// if the old message exchange is reliable and the empty ACK was already sent send another
// empty ACK
if (((IncomingReliableMessageExchange) oldMessageExchange).isAcknowledgementSent())
writeEmptyAcknowledgement(remoteEndpoint, coapMessage.getMessageID());
}
// if the old message was unreliable and the duplicate message is confirmable send empty ACK
else writeEmptyAcknowledgement(remoteEndpoint, coapMessage.getMessageID());
// As the message is already being processed there is nothing more to do
return;
}
// try to add new reliable message exchange
boolean added = false;
synchronized (monitor) {
Long time = System.currentTimeMillis() + MIN_EMPTY_ACK_DELAY_MILLIS;
// Add message exchange to set of ongoing exchanges to detect duplicates
if (!ongoingMessageExchanges.contains(remoteEndpoint, coapMessage.getMessageID())) {
ongoingMessageExchanges.put(remoteEndpoint, coapMessage.getMessageID(), newMessageExchange);
added = true;
}
// If the scheduling of the empty ACK does not work then it was already scheduled
if (!emptyAcknowledgementSchedule.put(time, newMessageExchange)) {
log.error("Could not schedule empty ACK for message: {}", coapMessage);
ongoingMessageExchanges.remove(remoteEndpoint, coapMessage.getMessageID());
added = false;
}
}
// everything is fine, so further process message
if (added) ctx.sendUpstream(me);
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
HttpRequest request = (HttpRequest) e.getMessage();
if (request.getContent().readableBytes() == 0) {
BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");
return;
}
transportMetrics.messagesReceived.mark();
transportMetrics.messagesReceivedSize.update(request.getContent().readableBytes());
// logger.debug("Received {}", request.getContent().toString(CharsetUtil.UTF_8));
String contentTypeHeader = request.getHeader(CONTENT_TYPE);
if (contentTypeHeader == null) {
contentTypeHeader = BaseTransport.CONTENT_TYPE_PLAIN;
}
String decodedContent;
if (BaseTransport.CONTENT_TYPE_FORM.equals(contentTypeHeader)) {
QueryStringDecoder decoder =
new QueryStringDecoder("?" + request.getContent().toString(CharsetUtil.UTF_8));
List<String> d = decoder.getParameters().get("d");
if (d == null) {
BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");
return;
}
decodedContent = d.get(0);
} else {
decodedContent = request.getContent().toString(CharsetUtil.UTF_8);
}
if (decodedContent.length() == 0) {
BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");
return;
}
String[] messages = MAPPER.readValue(decodedContent, String[].class);
for (String message : messages) {
SockJsMessage jsMessage = new SockJsMessage(message);
ctx.sendUpstream(new UpstreamMessageEvent(e.getChannel(), jsMessage, e.getRemoteAddress()));
}
if (isJsonpEnabled) {
BaseTransport.respond(e.getChannel(), OK, "ok");
} else {
BaseTransport.respond(e.getChannel(), NO_CONTENT, "");
}
}
static MessageEvent consolidateComposite(MessageEvent e) {
// Convert a composite buffer into a simple buffer to save memory
// bandwidth on full write buffer.
// This method should be eliminated once gathering write works.
Object m = e.getMessage();
if (m instanceof CompositeChannelBuffer) {
e =
new DownstreamMessageEvent(
e.getChannel(),
e.getFuture(),
((CompositeChannelBuffer) m).copy(),
e.getRemoteAddress());
}
return e;
}
private void handleIncomingConfirmableCoapMessage(ChannelHandlerContext ctx, MessageEvent me) {
InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
CoapMessage coapMessage = (CoapMessage) me.getMessage();
// Empty CON messages can be used as application layer PING (is CoAP endpoints alive?)
if (coapMessage.getMessageCodeName() == MessageCode.Name.EMPTY)
writeReset(remoteEndpoint, coapMessage.getMessageID());
else if (MessageCode.isResponse(coapMessage.getMessageCode()))
handleIncomingConfirmableCoapResponse(ctx, me);
else if (MessageCode.isRequest(coapMessage.getMessageCode()))
handleIncomingConfirmableCoapRequest(ctx, me);
else
log.error("Incoming CoAP message is neither empty nor request nor response: ", coapMessage);
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
ChannelBuffer buf = (ChannelBuffer) e.getMessage();
while (buf.readable()) {
char c = ((char) buf.readByte());
if (c == ';') {
processNotification(
queueArn.toString(),
e.getRemoteAddress() != null ? e.getRemoteAddress().toString() : "");
// start reading new message
queueArn = new StringBuffer("");
} else {
queueArn.append(c);
}
}
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
if (e.getMessage() instanceof Pressluft) {
Pressluft prsslft = ((Pressluft) e.getMessage());
switch (prsslft.getType()) {
case QUERY:
handleQuery(Query.fromByteArray(prsslft.getPayload()), e.getChannel());
break;
case RESULT:
handleResult(Result.fromByteArray(prsslft.getPayload()), e.getRemoteAddress());
break;
default:
logger.error("can not handle pressluft : " + prsslft.getType());
break;
}
}
}
/**
* If the incoming message is a confirmable {@link CoapRequest} it schedules the sending of an
* empty acknowledgement to the sender if there wasn't a piggy-backed response within a period of
* 2 seconds.
*
* <p>If the incoming message is a confirmable {@link CoapResponse} it immediately sends a proper
* acknowledgement if there was an open request waiting for a seperate response or
* update-notification. It immediately sends an RST if there was no such response expected.
*
* @param ctx The {@link ChannelHandlerContext} relating this handler (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 occured
*/
@Override
public void messageReceived(final ChannelHandlerContext ctx, MessageEvent me) throws Exception {
log.debug("Upstream from {}: {}.", me.getRemoteAddress(), me.getMessage());
if (isShutdown()) return;
if (me.getMessage() instanceof CoapMessage) {
CoapMessage coapMessage = (CoapMessage) me.getMessage();
if (coapMessage.getMessageTypeName() == MessageType.Name.CON)
handleIncomingConfirmableCoapMessage(ctx, me);
else if (coapMessage.getMessageTypeName() == MessageType.Name.NON)
handleIncomingNonConfirmableMessage(ctx, me);
else ctx.sendUpstream(me);
} else ctx.sendUpstream(me);
}
/* (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);
}
}
@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 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 messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
if (e.getMessage() == null) {
return;
} else if (e.getMessage() instanceof byte[]) {
byte[] bytes = (byte[]) e.getMessage();
Object msg;
if (bytes.length == 0) {
msg = Heartbeat.getSingleton();
} else {
try {
msg = serializer.deserialize(bytes);
} catch (Exception ex) {
throw ex;
}
}
UpstreamMessageEvent event =
new UpstreamMessageEvent(e.getChannel(), msg, e.getRemoteAddress());
super.messageReceived(ctx, event);
} else {
super.messageReceived(ctx, e);
}
}
public void eventSunk(ChannelPipeline pipeline, ChannelEvent e) throws Exception {
OioDatagramChannel channel = (OioDatagramChannel) e.getChannel();
ChannelFuture future = e.getFuture();
if (e instanceof ChannelStateEvent) {
ChannelStateEvent stateEvent = (ChannelStateEvent) e;
ChannelState state = stateEvent.getState();
Object value = stateEvent.getValue();
switch (state) {
case OPEN:
if (Boolean.FALSE.equals(value)) {
OioDatagramWorker.close(channel, future);
}
break;
case BOUND:
if (value != null) {
bind(channel, future, (SocketAddress) value);
} else {
OioDatagramWorker.close(channel, future);
}
break;
case CONNECTED:
if (value != null) {
connect(channel, future, (SocketAddress) value);
} else {
OioDatagramWorker.disconnect(channel, future);
}
break;
case INTEREST_OPS:
OioDatagramWorker.setInterestOps(channel, future, ((Integer) value).intValue());
break;
}
} else if (e instanceof MessageEvent) {
MessageEvent evt = (MessageEvent) e;
OioDatagramWorker.write(channel, future, evt.getMessage(), evt.getRemoteAddress());
}
}
private void handleIncomingNonConfirmableMessage(ChannelHandlerContext ctx, MessageEvent me) {
InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
CoapMessage coapMessage = (CoapMessage) me.getMessage();
boolean isDuplicate = true;
if (!ongoingMessageExchanges.contains(remoteEndpoint, coapMessage.getMessageID())) {
IncomingMessageExchange messageExchange =
new IncomingMessageExchange(remoteEndpoint, coapMessage.getMessageID());
synchronized (monitor) {
if (!ongoingMessageExchanges.contains(remoteEndpoint, coapMessage.getMessageID())) {
ongoingMessageExchanges.put(remoteEndpoint, coapMessage.getMessageID(), messageExchange);
isDuplicate = false;
}
}
ctx.sendUpstream(me);
}
if (isDuplicate)
log.info("Received duplicate (non-confirmable). IGNORE! (Message: {})", coapMessage);
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent me) {
log.info("Message received from {}", me.getRemoteAddress());
ctx.sendUpstream(me);
}
@Override
public void writeRequested(ChannelHandlerContext ctx, MessageEvent me) {
log.info("Message to be sent to {}", me.getRemoteAddress());
ctx.sendDownstream(me);
}
