public void addBuff(byte[] buff)
{
if (buff == null || buff.Length == 0)
{
return;
}
RecvBuffer.AddRange(buff);
if (RecvBuffer.Count <= 2)
{
return;
}
UInt16 len = (UInt16)System.Net.IPAddress.HostToNetworkOrder((short)BitConverter.ToUInt16(RecvBuffer.ToArray(), 0));
int total = len + 2;
if (RecvBuffer.Count < total)
{
return;
}
byte[] tbuff = new byte[len];
RecvBuffer.CopyTo(2, tbuff, 0, len);
RecvPacket.BeginRead(tbuff);
RecvBuffer.RemoveRange(0, total);
}
private bool TryReadNextMessage()
{
MessageHeader nextMessageHeader = default(MessageHeader);
int bytesRead = this.consumeStream.Read(this.rereadMessageHeaderBuffer, 0, this.rereadMessageHeaderBuffer.Length);
if (bytesRead < this.rereadMessageHeaderBuffer.Length)
{
// Reset to the start of a new message.
this.consumeStream.Seek(-bytesRead, SeekOrigin.Current);
return(false);
}
MessageHeader.ReadHeaderFromBuffer(this.rereadMessageHeaderBuffer, 0, ref nextMessageHeader, headerSerializer);
if (nextMessageHeader.Type == SerializedMessageType.CheckpointData)
{
// Skip this because we have already buffered these elements in memory.
this.consumeStream.Seek(nextMessageHeader.Length, SeekOrigin.Current);
Console.Error.WriteLine("Skipping a log message of length {0}", nextMessageHeader.Length);
return(TryReadNextMessage());
}
bytesRead = this.consumeStream.Read(this.rereadMessageBodyBuffer, 0, nextMessageHeader.Length);
if (bytesRead < nextMessageHeader.Length)
{
// Reset to the start of a new message.
this.consumeStream.Seek(-(bytesRead + MessageHeader.SizeOf), SeekOrigin.Current);
return(false);
}
RecvBuffer messageBody = new RecvBuffer(this.rereadMessageBodyBuffer, 0, nextMessageHeader.Length);
this.currentRereadMessage = new SerializedMessage(-1, nextMessageHeader, messageBody);
this.currentRereadMessageEnumerator = this.decoder.Elements(currentRereadMessage).GetEnumerator();
this.currentRereadMessageEnumerator.MoveNext();
return(true);
}
public void Clear()
{
mSendAsync = false;
RecvBuffer.Clear(RecvBuffer.Position);
SendBuffer.ClearPacket();
}
public override void Drain()
{
int recordsReceived = 0;
byte[] consumeBuffer = null;
for (; this.pagesRead < this.pagesFlushed; ++this.pagesRead)
{
Debug.Assert(this.consumeStream.Position % this.pageSize == 0);
if (consumeBuffer == null)
{
consumeBuffer = ThreadLocalBufferPools <byte> .pool.Value.CheckOut(this.pageSize);
}
int bytesRead = this.consumeStream.Read(consumeBuffer, 0, this.pageSize);
if (bytesRead < this.pageSize)
{
// We must be at the end of the file, where zero-bytes appear to be truncated.
MessageHeader innerHeader = default(MessageHeader);
MessageHeader.ReadHeaderFromBuffer(consumeBuffer, 0, ref innerHeader);
if (innerHeader.Length + MessageHeader.SizeOf == bytesRead)
{
Logging.Info("Read complete data from partial page {0} bytes", bytesRead);
// Get the consume stream in the correct place for the next read.
this.consumeStream.Seek(this.pageSize - bytesRead, SeekOrigin.Current);
}
else
{
Debug.Assert(false);
}
}
Debug.Assert(this.consumeStream.Position % this.pageSize == 0);
if (this.serializer == null)
{
this.serializer = AutoSerialization.GetSerializer <Pair <S, T> >();
}
MessageHeader header = default(MessageHeader);
MessageHeader.ReadHeaderFromBuffer(consumeBuffer, 0, ref header);
RecvBuffer messageBody = new RecvBuffer(consumeBuffer, MessageHeader.SizeOf, MessageHeader.SizeOf + header.Length);
Pair <S, T> record;
while (this.serializer.TryDeserialize(ref messageBody, out record))
{
this.endpoint.RecordReceived(record, new RemotePostbox());
if (progressBuffer != null)
{
progressBuffer.Update(record.v2, -1);
}
++recordsReceived;
}
Logging.Info("Drained a spilt page into operator {1}", recordsReceived, this.endpoint.Vertex);
}
if (recordsReceived > 0)
{
this.endpoint.Flush();
if (this.progressBuffer != null)
{
this.progressBuffer.Flush();
}
this.postOffice.Controller.Workers.NotifyOperatorReceivedRecords(this.endpoint.Vertex, this.id, recordsReceived);
Logging.Info("Drained {0} records into operator {1}", recordsReceived, this.endpoint.Vertex);
}
if (consumeBuffer != null)
{
ThreadLocalBufferPools <byte> .pool.Value.CheckIn(consumeBuffer);
}
}
public static bool TryDeserialize <T>(ref RecvBuffer source, out T value)
{
return(GetSerializer <T>().TryDeserialize(ref source, out value));
}
public void Clear()
{
isSending = false;
RecvBuffer.Clear(RecvBuffer.Position);
SendBuffer.ClearPacket();
}
public bool RecvAsync()
{
lock (sync)
{
// 写入数据内容
int lastPos = RecvBuffer.Position;
RecvBuffer.WriteBytes(RecvEventArgs.Buffer, RecvEventArgs.Offset, RecvEventArgs.BytesTransferred);
RecvBuffer.Clear(RecvBuffer.Position - lastPos); // Position位置回退
BytesTransferred = BytesTransferred + RecvEventArgs.BytesTransferred;
bool result = true;
int byteLenght = 0;
// 当字节长度大于一个包头时进行处理
while (BytesTransferred >= sizeof(short))
{
// 包头检查
short head = RecvBuffer.ReadInt16();
if (head != HEAD)
{
App.Error("包头错误, 关闭远程连接!");
return(false);
}
BytesTransferred = BytesTransferred - sizeof(short);
byteLenght = byteLenght + sizeof(short);
// 包长
int length = RecvBuffer.ReadInt32();
if ((length > 1024 * 1024) | (RecvBuffer.Position > BufferSize))
{
// 最大缓存保护
App.Error("字节流溢出,即将关闭远程连接!");
return(false);
}
BytesTransferred = BytesTransferred - sizeof(int);
byteLenght = byteLenght + sizeof(int);
lastPos = RecvBuffer.Position;
int packetID = RecvBuffer.ReadInt32();
RecvBuffer.Clear(RecvBuffer.Position - lastPos);
IPacket oPacket = PacketMgr.CreatePacket(packetID);
try
{
lastPos = RecvBuffer.Position;
oPacket.Serialization(RecvBuffer, false);
int oDataLength = RecvBuffer.Position - lastPos;
BytesTransferred = BytesTransferred - oDataLength;
byteLenght = byteLenght + oDataLength;
// 接收包
oPacket.SetOwner(Owner);
oPacket.SetSession(this);
PacketMgr.Push(oPacket);
}
catch (Exception e)
{
App.Error("协议解析出错, 即将关闭远程连接\n{0}", e);
return(false);
}
}
RecvBuffer.Clear(byteLenght);
return(result);
}
}
