public static async Task <(XdrBufferFactory.RentedBuffer messageBuffer, WebSocketMessageType messageType)> GetWebsocketBuffer(this WebSocket webSocket, int maxMessageSize, CancellationToken cancellationToken)
{
var length = 0;
var messageType = default(WebSocketMessageType);
var messageBuffer = XdrBufferFactory.Rent(maxMessageSize);
while (true)
{
if (length + ChunkSize > maxMessageSize)
{
throw new Exception("Too large message"); //TODO: handle it upstream
}
var chunk = messageBuffer.AsSegment(length, ChunkSize);
var result = await webSocket.ReceiveAsync(chunk, cancellationToken);
length += result.Count;
if (result.EndOfMessage)
{
messageType = result.MessageType;
break;
}
}
messageBuffer.Resize(length);
return(messageBuffer, messageType);
}
internal void SetAuditor()
{
incommingBuffer.Dispose();
incommingBuffer = XdrBufferFactory.Rent(AuditorBufferSize);
outgoingBuffer.Dispose();
outgoingBuffer = XdrBufferFactory.Rent(AuditorBufferSize);
IsResultRequired = false;
logger.Trace($"Connection {ClientKPAccountId} promoted to Auditor.");
}
public InfoWebSocketConnection(AlphaContext context, WebSocket webSocket, string connectionId, string ip)
: base(context)
{
this.webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
Ip = ip;
ConnectionId = connectionId;
cancellationTokenSource = new CancellationTokenSource();
cancellationToken = cancellationTokenSource.Token;
incomingBuffer = XdrBufferFactory.Rent(WebSocketExtension.ChunkSize);
}
public async Task GetInputStreamReaderTest()
{
using var buffer = XdrBufferFactory.Rent(20480);
var result = await new FakeWebSocket(Enumerable.Repeat((byte)1, 10240).ToArray()).GetWebsocketBuffer(buffer, CancellationToken.None);
Assert.AreEqual(10240, buffer.Length);
result = await new FakeWebSocket(Enumerable.Repeat((byte)1, 20480).ToArray()).GetWebsocketBuffer(buffer, CancellationToken.None);
Assert.AreEqual(20480, buffer.Length);
Assert.ThrowsAsync <Exception>(async() => await new FakeWebSocket(Enumerable.Repeat((byte)1, 25000).ToArray()).GetWebsocketBuffer(buffer, CancellationToken.None));
}
public BaseWebSocketConnection(Domain.ExecutionContext context, WebSocket webSocket, string ip, int inBufferSize, int outBufferSize)
: base(context)
{
this.webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
Ip = ip;
incommingBuffer = XdrBufferFactory.Rent(inBufferSize);
outgoingBuffer = XdrBufferFactory.Rent(outBufferSize);
cancellationTokenSource = new CancellationTokenSource();
cancellationToken = cancellationTokenSource.Token;
}
public static byte[] ComputeHash(this object objToSerialize)
{
var bytes = objToSerialize as byte[];
if (bytes != null)
{
return(SHA256.Create().ComputeHash(bytes));
}
using var buffer = XdrBufferFactory.Rent();
using var writer = new XdrBufferWriter(buffer.Buffer);
XdrConverter.Serialize(objToSerialize, writer);
var hash = SHA256.Create().ComputeHash(buffer.Buffer, 0, writer.Length);
return(hash);
}
public override Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
lock (sendingSemaphore)
{
if (!endOfMessage)
{
throw new InvalidOperationException("Only completed messages are supported.");
}
var message = XdrBufferFactory.Rent(buffer.Count);
var segment = message.AsSegment(0, buffer.Count);
buffer.CopyTo(segment);
message.Resize(buffer.Count);
secondPartyPendingMessages.Add(new TestMessage(message, messageType, endOfMessage));
}
return(Task.CompletedTask);
}
public virtual async Task SendMessage(MessageEnvelope envelope)
{
await sendMessageSemaphore.WaitAsync();
try
{
Global.ExtensionsManager.BeforeSendMessage(this, envelope);
if (!envelope.IsSignedBy(Global.Settings.KeyPair.PublicKey))
{
envelope.Sign(Global.Settings.KeyPair);
}
using var buffer = XdrBufferFactory.Rent();
using var writer = new XdrBufferWriter(buffer.Buffer);
XdrConverter.Serialize(envelope, writer);
if (webSocket == null)
{
throw new ObjectDisposedException(nameof(webSocket));
}
if (webSocket.State == WebSocketState.Open)
{
await webSocket.SendAsync(buffer.AsSegment(0, writer.Length), WebSocketMessageType.Binary, true, cancellationToken);
}
Global.ExtensionsManager.AfterSendMessage(this, envelope);
}
catch (Exception exc)
{
if (exc is OperationCanceledException ||
exc is WebSocketException socketException && (socketException.WebSocketErrorCode == WebSocketError.InvalidState))
{
return;
}
Global.ExtensionsManager.SendMessageFailed(this, envelope, exc);
throw;
}
finally
{
sendMessageSemaphore.Release();
}
}
public async Task TestWebsocket()
{
var leftWebsocket = new MockWebSocket();
var rightWebsocket = new MockWebSocket();
leftWebsocket.Connect(rightWebsocket);
rightWebsocket.Connect(leftWebsocket);
var receiveData = XdrBufferFactory.Rent(1024);
for (var i = 0; i < 100000; i++)
{
var data = GetTestData();
await rightWebsocket.SendAsync(data, WebSocketMessageType.Binary, true, CancellationToken.None);
var segment = receiveData.AsSegment(0, 1024);
var res = await leftWebsocket.ReceiveAsync(segment, CancellationToken.None);
Assert.AreEqual(data.Length, res.Count);
Assert.IsTrue(data.SequenceEqual(segment.Slice(0, res.Count).ToArray()));
}
}
public QuantumHandler(ExecutionContext context)
: base(context)
{
buffer = XdrBufferFactory.Rent(256 * 1024);
}
