Java tutorial
package com.tesora.dve.db.mysql.portal.protocol; /* * #%L * Tesora Inc. * Database Virtualization Engine * %% * Copyright (C) 2011 - 2014 Tesora Inc. * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License, version 3, * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * #L% */ import com.tesora.dve.db.mysql.libmy.MyMessage; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelDuplexHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPromise; import io.netty.handler.codec.ByteToMessageDecoder; import java.util.List; import com.tesora.dve.exceptions.PECodingException; import com.tesora.dve.exceptions.PEException; import org.slf4j.LoggerFactory; public class MSPProtocolDecoder extends ChannelDuplexHandler { private final static MSPMessage mspMessages[] = { MSPComQueryRequestMessage.PROTOTYPE, MSPComFieldListRequestMessage.PROTOTYPE, MSPComQuitRequestMessage.PROTOTYPE, MSPComSetOptionRequestMessage.PROTOTYPE, MSPComPingRequestMessage.PROTOTYPE, MSPComInitDBRequestMessage.PROTOTYPE, MSPComPrepareStmtRequestMessage.PROTOTYPE, MSPComStmtExecuteRequestMessage.PROTOTYPE, MSPComStmtCloseRequestMessage.PROTOTYPE, MSPComProcessInfoRequestMessage.PROTOTYPE, MSPComStatisticsRequestMessage.PROTOTYPE }; private final static MSPMessage[] messageMap = new MSPMessage[256]; static { for (final MSPMessage m : mspMessages) { messageMap[m.getMysqlMessageType()] = m; } } private final MSPMessage[] messageExecutor; private MyDecoderState currentState; private Packet mspPacket; public boolean firstPacket = true; //TODO: tracking this as a single entry assumes we won't get pipelined requests from the client. -sgossard byte nextSequence = 1; CachedAppendBuffer cachedAppendBuffer = new CachedAppendBuffer(); private final ByteToMessageDecoder decoder = new ByteToMessageDecoder() { @Override public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { MSPProtocolDecoder.this.decode(ctx, in, out); } @Override protected void decodeLast(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { MSPProtocolDecoder.this.decode(ctx, in, out); } }; public MSPProtocolDecoder(MyDecoderState initialState) throws PEException { super(); this.messageExecutor = messageMap; this.currentState = initialState; } @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { decoder.channelInactive(ctx); cachedAppendBuffer.releaseSlab(); if (mspPacket != null) { mspPacket.release(); mspPacket = null; } } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { decoder.channelRead(ctx, msg); } @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof MyMessage) { MyMessage message = (MyMessage) msg; ByteBuf appendableView = cachedAppendBuffer.startAppend(ctx); nextSequence = (byte) (0xFF & Packet.encodeFullMessage(nextSequence, message, appendableView)); ByteBuf writableSlice = cachedAppendBuffer.sliceWritableData(); ctx.write(writableSlice, promise); } else { //forward packet along. ctx.write(msg, promise); } } protected void decode(final ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { try { if (mspPacket == null) { //assumes next full inbound request will have a starting sequence (true except for auth handshake) //also assumes we only get one request at a time (synchronous), which is typical of most mysql clients int seq = firstPacket ? 1 : 0; mspPacket = new Packet(ctx.alloc(), seq, Packet.Modifier.HEAPCOPY_ON_READ, "frontend"); } //deals with the handshake packet firstPacket = false; if (!mspPacket.decodeMore(in)) return; int sequenceId = mspPacket.getSequenceNumber(); this.nextSequence = (byte) (0xFF & mspPacket.getNextSequenceNumber()); //save off the sequence for our outbound response. ByteBuf payload = mspPacket.unwrapPayload().retain();//retain a separate reference to the payload. mspPacket.release(); mspPacket = null; final MyDecoderState state = currentState; switch (state) { case READ_SERVER_GREETING: case READ_CLIENT_AUTH: { MSPMessage authMessage; if (state == MyDecoderState.READ_CLIENT_AUTH) { authMessage = MSPAuthenticateV10MessageMessage.newMessage(payload); } else if (state == MyDecoderState.READ_SERVER_GREETING) { authMessage = new MSPServerGreetingRequestMessage(payload); } else { throw new PECodingException("Unexpected state in packet decoding, " + state); } out.add(authMessage); this.currentState = MyDecoderState.READ_PACKET; break; } case READ_PACKET: out.add(buildMessage(payload, (byte) sequenceId)); break; } } catch (Exception e) { LoggerFactory.getLogger(MSPProtocolDecoder.class).warn("problem decoding frame", e); } finally { } } private MSPMessage buildMessage(final ByteBuf payload, final byte sequenceId) { final byte messageType = payload.getByte(0); //peek at the first byte in the payload to determine message type. try { return this.messageExecutor[messageType].newPrototype(payload); } catch (final Exception e) { return new MSPUnknown(messageType, payload); } } public enum MyDecoderState { READ_SERVER_GREETING, READ_CLIENT_AUTH, READ_PACKET } }