#1431 - Refactor internals for RemoteTransactionEvent binary serialisation

This commit is contained in:
rob bygrave committed 2018-06-17 22:25:45 +12:00
1 parent 4f1f3cadf9
commit e1d4159453
21 files changed
+306 -553

No files matched your search

@@ -0,0 +1,41 @@
package io.ebeaninternal.server.cluster;
import io.ebeaninternal.api.BinaryReadContext;
import io.ebeaninternal.api.SpiEbeanServer;
import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
import java.io.IOException;
/**
* Mechanism to convert RemoteTransactionEvent to/from byte[] content.
*/
public class BinaryTransactionEventReader {
private final ServerLookup serverLookup;
public BinaryTransactionEventReader(ServerLookup serverLookup) {
this.serverLookup = serverLookup;
}
/**
* Read Transaction from bytes.
*/
public RemoteTransactionEvent read(byte[] byteData) throws IOException {
return read(new BinaryReadContext(byteData));
}
/**
* Read Transaction using BinaryReadContext.
*/
public RemoteTransactionEvent read(BinaryReadContext dataInput) throws IOException {
String serverName = dataInput.readUTF();
SpiEbeanServer server = (SpiEbeanServer) serverLookup.getServer(serverName);
if (server == null) {
throw new IllegalStateException("EbeanServer not found for name [" + serverName + "]");
}
RemoteTransactionEvent event = new RemoteTransactionEvent(server);
event.readBinary(dataInput);
return event;
}
}
@@ -13,7 +13,7 @@ import java.util.concurrent.ConcurrentHashMap;
/**
* Manages the cluster service.
*/
public class ClusterManager implements MessageServerProvider {
public class ClusterManager implements ServerLookup {
private static final Logger clusterLogger = LoggerFactory.getLogger("io.ebean.Cluster");
@@ -5,7 +5,7 @@ import io.ebean.EbeanServer;
/**
* Returns EbeanServer instances for remote message reading.
*/
public interface MessageServerProvider {
public interface ServerLookup {
/**
* Return the EbeanServer instance by name.
@@ -1,75 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
import io.ebeaninternal.api.SpiEbeanServer;
import io.ebeaninternal.api.TransactionEventTable;
import io.ebeaninternal.server.cache.RemoteCacheEvent;
import io.ebeaninternal.server.cluster.MessageServerProvider;
import io.ebeaninternal.server.transaction.BeanPersistIds;
import io.ebeaninternal.server.transaction.RemoteTableMod;
import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
/**
* Reads the binary message returning RemoteTransactionEvent.
*/
class BinaryDataReader {
private final MessageServerProvider serverProvider;
private final DataInputStream dataInput;
private SpiEbeanServer server;
private RemoteTransactionEvent event;
BinaryDataReader(MessageServerProvider serverProvider, byte[] data) {
this.serverProvider = serverProvider;
this.dataInput = new DataInputStream(new ByteArrayInputStream(data));
}
/**
* Read the binary message returning a RemoteTransactionEvent.
*/
RemoteTransactionEvent read() throws IOException {
String serverName = dataInput.readUTF();
this.server = (SpiEbeanServer) serverProvider.getServer(serverName);
if (server == null) {
throw new IllegalStateException("EbeanServer not found for name [" + serverName + "]");
}
this.event = new RemoteTransactionEvent(server);
boolean more = dataInput.readBoolean();
while (more) {
readMessage();
more = dataInput.readBoolean();
}
return event;
}
private void readMessage() throws IOException {
int msgType = dataInput.readInt();
switch (msgType) {
case BinaryMessage.TYPE_BEANIUD:
event.addBeanPersistIds(BeanPersistIds.readBinaryMessage(server, dataInput));
break;
case BinaryMessage.TYPE_TABLEIUD:
event.addTableIUD(TransactionEventTable.TableIUD.readBinaryMessage(dataInput));
break;
case BinaryMessage.TYPE_CACHE:
event.addRemoteCacheEvent(RemoteCacheEvent.readBinaryMessage(dataInput));
break;
case BinaryMessage.TYPE_TABLEMOD:
event.addRemoteTableMod(RemoteTableMod.readBinaryMessage(dataInput));
break;
default:
throw new RuntimeException("Invalid Transaction msgType " + msgType);
}
}
}
@@ -1,49 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
/**
* Writes BinaryMessageList to DataHolder raw byte[].
*/
class BinaryDataWriter {
private final BinaryMessageList messageList;
private final ByteArrayOutputStream buffer;
private final DataOutputStream dataOut;
private final String serverName;
BinaryDataWriter(String serverName, BinaryMessageList messageList) {
this.serverName = serverName;
this.messageList = messageList;
this.buffer = new ByteArrayOutputStream(256);
this.dataOut = new DataOutputStream(buffer);
}
/**
* Write the message as raw byte[].
*/
byte[] write() throws IOException {
//TODO: Add Protocol version and "podId" to support pubsub cluster
//dataOut.writeInt(MsgKeys.MESSAGE_KEY);
dataOut.writeUTF(serverName);
for (BinaryMessage msg : messageList.getList()) {
write(msg);
}
dataOut.writeBoolean(false);
dataOut.flush();
return buffer.toByteArray();
}
private void write(BinaryMessage msg) throws IOException {
dataOut.writeBoolean(true);
dataOut.write(msg.getByteArray());
}
}
@@ -1,60 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
/**
* Represents a relatively small independent message.
* <p>
* In general terms we break up a potentially large object like
* RemoteTransactionEvent into many smaller BinaryMessages. This is so that if
* they don't all fit on a single Packet we can easily break them up and put
* them on multiple packets.
* </p>
* <p>
* Also note that for the Multicast approach a Packet will generally contain
* many messages each directed to different members of the cluster. So it would
* be common for many Ack, Resend and Control messages to all be contained in a
* single packet.
* </p>
*/
public class BinaryMessage {
public static final int TYPE_MSGCONTROL = 0;
public static final int TYPE_BEANIUD = 1;
public static final int TYPE_TABLEIUD = 2;
public static final int TYPE_CACHE = 3;
public static final int TYPE_TABLEMOD = 4;
public static final int TYPE_MSGACK = 8;
public static final int TYPE_MSGRESEND = 9;
private final ByteArrayOutputStream buffer;
private final DataOutputStream os;
private byte[] bytes;
/**
* Create with an estimated buffer size.
*/
public BinaryMessage(int bufSize) {
this.buffer = new ByteArrayOutputStream(bufSize);
this.os = new DataOutputStream(buffer);
}
/**
* Return the DataOutputStream to write content to.
*/
public DataOutputStream getOs() {
return os;
}
/**
* Return all the content as a byte array.
*/
public byte[] getByteArray() {
if (bytes == null) {
bytes = buffer.toByteArray();
}
return bytes;
}
}
@@ -1,21 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
import java.util.ArrayList;
import java.util.List;
/**
* Holds a List of BinaryMessage's.
*/
public class BinaryMessageList {
final List<BinaryMessage> list = new ArrayList<>();
public void add(BinaryMessage msg) {
list.add(msg);
}
public List<BinaryMessage> getList() {
return list;
}
}
@@ -1,147 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
/**
* The message broadcast around the cluster.
*/
public class ClusterMessage {
private static final int MAX_LENGTH = 10 * 1024 * 1024;
private final String registerIp;
private final String podName;
private final boolean register;
private final byte[] data;
/**
* Create a register message.
*/
public static ClusterMessage register(String registerIp, boolean register, String podName) {
return new ClusterMessage(registerIp, register, podName);
}
/**
* Create a transaction message.
*/
public static ClusterMessage transEvent(byte[] data) {
return new ClusterMessage(data);
}
/**
* Create for register online/offline message.
*/
private ClusterMessage(String registerIp, boolean register, String podName) {
this.registerIp = registerIp;
this.register = register;
this.podName = podName;
this.data = null;
}
/**
* Create for a transaction message.
*/
private ClusterMessage(byte[] data) {
this.data = data;
this.registerIp = null;
this.podName = null;
this.register = false;
}
public String toString() {
StringBuilder sb = new StringBuilder();
if (registerIp != null) {
sb.append("register ");
sb.append(register);
sb.append(" ");
sb.append(registerIp);
} else {
sb.append("[data]");
}
return sb.toString();
}
/**
* Return true if this is a register event as opposed to a transaction message.
*/
public boolean isRegisterEvent() {
return registerIp != null;
}
/**
* Return the register host for online/offline message.
*/
public String getRegisterIp() {
return registerIp;
}
public String getPodName() {
return podName;
}
/**
* Return true if register is true for a online/offline message.
*/
public boolean isRegister() {
return register;
}
/**
* Return the raw message data.
*/
public byte[] getData() {
return data;
}
/**
* Write the message in binary form.
*/
public void write(DataOutputStream dataOutput) throws IOException {
if (data != null) {
// write data message
dataOutput.writeInt(MsgKeys.DATA);
dataOutput.writeInt(data.length);
dataOutput.write(data);
} else {
// write header message
dataOutput.writeInt(MsgKeys.HEADER);
dataOutput.writeUTF(getRegisterIp());
dataOutput.writeBoolean(register);
dataOutput.writeUTF(getPodName());
}
dataOutput.flush();
}
/**
* Read the message from binary form.
*/
public static ClusterMessage read(DataInputStream dataInput) throws IOException, InvalidMessageException {
int key = dataInput.readInt();
if (key == MsgKeys.DATA) {
int length = dataInput.readInt();
if (length > MAX_LENGTH) {
throw new IOException("Message data too large length:"+length);
}
byte[] data = new byte[length];
dataInput.readFully(data);
return new ClusterMessage(data);
} else if (key == MsgKeys.HEADER) {
String host = dataInput.readUTF();
boolean registered = dataInput.readBoolean();
String podName = dataInput.readUTF();
return new ClusterMessage(host, registered, podName);
} else {
throw new InvalidMessageException("Invalid message key:" + key);
}
}
}
@@ -1,8 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
public class InvalidMessageException extends Exception {
public InvalidMessageException(String message) {
super(message);
}
}
@@ -1,37 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
import io.ebeaninternal.server.cluster.MessageServerProvider;
import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
import java.io.IOException;
/**
* Mechanism to convert RemoteTransactionEvent to/from byte[] content.
*/
public class MessageReadWrite {
private final MessageServerProvider serverProvider;
public MessageReadWrite(MessageServerProvider serverProvider) {
this.serverProvider = serverProvider;
}
/**
* Convert the RemoteTransactionEvent to raw byte[] content.
*/
public byte[] write(RemoteTransactionEvent transEvent) throws IOException {
BinaryMessageList messageList = new BinaryMessageList();
transEvent.writeBinaryMessage(messageList);
return new BinaryDataWriter(transEvent.getServerName(), messageList).write();
}
/**
* Convert the byte[] content to RemoteTransactionEvent.
*/
public RemoteTransactionEvent read(byte[] data) throws IOException {
return new BinaryDataReader(serverProvider, data).read();
}
}
@@ -1,19 +0,0 @@
package io.ebeaninternal.server.cluster.binarymessage;
public interface MsgKeys {
/**
* Used to identify client on connection initiation.
*/
int HELLO = 182;
/**
* Used to confirm protocol on reading messages.
*/
int HEADER = 11;
/**
* Used to confirm protocol on reading messages.
*/
int DATA = 12;
}