public void WriteMessage(HttpRequestMessage message, IBufferWriter <byte> output)
{
var writer = new BufferWriter <IBufferWriter <byte> >(output);
writer.WriteAsciiNoValidation(message.Method.Method);
writer.Write(Space);
writer.WriteAsciiNoValidation(message.RequestUri.PathAndQuery);
writer.Write(Space);
writer.Write(Http11);
writer.Write(NewLine);
var colon = (byte)':';
foreach (var header in message.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
writer.Write(NewLine);
writer.Commit();
}
public void ThrowsForInvalidParameters(int arrayLength, int offset, int length)
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
var array = new byte[arrayLength];
for (var i = 0; i < array.Length; i++)
{
array[i] = (byte)(i + 1);
}
writer.Write(new Span <byte>(array, 0, 0));
writer.Write(new Span <byte>(array, array.Length, 0));
try
{
writer.Write(new Span <byte>(array, offset, length));
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentOutOfRangeException);
}
writer.Write(new Span <byte>(array, 0, array.Length));
writer.Commit();
Assert.Equal(array, Read());
}
private Task WriteAsync(
ReadOnlySpan <byte> buffer,
CancellationToken cancellationToken = default)
{
lock (_contextLock)
{
if (_completed)
{
return(Task.CompletedTask);
}
var writer = new BufferWriter <PipeWriter>(_pipeWriter);
if (buffer.Length > 0)
{
writer.Write(buffer);
_unflushedBytes += buffer.Length;
}
writer.Commit();
var bytesWritten = _unflushedBytes;
_unflushedBytes = 0;
return(_flusher.FlushAsync(
_minResponseDataRateFeature.MinDataRate,
bytesWritten,
this,
cancellationToken));
}
}
private Task WriteAsync(
ReadOnlySpan <byte> buffer,
CancellationToken cancellationToken)
{
var writableBuffer = default(PipeWriter);
long bytesWritten = 0;
lock (_contextLock)
{
if (_completed)
{
return(Task.CompletedTask);
}
writableBuffer = _pipeWriter;
var writer = new BufferWriter <PipeWriter>(writableBuffer);
if (buffer.Length > 0)
{
writer.Write(buffer);
bytesWritten += buffer.Length;
}
writer.Commit();
}
return(FlushAsync(writableBuffer, bytesWritten, cancellationToken));
}
private void DoUpgrade()
{
var writer = new BufferWriter <PipeWriter>(Connection.Transport.Output);
// HTTP 1.1 OK
writer.Write(_http101);
// Server headers
writer.Write(_headerServer);
// Date header
writer.Write(_dateHeaderValueManager.GetDateHeaderValues().Bytes);
writer.Write(_crlf);
// Connection: Upgrade
writer.Write(_headerConnectionUpgrade);
// Upgrade: websocket
writer.Write(_headerUpgradeWebSocket);
// Sec-WebSocket-Key
writer.Write(_secWebSocketAccept);
writer.Write(_secWebSocketAcceptValue.Span);
// Clear the header
_secWebSocketAcceptValue = ReadOnlyMemory <byte> .Empty;
// End of headers
writer.Write(_crlf);
writer.Commit();
}
private void WriteHttpRequestMessage(HttpRequestMessage requestMessage)
{
var writer = new BufferWriter <PipeWriter>(_connection.Transport.Output);
writer.WriteAsciiNoValidation(requestMessage.Method.Method);
writer.Write(Space);
writer.WriteAsciiNoValidation(requestMessage.RequestUri.ToString());
writer.Write(Space);
writer.Write(Http11);
writer.Write(NewLine);
var colon = (byte)':';
foreach (var header in requestMessage.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
writer.Write(NewLine);
writer.Commit();
}
public void WriteMessage(NatsOperation operation, IBufferWriter <byte> output)
{
var writer = new BufferWriter <IBufferWriter <byte> >(output);
switch (operation.OpId)
{
case NatsOperationId.PING:
writer.WriteString("PING\r\n");
break;
case NatsOperationId.PONG:
writer.WriteString("PONG\r\n");
break;
case NatsOperationId.PUB:
WritePub(ref writer, (PubOperation)operation.Op);
break;
case NatsOperationId.SUB:
WriteSub(ref writer, (SubOperation)operation.Op);
break;
case NatsOperationId.CONNECT:
WriteConnect(ref writer, (ConnectOperation)operation.Op);
break;
}
writer.Commit();
}
public void WriteMessage(HttpResponseMessage message, IBufferWriter <byte> output)
{
var writer = new BufferWriter <IBufferWriter <byte> >(output);
writer.WriteAsciiNoValidation("HTTP/1.1");
writer.Write(Space);
writer.WriteNumeric((uint)message.StatusCode);
writer.Write(Space);
writer.WriteAsciiNoValidation(message.StatusCode.ToString());
writer.Write(NewLine);
var colon = (byte)':';
foreach (var header in message.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
writer.Write(NewLine);
writer.Commit();
}
private static void PlainText(PipeWriter pipeWriter)
{
var writer = new BufferWriter <PipeWriter>(pipeWriter);
// HTTP 1.1 OK
writer.Write(_http11OK);
// Server headers
writer.Write(_headerServer);
// Date header
writer.Write(_dateHeaderValueManager.GetDateHeaderValues().Bytes);
writer.Write(_crlf);
// Content-Type header
writer.Write(_headerContentTypeText);
writer.Write(_crlf);
// Content-Length header
writer.Write(_headerContentLength);
writer.WriteNumeric((ulong)_plainTextBody.Length);
writer.Write(_crlf);
// End of headers
writer.Write(_crlf);
// Body
writer.Write(_plainTextBody);
writer.Commit();
}
public void CanWriteIntoHeadlessBuffer()
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
writer.Write(new byte[] { 1, 2, 3 });
writer.Commit();
Assert.Equal(new byte[] { 1, 2, 3 }, Read());
}
public void CanWriteWithOffsetAndLenght(int offset, int length)
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
var array = new byte[] { 1, 2, 3 };
writer.Write(new Span <byte>(array, offset, length));
writer.Commit();
Assert.Equal(array.Skip(offset).Take(length).ToArray(), Read());
}
public void WriteMessage(HttpRequestMessage message, IBufferWriter <byte> output)
{
Debug.Assert(message.Method != null);
Debug.Assert(message.RequestUri != null);
var writer = new BufferWriter <IBufferWriter <byte> >(output);
writer.WriteAsciiNoValidation(message.Method.Method);
writer.Write(Space);
// REVIEW: This isn't right
writer.WriteAsciiNoValidation(message.RequestUri.ToString());
writer.Write(Space);
writer.Write(Http11);
writer.Write(NewLine);
if (message.Headers == null || message.Headers.Host == null)
{
writer.Write(Host);
writer.Write(Colon);
writer.Write(Space);
writer.Write(_hostHeaderValueBytes);
writer.Write(NewLine);
}
foreach (var header in message.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(Colon);
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
if (message.Content != null)
{
foreach (var header in message.Content.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(Colon);
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
}
writer.Write(NewLine);
writer.Commit();
}
public static void Render(IHeaderDictionary headerDictionary, PipeWriter pipeWriter, AsciiString utf8String)
{
headerDictionary.Add(_headerServer);
headerDictionary.Add(_headerContentType);
headerDictionary.Add(new KeyValuePair <string, StringValues>("Content-Length", utf8String.Length.ToString()));
var bufferWriter = new BufferWriter <WriterAdapter>(new WriterAdapter(pipeWriter), 208);
bufferWriter.Write(utf8String);
bufferWriter.Commit();
}
public void CanWriteEmpty()
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
var array = new byte[] { };
writer.Write(array);
writer.Write(new Span <byte>(array, 0, array.Length));
writer.Commit();
Assert.Equal(array, Read());
}
public void CanWriteMultipleTimes()
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
writer.Write(new byte[] { 1 });
writer.Write(new byte[] { 2 });
writer.Write(new byte[] { 3 });
writer.Commit();
Assert.Equal(new byte[] { 1, 2, 3 }, Read());
}
private void WriteBeginChunkBytes_Write()
{
var writer = new BufferWriter <PipeWriter>(_writer);
var dataLength = DataLength;
for (int i = 0; i < InnerLoopCount; i++)
{
ChunkWriter.WriteBeginChunkBytes(ref writer, dataLength);
}
writer.Commit();
}
public void WriteInt_must_write_integer_to_buffer_as_a_string(int number)
{
var buffer = new ArrayBufferWriter <byte>(initialCapacity: 64);
var writer = new BufferWriter <IBufferWriter <byte> >(buffer);
writer.WriteInt(number);
writer.Commit();
var writtenString = Encoding.UTF8.GetString(buffer.WrittenSpan);
Assert.Equal(number.ToString(), writtenString);
}
public void SlicesSpanAndAdvancesAfterWrite()
{
int initialLength = Pipe.Writer.GetMemory().Length;
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
writer.Write(new byte[] { 1, 2, 3 });
writer.Commit();
Assert.Equal(initialLength - 3, writer.Span.Length);
Assert.Equal(Pipe.Writer.GetMemory().Length, writer.Span.Length);
Assert.Equal(new byte[] { 1, 2, 3 }, Read());
}
public void WriteLargeDataBinary(int length)
{
var data = new byte[length];
new Random(length).NextBytes(data);
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
writer.Write(data);
writer.Commit();
Assert.Equal(length, writer.BytesCommitted);
Assert.Equal(data, Read());
}
public void CanWriteOverTheBlockLength()
{
Memory <byte> memory = Pipe.Writer.GetMemory();
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
IEnumerable <byte> source = Enumerable.Range(0, memory.Length).Select(i => (byte)i);
byte[] expectedBytes = source.Concat(source).Concat(source).ToArray();
writer.Write(expectedBytes);
writer.Commit();
Assert.Equal(expectedBytes, Read());
}
public void WriteAsciiNoValidationWritesOnlyOneBytePerChar(string input)
{
// WriteAscii doesn't validate if characters are in the ASCII range
// but it shouldn't produce more than one byte per character
var writerBuffer = _pipe.Writer;
var writer = new BufferWriter <PipeWriter>(writerBuffer);
writer.WriteAsciiNoValidation(input);
writer.Commit();
writerBuffer.FlushAsync().GetAwaiter().GetResult();
var reader = _pipe.Reader.ReadAsync().GetAwaiter().GetResult();
Assert.Equal(input.Length, reader.Buffer.Length);
}
public void WritesNumericToAscii(ulong number)
{
var writerBuffer = _pipe.Writer;
var writer = new BufferWriter <PipeWriter>(writerBuffer);
writer.WriteNumeric(number);
writer.Commit();
writerBuffer.FlushAsync().GetAwaiter().GetResult();
var reader = _pipe.Reader.ReadAsync().GetAwaiter().GetResult();
var numAsStr = number.ToString();
var expected = Encoding.ASCII.GetBytes(numAsStr);
AssertExtensions.Equal(expected, reader.Buffer.Slice(0, numAsStr.Length).ToArray());
}
public void BufferWriterCountsBytesCommitted()
{
BufferWriter <PipeWriter> writer = new BufferWriter <PipeWriter>(Pipe.Writer);
writer.Write(new byte[] { 1, 2, 3 });
Assert.Equal(0, writer.BytesCommitted);
writer.Commit();
Assert.Equal(3, writer.BytesCommitted);
writer.Ensure(10);
writer.Advance(10);
Assert.Equal(3, writer.BytesCommitted);
writer.Commit();
Assert.Equal(13, writer.BytesCommitted);
Pipe.Writer.FlushAsync().GetAwaiter().GetResult();
var readResult = Pipe.Reader.ReadAsync().GetAwaiter().GetResult();
// Consuming the buffer does not change BytesCommitted
Assert.Equal(13, readResult.Buffer.Length);
Assert.Equal(13, writer.BytesCommitted);
}
public void WriteJson_followed_by_other_writes_must_serialize_object_as_utf8_json_into_buffer()
{
var objectToSerialize = new SerializableObject {
SomeProp = 123, AnotherProp = "foobar"
};
var buffer = new ArrayBufferWriter <byte>();
var writer = new BufferWriter <IBufferWriter <byte> >(buffer);
writer.WriteJson(objectToSerialize);
writer.Write(new byte[] { 65, 66, 67, 68 }); // ABCD as ASCII
writer.Commit();
var writtenString = Encoding.UTF8.GetString(buffer.WrittenSpan);
Assert.EndsWith("ABCD", writtenString);
}
public void WriteTo(ref BufferWriter <byte> writer)
{
var timestamp = Timestamp.ToUnixTimeSeconds();
Debug.Assert(timestamp <= uint.MaxValue);
writer.WriteLittleEndian(Version);
writer.WriteLittleEndian(Services);
writer.WriteLittleEndian((uint)timestamp);
writer.WriteLittleEndian(Port);
writer.WriteLittleEndian(Nonce);
writer.WriteVarString(UserAgent);
writer.WriteLittleEndian(StartHeight);
writer.Write(Relay ? (byte)1 : (byte)0);
writer.Commit();
}
public void WriteJson_must_serialize_large_object_as_utf8_json_into_buffer()
{
var objectToSerialize = new SerializableObject {
SomeProp = 123, AnotherProp = new string('A', 1024)
};
var buffer = new ArrayBufferWriter <byte>(initialCapacity: 128);
var writer = new BufferWriter <IBufferWriter <byte> >(buffer);
writer.WriteJson(objectToSerialize);
writer.Commit();
var writtenString = Encoding.UTF8.GetString(buffer.WrittenSpan);
var deserializedObject = System.Text.Json.JsonSerializer.Deserialize <SerializableObject>(writtenString);
Assert.Equal(objectToSerialize.SomeProp, deserializedObject.SomeProp);
Assert.Equal(objectToSerialize.AnotherProp, deserializedObject.AnotherProp);
}
public void WriteMessage(HttpResponseMessage message, IBufferWriter <byte> output)
{
var writer = new BufferWriter <IBufferWriter <byte> >(output);
writer.WriteAsciiNoValidation("HTTP/1.1");
writer.Write(Space);
writer.WriteNumeric((uint)message.StatusCode);
writer.Write(Space);
writer.WriteAsciiNoValidation(message.StatusCode.ToString());
writer.Write(NewLine);
var colon = (byte)':';
foreach (var header in message.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
if (message.Content != null)
{
// Access the property to compute the content length (if there is any)
_ = message.Content.Headers.ContentLength;
foreach (var header in message.Content.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
}
writer.Write(NewLine);
writer.Commit();
}
public void WriteMessage(HttpRequestMessage message, IBufferWriter <byte> output)
{
var writer = new BufferWriter <IBufferWriter <byte> >(output);
writer.WriteAsciiNoValidation(message.Method.Method);
writer.Write(Space);
// REVIEW: This isn't right
writer.WriteAsciiNoValidation(message.RequestUri.ToString());
writer.Write(Space);
writer.Write(Http11);
writer.Write(NewLine);
var colon = (byte)':';
foreach (var header in message.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
if (message.Content != null)
{
foreach (var header in message.Content.Headers)
{
foreach (var value in header.Value)
{
writer.WriteAsciiNoValidation(header.Key);
writer.Write(MemoryMarshal.CreateReadOnlySpan(ref colon, 1));
writer.Write(Space);
writer.WriteAsciiNoValidation(value);
writer.Write(NewLine);
}
}
}
writer.Write(NewLine);
writer.Commit();
}
private static void Json(ref BufferWriter <WriterAdapter> writer, IBufferWriter <byte> bodyWriter)
{
writer.Write(_jsonPreamble);
// Date header
writer.Write(DateHeader.HeaderBytes);
writer.Commit();
Utf8JsonWriter utf8JsonWriter = t_writer ??= new Utf8JsonWriter(bodyWriter, new JsonWriterOptions {
SkipValidation = true
});
utf8JsonWriter.Reset(bodyWriter);
// Body
JsonSerializer.Serialize(utf8JsonWriter, new JsonMessage {
message = "Hello, World!"
}, SerializerContext.JsonMessage);
}
public void WriteResponseHeaders(int statusCode, string reasonPhrase, HttpResponseHeaders responseHeaders)
{
lock (_contextLock)
{
if (_completed)
{
return;
}
var buffer = _pipeWriter;
var writer = new BufferWriter <PipeWriter>(buffer);
writer.Write(_bytesHttpVersion11);
var statusBytes = ReasonPhrases.ToStatusBytes(statusCode, reasonPhrase);
writer.Write(statusBytes);
responseHeaders.CopyTo(ref writer);
writer.Write(_bytesEndHeaders);
writer.Commit();
}
}
