static void Ping(dynamic Message, WebsocketClient Client)
{
Console.WriteLine("Got a ping");
Ping ping = new Ping();
Client.Send(JsonConvert.SerializeObject(ping));
}
public void RxPingTest()
{
//Arrange
var objWebSocketClient = Substitute.For <IWebSocketClient>();
var objKeepAliveMonitor = Substitute.For <IKeepAliveMonitor>();
var objClient = new WebsocketClient(objWebSocketClient, objKeepAliveMonitor);
var handler = Substitute.For <EventHandler <byte[]> >();
var eventArgs = Substitute.For <IMessageEventArgs>();
eventArgs.IsText.Returns(false);
eventArgs.IsPing.Returns(true);
eventArgs.IsBinary.Returns(false);
objClient.Rx += handler;
//Act
objClient.ConnectAsync(new ClientParams()
{
HostName = "localhost", Port = 80, Secure = false
});
objWebSocketClient.OnMessage += Raise.Event <EventHandler <IMessageEventArgs> >(objClient, eventArgs);
//Assert
objKeepAliveMonitor.Received(1).Reset();
handler
.Received(0)
.Invoke(Arg.Any <IConnection.IConnection>(), Arg.Any <byte[]>())
;
}
public async Task Open(string url)
{
if (url.StartsWith("https"))
{
url = url.Replace("https", "wss");
}
else if (url.StartsWith("http"))
{
url = url.Replace("http", "ws");
}
if (client != null)
{
return;
}
client = new WebsocketClient(new Uri(url));
client.MessageReceived.Subscribe(OnMessageReceived);
client.DisconnectionHappened.Subscribe(delegate(DisconnectionInfo info) { client.Reconnect(); });
client.ReconnectionHappened.Subscribe(delegate(ReconnectionInfo info)
{
Console.WriteLine(info.Type);
});
await client.Start();
}
private HandlerWorkResult HandleGameList(BufferStream stream, WebsocketClient client)
{
stream.Read(out ushort gameCount);
Console.WriteLine(gameCount);
var gameList = new List <GameModel>();
for (int i = 0; i < gameCount; i++)
{
var game = new GameModel(stream);
gameList.Add(game);
}
foreach (var game in gameList.Where(x => x.Started == 0))
{
Console.WriteLine("Game:" + game.Name);
Console.WriteLine("Started:" + game.Started);
Console.WriteLine("HasPassword:"******"Tick:" + game.GameTicks);
Console.WriteLine("Counter:" + game.GameCounter);
foreach (var player in game.Players)
{
Console.WriteLine("\tPlayer: " + player.Name + " color: " + player.Color);
}
}
return(new HandlerWorkResult()
{
IsOk = true,
});
}
public void ConnectAsyncTest()
{
//Arrange
var objWebSocketClient = Substitute.For <IWebSocketClient>();
var objKeepAliveMonitor = Substitute.For <IKeepAliveMonitor>();
var objClient = new WebsocketClient(objWebSocketClient, objKeepAliveMonitor);
//Act
objClient.ConnectAsync(new ClientParams()
{
HostName = "localhost",
Port = 80,
Secure = false,
ConnectionTimeoutSeconds = 666
});
//Assert
objWebSocketClient.Received(1).OnOpen += Arg.Any <EventHandler>();
objWebSocketClient.Received(1).OnClose += Arg.Any <EventHandler <ICloseEventArgs> >();
objWebSocketClient.Received(1).OnError += Arg.Any <EventHandler <IErrorEventArgs> >();
objWebSocketClient.Received(1).OnMessage += Arg.Any <EventHandler <IMessageEventArgs> >();
objKeepAliveMonitor.Received(1).TimeOut += Arg.Any <EventHandler>();
objKeepAliveMonitor.Received(1).UnResponsive += Arg.Any <EventHandler>();
Assert.AreEqual(666, objWebSocketClient.ConnectionTimeoutSeconds);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var exitEvent = new ManualResetEvent(false);
//var url = new Uri("wss://localhost:5001/api/Test/stream");
var url = new Uri("wss://localhost:27926/testWebSocket");
using (var client = new WebsocketClient(url))
{
client.ReconnectTimeout = TimeSpan.FromSeconds(300);
client.ReconnectionHappened.Subscribe(info =>
{
Console.WriteLine($"重连,type: {info.Type}");
});
client.MessageReceived.Subscribe(msg =>
{
Console.WriteLine($"收到消息: {msg}");
});
client.Start().Wait();
//Task.Run(() => StartSendingPing(client));
exitEvent.WaitOne();
}
}
public void ListenToWsEvents(WebsocketClient websocketClient, int delayBeforeReconnectInMs)
{
_webSocketClient.ReconnectTimeout = TimeSpan.FromMilliseconds(delayBeforeReconnectInMs);
_webSocketClient.ErrorReconnectTimeout = TimeSpan.FromMilliseconds(delayBeforeReconnectInMs * 4);
_webSocketClient.DisconnectionHappened.Subscribe(type => this.OnClose(this, type));
_webSocketClient.MessageReceived.Subscribe(type => this.OnMessage(this, type));
}
private void HandleMessage(WebsocketClient client, ResponseMessage message)
{
LoggerService.Information("WebSocket", "Message received");
string content = message.Text;
LoggerService.Debug("WebSocket", content);
try
{
WebSocketMessage wsm = JsonConvert.DeserializeObject <WebSocketMessage>(content);
switch (wsm.code)
{
case WebSocketMessageCode.Covid:
OnCovidMessageReceived(wsm.data.ToString());
break;
case WebSocketMessageCode.Test:
OnTestMessageReceived(wsm.data.ToString());
break;
}
}
catch
{
LoggerService.Warning("WebSocket", "Received a message in the wrong format. Ignoring.");
}
}
// Use this for initialization
void Start()
{
GameObject wso = GameObject.FindWithTag("WebsocketTag");
wsc = wso.GetComponent <WebsocketClient> ();
Button ghl = gh_l.GetComponent <Button> ();
Button hpl = hp_l.GetComponent <Button> ();
Button spl = sp_l.GetComponent <Button> ();
Button cpl = cp_l.GetComponent <Button> ();
Button ghr = gh_r.GetComponent <Button> ();
Button hpr = hp_r.GetComponent <Button> ();
Button spr = sp_r.GetComponent <Button> ();
Button cpr = cp_r.GetComponent <Button> ();
ghl.onClick.AddListener(goHome_left);
hpl.onClick.AddListener(handingPose_left);
spl.onClick.AddListener(shrugPose_left);
cpl.onClick.AddListener(cranePose_left);
ghr.onClick.AddListener(goHome_right);
hpr.onClick.AddListener(handingPose_right);
spr.onClick.AddListener(shrugPose_right);
cpr.onClick.AddListener(cranePose_right);
}
protected override void InitConnection()
{
SetStatus(DisplayStatus.Connecting);
ServerDiscoverer discoverer = new ServerDiscoverer();
IpAddress address = null;
do
{
address = discoverer.discover();
} while (address == null && Status != DisplayStatus.Closing);
if (Status != DisplayStatus.Closing)
{
websocket = new WebsocketClient(new Uri($"ws://{address}"));
websocket.IsReconnectionEnabled = true;
websocket.ReconnectionHappened.Subscribe(info => {
ExternalEventArgs args = new ExternalEventArgs();
args.Action = ExternalAction.ConnectionChanged;
args.Command = DisplayStatus.Connected;
EventReceived(args);
Console.WriteLine($"Reconnection happened, type: {info.Type}");
});
websocket.ReconnectTimeout = null;
websocket.DisconnectionHappened.Subscribe(info => {
ExternalEventArgs args = new ExternalEventArgs();
args.Action = ExternalAction.ConnectionChanged;
args.Command = DisplayStatus.Connecting;
EventReceived(args);
Console.WriteLine($"Disconnect happened, type: {info.Type}");
});
websocket.MessageReceived.Subscribe(msg => MessageReceived(msg.Text));
websocket.StartOrFail().Wait();
SetStatus(DisplayStatus.Connected);
}
}
public void Initialize()
{
var exitEvent = new ManualResetEvent(false);
var url = new Uri("wss://api.anastarawneh.tech/v1/covid-19/ws");
Task.Run(() => {
try {
using (client = new WebsocketClient(url))
{
client.ReconnectTimeout = null;
client.ErrorReconnectTimeout = null;
client.ReconnectionHappened.Subscribe(info =>
LoggerService.Information("WebSocket", $"Reconnection happened, type: {info.Type}"));
client.DisconnectionHappened.Subscribe(info =>
{
LoggerService.Information("WebSocket", $"Disconnection happened, type: {info.Type}");
LoggerService.Information("WebSocket", info.Exception.ToString());
});
client.MessageReceived.Subscribe((msg) => HandleMessage(client, msg));
client.Start();
LoggerService.Information("WebSocket", "WebSocket client started");
resetEvent.WaitOne();
}
}
catch (Exception ex)
{
LoggerService.Exception(ex);
}
});
}
public async Task Invoke(HttpContext context)
{
if (context.Request.Path == "/ws")
{
if (context.WebSockets.IsWebSocketRequest)
{
WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
string clientId = Guid.NewGuid().ToString();
WebsocketClient client = new WebsocketClient()
{
ClientId = clientId,
Websocket = webSocket
};
try {
await Handle(client);
} catch (Exception ex) {
await context.Response.WriteAsync("closed");
}
}
else
{
context.Response.StatusCode = 404;
}
}
else
{
await _next(context);
}
}
/// <inheritdoc/>
public async Task <IWebsocketClient> CreateClientAsync(Action <WebsocketClient> config = null)
{
var client = new WebsocketClient(await _url.Value);
config?.Invoke(client);
return(client);
}
public async Task CloseClient(WebsocketClient client, WebSocketCloseStatus closeStatus, string closeDesc)
{
Clients.TryRemove(client.Id, out client);
await client.Client.CloseAsync(closeStatus, closeDesc, CancellationToken.None);
client.Client.Dispose();
}
void Start()
{
// Get the live websocket client
wsc = GameObject.Find("WebsocketClient").GetComponent <WebsocketClient>();
// Get the live TFListener
TFListener = GameObject.Find("TFListener").GetComponent <TFListener>();
// Create publisher to the Baxter's arm topic (uses Ein)
wsc.Advertise("ein/" + arm + "/forth_commands", "std_msgs/String");
// Asychrononously call sendControls every .1 seconds
InvokeRepeating("SendControls", .1f, .1f);
if (arm == "left")
{
grip_label = "Left Grip";
trigger_label = "Left Trigger";
}
else if (arm == "right")
{
grip_label = "Right Grip";
trigger_label = "Right Trigger";
}
else
{
Debug.LogError("arm variable is not set correctly");
}
}
static void Websocket(string[] args)
{
WebsocketClient ws = new WebsocketClient("localhost:15555");
ws.BeforeSend = (msg) =>
{
msg.Headers["cmd"] = "pub";
msg.Headers["mq"] = "MyRpc";
msg.Headers["ack"] = "false";
};
ws.OnOpen += async(client) =>
{
IDictionary <string, object> data = new Dictionary <string, object>();
data["method"] = "plus";
data["params"] = new object[] { 1, 2 };
data["module"] = "/";
for (int i = 0; i < 100; i++)
{
Message msg = new Message
{
Body = data
};
var res = await ws.InvokeAsync(msg);
Console.WriteLine(JsonKit.SerializeObject(res));
}
};
ws.ConnectAsync();
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var exitEvent = new ManualResetEvent(false);
var url = new Uri("wss://echo.websocket.org");
var loop = 1;
using (var client = new WebsocketClient(url))
{
client.ReconnectTimeoutMs = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
client.ReconnectionHappened.Subscribe(type => Console.WriteLine($"Reconnection happened, type: {type}"));
client.MessageReceived.Subscribe(async msg =>
{
Console.WriteLine($"Message received: {msg}");
await SendMessage(client, loop);
loop++;
});
await client.Start();
await Task.Run(() => client.Send($"sawasdee first time"));
exitEvent.WaitOne();
}
}
/// <summary>
/// Dispose
/// </summary>
/// <returns></returns>
public async ValueTask DisposeAsync()
{
await WebsocketClient.CloseAsync(WebSocketCloseStatus.NormalClosure, "unavailable", CancellationToken.None);
WebsocketClient.Dispose();
await OnDisconnectAsync();
}
public void StartInteracting()
{
UniLog.Log("Start Text interaction");
UniLog.Log("Attaching component");
client = metagen_comp.interaction_slot.GetComponent <WebsocketClient>();
if (client == null)
{
client = metagen_comp.interaction_slot.AttachComponent <WebsocketClient>();
}
//client = metagen_comp.Slot.AttachComponent<WebsocketClient>();
UniLog.Log("Attached component");
//client.Connected += AddEventHandlers;
client.TextMessageReceived += OnTextMessageReceived;
client.BinaryMessageReceived += OnBinaryMessageReceived;
//client.HandlingUser.Target = metagen_comp.LocalUser;
client.HandlingUser.Target = FrooxEngine.Engine.Current.WorldManager.FocusedWorld.LocalUser;
client.URL.Value = new Uri("ws://localhost:8765");
//client.URL.Value = new Uri("ws://localhost:8765");
//client.TextMessageReceived += OnTextMessageReceived;
//client.BinaryMessageReceived += OnBinaryMessageReceived;
bool could_read_output_field = metagen_comp.interaction_space.TryReadValue <Sync <string> >("output field", out output_field);
bool could_read_input_field = metagen_comp.interaction_space.TryReadValue <Sync <string> >("input field", out input_field);
if (input_field != null)
{
input_field.OnValueChange += new SyncFieldEvent <string>(OnInputFieldChanged);
}
isInteracting = true;
}
private void Call()
{
roomName = roomNameText.text;
Debug.Log($"Calling room {roomName}");
if (roomName.Length == 0)
{
infoText.text = "Please enter a room name";
return;
}
callButton.interactable = false;
void onOpen()
{
Debug.Log("onOpen");
SendWsMessage("create or join", new JsonMessageData {
room = roomName
});
}
void onMessage(string msg)
{
Debug.Log("onMessage");
HandleMessage(msg);
}
ws = new WebsocketClient(onOpen, onMessage);
ws.Connect();
}
private HandlerWorkResult HandleMessage(BufferStream stream, WebsocketClient client)
{
Console.WriteLine("new chat message");
string chatMsg = "";
try
{
stream.Read(out string msgStr);
chatMsg += " " + msgStr;
stream.Read(out msgStr);
chatMsg += " " + msgStr;
stream.Read(out msgStr);
chatMsg += " " + msgStr;
stream.Read(out msgStr);
chatMsg += " " + msgStr;
Console.WriteLine(chatMsg);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(new HandlerWorkResult()
{
IsOk = true,
});
}
public async Task DisabledReconnecting_ShouldWorkAtRuntime()
{
using (IWebsocketClient client = new WebsocketClient(WebsocketUrl))
{
var receivedCount = 0;
client.IsReconnectionEnabled = true;
client.ReconnectTimeout = TimeSpan.FromSeconds(5);
client.MessageReceived.Subscribe(msg =>
{
receivedCount++;
if (receivedCount >= 2)
{
client.IsReconnectionEnabled = false;
}
});
await client.Start();
await Task.Delay(17000);
Assert.Equal(2, receivedCount);
}
}
public void DisconnectTest()
{
//Arrange
var objWebSocketClient = Substitute.For <IWebSocketClient>();
var objKeepAliveMonitor = Substitute.For <IKeepAliveMonitor>();
var objClient = new WebsocketClient(objWebSocketClient, objKeepAliveMonitor);
var objHandler = Substitute.For <EventHandler <IConnection.IConnection> >();
objClient.Disconnected += objHandler;
//Act
objClient.ConnectAsync(new ClientParams()
{
HostName = "localhost", Port = 80, Secure = false
});
objClient.Disconnect();
//Assert
objWebSocketClient.Received(1).OnOpen -= Arg.Any <EventHandler>();
objWebSocketClient.Received(1).OnClose -= Arg.Any <EventHandler <ICloseEventArgs> >();
objWebSocketClient.Received(1).OnError -= Arg.Any <EventHandler <IErrorEventArgs> >();
objWebSocketClient.Received(1).OnMessage -= Arg.Any <EventHandler <IMessageEventArgs> >();
objKeepAliveMonitor.Received(1).TimeOut -= Arg.Any <EventHandler>();
objKeepAliveMonitor.Received(1).UnResponsive -= Arg.Any <EventHandler>();
objKeepAliveMonitor.Received(1).Stop();
objHandler
.Received(1)
.Invoke(Arg.Is(objClient), Arg.Is(objClient))
;
}
public async Task SendBinaryMessage_ShouldWork()
{
using (IWebsocketClient client = new WebsocketClient(WebsocketUrl))
{
string received = null;
var receivedEvent = new ManualResetEvent(false);
client.MessageReceived.Subscribe(msg =>
{
var msgText = msg.Text ?? string.Empty;
if (msgText.Contains("Unrecognized request"))
{
received = msgText;
receivedEvent.Set();
}
});
await client.Start();
client.Send(new byte[] { 10, 14, 15, 16 });
receivedEvent.WaitOne(TimeSpan.FromSeconds(30));
Assert.NotNull(received);
}
}
public void RxTextTest()
{
//Arrange
var objWebSocketClient = Substitute.For <IWebSocketClient>();
var objKeepAliveMonitor = Substitute.For <IKeepAliveMonitor>();
var objClient = new WebsocketClient(objWebSocketClient, objKeepAliveMonitor);
var handler = Substitute.For <EventHandler <byte[]> >();
var eventArgs = Substitute.For <IMessageEventArgs>();
eventArgs.IsText.Returns(true);
eventArgs.IsPing.Returns(false);
eventArgs.IsBinary.Returns(false);
objClient.Rx += handler;
eventArgs.Data.Returns("TEST");
//Act
objClient.ConnectAsync(new ClientParams()
{
HostName = "localhost", Port = 80, Secure = false
});
objWebSocketClient.OnMessage += Raise.Event <EventHandler <IMessageEventArgs> >(objClient, eventArgs);
//Assert
objKeepAliveMonitor.Received(1).Reset();
handler
.Received(1)
.Invoke(Arg.Is <IConnection.IConnection>(m => m.Equals(objClient)), Arg.Is <byte[]>(b => b.SequenceEqual(System.Text.Encoding.UTF32.GetBytes("TEST"))))
;
}
public async Task Invoke(HttpContext context)
{
if (context.Request.Path == "/wss")
{
if (context.WebSockets.IsWebSocketRequest) //检验是不是websocket请求
{
WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(); //是websocket请求的话就接受
string clientId = Guid.NewGuid().ToString(); //Guid是一个128位整数（16字节），可以在需要唯一标识符的所有计算机和网络中使用，此类标识符的重复率极低（具体详细参考MSDN即可）
var wsClient = new WebsocketClient
{
Id = clientId,
WebSocket = webSocket
};
try
{
await Handle(wsClient);
}
catch (Exception ex)
{
_logger.LogError(ex, "Echo websocket client {0} err .", clientId);
await context.Response.WriteAsync("closed");
}
}
else
{
context.Response.StatusCode = 404;
}
}
else
{
await _next(context);
}
}
public async Task SetupDiscordWebSocket()
{
Func <ClientWebSocket> factory = () => new ClientWebSocket()
{
Options =
{
KeepAliveInterval = TimeSpan.FromSeconds(120),
Credentials = CredentialCache.DefaultNetworkCredentials,
UseDefaultCredentials = true
}
};
using (discordWebSocket = new WebsocketClient(new Uri(discordUrl), factory))
{
discordWebSocket.IsReconnectionEnabled = true;
discordWebSocket.ErrorReconnectTimeout = TimeSpan.FromSeconds(30);
discordWebSocket.ReconnectTimeout = null; //TimeSpan.FromSeconds(60);
discordWebSocket.MessageReceived.Subscribe(HandleDiscordWebSocketMessage);
discordWebSocket.ReconnectionHappened.Subscribe(HandleDiscordWebSocketReconnection);
discordWebSocket.DisconnectionHappened.Subscribe(HandleDiscordWebSocketDisconnection);
Task.Run(() => discordWebSocket.Start());
Console.WriteLine("Started WebSocket Client for Discord bot");
exitEvent.WaitOne();
}
}
private async Task Handle(WebsocketClient webSocket)
{
WebsocketClientCollection.Add(webSocket);
_logger.LogInformation($"Websocket client added.");
WebSocketReceiveResult result = null;
do
{
var buffer = new byte[1024 * 1];
result = await webSocket.WebSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
//WebSocketMessageType的值：Binary=>二进制形式 Close=>因为收到关闭消息，接收完成 Text=>消息为明文格式
if (result.MessageType == WebSocketMessageType.Text && !result.CloseStatus.HasValue)
{
var msgString = Encoding.UTF8.GetString(buffer);
_logger.LogInformation($"Websocket client ReceiveAsync message {msgString}.");
var message = JsonConvert.DeserializeObject <Message>(msgString);
message.SendClientId = webSocket.Id;
MessageRoute(message);
}
}while (!result.CloseStatus.HasValue);
WebsocketClientCollection.Remove(webSocket);
_logger.LogInformation($"Websocket client closed.");
}
// Use this for initialization
void Start()
{
Debug.Log("TFListener Starting");
wsc = GameObject
.Find("WebsocketClient").GetComponent <WebsocketClient>();
wsc.Subscribe(topic, "std_msgs/String", 0, (success) => { this.subscribed = success; });
}
static void OnCommand(dynamic Message, WebsocketClient Client)
{
Console.WriteLine("Got a command");
string data = Message.data;
List <string> argus = Library.stringParse(data);
Console.WriteLine(argus);
if (argus.Count == 3)
{
if (argus[2] == "uri")
{
argus[1] = Library.PathToURI(argus[1]);
}
}
string message = null;
try
{
Process.Start(argus[0], argus[1]);
message = "The Command Was Successful";
}catch (Exception err)
{
message = $"The Command UnSuccessful \n {err}";
}
Message msg = new Message {
message = message, from = "shell"
};
Client.Send(JsonConvert.SerializeObject(msg));
}
