public static ChunkedStream ToJsonArray(this IEnumerable <DbRow> dbRows)
{
var result = new ChunkedStream();
result.Write(OpenArray);
var firstLine = true;
foreach (var row in dbRows)
{
if (firstLine)
{
firstLine = false;
}
else
{
result.Write(Comma);
}
result.Write(row.Data);
}
result.Write(CloseArray);
return(result);
}
public void TestMixCopy()
{
var array = new byte[] { 0, 1, 2, 3, 4, 5 };
var chunkedStream = new ChunkedStream();
chunkedStream.Write(array, 1, 3);
chunkedStream.Write(array, 2, 4);
chunkedStream.Write(array, 3, 3);
var b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[1]);
var destArray = new byte[8];
chunkedStream.Read(destArray, 0, destArray.Length);
Assert.AreEqual(array[2], destArray[0]);
Assert.AreEqual(array[3], destArray[1]);
Assert.AreEqual(array[2], destArray[2]);
Assert.AreEqual(array[3], destArray[3]);
Assert.AreEqual(array[4], destArray[4]);
Assert.AreEqual(array[5], destArray[5]);
Assert.AreEqual(array[3], destArray[6]);
Assert.AreEqual(array[4], destArray[7]);
}
public void TestReadOneByOneWholeStream()
{
var array = new byte[] { 0, 1, 2, 3, 4, 5 };
var chunkedStream = new ChunkedStream();
chunkedStream.Write(array, 1, 3);
chunkedStream.Write(array, 2, 4);
chunkedStream.Write(array, 3, 3);
var b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[1]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[2]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[3]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[2]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[3]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[4]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[5]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[3]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[4]);
b = chunkedStream.ReadByte();
Assert.AreEqual(b, array[5]);
}
public void TestCopyToNewArray()
{
var array = new byte[] { 0, 1, 2, 3, 4, 5 };
var chunkedStream = new ChunkedStream();
chunkedStream.Write(array, 1, 3);
chunkedStream.Write(array, 2, 4);
chunkedStream.Write(array, 3, 3);
var destArray = chunkedStream.AsArray();
Assert.AreEqual(destArray[0], array[1]);
Assert.AreEqual(destArray[1], array[2]);
Assert.AreEqual(destArray[2], array[3]);
Assert.AreEqual(destArray[3], array[2]);
Assert.AreEqual(destArray[4], array[3]);
Assert.AreEqual(destArray[5], array[4]);
Assert.AreEqual(destArray[6], array[5]);
Assert.AreEqual(destArray[7], array[3]);
Assert.AreEqual(destArray[8], array[4]);
Assert.AreEqual(destArray[9], array[5]);
}
public bool OnReceiveData(byte[] buffer, int offset, int bytesReceived)
{
var parsed = false;
if ((buffer != null) && (bytesReceived > 0))
{
_stream.Write(buffer, offset, bytesReceived);
while (RpcMessageParser.TryParse(_stream, out IEnumerable <WireMessage> messages))
{
if (messages == null)
{
continue;
}
foreach (var message in messages)
{
if (message != null)
{
_messageQueue.Enqueue(message);
Interlocked.Add(ref _count, 1L);
parsed = true;
}
}
}
}
return(parsed);
}
public void TestTwoArrays()
{
var str1 = "[{A}, {";
var str2 = "B}]";
var bytes1 = Encoding.UTF8.GetBytes(str1);
var bytes2 = Encoding.UTF8.GetBytes(str2);
var mem1 = new ReadOnlyMemory <byte>(bytes1);
var mem2 = new ReadOnlyMemory <byte>(bytes2);
var chunkMem = new ChunkedStream();
chunkMem.Write(mem1);
chunkMem.Write(mem2);
var result = chunkMem.SplitJsonArrayToObjects().ToArray();
Assert.Equal("{A}", Encoding.UTF8.GetString(result[0].Span));
Assert.Equal("{B}", Encoding.UTF8.GetString(result[1].Span));
}
public void TestThreeArrays()
{
var str1 = "[{A}, {";
var str2 = "B";
var str3 = "}]";
var bytes1 = Encoding.UTF8.GetBytes(str1);
var bytes2 = Encoding.UTF8.GetBytes(str2);
var bytes3 = Encoding.UTF8.GetBytes(str3);
var chunkMem = new ChunkedStream();
chunkMem.Write(bytes1);
chunkMem.Write(bytes2);
chunkMem.Write(bytes3);
var result = chunkMem.SplitJsonArrayToObjects().ToArray();
Assert.Equal("{A}", Encoding.UTF8.GetString(result[0].Span));
Assert.Equal("{B}", Encoding.UTF8.GetString(result[1].Span));
}
public void TestWrite()
{
using (MemoryStream file = new MemoryStream())
using (ChunkedStream chunked = new ChunkedStream(file, this.chunkSize))
{
byte[] buffer = new byte[2 * this.chunkSize];
this.FillArray <byte>(buffer, (byte)'a');
Assert.AreEqual(0, chunked.ChunkPosition);
Assert.AreEqual(0, chunked.Position);
Assert.AreEqual(0, chunked.Length);
chunked.Write(buffer, 0, 1);
Assert.AreEqual(1, file.Position);
Assert.AreEqual(1, chunked.Position);
Assert.AreEqual(1, chunked.Length);
System.ArgumentOutOfRangeException e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, this.chunkSize));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(this.chunkSize, e.ActualValue);
Assert.AreEqual(1, file.Position);
Assert.AreEqual(1, chunked.Position);
Assert.AreEqual(1, chunked.Length);
chunked.Write(buffer, 1, this.chunkSize - 1);
Assert.AreEqual(this.chunkSize, file.Position);
Assert.AreEqual(this.chunkSize, chunked.Position);
Assert.AreEqual(this.chunkSize, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, 1));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(1, e.ActualValue);
Assert.AreEqual(this.chunkSize, file.Position);
Assert.AreEqual(this.chunkSize, chunked.Position);
Assert.AreEqual(this.chunkSize, chunked.Length);
chunked.ChunkPosition = this.chunkSize;
Assert.AreEqual(this.chunkSize, chunked.ChunkPosition);
Assert.AreEqual(this.chunkSize, file.Position);
Assert.AreEqual(0, chunked.Position);
Assert.AreEqual(0, chunked.Length);
chunked.Write(buffer, 0, this.chunkSize);
Assert.AreEqual(2 * this.chunkSize, file.Position);
Assert.AreEqual(this.chunkSize, chunked.Position);
Assert.AreEqual(this.chunkSize, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, 1));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(1, e.ActualValue);
Assert.AreEqual(2 * this.chunkSize, file.Position);
Assert.AreEqual(this.chunkSize, chunked.Position);
Assert.AreEqual(this.chunkSize, chunked.Length);
chunked.ChunkPosition = 4 * this.chunkSize;
Assert.AreEqual(4 * this.chunkSize, chunked.ChunkPosition);
Assert.AreEqual(4 * this.chunkSize, file.Position);
Assert.AreEqual(0, chunked.Position);
Assert.AreEqual(0, chunked.Length);
chunked.Write(buffer, 1, this.chunkSize - 1);
Assert.AreEqual((5 * this.chunkSize) - 1, file.Position);
Assert.AreEqual(this.chunkSize - 1, chunked.Position);
Assert.AreEqual(this.chunkSize - 1, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, this.chunkSize));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(this.chunkSize, e.ActualValue);
Assert.AreEqual((5 * this.chunkSize) - 1, file.Position);
Assert.AreEqual(this.chunkSize - 1, chunked.Position);
Assert.AreEqual(this.chunkSize - 1, chunked.Length);
chunked.Write(buffer, 0, 1);
Assert.AreEqual(5 * this.chunkSize, file.Position);
Assert.AreEqual(this.chunkSize, chunked.Position);
Assert.AreEqual(this.chunkSize, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, 1));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(1, e.ActualValue);
Assert.AreEqual(5 * this.chunkSize, file.Position);
Assert.AreEqual(this.chunkSize, chunked.Position);
Assert.AreEqual(this.chunkSize, chunked.Length);
}
}
private void ReadData(int dataTypeCd, WireMessage message, IStreamReader reader)
{
switch ((TypeCode)dataTypeCd)
{
case TypeCode.Boolean:
message.Data = reader.ReadBoolean();
break;
case TypeCode.Byte:
message.Data = reader.ReadByte();
break;
case TypeCode.Char:
message.Data = reader.ReadChar();
break;
case TypeCode.DateTime:
message.Data = new DateTime(reader.ReadInt64());
break;
case TypeCode.DBNull:
reader.ReadByte();
message.Data = DBNull.Value;
break;
case TypeCode.Decimal:
message.Data = reader.ReadDecimal();
break;
case TypeCode.Double:
message.Data = reader.ReadDouble();
break;
case TypeCode.Empty:
reader.ReadByte();
break;
case TypeCode.Int16:
message.Data = reader.ReadInt16();
break;
case TypeCode.Int32:
message.Data = reader.ReadInt32();
break;
case TypeCode.Int64:
message.Data = reader.ReadInt64();
break;
case TypeCode.SByte:
message.Data = reader.ReadSByte();
break;
case TypeCode.Single:
message.Data = reader.ReadSingle();
break;
case TypeCode.String:
message.Data = ReadString(reader);
break;
case TypeCode.UInt16:
message.Data = reader.ReadUInt16();
break;
case TypeCode.UInt32:
message.Data = reader.ReadUInt32();
break;
case TypeCode.UInt64:
message.Data = reader.ReadUInt64();
break;
default:
{
var len = reader.ReadInt32();
if (len > 0)
{
using (var tempStream = new ChunkedStream())
{
var chunkSize = tempStream.ChunkSize;
while (len > 0)
{
var bytes = reader.ReadBytes(chunkSize);
var readLen = bytes?.Length ?? 0;
if (readLen == 0)
{
throw new Exception(SerializationErrors.StreamNotContainingValidWireMessage);
}
len -= readLen;
tempStream.Write(bytes, 0, readLen);
}
tempStream.Position = 0;
message.Data = GetSerializer().Deserialize(tempStream);
}
}
}
break;
}
}
private WireMessage Read(IStreamReader reader)
{
var dataTypeCd = reader.ReadByte() - NotNullFlag;
if (dataTypeCd > 0)
{
var message = new WireMessage();
var buffer = StringBytesCache.Acquire();
try
{
var sizeOfDataTypeCd = WireMessageFieldSizeOf.DataTypeCd;
reader.Read(buffer, 0, WireMessageSizeOf.ConstantFields - sizeOfDataTypeCd);
message.MessageType = (MessageType)buffer[WireMessageBufferOffsetOf.MessageType - sizeOfDataTypeCd];
message.State = (WireMessageState)buffer[WireMessageBufferOffsetOf.State - sizeOfDataTypeCd];
var timeoutMSec = buffer.ToInt(WireMessageBufferOffsetOf.TimeoutMSec - sizeOfDataTypeCd);
message.TimeoutMSec = timeoutMSec != int.MinValue ? timeoutMSec : (int?)null;
message.Id = new WireMessageId(
buffer.ToInt(WireMessageBufferOffsetOf.IdMajor - sizeOfDataTypeCd),
buffer.ToInt(WireMessageBufferOffsetOf.IdMajorRevision - sizeOfDataTypeCd),
buffer.ToInt(WireMessageBufferOffsetOf.IdMinor - sizeOfDataTypeCd),
buffer.ToInt(WireMessageBufferOffsetOf.IdMinorRevision - sizeOfDataTypeCd),
buffer.ToInt(WireMessageBufferOffsetOf.IdProcessId - sizeOfDataTypeCd)
);
}
finally
{
StringBytesCache.Release(buffer);
}
message.From = Aid.Parse(ReadString(reader));
message.To = Aid.Parse(ReadString(reader));
var isNullByte = reader.ReadByte();
if (isNullByte != NullFlag)
{
var header = new Dictionary <string, string>();
message.Header = header;
var count = reader.ReadInt32();
if (count > 0)
{
string key;
for (var i = 0; i < count; i++)
{
key = ReadString(reader);
if (key != null)
{
header[key] = ReadString(reader);
}
}
}
}
isNullByte = reader.ReadByte();
if (isNullByte != NullFlag)
{
var len = reader.ReadInt32();
if (len > 0)
{
using (var tempStream = new ChunkedStream())
{
var chunkSize = tempStream.ChunkSize;
while (len > 0)
{
var bytes = reader.ReadBytes(chunkSize);
var readLen = bytes?.Length ?? 0;
if (readLen == 0)
{
throw new Exception(SerializationErrors.StreamNotContainingValidWireMessage);
}
len -= readLen;
tempStream.Write(bytes, 0, readLen);
}
tempStream.Position = 0;
message.Exception = GetSerializer().Deserialize <Exception>(tempStream);
}
}
}
ReadData(dataTypeCd, message, reader);
return(message);
}
return(null);
}
public void TestWrite()
{
//using (Database database = new Database(DatabasePath))
using (Stream file = new FileStream(TestFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
using (ChunkedStream chunked = new ChunkedStream(file, ChunkSize))
{
byte[] buffer = new byte[2 * ChunkSize];
FillArray <byte>(buffer, (byte)'a');
Assert.AreEqual(0, chunked.ChunkPosition);
Assert.AreEqual(0, chunked.Position);
Assert.AreEqual(0, chunked.Length);
chunked.Write(buffer, 0, 1);
Assert.AreEqual(1, file.Position);
Assert.AreEqual(1, chunked.Position);
Assert.AreEqual(1, chunked.Length);
System.ArgumentOutOfRangeException e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, ChunkSize));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(ChunkSize, e.ActualValue);
Assert.AreEqual(1, file.Position);
Assert.AreEqual(1, chunked.Position);
Assert.AreEqual(1, chunked.Length);
chunked.Write(buffer, 1, ChunkSize - 1);
Assert.AreEqual(ChunkSize, file.Position);
Assert.AreEqual(ChunkSize, chunked.Position);
Assert.AreEqual(ChunkSize, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, 1));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(1, e.ActualValue);
Assert.AreEqual(ChunkSize, file.Position);
Assert.AreEqual(ChunkSize, chunked.Position);
Assert.AreEqual(ChunkSize, chunked.Length);
chunked.ChunkPosition = ChunkSize;
Assert.AreEqual(ChunkSize, chunked.ChunkPosition);
Assert.AreEqual(ChunkSize, file.Position);
Assert.AreEqual(0, chunked.Position);
Assert.AreEqual(0, chunked.Length);
chunked.Write(buffer, 0, ChunkSize);
Assert.AreEqual(2 * ChunkSize, file.Position);
Assert.AreEqual(ChunkSize, chunked.Position);
Assert.AreEqual(ChunkSize, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, 1));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(1, e.ActualValue);
Assert.AreEqual(2 * ChunkSize, file.Position);
Assert.AreEqual(ChunkSize, chunked.Position);
Assert.AreEqual(ChunkSize, chunked.Length);
chunked.ChunkPosition = 4 * ChunkSize;
Assert.AreEqual(4 * ChunkSize, chunked.ChunkPosition);
Assert.AreEqual(4 * ChunkSize, file.Position);
Assert.AreEqual(0, chunked.Position);
Assert.AreEqual(0, chunked.Length);
chunked.Write(buffer, 1, ChunkSize - 1);
Assert.AreEqual(5 * ChunkSize - 1, file.Position);
Assert.AreEqual(ChunkSize - 1, chunked.Position);
Assert.AreEqual(ChunkSize - 1, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, ChunkSize));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(ChunkSize, e.ActualValue);
Assert.AreEqual(5 * ChunkSize - 1, file.Position);
Assert.AreEqual(ChunkSize - 1, chunked.Position);
Assert.AreEqual(ChunkSize - 1, chunked.Length);
chunked.Write(buffer, 0, 1);
Assert.AreEqual(5 * ChunkSize, file.Position);
Assert.AreEqual(ChunkSize, chunked.Position);
Assert.AreEqual(ChunkSize, chunked.Length);
e = Assert.Catch <System.ArgumentOutOfRangeException>(() => chunked.Write(buffer, 0, 1));
Assert.AreEqual("count", e.ParamName);
Assert.AreEqual(1, e.ActualValue);
Assert.AreEqual(5 * ChunkSize, file.Position);
Assert.AreEqual(ChunkSize, chunked.Position);
Assert.AreEqual(ChunkSize, chunked.Length);
}
}
