public static BufferWriter AsHttpWriter(this Span <byte> buffer) { var writer = BufferWriter.Create(buffer); writer.NewLine = s_httpNewline; return(writer); }
public static bool TryWrite(Span <byte> output, Sha256 hash, Utf8Span keyType, Utf8Span verb, Utf8Span resourceId, Utf8Span resourceType, Utf8Span tokenVersion, DateTime utc, out int bytesWritten) { Span <byte> buffer = stackalloc byte[AuthenticationHeaderBufferSize]; var writer = BufferWriter.Create(buffer); writer.Enlarge = (minumumSize) => { return(new byte[minumumSize * 2]); }; // compute signature hash writer.WriteLine(verb, s_toLower); writer.WriteLine(resourceType, s_toLower); writer.WriteLine(resourceId, s_toLower); writer.WriteLine(utc, 'l'); writer.Write('\n'); hash.Append(writer.Written); // combine token writer.WrittenCount = 0; // reuse writer and buffer writer.Write(s_typeLiteral); writer.Write(keyType); writer.Write(s_verLiteral); writer.Write(tokenVersion); writer.Write(s_sigLiteral); writer.WriteBytes(hash, s_toBase64); if (UrlEncoder.Utf8.Encode(writer.Written, output, out var consumed, out bytesWritten) != OperationStatus.Done) { bytesWritten = 0; return(false); } return(true); }
public void BufferWriterPlaintextUtf8() { s_sink.Reset(); var writer = BufferWriter.Create(s_sink); // HTTP 1.1 OK writer.Write(s_http11OKU8); // Server headers writer.Write(s_headerServerU8); // Date header writer.Write(DateHeader.HeaderBytes); // Content-Type header writer.Write(s_headerContentTypeTextU8); // Content-Length header writer.Write(s_headerContentLengthU8); writer.Write((ulong)s_plainTextBody.Length); // End of headers writer.Write(s_eohU8); // Body writer.Write(s_plainTextBodyU8); writer.Flush(); }
public bool TryWrite(Span <byte> buffer, out int written, StandardFormat format = default) { try { var writer = BufferWriter.Create(buffer); writer.Write("SharedKey "); writer.Write(AccountName); writer.Write(':'); int signatureStart = writer.WrittenCount; writer.WriteBytes(HttpVerb); if (ContentLength == 0) { writer.Write("\n\n\n\n\n\n\n\n\n\n\n\n"); } else { writer.Write("\n\n\n"); writer.Write(ContentLength); writer.Write("\n\n\n\n\n\n\n\n\n"); } writer.WriteBytes(CanonicalizedHeaders, s_removeCR); // write canonicalized resource writer.Write('/'); writer.Write(AccountName); writer.Write('/'); writer.Write(CanonicalizedResource); // compute hash Hash.Append(writer.Written.Slice(signatureStart)); writer.WrittenCount = signatureStart; // write hash writer.WriteBytes(Hash, s_toBase64); written = writer.WrittenCount; return(true); } catch (BufferWriter.BufferTooSmallException) { buffer.Clear(); written = 0; return(false); } }
public void WriteIntegers() { using var bw = BufferWriter <byte> .Create(); using var tw = BufferWriterTextWriter.Create(bw); for (int i = 0; i < 1000; i++) { tw.WriteLine(i); } tw.Flush(); var expectedLength = (10 * 1) + (90 * 2) + (900 * 3) + (1000 * tw.NewLine.Length); Assert.Equal(expectedLength, bw.Length); }
public void CanSerializeViaInputOutputAPI_Buffers() { using var buffer = BufferWriter <byte> .Create(); IProtoOutput <IBufferWriter <byte> > output = RuntimeTypeModel.Default; var orig = new SomeModel { Id = 42 }; output.Serialize(buffer, orig); using var payload = buffer.Flush(); IProtoInput <ReadOnlySequence <byte> > input = RuntimeTypeModel.Default; var clone = input.Deserialize <SomeModel>(payload.Value); Assert.NotSame(orig, clone); Assert.Equal(42, clone.Id); }
private void WriteBufferWriter(TypeModel model) { using var buffer = BufferWriter <byte> .Create(64 * 1024); for (int i = 0; i < OperationsPerInvoke; i++) { var state = ProtoWriter.State.Create(buffer, model); try { state.SerializeRoot(_database); state.Close(); } finally { state.Dispose(); } AssertLength(buffer.Length); buffer.Flush().Dispose(); } }
public static bool TryWrite(Span <byte> output, Sha256 hash, Utf8Span verb, Utf8Span canonicalizedResource, DateTime utc, out int bytesWritten) { try { var writer = BufferWriter.Create(output); writer.WriteLine(verb); writer.Write(s_emptyHeaders); writer.WriteLine(utc, 'R'); writer.Write(canonicalizedResource); hash.Append(writer.Written); writer.WrittenCount = 0; writer.WriteBytes(hash, s_toBase64); bytesWritten = writer.WrittenCount; return(true); } catch (BufferWriter.BufferTooSmallException) { bytesWritten = 0; return(false); } }
public void WriteToBuffer() { var metadata = new List <MetaData>(); for (var i = 0; i < 25; i++) { var tags = new Dictionary <string, string> { ["host"] = Environment.MachineName.ToLower(), ["tag"] = "value" }; metadata.Add(new MetaData("Metric " + i, "rate", tags, "rate")); metadata.Add(new MetaData("Metric " + i, "unit", tags, "unit")); metadata.Add(new MetaData("Metric " + i, "desc", tags, "description")); } var bufferWriter = BufferWriter <byte> .Create(blockSize : 320); using var utfWriter = new Utf8JsonWriter(bufferWriter.Writer); JsonSerializer.Serialize(utfWriter, metadata); }
static void BufferWriterPlaintext() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { for (int i = 0; i < InnerIterations; i++) { s_sink.Reset(); var writer = BufferWriter.Create(s_sink); // HTTP 1.1 OK writer.Write(s_http11OK); // Server headers writer.Write(s_headerServer); // Date header writer.Write(DateHeader.HeaderBytes); // Content-Type header writer.Write(s_headerContentTypeText); // Content-Length header writer.Write(s_headerContentLength); writer.Write((ulong)s_plainTextBody.Length); // End of headers writer.Write(s_eoh); // Body writer.Write(s_plainTextBody); writer.Flush(); } } } }
public void RoundTripViaBuffers() { var db = LoadFromDisk(out var contents); Assert.Equal(830, db.Orders.Count); using var bw = BufferWriter <byte> .Create(); var writeState = ProtoWriter.State.Create(bw.Writer, RuntimeTypeModel.Default); try { Write(db, ref writeState); } finally { writeState.Dispose(); } using var buffer = bw.Flush(); var b = buffer.Value; int len = checked ((int)b.Length); var arr = ArrayPool <byte> .Shared.Rent(len); try { var span = new Span <byte>(arr, 0, len); b.CopyTo(span); Assert.True(contents.SequenceEqual(span)); Log?.WriteLine($"{span.Length} bytes verified"); } finally { ArrayPool <byte> .Shared.Return(arr); } }
public void SlicesDisposeSlabs() { var payload = new byte[32 * 1024]; var tasks = new List <Task>(); for (int t = 0; t < 100; t++) { tasks.Add(Task.Run(() => { for (int i = 0; i < 10000; i++) { var bw = BufferWriter.Create(); bw.WriteSpan(payload); bw.WriteSpan(payload); bw.WriteSpan(payload); bw.WriteSpan(payload); bw.Dispose(); } })); } Task.WaitAll(tasks.ToArray()); }
/// <summary> /// Consumes the <paramref name="stream"/> to the end into a <see cref="BufferWriter"/> and disposes the stream. /// </summary> /// <param name="stream"></param> /// <param name="ct"></param> /// <returns></returns> public static ValueTask <BufferWriter> Consume(this Stream stream, CancellationToken ct = default) // TODO dispose stream? { const int minReadCapacity = 1024; var knownSize = -1; if (stream.CanSeek) { knownSize = checked ((int)stream.Length); } var bw = BufferWriter.Create(knownSize); // ReSharper disable RedundantAssignment ValueTask <int> t = default; bool finishSync = false; // ReSharper restore RedundantAssignment #if NETCOREAPP while (true) { bw.EnsureCapacity(minReadCapacity); t = stream.ReadAsync(bw.FreeMemory, ct); if (t.IsCompletedSuccessfully) { bw.Advance(t.Result); if (t.Result == 0 || (knownSize >= 0 && t.Result == knownSize)) { stream.Dispose(); return(new ValueTask <BufferWriter>(bw)); } // Continue, we do not know the size or have read partially. Cannot tell that at the end of stream until ReadAsync returns 0. } else { finishSync = true; break; } } #endif return(ConsumeAsync()); async ValueTask <BufferWriter> ConsumeAsync() { byte[] tempBuff = null; try { do { if (finishSync) { #if NETCOREAPP await t; #endif // we have written to free memory but not advanced yet bw.Advance(t.Result); if (t.Result == 0 || (knownSize >= 0 && t.Result == knownSize)) { return(bw); } } bw.EnsureCapacity(minReadCapacity); #if NETCOREAPP t = stream.ReadAsync(bw.FreeMemory, ct); #else if (tempBuff == null) { tempBuff = BufferPool <byte> .Rent(bw.FreeCapacity); } var bytesRead = await stream.ReadAsync(tempBuff, 0, tempBuff.Length, ct); if (bytesRead > 0) { tempBuff.AsSpan().Slice(0, bytesRead).CopyTo(bw.FreeSpan); } t = new ValueTask <int>(bytesRead); #endif finishSync = true; } while (true); } finally { // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (tempBuff != null) { BufferPool <byte> .Return(tempBuff); } stream.Dispose(); } } }