public ChatMessagesBusinessTest()
{
connectionManager = new ConnectionManager();
webSocketMessageHandler = new WebSocketMessageHandler(connectionManager);
chatUsersRepository = new Mock <IChatUsersRepository>();
channelRepository = new Mock <IChannelRepository>();
}
private const int LengthOfStringQuotes = 2; // ""
public WebSocketMessageHandlerTests(IJsonRpcMessageFormatter formatter, ITestOutputHelper logger)
: base(logger)
{
this.socket = new MockWebSocket();
this.formatter = formatter;
this.handler = new WebSocketMessageHandler(this.socket, this.formatter, BufferSize);
}
static async Task Main(string[] args)
{
using (var webSocket = new ClientWebSocket())
{
Console.WriteLine("正在与服务端建立连接...");
var uri = new Uri("ws://localhost:5000/rpc/greeter");
await webSocket.ConnectAsync(uri, CancellationToken.None);
Console.WriteLine("已建立连接");
Console.WriteLine("开始向服务端发送消息...");
var messageHandler = new WebSocketMessageHandler(webSocket);
var greeterClient = JsonRpc.Attach <IGreeter>(messageHandler);
var request = new HelloRequest {
Name = "精致码农"
};
var response = await greeterClient.SayHelloAsync(request);
Console.WriteLine($"收到来自服务端的响应：{response.Message}");
Console.WriteLine("正在断开连接...");
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "断开连接", CancellationToken.None);
Console.WriteLine("已断开连接");
}
Console.ReadKey();
}
/// <summary>
/// Connect to Binance Websocket Market Streams.
/// </summary>
/// <typeparam name="T">Type of stream message to return.</typeparam>
/// <param name="streamName">Stream Name to send Web Socket.</param>
/// <param name="webSocketMessageHandler">Callback for receive message.</param>
public void ConnectToWebSocketMarketStreams <T>(string streamName, WebSocketMessageHandler <T> webSocketMessageHandler)
{
var targetURI = BinanceConstants.WEBSOCKET_BASE_ENDPOINT_URL + streamName;
var ws = new WebSocket(targetURI);
ws.OnMessage += (sender, e) =>
{
var responseData = JsonConvert.DeserializeObject <T>(e.Data);
webSocketMessageHandler(responseData);
};
ws.OnError += (sender, e) =>
{
_socketList.Remove(ws);
};
ws.OnClose += (sender, e) =>
{
_socketList.Remove(ws);
};
ws.Connect();
_socketList.Add(ws);
}
public WebSocketManagerMiddleware(RequestDelegate next, WebSocketMessageHandler webSocketHandler, IHttpContextAccessor httpContextAccessor, ILogger <WebSocketManagerMiddleware> logger, IConfiguration configuration)
{
_configuration = configuration;
_next = next;
_webSocketHandler = webSocketHandler;
_httpContextAccessor = httpContextAccessor;
_logger = logger;
}
public SenparcWebSocketHubBase()
{
if (WebSocket.WebSocketConfig.WebSocketMessageHandlerFunc == null)
{
throw new WebSocketExceptionBase("WebSocket.WebSocketConfig.WebSocketMessageHandlerFunc 不能为 null！");
}
_webSocketMessageHandler = WebSocket.WebSocketConfig.WebSocketMessageHandlerFunc();
}
public ChatMessagesBusiness(IChatUsersRepository chatUsersRepository, WebSocketMessageHandler webSocketMessageHandler, ConnectionManager connectionManager,
IChannelRepository channelRepository)
{
this.chatUsersRepository = chatUsersRepository;
this.webSocketMessageHandler = webSocketMessageHandler;
this.connectionManager = connectionManager;
this.channelRepository = channelRepository;
}
private void ConnectWebSocketEndpoint <T>(Uri endpoint, WebSocketMessageHandler <T> messageHandler, ResponseParseHandler <T> customParseHandler = null) where T : WebSocketMessageBase
{
var ws = CreateNewWebSocket(endpoint);
ws.OnMessage += (sender, e) =>
{
logger.Debug("Msg: " + e.Data);
var eventData = customParseHandler == null?
JsonConvert.DeserializeObject <T>(e.Data) :
customParseHandler(e.Data);
messageHandler(eventData);
};
ws.Connect();
ActiveSockets.Add(ws);
}
public async Task <string> ConnectUserDataEndpoint(BinanceClient client, WebSocketMessageHandler <WsUserDataAccountUpdateMessage> accountUpdateHandler,
WebSocketMessageHandler <WsUserDataOrderUpdateMessage> orderUpdateHandler, WebSocketMessageHandler <WsUserDataTradeUpdateMessage> tradeUpdateHandler)
{
var listenKey = await client.StartUserDataStream();
var endpoint = GetWsEndpoint(string.Empty, listenKey);
var ws = CreateNewWebSocket(endpoint, listenKey);
ws.OnMessage += (sender, e) =>
{
logger.Debug("Msg: " + e.Data);
var responseObject = JObject.Parse(e.Data);
var eventType = (string)responseObject["e"];
switch (eventType)
{
case "outboundAccountInfo":
accountUpdateHandler(JsonConvert.DeserializeObject <WsUserDataAccountUpdateMessage>(e.Data));
return;
case "executionReport":
var executionType = (string)responseObject["x"];
if (executionType == ExecutionType.Trade)
{
tradeUpdateHandler(JsonConvert.DeserializeObject <WsUserDataTradeUpdateMessage>(e.Data));
return;
}
orderUpdateHandler(JsonConvert.DeserializeObject <WsUserDataOrderUpdateMessage>(e.Data));
return;
default:
throw new ApplicationException("Unexpected Event Type In Message");
}
};
ws.Connect();
ActiveSockets.Add(ws);
var keepAliveTimer = new Timer(KeepAliveHandler, new KeepAliveContext
{
Client = client,
ListenKey = listenKey
}, KeepAliveMilliseconds, KeepAliveMilliseconds);
return(listenKey);
}
static async Task Main(string[] args)
{
using (var webSocket = new ClientWebSocket())
{
await webSocket.ConnectAsync(new Uri("ws://localhost:5000/json-rpc-greeter"), CancellationToken.None);
IJsonRpcMessageHandler jsonRpcMessageHandler = new WebSocketMessageHandler(webSocket);
IGreeter jsonRpcGreeterClient = JsonRpc.Attach <IGreeter>(jsonRpcMessageHandler);
HelloReply helloReply = await jsonRpcGreeterClient.SayHelloAsync(new HelloRequest { Name = "Tomasz Pęczek" });
Console.WriteLine(helloReply.Message);
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Client closing", CancellationToken.None);
}
Console.ReadKey();
}
/// <summary>
/// Connect to Binance User Data Streams.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="listenKey"></param>
/// <param name="AccountUpdateMessageHandler">Callback for outboundAccountPosition receive message.</param>
/// <param name="BalanceUpdateMessageHandler">Callback for balanceUpdate receive message.</param>
/// <param name="OrderUpdateMessageHandler">Callback for executionReport receive message.</param>
public void ConnectToUserDataStreams <T>(string listenKey, WebSocketMessageHandler <AccountUpdate> AccountUpdateMessageHandler, WebSocketMessageHandler <BalanceUpdate> BalanceUpdateMessageHandler, WebSocketMessageHandler <OrderUpdate> OrderUpdateMessageHandler)
{
var targetURI = BinanceConstants.WEBSOCKET_BASE_ENDPOINT_URL + listenKey;
var ws = new WebSocket(targetURI);
ws.OnMessage += (sender, e) =>
{
var payload = JsonConvert.DeserializeObject <dynamic>(e.Data);
switch (payload.e.Value)
{
case "outboundAccountPosition":
var AccountUpdate = JsonConvert.DeserializeObject <AccountUpdate>(e.Data);
AccountUpdateMessageHandler(AccountUpdate);
break;
case "balanceUpdate":
var BalanceUpdate = JsonConvert.DeserializeObject <BalanceUpdate>(e.Data);
BalanceUpdateMessageHandler(BalanceUpdate);
break;
case "executionReport":
var OrderUpdate = JsonConvert.DeserializeObject <OrderUpdate>(e.Data);
OrderUpdateMessageHandler(OrderUpdate);
break;
}
};
ws.OnError += (sender, e) =>
{
_socketList.Remove(ws);
};
ws.OnClose += (sender, e) =>
{
_socketList.Remove(ws);
};
ws.Connect();
_socketList.Add(ws);
}
public async Task Invoke(HttpContext context)
{
if (context.WebSockets.IsWebSocketRequest)
{
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
IJsonRpcMessageHandler jsonRpcMessageHandler = new WebSocketMessageHandler(webSocket);
using (var jsonRpc = new JsonRpc(jsonRpcMessageHandler, new GreeterServer()))
{
jsonRpc.StartListening();
await jsonRpc.Completion;
}
}
else
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
}
}
public ConnectionMaintainer(String version, List <String> destinations, List <Int32> ports, X509Certificate2 cert)
{
this.Protocol = "message";
_cacert = cert;
_servers = new List <Uri>();
foreach (Int32 port in ports)
{
foreach (String destination in destinations)
{
String uriString = "ws://" + destination + ":" + port + "/gwupe-ws/ws";
try
{
Uri uri = new Uri(uriString);
_servers.Add(uri);
}
catch (UriFormatException e)
{
Logger.Error("Failed to parse URI " + uriString + ", skipping : " + e.Message);
}
}
}
_wsMessageHandler = new WebSocketMessageHandler(this);
}
//------------------------------------------------------------------------------------------------
// construction
//------------------------------------------------------------------------------------------------
public DeribitJsonRpcService
(
IDeribitService deribit,
IDeribitWebSocketService wsservice,
DeribitConfig config
)
{
// dependencies
this.deribit = deribit;
this.deribitconfig = config;
this.wsservice = wsservice;
// logger
this.logger = Serilog.Log.ForContext <DeribitJsonRpcService>();
// message formatter
JsonMessageFormatter messageformatter = new JsonMessageFormatter()
{
Encoding = Encoding.UTF8,
ProtocolVersion = new Version(2, 0),
};
// attach json rpc to websocket
WebSocketMessageHandler wsmh = new WebSocketMessageHandler(wsservice.ClientWebSocket);
this.JsonRpc = new StreamJsonRpc.JsonRpc(wsmh);
// build proxy // https://github.com/microsoft/vs-streamjsonrpc/blob/master/doc/dynamicproxy.md
this.RpcProxy = this.JsonRpc.Attach <IDeribitJsonRpcProxy>(new JsonRpcProxyOptions
{
ServerRequiresNamedArguments = true,
});
// tracing
if (config.EnableJsonRpcTracing)
{
var listener = new global::SerilogTraceListener.SerilogTraceListener();
this.JsonRpc.TraceSource.Listeners.Add(listener);
this.JsonRpc.TraceSource.Switch.Level = System.Diagnostics.SourceLevels.Information;
this.logger.Verbose("JsonRpc tracing enabled");
}
}
public async Task <IActionResult> Greeter()
{
if (!HttpContext.WebSockets.IsWebSocketRequest)
{
return(new BadRequestResult());
}
_logger.LogInformation("等待客户端连接...");
var socket = await HttpContext.WebSockets.AcceptWebSocketAsync();
_logger.LogInformation("已与客户端建立连接");
var handler = new WebSocketMessageHandler(socket);
using (var jsonRpc = new JsonRpc(handler, _greeterServer))
{
_logger.LogInformation("开始监听客户端消息...");
jsonRpc.StartListening();
await jsonRpc.Completion;
_logger.LogInformation("客户端断开了连接");
}
return(new EmptyResult());
}
public async Task WriteMessage_BufferIsSmallerThanOneEncodedChar()
{
this.handler = new WebSocketMessageHandler(this.socket, new JsonMessageFormatter(), 2);
this.formatter.Encoding = Encoding.UTF32;
await this.handler.WriteAsync(CreateDefaultMessage(), this.TimeoutToken);
}
public NotificationController(IBrokerRepository repo)
{
_messageHandler = new WebSocketMessageHandler(new WebSocketConnectionManager(), repo);
}
public WebSocketMessageHandlerTests(ITestOutputHelper logger)
: base(logger)
{
this.socket = new MockWebSocket();
this.handler = new WebSocketMessageHandler(this.socket, BufferSize);
}
public async Task WriteMessage_BufferIsSmallerThanOneEncodedChar()
{
this.handler = new WebSocketMessageHandler(this.socket, 2);
this.handler.Encoding = Encoding.UTF32;
await this.handler.WriteAsync(1, this.TimeoutToken);
}
public MessageApiController(IMessageService messageService, WebSocketMessageHandler chat)
{
_messageService = messageService;
_chat = chat;
}
public ChannelBusiness(IChannelRepository channelRepository, WebSocketMessageHandler webSocketMessageHandler)
{
this.channelRepository = channelRepository;
this.webSocketMessageHandler = webSocketMessageHandler;
}
public string ConnectUserDataEndpointSync(BinanceClient client,
WebSocketMessageHandler <WsUserDataAccountUpdateMessage> accountUpdateHandler,
WebSocketMessageHandler <WsUserDataOrderUpdateMessage> orderUpdateHandler,
WebSocketMessageHandler <WsUserDataTradeUpdateMessage> tradeUpdateHandler)
=> ConnectUserDataEndpoint(client, accountUpdateHandler, orderUpdateHandler, tradeUpdateHandler).Result;
public void ConnectTradesEndpoint(string symbol, WebSocketMessageHandler <WebSocketTradesMessage> messageHandler)
{
ConnectWebSocketEndpoint(GetWsEndpoint("aggTrade", symbol), messageHandler);
}
public void ConnectKlineEndpoint(string symbol, KlineInterval interval, WebSocketMessageHandler <WebSocketKlineMessage> messageHandler)
{
ConnectWebSocketEndpoint(GetWsEndpoint("kline_" + interval, symbol), messageHandler);
}
public void ConnectDepthEndpoint(string symbol, WebSocketMessageHandler <WebSocketDepthMessage> messageHandler)
{
ConnectWebSocketEndpoint(GetWsEndpoint("depth", symbol), messageHandler, CustomJsonParsers.DepthMessageParser);
}
public async Task WriteMessage_BufferIsSmallerThanOneEncodedChar()
{
this.handler = new WebSocketMessageHandler(this.socket, 2);
this.handler.Encoding = Encoding.UTF32;
await Assert.ThrowsAsync <ArgumentException>(() => this.handler.WriteAsync("a", this.TimeoutToken));
}
