private void Awake()
{
_websocketListener = WebSocketListener.Platform;
_websocketListener.NewMessage += this.OnNewMessage;
try
{
var uri = new Uri(_uri);
_websocketListener.Connect(
uri,
// success
() =>
{
Debug.Log("Connected");
},
// failure
() =>
{
_websocketListener.Dispose();
_websocketListener = null;
Debug.LogError("Failed to connect");
});
}
catch (Exception e)
{
Debug.LogError(e);
}
}
private void OnDisable()
{
if (_websocketListener != null)
{
_websocketListener.Dispose();
}
}
public async Task BasicClientServerTest()
{
WebSocketListener server = new WebSocketListener(PORT);
byte[] message = new byte[] { 100, 101, 102, 103 };
server.Start();
Task task = Task.Run(async() => {
Stream socket = await server.AcceptWebSocketAsync();
byte[] buffer = new byte[1024];
int read = await socket.ReadAsync(buffer, 0, buffer.Length);
Assert.Equal(4, read);
Assert.Equal(message, buffer.Take(4).ToArray());
});
Stream client = WebSocketStream.Connect($"ws://localhost:{PORT}");
await client.WriteAsync(message, 0, message.Length);
client.Dispose();
server.Dispose();
await task;
}
protected override void OnStop()
{
if (_listener != null)
{
try { _cancellation.Cancel(); }
catch { }
_listener.Dispose();
_listener = null;
}
}
public async Task DisposeServerTest()
{
WebSocketListener server = new WebSocketListener(PORT);
server.Start();
Task <WebSocketStream> task = server.AcceptWebSocketAsync();
server.Dispose();
await Assert.ThrowsAsync <ObjectDisposedException>(() => task);
}
public override void Dispose()
{
try
{
cancellationTokenSource.Cancel();
server?.Dispose();
}catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
public static void Stop()
{
Logging.Log("[StreamServer] Stopping server...");
running = false;
foreach (WebSocket ws in webSockets)
{
using (ws)
ws.WriteString("{ \"event\": \"close\" }");
}
webSockets.Clear();
server.Stop();
server.Dispose();
Logging.Log("[StreamServer] Stopped server");
}
private void Dispose(Boolean disposing)
{
if (Interlocked.CompareExchange(ref _disposed, 1, 0) == 1)
{
return;
}
if (disposing)
{
GC.SuppressFinalize(this);
}
_cancel.Cancel();
_semaphore.Dispose();
_listener.Dispose();
}
public void BasicRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(6000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService <IMyService>(new MyService());
listener.Start();
var client = new WebSocket("ws://localhost:" + port + "/", "SignalR", WebSocket4Net.WebSocketVersion.Rfc6455);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <IMyService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
{
Thread.Sleep(10);
}
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public async Task ClientServerTest()
{
WebSocketListener server = new WebSocketListener(PORT);
byte[] clientMessage = new byte[] { 100, 101, 102, 103 };
byte[] serverMessage = new byte[] { 80, 81, 82, 83 };
byte[] clientBuffer = new byte[1024];
server.Start();
Task task = Task.Run(async() => {
WebSocketStream socket = await server.AcceptWebSocketAsync();
byte[] serverBuffer = new byte[1024];
int serverRead = await socket.ReadAsync(serverBuffer, 0, serverBuffer.Length);
Assert.Equal(4, serverRead);
Assert.Equal(clientMessage, serverBuffer.Take(4).ToArray());
await socket.WriteAsync(serverMessage, 0, serverMessage.Length);
serverRead = await socket.ReadAsync(serverBuffer, 0, serverBuffer.Length);
Assert.Equal(0, serverRead);
});
WebSocketStream client = WebSocketStream.Connect($"ws://localhost:{PORT}");
await client.WriteAsync(clientMessage, 0, clientMessage.Length);
int clientRead = await client.ReadAsync(clientBuffer, 0, clientBuffer.Length);
Assert.Equal(4, clientRead);
Assert.Equal(serverMessage, clientBuffer.Take(4).ToArray());
await client.CloseAsync();
client.Dispose();
server.Dispose();
await task;
}
public void BasicRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(6000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService <IMyService>(new MyService());
listener.Start();
var client = new ClientWebSocket();
client.Options.AddSubProtocol("SignalR");
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <IMyService>();
client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait();
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public void Benchmark()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(30000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService <ISumService>(new SumService());
listener.Start();
var client = new ClientWebSocket();
client.Options.AddSubProtocol("SignalR");
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <ISumService>();
client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait();
const int randCnt = 100;
var rand = new Random(42);
var randoms = new int[randCnt];
for (int i = 0; i < randCnt; i++)
{
randoms[i] = rand.Next(10000000, 20000000);
}
var sw = new Stopwatch();
long timeFromClient = 0, timeToClient = 0;
const int cnt = 1000;
for (int j = 0; j < cnt; j++)
{
sw.Start();
var sum = proxy.Sum(randoms).Result;
sw.Stop();
Assert.Equal(randoms.Sum(), sum);
for (int i = 0; i < randCnt; i++)
{
randoms[i] = rand.Next(10000000, 20000000);
}
var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
timeFromClient += times.Item1;
timeToClient += Stopwatch.GetTimestamp() - times.Item2;
}
_testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
_testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
_testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);
sw.Reset();
var tree = new SumServiceTree();
SumServiceTree.FillTree(tree, rand, 2);
_testOutputHelper.WriteLine("Starting large message transfer.");
sw.Start();
var result = proxy.Increment(tree).Result;
sw.Stop();
Assert.Equal(tree.Leaf + 1, result.Leaf);
_testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public override void Dispose()
{
mCancellationToken.Cancel();
mListener.Stop();
mListener.Dispose();
}
public void Dispose()
{
_listener.Dispose();
}
public void Dispose()
{
_cts.Cancel();
_listener.Dispose();
}
public override void Dispose()
{
mListener.Stop();
mListener.Dispose();
}
public void Dispose()
{
_cancellation.Cancel();
_wsServer.Dispose();
}
