| public abstract CreateMessageWriter ( WebSocketMessageType messageType ) : vtortola.WebSockets.WebSocketMessageWriteStream | ||
| messageType | WebSocketMessageType | |
| Résultat | vtortola.WebSockets.WebSocketMessageWriteStream | |
public async Task SendWSMessage(NetworkWriter msg)
{
var responseStream = new MemoryStream();
responseStream.Write(msg.AsArraySegment().Array, 0, msg.AsArraySegment().Count);
using (var writer = Socket.CreateMessageWriter(WebSocketMessageType.Binary))
{
await writer.WriteAsync(UNetMessage.Serialize(responseStream.ToArray()));
await writer.FlushAsync();
}
}
private async void WriteSocketAsync(CancellationToken ct)
{
try
{
while (!ct.IsCancellationRequested && _listener.IsConnected)
{
var message = await _sendBuffer.DequeueAsync(ct).ConfigureAwait(false);
using (var output = _listener.CreateMessageWriter(WebSocketMessageType.Text))
using (var writer = new StreamWriter(output))
{
if (Trace)
{
Logger.DebugFormat("Socket write message: '{0}'", message);
}
await writer.WriteAsync(message).ConfigureAwait(false);
}
}
}
catch (OperationCanceledException e)
{
if (Trace)
{
Logger.DebugFormat("Socket operation cancelled: '{0}'", e.Message);
}
}
catch (Exception e)
{
OnError?.Invoke(this, e);
}
}
public static async Task WriteStringAsync([NotNull] this WebSocket webSocket, [NotNull] char[] data, int offset, int count, CancellationToken cancellationToken = default(CancellationToken))
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if (offset + count > data.Length)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
cancellationToken.ThrowIfCancellationRequested();
using (var msg = webSocket.CreateMessageWriter(WebSocketMessageType.Text))
using (var writer = new StreamWriter(msg, Utf8NoBom))
{
await writer.WriteAsync(data, offset, count).ConfigureAwait(false);
await writer.FlushAsync().ConfigureAwait(false);
await msg.CloseAsync().ConfigureAwait(false);
}
}
public static async Task WriteBytesAsync([NotNull] this WebSocket webSocket, [NotNull] byte[] data, int offset, int count, CancellationToken cancellationToken = default(CancellationToken))
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if (offset + count > data.Length)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
cancellationToken.ThrowIfCancellationRequested();
using (var writer = webSocket.CreateMessageWriter(WebSocketMessageType.Binary))
{
await writer.WriteAndCloseAsync(data, offset, count, cancellationToken).ConfigureAwait(false);
}
}
public static async Task WriteStringAsync(this WebSocket ws, String data, CancellationToken cancel)
{
using (var msg = ws.CreateMessageWriter(WebSocketMessageType.Text))
using (var writer = new StreamWriter(msg, Encoding.UTF8))
{
writer.Write(data);
await writer.FlushAsync().ConfigureAwait(false);
}
}
public async void PushBinary(WebSocket client, string endpoint, string syncKey, byte[] data)
{
try
{
using (var messageWriter = client.CreateMessageWriter(WebSocketMessageType.Binary))
{
using (var stream = new MemoryStream(data))
{
await stream.CopyToAsync(messageWriter);
}
}
}
catch (Exception)
{
//should never happen
}
}
public static async Task WriteStringAsync(this WebSocket webSocket, string data, CancellationToken cancellationToken = default(CancellationToken))
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
cancellationToken.ThrowIfCancellationRequested();
using (var msg = webSocket.CreateMessageWriter(WebSocketMessageType.Text))
using (var writer = new StreamWriter(msg, Utf8NoBom))
{
await writer.WriteAsync(data).ConfigureAwait(false);
await writer.FlushAsync().ConfigureAwait(false);
await msg.CloseAsync().ConfigureAwait(false);
}
}
public override async Task SendAsync(Envelope envelope, CancellationToken cancellationToken)
{
EnsureIsConnected();
await _sendSemaphore.WaitAsync(cancellationToken);
try
{
using (var stream = _webSocket.CreateMessageWriter(WebSocketMessageType.Text))
{
using (var writer = new StreamWriter(stream, Encoding.UTF8))
{
var envelopeJson = _envelopeSerializer.Serialize(envelope);
await TraceDataIfEnabledAsync(envelopeJson, DataOperation.Send).ConfigureAwait(false);
await writer.WriteAsync(envelopeJson).ConfigureAwait(false);
}
}
}
finally
{
_sendSemaphore.Release();
}
}
public static void WriteString(this WebSocket ws, String data)
{
using (var msg = ws.CreateMessageWriter(WebSocketMessageType.Text))
using (var writer = new StreamWriter(msg, Encoding.UTF8))
writer.Write(data);
}
static async Task HandleConnectionAsync(WebSocket ws, CancellationToken token)
{
try
{
PerformanceCounters.Connected.Increment();
Byte[] buffer = new Byte[2046];
Int32 readed;
IWebSocketLatencyMeasure l = ws as IWebSocketLatencyMeasure;
while (ws.IsConnected && !token.IsCancellationRequested)
{
// await a message
using (var messageReader = await ws.ReadMessageAsync(token).ConfigureAwait(false))
{
if (messageReader == null)
continue; // disconnection
switch (messageReader.MessageType)
{
case WebSocketMessageType.Text:
PerformanceCounters.MessagesIn.Increment();
using (var messageWriter = ws.CreateMessageWriter(WebSocketMessageType.Text))
{
readed = -1;
Int32 r = 0;
while(readed!=0)
{
readed = messageReader.Read(buffer, 0, buffer.Length);
if (readed != 0)
{
messageWriter.Write(buffer, 0, readed);
r += readed;
}
}
await messageWriter.CloseAsync(token).ConfigureAwait(false);
}
PerformanceCounters.MessagesOut.Increment();
break;
case WebSocketMessageType.Binary:
using (var messageWriter = ws.CreateMessageWriter(WebSocketMessageType.Binary))
await messageReader.CopyToAsync(messageWriter).ConfigureAwait(false);
break;
}
}
PerformanceCounters.Delay.IncrementBy(l.Latency.Ticks * Stopwatch.Frequency / 10000);
PerformanceCounters.DelayBase.Increment();
}
}
catch (TaskCanceledException)
{
}
catch (Exception aex)
{
var ex = aex.GetBaseException();
_log.Error("HandleConnectionAsync", ex);
Log("Error Handling connection: " + ex.GetType().Name + ": " + ex.Message);
try { ws.Close(); }
catch { }
}
finally
{
ws.Dispose();
PerformanceCounters.Connected.Decrement();
}
}
public async void PushFile(WebSocket client, string filePath)
{
using (var messageWriter = client.CreateMessageWriter(WebSocketMessageType.Binary))
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
await fs.CopyToAsync(messageWriter);
}
}
