public async Task RunInboxAsync()
{
while (true)
{
try
{
if (Socket.State != WebSocketState.Open)
{
break;
}
var receivedString = await WebSocketUtils.ReceiveStringAsync(Socket, cancellationToken);
if (string.IsNullOrEmpty(receivedString))
{
continue;
}
Console.WriteLine(receivedString);
if (receivedString.StartsWith("MUSE:"))
{
string museJsonMessage = receivedString.Substring(5);
HandleMessage(museJsonMessage);
continue;
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message, e.StackTrace);
}
}
}
private void Init()
{
var webSocket = _webSocket = HuobiWebSocketClient.GetWebSocket();
webSocket.OnMessage += (sender, e) => {
var data = GZipDecompresser.Decompress(e.RawData);
if (data.Contains("ping"))
{
webSocket.Send(data.Replace("ping", "pong"));
}
else
{
try {
var updateEvent = Json.Deserialize <DepthTickUpdateEvent>(data);
_cache[updateEvent.Ch] = updateEvent.Tick;
}
catch (Exception) {
// ignored
}
}
};
webSocket.OnClose += (sender, e) => _cache.Clear();
webSocket.OnError += (sender, e) => WebSocketUtils.CloseWebSocket(webSocket);
webSocket.Connect();
}
public async Task RunOutboxAsync()
{
while (true)
{
try
{
if (Socket.State != WebSocketState.Open)
{
break;
}
// Send messages from the outbox.
string message = null;
while (Outbox.TryDequeue(out message))
{
await WebSocketUtils.SendStringAsync(Socket, message, cancellationToken);
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message, e.StackTrace);
}
}
}
/// <summary>
/// Create a new instance of <see cref="WebSocketUpgradeRequest"/>.
/// </summary>
public WebSocketUpgradeRequest()
: base("GET", "/", "HTTP/1.1")
{
Headers["Upgrade"] = "websocket";
Headers["Connection"] = "Upgrade";
Headers["Sec-WebSocket-Key"] = WebSocketUtils.CreateWebSocketKey();
Headers["Sec-WebSocket-Version"] = "13";
}
public WebSocketFrame Read(Stream stream, WebSocketClient client)
{
byte first;
try {
first = (byte)stream.ReadByte();
} catch (Exception e) {
return(null);
}
if (!WebSocketUtils.IsClientConnected(client))
{
return(null);
}
byte bitFinFlag = 0x80;
byte opcodeFlag = 0x0F;
bool bitFinSet = (first & bitFinFlag) == bitFinFlag;
WebSocketOpcode opcode = (WebSocketOpcode)(first & opcodeFlag);
byte bitMaskFlag = 0x80;
byte second = (byte)stream.ReadByte();
bool bitMaskSet = (second & bitMaskFlag) == bitMaskFlag;
uint length = ReadLength(stream, second);
if (length != 0)
{
byte[] decoded;
if (bitMaskSet)
{
byte[] key = WebSocketReaderWriter.Read(stream, 4);
byte[] encoded = WebSocketReaderWriter.Read(stream, length);
decoded = new byte[length];
for (int i = 0; i < encoded.Length; i++)
{
decoded[i] = (byte)(encoded[i] ^ key[i % 4]);
}
}
else
{
decoded = WebSocketReaderWriter.Read(stream, length);
}
WebSocketFrame frame = new WebSocketFrame(opcode, decoded);
return(frame);
}
return(null);
}
private void SetTimer()
{
var timer = new System.Timers.Timer(5000);
timer.Elapsed += (a, b) => {
if (_webSocket.IsAlive)
{
return;
}
WebSocketUtils.CloseWebSocket(_webSocket);
_cache.Clear();
Init();
};
timer.AutoReset = true;
timer.Enabled = true;
}
private void Init()
{
var webSocket = _webSocket = HuobiWebSocketClient.GetWebSocket();
webSocket.OnMessage += (sender, e) => {
var data = GZipDecompresser.Decompress(e.RawData);
if (data.Contains("ping"))
{
webSocket.Send(data.Replace("ping", "pong"));
}
else
{
try {
var updateEvent = Json.Deserialize <TrickUpdateEvent>(data);
if (!_cache.ContainsKey(updateEvent.Ch))
{
lock (this) {
if (!_cache.ContainsKey(updateEvent.Ch))
{
_cache[updateEvent.Ch] = SortedDictionaryFactory.NewSortedDictionary();
}
}
}
var ticks = _cache[updateEvent.Ch];
ticks[updateEvent.Tick.Id] = updateEvent.Tick;
while (ticks.Count > Size)
{
ticks.Remove(ticks.Last().Key);
}
}
catch (Exception) {
// ignored
}
}
};
webSocket.OnClose += (sender, e) => _cache.Clear();
webSocket.OnError += (sender, e) => WebSocketUtils.CloseWebSocket(webSocket);
webSocket.Connect();
}
public void Send(string connectionId, byte[] buffer)
{
UserTokenEventArgs userToken = UserDic.Get(connectionId);
if (userToken == null || userToken.UserSocket == null)
{
return;
}
if (userToken.ClientType == ClientType.WebSocket)
{
buffer = WebSocketUtils.PackServerData(buffer);//或者使用DataFram
}
SocketAsyncEventArgs sendEventArgs = null;
if (this.sendStackPool.TryPop(out sendEventArgs))
{
try
{
sendEventArgs.UserToken = userToken;
sendEventArgs.SetBuffer(buffer, 0, buffer.Length);//最后设置发送数据
//异步发送数据
//Array.Copy(buffer, 0, sendEventArgs.Buffer, 0, buffer.Length);//设置发送数据
bool willRaiseEvent = userToken.UserSocket.SendAsync(sendEventArgs);//采用异步发送才能处理sendStackPool
if (!willRaiseEvent)
{
ProcessSend(sendEventArgs);
}
}
catch (ObjectDisposedException)//调用此处的异步发送可能socket被其他进程关闭异常
{
RaiseDisconnectedEvent(userToken);
}
catch (Exception ex)
{
RaiseErrorEvent(userToken, ex);
RaiseDisconnectedEvent(userToken);
}
}
}
private void Init()
{
var webSocket = _webSocket = HuobiWebSocketClient.GetWebSocket();
webSocket.OnMessage += (sender, e) => {
var data = GZipDecompresser.Decompress(e.RawData);
if (data.Contains("ping"))
{
(sender as WebSocket)?.Send(data.Replace("ping", "pong"));
}
else
{
try {
var updateEvent = Json.Deserialize <TradeTickUpdateEvent>(data);
if (!_cache.ContainsKey(updateEvent.Ch))
{
_cache[updateEvent.Ch] = new ConcurrentQueue <TradeData>();
}
foreach (var tradeData in updateEvent.Tick.Data)
{
_cache[updateEvent.Ch].Enqueue(tradeData);
}
while (_cache[updateEvent.Ch].Count > 100)
{
_cache[updateEvent.Ch].TryDequeue(out _);
}
}
catch (Exception exception) {
Console.WriteLine(exception);
}
}
};
webSocket.OnClose += (sender, e) => _cache.Clear();
webSocket.OnError += (sender, e) => WebSocketUtils.CloseWebSocket(webSocket);
webSocket.Connect();
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
//TODO: fix this hack
filterContext.HttpContext.Response.Content = new HttpStringContent(" ");
if (filterContext.HttpContext.RouteUri == null)
{
filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Bad Request");
return;
}
if (this.Request.Headers.Contains(new KeyValuePair <string, string>("Upgrade", "Websocket")) &&
this.Request.Headers.Contains(new KeyValuePair <string, string>("Connection", "Upgrade")))
{
string webSocketVersion;
this.Request.Headers.TryGetValue("Sec-WebSocket-Version", out webSocketVersion);
if (webSocketVersion != "13")
{
filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Invalid Websocket Version");
return;
}
string webSocketKey;
if (this.Request.Headers.TryGetValue("Sec-WebSocket-Key", out webSocketKey))
{
filterContext.HttpContext.Response.Headers.Add("Upgrade", "Websocket");
filterContext.HttpContext.Response.Headers.Add("Sec-WebSocket-Accept", WebSocketUtils.HashWebSocketKey(webSocketKey));
filterContext.HttpContext.Response.Headers.Add("Sec-WebSocket-Location", "ws://localhost:8181/websession");
string webSocketOrigin;
this.Request.Headers.TryGetValue("Sec-WebSocket-Origin", out webSocketOrigin);
if (webSocketOrigin != null)
{
filterContext.HttpContext.Response.Headers.Add("Sec-WebSocket-Origin", webSocketOrigin);
}
filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.SwitchingProtocols, "WebSocket Protocol Handshake");
base.OnActionExecuting(filterContext);
}
}
}
/// <summary>
/// Handle the request.
/// </summary>
/// <param name="context">HTTP context</param>
/// <returns><see cref="ModuleResult.Stop"/> will stop all processing except <see cref="IHttpModule.EndRequest"/>.</returns>
/// <remarks>Invoked in turn for all modules unless you return <see cref="ModuleResult.Stop"/>.</remarks>
public ModuleResult HandleRequest(IHttpContext context)
{
if (context.RouteUri == null)
{
context.Response.StatusCode = HttpStatusCode.BadRequest;
context.Response.ReasonPhrase = "Bad Request";
return(ModuleResult.Stop);
}
// only handle GET requests
if (context.Response.RequestMessage.Method != HttpMethod.Get)
{
return(ModuleResult.Continue);
}
if (context.RouteUri.AbsolutePath == _uriEndPoint)
{
HttpRequestMessage httpMessage = context.Response.RequestMessage;
if (httpMessage.Headers.Contains(new KeyValuePair <string, string>("Upgrade", "Websocket")) &&
httpMessage.Headers.Contains(new KeyValuePair <string, string>("Connection", "Upgrade")))
{
string webSocketVersion;
httpMessage.Headers.TryGetValue("Sec-WebSocket-Version", out webSocketVersion);
if (webSocketVersion != "13")
{
context.Response.StatusCode = HttpStatusCode.BadRequest;
context.Response.ReasonPhrase = "Invalid Websocket Version";
return(ModuleResult.Stop);
}
string webSocketKey;
if (httpMessage.Headers.TryGetValue("Sec-WebSocket-Key", out webSocketKey))
{
context.Response.StatusCode = HttpStatusCode.SwitchingProtocols;
context.Response.ReasonPhrase = "WebSocket Protocol Handshake";
context.Response.Headers.Add("Upgrade", "Websocket");
context.Response.Headers.Add("Sec-WebSocket-Accept", WebSocketUtils.HashWebSocketKey(webSocketKey));
context.Response.Headers.Add("Sec-WebSocket-Location", "ws://localhost:8181/websession");
string webSocketOrigin;
httpMessage.Headers.TryGetValue("Sec-WebSocket-Origin", out webSocketOrigin);
if (webSocketOrigin != null)
{
context.Response.Headers.Add("Sec-WebSocket-Origin", webSocketOrigin);
}
context.Response.Content = new HttpStringContent("Switching Protocols");
//IWebSocketMessage webSocketMessage = msg as IWebSocketMessage;
//if (webSocketMessage != null)
//{
// // standard message responses handled by listener
// switch (webSocketMessage.Opcode)
// {
// case WebSocketOpcode.Ping:
// source.Send(new WebSocketMessage(WebSocketOpcode.Pong, webSocketMessage.Payload));
// return;
// case WebSocketOpcode.Close:
// source.Send(new WebSocketMessage(WebSocketOpcode.Close));
// source.Close();
// WebSocketClientDisconnected(this,
// new ClientDisconnectedEventArgs(source, new Exception("WebSocket closed")));
// return;
// }
// _webSocketMessageReceived(source, webSocketMessage);
// return;
return(ModuleResult.Stop);
}
else
{
context.Response.StatusCode = HttpStatusCode.BadRequest;
context.Response.ReasonPhrase = "Bad Request";
return(ModuleResult.Stop);
}
}
}
return(ModuleResult.Continue);
}
