private async Task HandleIncomingMessagesAsync(ClientWebSocket client, CancellationToken cancellationToken)
{
var lastChunk = string.Empty;
var readBufferSize = 512;
int bytesRead = 0;
byte[] chunkedBuffer = new byte[readBufferSize];
bytesRead = await ReceiveBufferedResponseAsync(client, chunkedBuffer, cancellationToken).ConfigureAwait(false);
while (!cancellationToken.IsCancellationRequested && bytesRead > 0)
{
var data = Encoding.UTF8.GetString(chunkedBuffer, 0, bytesRead);
var dechunkedData = DeChunkResponse(data);
foreach (var chunk in dechunkedData)
{
var localChunk = chunk;
if (!string.IsNullOrEmpty(lastChunk))
{
localChunk = lastChunk + localChunk;
}
try
{
var temp = JsonConvert.DeserializeAnonymousType(localChunk, new { id = string.Empty }, JsonSerializerSettings);
if (temp.id == null)
{
// assume streaming subscription response
RpcStreamingResponseMessage streamingResult = JsonConvert.DeserializeObject <RpcStreamingResponseMessage>(localChunk, JsonSerializerSettings);
var streamingArgs = new RpcStreamingResponseMessageEventArgs(streamingResult);
OnStreamingMessageRecieved(this, streamingArgs);
}
else
{
// assume regular rpc response
RpcResponseMessage result = JsonConvert.DeserializeObject <RpcResponseMessage>(localChunk, JsonSerializerSettings);
var rpcEventArgs = new RpcResponseMessageEventArgs(result);
OnMessageRecieved(this, rpcEventArgs);
continue;
}
lastChunk = string.Empty;
}
catch (Exception)
{
lastChunk = localChunk;
// swallow...
continue;
}
}
bytesRead = await ReceiveBufferedResponseAsync(client, chunkedBuffer, cancellationToken).ConfigureAwait(false);
}
}
public void HandleResponse(RpcStreamingResponseMessage rpcStreamingResponse)
{
lock (_lockingObject)
{
if (rpcStreamingResponse.Method == null)
{
if (rpcStreamingResponse.Id.ToString() == SubscribeRequestId.ToString())
{
if (rpcStreamingResponse.HasError)
{
HandleSubscribeResponseError(GetException(rpcStreamingResponse));
}
else
{
var result = rpcStreamingResponse.GetStreamingResult <string>();
this.SubscriptionState = SubscriptionState.Subscribed;
this.SubscriptionId = result;
StreamingClient.AddSubscription(SubscriptionId, this);
HandleSubscribeResponse(result);
}
}
if (!string.IsNullOrEmpty(UnsubscribeRequestId) && rpcStreamingResponse.Id.ToString() == UnsubscribeRequestId)
{
if (rpcStreamingResponse.HasError)
{
HandleUnsubscribeResponseError(GetException(rpcStreamingResponse));
}
else
{
var result = rpcStreamingResponse.GetStreamingResult <bool>();
if (result)
{
this.SubscriptionState = SubscriptionState.Unsubscribed;
StreamingClient.RemoveSubscription(SubscriptionId);
}
HandleUnsubscribeResponse(result);
}
}
}
else
{
if (rpcStreamingResponse.HasError)
{
HandleDataResponseError(GetException(rpcStreamingResponse));
}
else
{
var result = rpcStreamingResponse.GetStreamingResult <TSubscriptionDataResponse>();
HandleDataResponse(result);
}
}
}
}
public void HandleResponse(RpcStreamingResponseMessage rpcStreamingResponse)
{
if (rpcStreamingResponse.HasError)
{
HandleResponseError(
new RpcResponseException(new RpcError(rpcStreamingResponse.Error.Code, rpcStreamingResponse.Error.Message,
rpcStreamingResponse.Error.Data)));
}
else
{
var result = rpcStreamingResponse.GetStreamingResult <TResponse>();
HandleResponse(result);
}
}
private void HandleResponse(RpcStreamingResponseMessage response)
{
if (response.Method != null) // subscription
{
IRpcStreamingResponseHandler handler;
if (_requests.TryGetValue(response.Params.Subscription, out handler))
{
handler.HandleResponse(response);
}
}
else
{
IRpcStreamingResponseHandler handler;
if (_requests.TryRemove(response.Id.ToString(), out handler))
{
handler.HandleResponse(response);
}
}
}
protected RpcResponseException GetException(RpcStreamingResponseMessage rpcStreamingResponse)
{
return(new RpcResponseException(new Client.RpcError(rpcStreamingResponse.Error.Code, rpcStreamingResponse.Error.Message,
rpcStreamingResponse.Error.Data)));
}
public RpcStreamingResponseMessageEventArgs(RpcStreamingResponseMessage message)
{
this.Message = message;
}
