public void ReadBlocking(MessagePipeCallback callback)
{
LinkedList <WebSocketRequestMessage> requests = Websocket.readRequests();
int amount = requests.Count;
SignalServiceEnvelope[] envelopes = new SignalServiceEnvelope[amount];
WebSocketResponseMessage[] responses = new WebSocketResponseMessage[amount];
for (int i = 0; i < amount; i++)
{
WebSocketRequestMessage msg = requests.First.Value;
requests.RemoveFirst();
if (isSignalServiceEnvelope(msg))
{
envelopes[i] = new SignalServiceEnvelope(msg.Body.ToByteArray(), CredentialsProvider.GetSignalingKey());
}
responses[i] = createWebSocketResponse(msg);
}
try
{
callback.onMessages(envelopes);
}
finally
{
foreach (WebSocketResponseMessage response in responses)
{
Websocket.SendResponse(response);
}
}
}
/// <summary>
/// Blocks until a message was received, calls the IMessagePipeCallback and confirms the message to the server, unless the pipe's token is cancelled.
/// </summary>
/// <param name="callback"></param>
public async Task ReadBlocking(IMessagePipeCallback callback)
{
Logger.LogTrace("ReadBlocking()");
WebSocketRequestMessage request = Websocket.ReadRequestBlocking();
if (IsSignalServiceEnvelope(request))
{
SignalServiceMessagePipeMessage message = new SignalServiceEnvelope(request.Body.ToByteArray(), CredentialsProvider.SignalingKey);
WebSocketResponseMessage response = CreateWebSocketResponse(request);
try
{
Logger.LogDebug("Calling callback with message {0}", request.Id);
await callback.OnMessage(message);
}
finally
{
if (!Token.IsCancellationRequested)
{
Logger.LogDebug("Confirming message {0}", request.Id);
Websocket.SendResponse(response);
}
}
}
else if (IsPipeEmptyMessage(request))
{
Logger.LogInformation("Calling callback with SignalServiceMessagePipeEmptyMessage");
await callback.OnMessage(new SignalServiceMessagePipeEmptyMessage());
}
else
{
Logger.LogWarning("Unknown request: {0} {1}", request.Verb, request.Path);
}
}
public void SendErrorResponse(WebSocketResponseMessage response, int requestId, string message)
{
response.Success = false;
response.ErrorMessage = message;
response.ResponseId = requestId;
Log.Print(LogType.Error, message);
Send(response);
}
public void SendErrorResponse(WebSocketResponseMessage response, int requestId, Exception error)
{
response.Success = false;
response.ErrorMessage = error.Message;
response.ResponseId = requestId;
Log.Print(LogType.Error, error.Message);
Console.WriteLine(error);
Send(response);
}
public void OnEvent(string resp)
{
WebSocketResponseMessage wsResp = wsResp = JsonConvert.DeserializeObject <WebSocketResponseMessage>(resp);
lock (tSubscrLock)
{
if (wsResp.IsResponse())//We have the response to a subscription
{
WebSocketSubscriptionResponse requestRespSubscr = JsonConvert.DeserializeObject <WebSocketSubscriptionResponse>(resp);
if (ResponseRequestSubscriptions.ContainsKey(requestRespSubscr.GetSubscriptionEvent()))
{
WebSocketSubscriptionResponse requestRespEvent = ResponseRequestSubscriptions[requestRespSubscr.GetSubscriptionEvent()];
requestRespEvent.RunSubscritionEvent(requestRespSubscr);
}
}
else if (resp.Contains("error"))
{
WebSocketErrorMessage wsError = JsonConvert.DeserializeObject <WebSocketErrorMessage>(resp);
if (wsError.request != null)
{
foreach (string ev in wsError.request.args)
{
string[] fields = ev.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
string key = fields[0];
string symbol = fields.Length > 1 ? fields[1] : null;
WebSocketSubscriptionEvent subscrEvent = EventSubscriptions[key];
if (subscrEvent != null)
{
wsError.Symbol = symbol;
subscrEvent.RunEvent(wsError);
}
}
}
else
{
ProcessSubscriptionEvent(resp);
}
}
else //We have an event from a subscription
{
ProcessSubscriptionEvent(resp);
}
}
}
public async void sendResponse(WebSocketResponseMessage response)
{
if (socket == null)
{
throw new Exception("Connection closed!");
}
WebSocketMessage message = WebSocketMessage.CreateBuilder()
.SetType(WebSocketMessage.Types.Type.RESPONSE)
.SetResponse(response)
.Build();
messageWriter.WriteBytes(message.ToByteArray());
await messageWriter.StoreAsync();
}
private void HandleGenericSubscription(WebSocketResponseMessage WebSocketResponseMessage)
{
WebSocketSubscriptionResponse resp = (WebSocketSubscriptionResponse)WebSocketResponseMessage;
if (resp.success)
{
DoLog(string.Format("Successfully subscribed to {0} event on symbol {1}",
resp.GetSubscriptionEvent(), resp.GetSubscriptionAsset()), Main.Common.Util.Constants.MessageType.Information);
}
else
{
Console.WriteLine(string.Format("Error on subscription to {0} event on symbol {1}:{2}",
resp.GetSubscriptionEvent(), resp.GetSubscriptionAsset(), resp.error), Main.Common.Util.Constants.MessageType.Error);
}
}
protected void HandleGenericSubscription(WebSocketResponseMessage WebSocketResponseMessage)
{
WebSocketSubscriptionResponse resp = (WebSocketSubscriptionResponse)WebSocketResponseMessage;
if (resp.success)
{
DoLog(string.Format("Successfully subscribed to {0} event ",
resp.GetSubscriptionEvent()), Main.Common.Util.Constants.MessageType.Information);
}
else
{
DoLog(string.Format("Error on subscription to {0} event:{!}",
resp.GetSubscriptionEvent(), resp.error), Main.Common.Util.Constants.MessageType.Error);
}
}
private WebSocketResponseMessage createWebSocketResponse(WebSocketRequestMessage request)
{
if (isSignalServiceEnvelope(request))
{
return(WebSocketResponseMessage.CreateBuilder()
.SetId(request.Id)
.SetStatus(200)
.SetMessage("OK")
.Build());
}
else
{
return(WebSocketResponseMessage.CreateBuilder()
.SetId(request.Id)
.SetStatus(400)
.SetMessage("Unknown")
.Build());
}
}
private void OnMessageReceived(WebSocketConnection sender, WebSocketRequestMessage request)
{
WebSocketResponseMessage response = createWebSocketResponse(request);
Debug.WriteLine($"Verb: {request.Verb}, Path {request.Path}, Body({request.Body.Length}): {request.Body}, Id: {request.Id}");
try
{
if (isSignalServiceEnvelope(request))
{
SignalServiceEnvelope envelope = new SignalServiceEnvelope(request.Body.ToByteArray(),
credentialsProvider.GetSignalingKey());
MessageReceived(this, envelope);
}
}
//catch (Exception e) { } // ignore for now
finally
{
websocket.sendResponse(response);
}
}
/// <summary>
/// Blocks until a message was received, calls the IMessagePipeCallback and confirms the message to the server, unless the pipe's token is canceled.
/// </summary>
/// <param name="callback"></param>
public async Task ReadBlockingAsync(IMessagePipeCallback callback)
{
logger.LogTrace("ReadBlocking()");
if (credentialsProvider == null)
{
throw new ArgumentException("You can't read messages if you haven't specified credentials");
}
WebSocketRequestMessage request = websocket.ReadRequestBlocking();
if (IsSignalServiceEnvelope(request))
{
SignalServiceMessagePipeMessage message = new SignalServiceEnvelope(request.Body.ToByteArray());
WebSocketResponseMessage response = CreateWebSocketResponse(request);
try
{
logger.LogDebug("Calling callback with message {0}", request.Id);
await callback.OnMessageAsync(message);
}
finally
{
if (!token.IsCancellationRequested)
{
logger.LogDebug("Confirming message {0}", request.Id);
websocket.SendResponse(response);
}
}
}
else if (IsPipeEmptyMessage(request))
{
logger.LogInformation("Calling callback with SignalServiceMessagePipeEmptyMessage");
await callback.OnMessageAsync(new SignalServiceMessagePipeEmptyMessage());
}
else
{
logger.LogWarning("Unknown request: {0} {1}", request.Verb, request.Path);
}
}
public async void sendResponse(WebSocketResponseMessage response)
{
if (socket == null)
{
throw new Exception("Connection closed!");
}
WebSocketMessage message = WebSocketMessage.CreateBuilder()
.SetType(WebSocketMessage.Types.Type.RESPONSE)
.SetResponse(response)
.Build();
messageWriter.WriteBytes(message.ToByteArray());
await messageWriter.StoreAsync();
}
protected void QuoteSubscriptionResponse(WebSocketResponseMessage subcrResp)
{
HandleGenericSubscription(subcrResp);
}
protected void OrderBookSubscriptionResponse(WebSocketResponseMessage WebSocketResponseMessage)
{
HandleGenericSubscription(WebSocketResponseMessage);
}
protected void ExecutionReportSubscriptionResponse(WebSocketResponseMessage WebSocketResponseMessage)
{
HandleGenericSubscription(WebSocketResponseMessage);
}
