internal void ConnectIfNotOpen()
{
if (!IsConnected)
{
m_LastReceiveHeartbeatTime = 0;
m_LastQueueingTime = 0;
m_LastShowQueueingNum = 0;
m_LastConnectTime = TimeUtility.GetLocalMilliseconds();
LogSystem.Debug("ConnectIfNotOpen at time:{0} ServerAddress:{1}", m_LastConnectTime, m_Url);
WorldSystem.Instance.WaitMatchSceneId = -1;
m_IsLogining = true;
m_IsQueueing = false;
#if !PLATFORM_WEBGL
m_WebSocket = new WebSocket4Net.WebSocket(m_Url);
#else
m_WebSocket = WebSocketWrapper.Instance;
m_WebSocket.SetUrl(m_Url);
#endif
m_WebSocket.AllowUnstrustedCertificate = true;
m_WebSocket.EnableAutoSendPing = true;
m_WebSocket.AutoSendPingInterval = 10;
m_WebSocket.Opened += OnWsOpened;
m_WebSocket.MessageReceived += OnWsMessageReceived;
m_WebSocket.DataReceived += OnWsDataReceived;
m_WebSocket.Error += OnWsError;
m_WebSocket.Closed += OnWsClosed;
m_WebSocket.Open();
}
}
public void WebSocket4NetRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(20000, 60000);
var server = WebApp.Start<Startup>("http://localhost:" + port + "/");
var client = new WebSocket4Net.WebSocket("ws://localhost:" + port + "/rt1", "", 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();
server.Dispose();
}
private static void SimpleMessageTest()
{
var sweb = new WebSocket4Net.WebSocket("ws://localhost:8181/");
sweb.Open();
sweb.Closed += (o, e) => Console.WriteLine("Closed.");
sweb.Opened += (o, e) => Console.WriteLine("Opened.");
sweb.MessageReceived += (o, e) =>
{
Console.WriteLine(">>: " + e.Message);
};
sweb.Error += (o, e) => Console.WriteLine("ERR: " + e.Exception.Message);
Console.WriteLine("Enter a command, or 'q' to quit.");
var command = Console.ReadLine();
while (command != "q")
{
if (command == "clear")
{
Console.Clear();
}
else
{
sweb.Send(command);
}
command = Console.ReadLine();
}
sweb.Close();
}
public void WebSocket4NetRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(20000, 60000);
var server = WebApp.Start <Startup>("http://localhost:" + port + "/");
var client = new WebSocket4Net.WebSocket("ws://localhost:" + port + "/rt1", "", 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();
server.Dispose();
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
string ip;
string jogar;
NavigationContext.QueryString.TryGetValue("ip", out ip);
NavigationContext.QueryString.TryGetValue("jogar", out jogar);
string conexao = string.Concat("ws://", ip, ":8080/TronWebsocket/tron");
_mostrarCanvas = Convert.ToBoolean(jogar);
if (!_mostrarCanvas)
{
ConfigurarVisualizacaoBotao(btnTop);
ConfigurarVisualizacaoBotao(btnBottom);
ConfigurarVisualizacaoBotao(btnLeft);
ConfigurarVisualizacaoBotao(btnRight);
}
_websocket = new WebSocket4Net.WebSocket(conexao);
//Caso queira implementar demais eventos
//_websocket.Opened += websocket_Opened;
//_websocket.Error += websocket_Error;
//_websocket.Closed += websocket_Closed;
_websocket.MessageReceived += websocket_MessageReceived;
_websocket.Open();
}
private void ConnectedButton_Click(object sender, RoutedEventArgs e)
{
Output("Starting Connected...");
ConnectedButton.IsEnabled = false;
DisconnectedButton.IsEnabled = true;
websocket = new WebSocket4Net.WebSocket(ServerAddressField.Text);
WebsocketIn();
}
/// <inheritdoc/>
public override async Task <bool> ConnectAsync()
{
string msbWebsocketUrlWithPath = this.MsbUrl;
if (this.UseSockJs)
{
if (!msbWebsocketUrlWithPath.EndsWith("/"))
{
msbWebsocketUrlWithPath += "/";
}
msbWebsocketUrlWithPath += this.GenerateSockJSPath();
}
Log.Debug($"Connecting to address '{msbWebsocketUrlWithPath}'");
this.webSocket = new WebSocket4Net.WebSocket(msbWebsocketUrlWithPath);
// Security
this.webSocket.Security.AllowCertificateChainErrors = this.AllowSslCertificateChainErrors;
this.webSocket.Security.AllowUnstrustedCertificate = this.AllowSslUnstrustedCertificate;
this.webSocket.Security.AllowNameMismatchCertificate = this.AllowSslCertificateNameMismatch;
this.webSocket.Security.EnabledSslProtocols = SslProtocols;
// Connection
this.webSocket.AutoSendPingInterval = this.HeatbeatIntervalInMilliseconds;
this.webSocket.EnableAutoSendPing = true;
// Add listeners
this.webSocket.MessageReceived += this.OnWebsocketMessageReceived;
this.webSocket.Opened += this.OnWebsocketOpend;
this.webSocket.Error += this.OnWebsocketError;
this.webSocket.Closed += this.OnWebsocketClosed;
var connectTask = Task.Run(() =>
{
this.webSocket.Open();
CancellationTokenSource source = new CancellationTokenSource();
while (!this.IsConnected() && !source.IsCancellationRequested)
{
Thread.Sleep(10);
}
});
if (await Task.WhenAny(connectTask, Task.Delay(this.WaitForConnectedInMilliseconds, default(CancellationToken))) == connectTask)
{
await connectTask;
return(true);
}
else
{
Log.Warn($"Connection try to '{this.MsbUrl}' timed out");
this.ConnectionFailed?.Invoke(this, EventArgs.Empty);
return(false);
}
}
// private constructor.
private BitfinexWatchlistSocket()
{
comman = new clsComman();
webSocket = new WebSocket4Net.WebSocket(host);
webSocket.Open();
webSocket.Opened += WebSocket_Opened;
webSocket.Closed += WebSocket_Closed;
webSocket.Error += WebSocket_Error;
webSocket.MessageReceived += WebSocket_MessageReceived;
}
public void Close()
{
if (this.socket != null)
{
Debug.Log("<color=magenta>[WS CLOSING]</color> " + this.url);
this.sendCache = null;
this.socket.Close();
this.socket = null;
}
}
static void Main(string[] args)
{
a = new WebSocket4Net.WebSocket("ws://localhost:2668");
a.MessageReceived += A_MessageReceived;
a.Error += A_Error;
a.Opened += A_Opened;
a.Open();
Console.ReadLine();
}
public void Start()
{
//https://docs.gdax.com/#protocol-overview
WebSocket4Net.WebSocket socket = new WebSocket4Net.WebSocket("wss://ws-feed.gdax.com");
socket.Opened += Socket_Opened;
socket.MessageReceived += Socket_MessageReceived;
socket.Open();
socket.Closed += Socket_Closed;
//socket.Send(Resource1.subscribe);
}
public Task ConnectAsync(Uri uri, CancellationToken cancellationToken)
{
webSocket = new WebSocket4Net.WebSocket(uri.ToString())
{
AutoSendPingInterval = (int)KeepAliveInterval.TotalMilliseconds,
EnableAutoSendPing = true
};
webSocket.DataReceived += WebSocket_OnData;
webSocket.MessageReceived += WebSocket_OnMessage;
webSocket.Open();
return(Task.CompletedTask);
}
private void WebSocket_Closed(object sender, EventArgs e)
{
webSocket.Dispose();
//form.ObjTrading = new BindingList<FinexTicker>();
webSocket = new WebSocket4Net.WebSocket(host);
webSocket.Open();
webSocket.Opened += WebSocket_Opened;
webSocket.Closed += WebSocket_Closed;
webSocket.Error += WebSocket_Error;
webSocket.MessageReceived += WebSocket_MessageReceived;
ReInitallizeForm();
}
/// <inheritdoc/>
public override void Disconnect()
{
if (this.webSocket != null)
{
Log.Debug($"Disconnecting from {this.MsbUrl}");
this.webSocket.Close("Normal");
this.receivedIOConnected = false;
this.webSocket = null;
}
this.Disconnected?.Invoke(this, EventArgs.Empty);
}
public void Close()
{
lock (syncRoot)
{
receiveQueue.Clear();
if (socket != null)
{
try { socket.Close(); }
catch { }
socket = null;
}
}
}
public Task ReceiveAsync()
{
_tcs = new TaskCompletionSource <object>();
var cookies = new List <KeyValuePair <string, string> >();
_ws = new WebSocket4Net.WebSocket(_url, "", cookies);
_ws.MessageReceived += _ws_MessageReceived;
//_ws.NoDelay = true;
_ws.Opened += _ws_Opened;
_ws.Error += _ws_Error;
_ws.Closed += _ws_Closed;
_ws.Open();
return(_tcs.Task);
}
public JsonSocket(string url)
{
this.url = url;
this.socket = new WebSocket4Net.WebSocket(url);
this.Dispatcher = new MessageDispatcher <object>();
this.Dispatcher.Register(this);
Debug.Log("<color=magenta>[WS OPENING]</color> " + url);
this.socket.Opened += (s, e) =>
{
Debug.Log("<color=magenta>[WS OPEN]</color> " + url);
lock (sendCacheLock)
{
if (this.sendCache != null)
{
foreach (var str in this.sendCache)
{
this.socket.Send(str);
Debug.Log("<color=green>[WS SEND CACHE]</color> " + str);
}
this.sendCache = null;
}
}
};
this.socket.MessageReceived += (s, e) =>
{
Debug.Log("<color=cyan>[WS RECV]</color> " + e.Message);
lock (receivedLock)
{
received.Add(e.Message);
}
};
this.socket.Error += (s, e) =>
{
Debug.LogError("<color=red>[WS ERROR]</color> " + url);
};
this.socket.Closed += (s, e) =>
{
Debug.Log("<color=magenta>[WS CLOSE]</color> " + url);
this.socket = null;
};
this.m_dispatchCoroutine = Singleton.Instance.StartCoroutine(this.Dispatch());
this.socket.Open();
}
public void CreateSocketConnection(string serverURL)
{
try
{
webSocket = new WebSocket4Net.WebSocket(serverURL);
webSocket.Error += new EventHandler <SuperSocket.ClientEngine.ErrorEventArgs>(ConnectionError);
webSocket.Opened += new EventHandler(ConnectionOpened);
webSocket.Closed += new EventHandler(ConnectionClosed);
webSocket.MessageReceived += new EventHandler <WebSocket4Net.MessageReceivedEventArgs>(websocket_MessageReceived);
webSocket.Open();
}
catch (Exception ex)
{
Notify("Server Connection Problem: " + ex.Message);
}
}
private void BuildWebSocket()
{
try {
m_WebSocket = new WebSocket4Net.WebSocket(m_Url);
m_WebSocket.AllowUnstrustedCertificate = true;
m_WebSocket.EnableAutoSendPing = false;
m_WebSocket.AutoSendPingInterval = 10;
m_WebSocket.Opened += OnWsOpened;
m_WebSocket.MessageReceived += OnWsMessageReceived;
m_WebSocket.DataReceived += OnWsDataReceived;
m_WebSocket.Error += OnWsError;
m_WebSocket.Log += OnWsLog;
m_WebSocket.Closed += OnWsClosed;
} catch (Exception ex) {
LogSystem.Warn("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
public void Dispose()
{
Lock(() => {
this.retry = null;
if (sock != null)
{
sock.Close();
sock = null;
}
if (timer != null)
{
timer.Dispose();
timer = null;
}
}, false);
}
/// <summary>
/// Makes this object and sets the Chrome remote debugging url
/// </summary>
/// <param name="remoteDebuggingUri"></param>
internal Communicator(Uri remoteDebuggingUri)
{
var sessions = GetAvailableSessions(remoteDebuggingUri);
if (sessions.Count == 0)
{
throw new Exception("Could not retrieve remote sessions from Chrome");
}
_webSocket = new WebSocket(sessions[0].WebSocketDebuggerUrl.Replace("ws://localhost", "ws://127.0.0.1"));
_webSocket.Error += WebSocketOnError;
var waitEvent = new ManualResetEvent(false);
_webSocket.Opened += (sender, args) => { waitEvent.Set(); };
_webSocket.Open();
waitEvent.WaitOne();
}
public WebSocketClient(
string uri,
IConnectionProcessor processor,
WebSocketCredential credential = null)
{
this.processor = processor;
this.retry = this.BeginRetry;
var cookies = new List <KeyValuePair <string, string> >();
if (credential != null)
{
var token = credential.ToString();
if (token == null)
{
throw new NullReferenceException("The credential must be a non-null string.");
}
cookies.Add(new KeyValuePair <string, string>(credential.Type, token));
}
this.sock = new WebSocket4Net.WebSocket(uri: uri, cookies: cookies);
this.sock.Opened += (o, e) =>
{
this.EndRetry();
this.processor.Opened();
};
this.sock.Closed += (o, e) =>
{
this.processor.Closed();
Lock(() => this.retry());
};
this.sock.MessageReceived += (o, e) => this.processor.MessageReceived(e.Message);
this.sock.Error += (o, e) =>
{
this.processor.Error(e.Exception);
Lock(() => this.retry());
};
this.Open();
}
private void InitWebSocket()
{
try
{
var uri = string.Format("ws://{0}:{1}/DataServer_Service", txtHost.Text, numPort.Value);
_socket = new WebSocket4Net.WebSocket(uri);
_socket.Opened += _socket_Opened;
_socket.Closed += _socket_Closed;
_socket.Error += _socket_Error;
_socket.MessageReceived += _socket_MessageReceived;
AppendToLog("Connecting...");
_socket.Open();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
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();
}
/// <summary>
/// Initializes a Web Socket connection to taskt Server
/// </summary>
/// <param name="serverUri">URI to the socket server, ex. wss://ip:port/ws</param>
public static void Connect(string serverUri)
{
try
{
//var fileName = "Server Connection Logs";
//taskt.Core.Logging.Setup(fileName, log4net.Core.Level.Debug);
//log = log4net.LogManager.GetLogger(fileName);
//var fileName = "Server Connection Logs";
//var logging = new taskt.Core.Logging();
//log = logging.Setup(fileName, log4net.Core.Level.Debug);
if (bypassCertificationValidation)
{
Logging.log.Info("Client bypassing certificate validation");
//trust all certificates -- for self signed certificates, etc.
System.Net.ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => true;
}
//reset connection exception
connectionException = string.Empty;
Logging.log.Info("Client Requesting To Connect to URI: " + serverUri);
//handle if insecure or invalid connection is defined
if (!serverUri.ToLower().StartsWith("wss://"))
{
throw new InvalidSocketURI("Socket connections must begin with wss://");
}
//create socket connection
webSocket = new WebSocket4Net.WebSocket(serverUri);
webSocket.Error += new EventHandler <SuperSocket.ClientEngine.ErrorEventArgs>(ConnectionError);
webSocket.Opened += new EventHandler(ConnectionOpened);
webSocket.Closed += new EventHandler(ConnectionClosed);
webSocket.MessageReceived += new EventHandler <WebSocket4Net.MessageReceivedEventArgs>(MessageReceived);
webSocket.Open();
}
catch (Exception)
{
throw;
}
}
private bool InitClient()
{
try
{
url = InputAddr.Text.ToString();
socketClient = new WebSocket4Net.WebSocket(url);
socketClient.DataReceived += SocketClient_DataReceived;
socketClient.MessageReceived += SocketClient_MessageReceived;;
socketClient.Closed += SocketClient_Closed;
socketClient.Error += SocketClient_Error;
socketClient.Opened += SocketClient_Opened;
socketClient.Open();
AppendInfo($">>正在连接[{url}]，请等待...");
}
catch (Exception e)
{
MessageDialog.Show(this, "连接初始化异常：" + e.Message);
return(false);
}
return(true);
}
private void ConnectIfNotOpen()
{
if (!IsConnected)
{
m_IsLogged = false;
m_LastReceiveHeartbeatTime = 0;
m_LastConnectTime = TimeUtility.GetLocalMilliseconds();
LogSystem.Info("ConnectIfNotOpen at time {0}", m_LastConnectTime);
m_WebSocket = new WebSocket4Net.WebSocket(m_Url);
m_WebSocket.AllowUnstrustedCertificate = true;
m_WebSocket.EnableAutoSendPing = true;
m_WebSocket.AutoSendPingInterval = 10;
m_WebSocket.Opened += OnOpened;
m_WebSocket.MessageReceived += OnMessageReceived;
m_WebSocket.DataReceived += OnDataReceived;
m_WebSocket.Error += OnError;
m_WebSocket.Closed += OnClosed;
m_WebSocket.Open();
}
}
private void SetupClient(string prefix, string expectedResult)
{
string url = string.Format("{0}://{1}", prefix, Utility.SITE_URL);
this.socket = new WebSocket4Net.WebSocket(url);
this.socket.Closed += (sender, args) =>
{
this.logger.Object.Info("Socket Closed");
this.clientResetEvent.Set();
};
this.socket.Opened += (sender, args) =>
{
this.logger.Object.Info("Socket Opened");
this.clientResetEvent.Set();
};
this.socket.MessageReceived += (sender, args) =>
{
this.logger.Object.Info("Got Message");
this.areEqual = string.Compare(expectedResult, args.Message, StringComparison.Ordinal) == 0;
this.clientResetEvent.Set();
};
this.socket.DataReceived += (sender, args) =>
{
this.logger.Object.Info("Got Data");
this.areEqual = string.Compare(expectedResult, Encoding.UTF8.GetString(args.Data), StringComparison.Ordinal) == 0;
this.clientResetEvent.Set();
};
this.socket.Open();
Assert.IsTrue(this.serverResetEvent.WaitOne(WaitOneTimeout), "Timeout waiting for server to accept connection"); // Wait for server to complete connection
Assert.IsTrue(this.clientResetEvent.WaitOne(WaitOneTimeout), "Timeout waiting for client to open"); // Wait for client Open
}
public Task ReceiveAsync()
{
var url = _url;
_tcs = new TaskCompletionSource <object>();
var cookies = new List <KeyValuePair <string, string> >();
var userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36";
_ws = new WebSocket4Net.WebSocket(url, "", cookies, null, userAgent)
{
EnableAutoSendPing = true,
AutoSendPingInterval = 10 * 1000,
ReceiveBufferSize = 8192,
NoDelay = true
};
_ws.MessageReceived += _ws_MessageReceived;
_ws.Opened += _ws_Opened;
_ws.Error += _ws_Error;
_ws.Closed += _ws_Closed;
_ws.Open();
return(_tcs.Task);
}
static void Main(string[] args)
{
log4j.Info("Start Main");
//WebSocket4Net.JsonWebSocket websocket = new WebSocket4Net.JsonWebSocket("ws://127.0.0.1:2012");
WebSocket4Net.WebSocket websocket = new WebSocket4Net.WebSocket("ws://127.0.0.1:2012");
websocket.Opened += new EventHandler((s, e) =>
{
log4j.Info("Opened");
});
websocket.Closed += new EventHandler((s, e) =>
{
log4j.Info("Closed");
});
websocket.MessageReceived += new EventHandler <WebSocket4Net.MessageReceivedEventArgs>((s, e) =>
{
log4j.Info("received from server: " + e.Message);
});
websocket.Open();
log4j.Info(websocket.State);
string cmd = "";
while (cmd != "q")
{
//websocket.
if (cmd != "")
{
websocket.Send(cmd);
}
cmd = Console.ReadLine();
}
websocket.Close();
}
internal void ConnectIfNotOpen()
{
if (!IsConnected)
{
m_LastReceiveHeartbeatTime = 0;
m_LastQueueingTime = 0;
m_IsLogining = true;
m_IsQueueing = false;
m_LastConnectTime = TimeUtility.GetLocalMilliseconds();
LogSystem.Info("ConnectIfNotOpen at time {0} {1} {2}", m_LastConnectTime, m_User, LobbyRobot.Robot.GetDateTime());
m_WebSocket = new WebSocket4Net.WebSocket(m_Url);
m_WebSocket.AllowUnstrustedCertificate = true;
m_WebSocket.EnableAutoSendPing = true;
m_WebSocket.AutoSendPingInterval = 10;
m_WebSocket.Opened += OnWsOpened;
m_WebSocket.MessageReceived += OnWsMessageReceived;
m_WebSocket.DataReceived += OnWsDataReceived;
m_WebSocket.Error += OnWsError;
m_WebSocket.Closed += OnWsClosed;
m_WebSocket.Open();
}
}
/// <summary>
/// Initializes a Web Socket connection to taskt Server
/// </summary>
/// <param name="serverUri">URI to the socket server, ex. wss://ip:port/ws</param>
public static void Connect(string serverUri)
{
try
{
if (bypassCertificationValidation)
{
socketLogger.Information("Socket Client Bypasses SSL Validation");
//trust all certificates -- for self signed certificates, etc.
System.Net.ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => true;
}
//reset connection exception
connectionException = string.Empty;
//handle if insecure or invalid connection is defined
if (!serverUri.ToLower().StartsWith("wss://"))
{
socketLogger.Information("Socket Client URI Invalid");
throw new InvalidSocketURI("Socket connections must begin with wss://");
}
//create socket connection
webSocket = new WebSocket4Net.WebSocket(serverUri);
webSocket.Error += new EventHandler <SuperSocket.ClientEngine.ErrorEventArgs>(ConnectionError);
webSocket.Opened += new EventHandler(ConnectionOpened);
webSocket.Closed += new EventHandler(ConnectionClosed);
webSocket.MessageReceived += new EventHandler <WebSocket4Net.MessageReceivedEventArgs>(MessageReceived);
socketLogger.Information("Socket Client Opening Connection To: " + serverUri);
webSocket.Open();
}
catch (Exception ex)
{
socketLogger.Information("Connection Error: " + ex.ToString());
}
}
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();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (_socket != null) _socket.Close();
if (_socket != null) _socket = null;
if (_config != null) _config = null;
}
private static void InitNetWork()
{
var extension = new List<KeyValuePair<string, string>>();
extension.Add(new KeyValuePair<string, string>("sec-websocket-extensions", "permessage-deflate; client_max_window_bits, x-webkit-deflate-frame"));
mSocketClient = new WebSocket4Net.WebSocket("ws://127.0.0.1:8000/", subProtocol:"nodejs1", customHeaderItems:extension);
mSocketClient.Opened += new EventHandler(websocket_Opened);
mSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
mSocketClient.Closed += new EventHandler(websocket_Closed);
mSocketClient.MessageReceived += new EventHandler<WebSocket4Net.MessageReceivedEventArgs>(websocket_MessageReceived);
mSocketClient.DataReceived += new EventHandler<WebSocket4Net.DataReceivedEventArgs>(websocket_DataReceived);
mSocketClient.Open();
}
private void SetupClient(string prefix, string expectedResult)
{
string url = string.Format("{0}://{1}", prefix, Utility.SITE_URL);
this.socket = new WebSocket4Net.WebSocket(url);
this.socket.Closed += (sender, args) =>
{
this.logger.Object.Info("Socket Closed");
this.clientResetEvent.Set();
};
this.socket.Opened += (sender, args) =>
{
this.logger.Object.Info("Socket Opened");
this.clientResetEvent.Set();
};
this.socket.MessageReceived += (sender, args) =>
{
this.logger.Object.Info("Got Message");
this.areEqual = string.Compare(expectedResult, args.Message, StringComparison.Ordinal) == 0;
this.clientResetEvent.Set();
};
this.socket.DataReceived += (sender, args) =>
{
this.logger.Object.Info("Got Data");
this.areEqual = string.Compare(expectedResult, Encoding.UTF8.GetString(args.Data), StringComparison.Ordinal) == 0;
this.clientResetEvent.Set();
};
this.socket.Open();
Assert.IsTrue(this.serverResetEvent.WaitOne(WaitOneTimeout), "Timeout waiting for server to accept connection"); // Wait for server to complete connection
Assert.IsTrue(this.clientResetEvent.WaitOne(WaitOneTimeout), "Timeout waiting for client to open"); // Wait for client Open
}
public void Benchmark()
{
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<ISumService>(new SumService());
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<ISumService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
Thread.Sleep(10);
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();
}
/// <summary>
/// Open a real-time connection with the server
/// </summary>
public void Open()
{
_socket = new WebSocket4Net.WebSocket(_config.ToString());
_socket.EnableAutoSendPing = true;
_socket.AutoSendPingInterval = (1000 * 60); // 1 Minute
_socket.Open();
}
private void BuildWebSocket()
{
try {
m_WebSocket = new WebSocket4Net.WebSocket(m_Url);
m_WebSocket.AllowUnstrustedCertificate = true;
m_WebSocket.EnableAutoSendPing = false;
m_WebSocket.AutoSendPingInterval = 10;
m_WebSocket.Opened += OnWsOpened;
m_WebSocket.MessageReceived += OnWsMessageReceived;
m_WebSocket.DataReceived += OnWsDataReceived;
m_WebSocket.Error += OnWsError;
m_WebSocket.Log += OnWsLog;
m_WebSocket.Closed += OnWsClosed;
} catch (Exception ex) {
LogSystem.Warn("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
