internal void SendPartialPacket(PartialPacket p) { byte[] type = { (byte)p.Type }; byte[] hasId = { p.HasId ? (byte)1 : (byte)0 }; byte[] isbuffered = { 1 }; byte[] length = BitConverter.GetBytes(p.Data.Length); byte[] posBytes = BitConverter.GetBytes(p.Position); byte[] isEndBytes = p.IsEnd ? new byte[] { 1 } : new byte[] { 0 }; byte[] totalLengthBytes = BitConverter.GetBytes(p.TotalDataSize); byte[] arrData = p.Data; byte[] b; if (p.HasId) { b = ByteArrayHelpers.Combine(type, hasId, p.Id, isbuffered, length, posBytes, isEndBytes, totalLengthBytes, arrData); } else { b = ByteArrayHelpers.Combine(type, hasId, isbuffered, length, posBytes, isEndBytes, totalLengthBytes, arrData); } _stream.Write(b, 0, b.Length); }
public Hash GetSummarizedStateHash() { if (InlineTraces.Count == 0) { return(StateHash ?? Hash.Default); } var hashes = new List <Hash>() { StateHash }; hashes.AddRange(InlineTraces.Select(x => x.GetSummarizedStateHash())); return(Hash.FromRawBytes(ByteArrayHelpers.Combine(hashes.Select(x => x.DumpByteArray()).ToArray()))); }
public void Bytes_Combine_And_SubArray() { var byteArray1 = Hash.Generate().DumpByteArray(); var byteArray2 = Hash.Generate().DumpByteArray(); var bytes = ByteArrayHelpers.Combine(byteArray1, byteArray2); bytes.Length.ShouldBe(byteArray1.Length + byteArray2.Length); var bytes1 = ByteArrayHelpers.ConcatArrays(byteArray1, byteArray2, bytes); bytes1.Length.ShouldBe(byteArray1.Length + byteArray2.Length + bytes.Length); var subArray1 = ByteArrayHelpers.SubArray(bytes, 0, byteArray1.Length); var subArray2 = ByteArrayHelpers.SubArray(bytes, byteArray1.Length, byteArray2.Length); subArray1.ShouldBe(byteArray1); subArray2.ShouldBe(byteArray2); }
public static async Task CommitChangesAsync(this TransactionTrace trace, IStateStore stateStore) { if (trace.ExecutionStatus != ExecutionStatus.ExecutedButNotCommitted) { throw new InvalidOperationException( $"Attempting to commit a trace with a wrong status {trace.ExecutionStatus}."); } if (trace.StateChanges.Count > 0) { await stateStore.PipelineSetDataAsync(trace.StateChanges.ToDictionary(x => x.StatePath, x => x.StateValue.CurrentValue.ToByteArray())); } trace.StateHash = Hash.FromRawBytes(ByteArrayHelpers.Combine(trace.StateChanges.Select(x => x.StatePath.GetHash()).OrderBy(x => x).Select(x => x.Value.ToByteArray()).ToArray())); trace.ExecutionStatus = ExecutionStatus.ExecutedAndCommitted; foreach (var trc in trace.InlineTraces) { await trc.CommitChangesAsync(stateStore); } }
internal void SendPacketFromMessage(Message p) { byte[] type = { (byte)p.Type }; byte[] hasId = { p.HasId ? (byte)1 : (byte)0 }; byte[] isbuffered = { 0 }; byte[] length = BitConverter.GetBytes(p.Length); byte[] arrData = p.Payload; byte[] b; if (p.HasId) { b = ByteArrayHelpers.Combine(type, hasId, p.Id, isbuffered, length, arrData); } else { b = ByteArrayHelpers.Combine(type, hasId, isbuffered, length, arrData); } _stream.Write(b, 0, b.Length); }
/// <summary> /// Reads the bytes from the stream. /// </summary> private async Task Read() { try { while (true) { // Read type int type = await ReadByte(); // Read if the message is associated with an id bool hasId = await ReadBoolean(); byte[] id = null; if (hasId) { // The Id is a 128-bit guid id = await ReadBytesAsync(IdLength); } // Is this a partial reception ? bool isBuffered = await ReadBoolean(); // Read the size of the data int length = await ReadInt(); if (isBuffered) { // If it's a partial packet read the packet info PartialPacket partialPacket = await ReadPartialPacket(length); // todo property control if (!partialPacket.IsEnd) { _partialPacketBuffer.Add(partialPacket); if (_partialPacketBuffer.Count == 0) { _logger.Trace($"Received first packet: {partialPacket.Type}, total size: {partialPacket.TotalDataSize}."); } } else { // This is the last packet // Concat all data _partialPacketBuffer.Add(partialPacket); byte[] allData = ByteArrayHelpers.Combine(_partialPacketBuffer.Select(pp => pp.Data).ToArray()); _logger.Trace($"Received last packet: {_partialPacketBuffer.Count}, total length: {allData.Length}."); // Clear the buffer for the next partial to receive _partialPacketBuffer.Clear(); Message message; if (hasId) { message = new Message { Type = type, HasId = true, Id = id, Length = allData.Length, Payload = allData }; } else { message = new Message { Type = type, HasId = false, Length = allData.Length, Payload = allData }; } FireMessageReceivedEvent(message); } } else { // If it's not a partial packet the next "length" bytes should be // the entire data byte[] packetData = await ReadBytesAsync(length); Message message; if (hasId) { message = new Message { Type = type, HasId = true, Id = id, Length = length, Payload = packetData }; } else { message = new Message { Type = type, HasId = false, Length = length, Payload = packetData }; } FireMessageReceivedEvent(message); } } } catch (PeerDisconnectedException) { StreamClosed?.Invoke(this, EventArgs.Empty); Close(); } catch (Exception e) { if (!IsConnected && e is IOException) { // If the stream fails while the connection is logically closed (call to Close()) // we simply return - the StreamClosed event will no be closed. return; } Close(); StreamClosed?.Invoke(this, EventArgs.Empty); } }