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();
}
}
}
