/// <summary>
/// Sends an envelope to
/// the connected node
/// </summary>
/// <param name="envelope">Envelope to be transported</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override async Task SendAsync(Envelope envelope, CancellationToken cancellationToken)
{
if (envelope == null)
{
throw new ArgumentNullException("envelope");
}
if (_stream == null ||
!_stream.CanWrite)
{
throw new InvalidOperationException("Invalid stream state. Call OpenAsync first.");
}
var envelopeJson = _envelopeSerializer.Serialize(envelope);
if (_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync(envelopeJson, DataOperation.Send).ConfigureAwait(false);
}
var jsonBytes = Encoding.UTF8.GetBytes(envelopeJson);
await _sendSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
await _stream.WriteAsync(jsonBytes, 0, jsonBytes.Length, cancellationToken).ConfigureAwait(false);
}
finally
{
_sendSemaphore.Release();
}
}
public override async Task SendAsync(Envelope envelope, CancellationToken cancellationToken)
{
if (envelope == null)
{
throw new ArgumentNullException(nameof(envelope));
}
if (_clientWebSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException("The connection was not initialized. Call OpenAsync first.");
}
var envelopeJson = _envelopeSerializer.Serialize(envelope);
if (_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync(envelopeJson, DataOperation.Send).ConfigureAwait(false);
}
var jsonBytes = Encoding.UTF8.GetBytes(envelopeJson);
await _sendSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
await _clientWebSocket.SendAsync(new ArraySegment <byte>(jsonBytes), WebSocketMessageType.Text, true,
cancellationToken).ConfigureAwait(false);
}
finally
{
_sendSemaphore.Release();
}
}
private void HandleReceivedData(RedisChannel channel, RedisValue value)
{
var envelopeJson = (string)value;
_traceWriter.TraceIfEnabledAsync(envelopeJson, DataOperation.Receive).Wait();
var envelope = _envelopeSerializer.Deserialize(envelopeJson);
var session = envelope as Session;
if (session == null ||
session.State != SessionState.New)
{
_traceWriter.TraceAsync("RedisTransportListener: An unexpected envelope was received", DataOperation.Error).Wait();
}
else
{
var transport = new RedisTransport(
_connectionMultiplexer,
_envelopeSerializer,
_traceWriter,
_channelNamespace,
RedisTransport.ClientChannelPrefix,
RedisTransport.ServerChannelPrefix);
_transportBufferBlock.SendAsync(transport).Wait();
transport.ReceivedEnvelopesBufferBlock.SendAsync(envelope).Wait();
}
}
private Task TraceAsync(string data, DataOperation operation)
{
if (_traceWriter == null || !_traceWriter.IsEnabled)
{
return(Task.CompletedTask);
}
return(_traceWriter.TraceAsync(data, operation));
}
private async Task TraceDataIfEnabledAsync(string envelopeJson, DataOperation dataOperation)
{
if (_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync(envelopeJson, dataOperation).ConfigureAwait(false);
}
}
public static Task TraceIfEnabledAsync(this ITraceWriter traceWriter, string data, DataOperation operation)
{
if (traceWriter == null || !traceWriter.IsEnabled)
{
return(TaskUtil.CompletedTask);
}
return(traceWriter.TraceAsync(data, operation));
}
public override async Task SendAsync(Envelope envelope, CancellationToken cancellationToken)
{
if (envelope == null)
{
throw new ArgumentNullException(nameof(envelope));
}
if (WebSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException("Could not send envelope: websocket is not open");
}
var envelopeJson = _envelopeSerializer.Serialize(envelope);
if (_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync(envelopeJson, DataOperation.Send).ConfigureAwait(false);
}
var jsonBytes = Encoding.UTF8.GetBytes(envelopeJson);
await _sendSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
if (WebSocket.State != WebSocketState.Open)
{
throw new InvalidOperationException("Could not send envelope: websocket is not open");
}
try
{
await WebSocket.SendAsync(new ArraySegment <byte>(jsonBytes), _webSocketMessageType, true,
cancellationToken).ConfigureAwait(false);
}
catch (WebSocketException)
{
await CloseWithTimeoutAsync().ConfigureAwait(false);
throw;
}
finally
{
_sendSemaphore.Release();
}
}
/// <summary>
/// Submits the response
/// to the HTTP server.
/// </summary>
/// <param name="response">The response.</param>
/// <returns></returns>
private async Task SubmitResponseAsync(HttpResponse response)
{
Exception exception = null;
try
{
await _httpServer.SubmitResponseAsync(response).ConfigureAwait(false);
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null &&
_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync("SubmitResponseAsync: " + exception.ToString(), DataOperation.Send).ConfigureAwait(false);
}
}
protected async Task <Document> ParseDocumentAsync(HttpRequest request)
{
Document document = null;
MediaType mediaType;
if (MediaType.TryParse(request.Headers[HttpRequestHeader.ContentType], out mediaType))
{
using (var streamReader = new StreamReader(request.BodyStream))
{
var body = await streamReader.ReadToEndAsync().ConfigureAwait(false);
if (_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync(body, DataOperation.Receive).ConfigureAwait(false);
}
document = _serializer.Deserialize(body, mediaType);
}
}
return(document);
}
