protected override void OnStop()
{
ClosePort();
this.timer_inv.Enabled = false;
websocket.Close();
HelperLog.Info("RFIDService Stop");
//websocket.Close();
}
public void Close()
{
if (socket.State == WebSocketState.Open)
{
socket.Close();
}
}
public static WebSocketDisposable ReserveConnection(string uri)
{
Tuple<WebSocket, RefCountDisposable> connection;
lock(openConnectionsLock)
{
if(!openConnections.TryGetValue(uri, out connection))
{
Debug.WriteLine("Creating new websocket");
WebSocket ws = new WebSocket(uri);
// Set callbacks?
ws.Open();
var dispose = Disposable.Create(() =>
{
Debug.WriteLine("Disposing of websocket");
ws.Close();
openConnections.Remove(uri);
});
RefCountDisposable refCount = new RefCountDisposable(dispose);
connection = Tuple.Create(ws, refCount);
openConnections.Add(uri, connection);
return new WebSocketDisposable(connection.Item1, connection.Item2.GetDisposable());
}
}
Debug.WriteLine("Returning old websocket");
return new WebSocketDisposable(connection.Item1, connection.Item2.GetDisposable());
}
private Task DisconnectInternalAsync(int closeCode = 1000, bool isDisposing = false)
{
_disconnectCancelTokenSource.Cancel();
if (_client == null)
{
return(Task.Delay(0));
}
if (_client.State == WebSocketState.Open)
{
try { _client.Close(closeCode, ""); }
catch { }
}
_client.MessageReceived -= OnTextMessage;
_client.DataReceived -= OnBinaryMessage;
_client.Opened -= OnConnected;
_client.Closed -= OnClosed;
try { _client.Dispose(); }
catch { }
_client = null;
_waitUntilConnect.Reset();
return(Task.Delay(0));
}
/// <summary>
/// The pump for received messages.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The observable stream of messages.</returns>
private static IObservable <string> SocketReceivePump(WebSocket4Net.WebSocket socket, CancellationToken cancellationToken)
{
var dispose = new Action[] { null };
var incoming = new BufferBlock <string>();
EventHandler <MessageReceivedEventArgs> received = (sender, args) => incoming.Post(args.Message);
socket.MessageReceived += received;
EventHandler <ErrorEventArgs> errored = (sender, args) =>
{
((ITargetBlock <string>)incoming).Fault(args.Exception);
dispose[0]();
};
socket.Error += errored;
EventHandler closed = (sender, args) => dispose[0]();
socket.Closed += closed;
dispose[0] = () =>
{
incoming.Complete();
socket.MessageReceived -= received;
socket.Error -= errored;
socket.Closed -= closed;
socket.Close();
};
cancellationToken.Register(dispose[0]);
return(incoming.AsObservable().Publish().RefCount());
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (_socket != null)
{
_socket.Close();
_socket = null;
}
}
public override Task InternalDisconnectAsync(SocketCloseEventArgs e)
{
if (_socket.State != ws4net.WebSocketState.Closed)
{
_socket.Close();
}
return(Task.Delay(0));
}
private void CloseAutoServer()
{
m_WebSocketClient.Close();
if (m_TimerThread != null)
{
m_TimerThread.Abort();
m_TimerThread = null;
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool dispose)
{
if (dispose)
{
if (_socket != null)
{
_socket.Close();
_socket = null;
}
}
}
private string SendCommand(string sessionWSEndpoint, string cmd)
{
WebSocket4Net.WebSocket j = new WebSocket4Net.WebSocket(sessionWSEndpoint);
ManualResetEvent waitEvent = new ManualResetEvent(false);
ManualResetEvent closedEvent = new ManualResetEvent(false);
string message = "";
byte[] data;
Exception exc = null;
j.Opened += delegate(System.Object o, EventArgs e)
{
j.Send(cmd);
};
j.MessageReceived += delegate(System.Object o, MessageReceivedEventArgs e)
{
message = e.Message;
waitEvent.Set();
};
j.Error += delegate(System.Object o, SuperSocket.ClientEngine.ErrorEventArgs e)
{
exc = e.Exception;
waitEvent.Set();
};
j.Closed += delegate(System.Object o, EventArgs e)
{
closedEvent.Set();
};
j.DataReceived += delegate(System.Object o, DataReceivedEventArgs e)
{
data = e.Data;
waitEvent.Set();
};
j.Open();
waitEvent.WaitOne();
if (j.State == WebSocket4Net.WebSocketState.Open)
{
j.Close();
closedEvent.WaitOne();
}
if (exc != null)
{
throw exc;
}
return(message);
}
private void connectSocket()
{
socket = new WebSocket(socketAdress, "", WebSocketVersion.Rfc6455);
if (socket.State == WebSocketState.Open)
socket.Close();
socket.EnableAutoSendPing = true;
socket.Closed += new EventHandler(socket_Closed);
socket.Error += new EventHandler<ErrorEventArgs>(socket_Error);
socket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(socket_MessageReceived);
socket.Opened += socket_Opened;
socket.Open();
Debug.WriteLine("Cybergame socket connected.");
}
public Task DisconnectAsync()
{
if (_webSocket != null)
{
_webSocket.DataReceived -= OnDataReceived;
_webSocket.Close();
SpinWait.SpinUntil(() => _webSocket.State == WebSocketState.Closed, _clientOptions.CommunicationTimeout);
}
_webSocket = null;
return(Task.FromResult(0));
}
protected override void DoClose()
{
if (ws != null)
{
try
{
ws.Close();
}
catch (Exception e)
{
var log = LogManager.GetLogger(Global.CallerName());
log.Info("DoClose ws.Close() Exception= " + e.Message);
}
}
}
private void websocket_Opened(object sender, EventArgs e)
{
if (this.data != null)
{
websocket.Send(this.data);
}
if (this.datas != null && this.datas.Count > 0)
{
for (int i = 0; i < this.datas.Count; i++)
{
websocket.Send(this.datas[i]);
}
}
websocket.Close();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (_socket != null)
{
var state = State;
if (state == WebSocketState.Open || state == WebSocketState.Connecting)
{
_logger.LogInformation("Sending web socket close message");
_socket.Close();
}
_socket = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing && _socket != null)
{
var state = State;
if (state == WebSocketState.Open || state == WebSocketState.Connecting)
{
var logger = LogManager.GetCurrentClassLogger();
logger.Info("Sending web socket close message");
_socket.Close();
}
_socket = null;
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (_socket != null)
{
var state = State;
if (state == MediaBrowser.Model.Net.WebSocketState.Open || state == MediaBrowser.Model.Net.WebSocketState.Connecting)
{
_logger.Info("Sending web socket close message");
_socket.Close();
}
_socket = null;
}
}
public void Dispose()
{
Lock(() => {
this.retry = null;
if (socket != null)
{
socket.Close();
socket = null;
}
if (timer != null)
{
timer.Dispose();
timer = null;
}
}, false);
}
static void Main(string[] args)
{
_webSocket = new WebSocket("ws://localhost:44961/wsapp?token=ABCD");
_webSocket.Opened += WebSocketOnOpened;
_webSocket.Closed += (sender, eventArgs) => Console.WriteLine("Closed");
_webSocket.Error += (sender, eventArgs) => Console.WriteLine("Error" + eventArgs.Exception);
_webSocket.MessageReceived += (sender, eventArgs) => Console.WriteLine(eventArgs.Message);
_webSocket.DataReceived += (sender, eventArgs) => Console.WriteLine("Data received");
_webSocket.Open();
while (Console.ReadKey().KeyChar != 'q')
{
Console.WriteLine();
}
_webSocket.Close();
}
public void TestConnection()
{
var webSocketClient = new WebSocket("ws://echo.websocket.org");
//webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(5000))
{
Assert.Fail("Failed to Opened session ontime");
}
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
for (var i = 0; i < 10; i++)
{
var message = Guid.NewGuid().ToString();
webSocketClient.Send(message);
if (!m_MessageReceiveEvent.WaitOne(5000))
{
Assert.Fail("Failed to get echo messsage on time");
break;
}
Assert.AreEqual(m_CurrentMessage, message);
}
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(5000))
{
Assert.Fail("Failed to close session ontime");
}
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
public List<SniperInfo> FindAll()
{
List<SniperInfo> newSniperInfos = new List<SniperInfo>();
try
{
using (var client = new WebSocket(URL, "basic", WebSocketVersion.Rfc6455))
{
client.MessageReceived += (s, e) =>
{
var message = e.Message;
var match = Regex.Match(message, @"^(1?\d+)\[""[a|b]"",""(2?.*)""\]$");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfos = Parse(match.Groups[2].Value);
if (sniperInfos != null && sniperInfos.Any())
{
newSniperInfos.AddRange(sniperInfos);
}
}
}
};
client.Open();
Thread.Sleep(Timeout);
client.Close();
}
}
catch (Exception e)
{
Log.Warn("Received error from Pokezz. More info the logs");
Log.Debug("Received error from Pokezz: ", e);
}
return newSniperInfos;
}
public void SendMessageTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("ws://127.0.0.1:{0}/websocket", m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(1000))
Assert.Fail("Failed to Opened session ontime");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++)
{
sb.Append(Guid.NewGuid().ToString());
}
string messageSource = sb.ToString();
Random rd = new Random();
for (int i = 0; i < 100; i++)
{
int startPos = rd.Next(0, messageSource.Length - 2);
int endPos = rd.Next(startPos + 1, messageSource.Length - 1);
string message = messageSource.Substring(startPos, endPos - startPos);
webSocketClient.Send("ECHO " + message);
Console.WriteLine("Client:" + message);
if (!m_MessageReceiveEvent.WaitOne(1000))
Assert.Fail("Cannot get response in time!");
Assert.AreEqual(message, m_CurrentMessage);
}
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
}
public void ConnectionTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("ws://127.0.0.1:{0}/websocket", m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(1000))
Assert.Fail("Failed to Opened session ontime");
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
public void IncorrectDNSTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", "ws://localhostx", m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error);
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(2000))
Assert.Fail("Failed to Opened session ontime");
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
public void TestWebSocketOrg()
{
WebSocket webSocketClient = new WebSocket("ws://echo.websocket.org/");
webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error);
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(5000))
Assert.Fail("Failed to Opened session ontime");
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
for (var i = 0; i < 10; i++)
{
var message = Guid.NewGuid().ToString();
webSocketClient.Send(message);
if (!m_MessageReceiveEvent.WaitOne(5000))
{
Assert.Fail("Failed to get echo messsage on time");
break;
}
Console.WriteLine("Received echo message: {0}", m_CurrentMessage);
Assert.AreEqual(m_CurrentMessage, message);
}
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(5000))
Assert.Fail("Failed to close session ontime");
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
public void SendPingReactTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(2000))
Assert.Fail("Failed to Opened session ontime");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++)
{
sb.Append(Guid.NewGuid().ToString());
}
string messageSource = sb.ToString();
Random rd = new Random();
for (int i = 0; i < 10; i++)
{
int startPos = rd.Next(0, messageSource.Length - 2);
int endPos = rd.Next(startPos + 1, messageSource.Length - 1);
string message = messageSource.Substring(startPos, endPos - startPos);
Console.WriteLine("PING:" + message);
webSocketClient.Send("PING " + message);
}
Thread.Sleep(5000);
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
}
public void UnreachableReconnectTestB()
{
StopServer();
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error);
webSocketClient.Error += (s, e) => { m_OpenedEvent.Set(); };
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
m_OpenedEvent.WaitOne();
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
StartServer();
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(5000))
Assert.Fail("Failed to Opened session ontime");
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
m_CloseEvent.Reset();
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(2000))
Assert.Fail("Failed to close session ontime");
Console.WriteLine("State {0}: {1}", webSocketClient.GetHashCode(), webSocketClient.State);
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
public List<SniperInfo> FindAll()
{
List<SniperInfo> newSniperInfos = new List<SniperInfo>();
try
{
using (var client = new WebSocket(URL, "basic", null,
new List<KeyValuePair<string, string>>() {new KeyValuePair<string, string>("Referer","http://www.rarespawns.be/"), new KeyValuePair<string, string>("Host", "188.165.224.208:49001") },
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36", "http://www.rarespawns.be", WebSocketVersion.Rfc6455, null))
{
client.MessageReceived += (s, e) =>
{
try
{
var message = e.Message;
if (message == "40")
{
client.Send("40/pokes");
}
var match = Regex.Match(message, @"(1?\d+)+.*\[""helo"",(2?.*)\]");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfos = GetJsonList(match.Groups[2].Value);
if (sniperInfos != null && sniperInfos.Any())
{
newSniperInfos.AddRange(sniperInfos);
}
}
}
else
{
match = Regex.Match(message, @"(1?\d+)+.*\[""poke"",(2?.*)\]");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfo = GetJson(match.Groups[2].Value);
if (sniperInfo != null)
{
newSniperInfos.Add(sniperInfo);
}
}
}
}
}
catch (Exception ex)
{
Log.Debug("Error receiving message from RareSpawns", ex);
}
};
client.Open();
Thread.Sleep(Timeout);
client.Close();
}
}
catch (Exception e)
{
Log.Warn("Received error from Pokezz. More info the logs");
Log.Debug("Received error from Pokezz: ", e);
}
return newSniperInfos;
}
private void SockUpdate()
{
ws = new WebSocket(URL);
/// 文字列受信
ws.MessageReceived += (s, e) =>
{
// Console.WriteLine("{0}:String Received:{1}", DateTime.Now.ToString(), e.Message);
recvText = (e.Message);
};
/// バイナリ受信
ws.DataReceived += (s, e) =>
{
IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(e.Data, 0);
recvData = (RecvData)Marshal.PtrToStructure(ptr, typeof(RecvData));
string test = recvData.ToString();
LeadIsShow = false;
};
/// サーバ接続完了
ws.Opened += (s, e) =>
{
recvData.events = LedEvent.Conect;
};
// 接続切れた
ws.Closed += (s, e) =>
{
recvData.events = LedEvent.NoneConect;
};
/// サーバ接続開始
ws.Open();
/// 送受信ループ
while (!IsExit)
{
// 空いた
if (ws.State == WebSocketState.Open)
{
}
// コネクトが出来なけれなもう一度試す
if (ws.State == WebSocketState.Closed)
{
// 1秒スリーブ
Thread.Sleep(1000);
ws.Open();
}
}
/// ソケットを閉じる
ws.Close();
}
public async Task StreamAsync(Uri uri, CancellationToken token)
{
Throw.IfNull(uri, nameof(uri));
if (!token.CanBeCanceled)
{
throw new ArgumentException("Token must be capable of being in the canceled state.", nameof(token));
}
token.ThrowIfCancellationRequested();
IsStreaming = true;
var webSocket = new WebSocket4Net.WebSocket(uri.ToString(), "basic", WebSocketVersion.Rfc6455);
webSocket.Security.AllowUnstrustedCertificate = true;
webSocket.Security.AllowNameMismatchCertificate = true;
webSocket.EnableAutoSendPing = true;
webSocket.DataReceived += WebSocket_DataReceived;
//var webSocket = new ClientWebSocket();
//webSocket.Options.KeepAliveInterval = TimeSpan.FromSeconds(30);
try
{
try
{
webSocket.Open();
if (webSocket.State == WebSocketState.Open)
{
RaiseOpenEvent();
}
}
catch (OperationCanceledException) { }
catch (Exception e)
{
if (!token.IsCancellationRequested)
{
_logger?.LogError(e, $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket connect exception.");
throw;
}
}
while (!token.IsCancellationRequested)
{
// do nothing
}
/*
*
* var bytes = new byte[ReceiveBufferSize];
* var buffer = new ArraySegment<byte>(bytes);
*
* while (!token.IsCancellationRequested)
* {
* var stringBuilder = new StringBuilder();
* stringBuilder.Clear();
*
* try
* {
* WebSocketReceiveResult result;
* do
* {
* if (webSocket.State != WebSocketState.Open)
* {
* throw new Exception($"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket is not open (state: {webSocket.State}).");
* }
*
* result = await webSocket
* .ReceiveAsync(buffer, token)
* .ConfigureAwait(false);
*
* switch (result.MessageType)
* {
* case WebSocketMessageType.Close:
* throw new Exception(result.CloseStatus.HasValue
* ? $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket closed ({result.CloseStatus.Value}): \"{result.CloseStatusDescription ?? "[no reason provided]"}\""
* : $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket closed: \"{result.CloseStatusDescription ?? "[no reason provided]"}\"");
*
* case WebSocketMessageType.Text when result.Count > 0:
* stringBuilder.Append(Encoding.UTF8.GetString(bytes, 0, result.Count));
* break;
*
* case WebSocketMessageType.Binary:
* _logger?.LogWarning($"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: Received unsupported binary message type.");
* break;
*
* default:
* throw new ArgumentOutOfRangeException(nameof(result.MessageType), $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: Unknown result message type ({result.MessageType}).");
* }
* }
* while (!result.EndOfMessage);
* }
* catch (OperationCanceledException) { }
* catch (Exception e)
* {
* if (!token.IsCancellationRequested)
* {
* _logger?.LogError(e, $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket receive exception.");
* throw;
* }
* }
*
* if (token.IsCancellationRequested)
* continue;
*
* var json = stringBuilder.ToString();
* if (!string.IsNullOrWhiteSpace(json))
* {
* RaiseMessageEvent(new WebSocketClientEventArgs(json));
* }
* else
* {
* _logger?.LogWarning($"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: Received empty JSON message.");
* }
* }
*/
}
finally
{
IsStreaming = false;
// NOTE: WebSocketState.CloseSent should not be encountered since CloseOutputAsync is not used.
if (webSocket.State == WebSocketState.Open || webSocket.State == WebSocketState.Closing)
{
webSocket.Close();
//await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
}
if (webSocket != null)
{
webSocket.Dispose();
}
RaiseCloseEvent();
}
}
public bool Connect(string holoChainServerURI)
{
/*
* var services = new ServiceCollection();
* services.AddNodeServices(options => {
* // Set any properties that you want on 'options' here
* });
*/
//CallZomeFunction(holoChainServerURI);
//var func = Edge.Func(@"return require('./../myfunc.js')");
//var func = Edge.Func(File.ReadAllText("myfunc.js"));
/*
* JsonRpcHttpClient client = new JsonRpcHttpClient(new Uri(holoChainServerURI));
*
*
* client.Invoke<string>("info/instances").ContinueWith((antecedent) =>
* {
* object obj = antecedent.Result;
*
* if (antecedent.Status == TaskStatus.RanToCompletion)
* {
* Console.WriteLine("completed");
* }
* });
*/
//var socket = await this.HttpContext.WebSockets.AcceptWebSocketAsync();
//var jsonRpc = new JsonRpc(new WebSocketMessageHandler(socket), new JsonRpcServer());
//jsonRpc.StartListening();
//await jsonRpc.Completion;
// return true;
/*
* client.Invoke<string>("info/instances", new ).ContinueWith((antecedent) =>
* {
* object obj = antecedent.Result;
*
* if (antecedent.Status == TaskStatus.RanToCompletion)
* {
* Console.WriteLine("completed");
* }
* });*/
/*
* var websocket = new JsonWebSocket(holoChainServerURI);
*
* websocket.Opened += (sender, e) =>
* {
* websocket.Send("info/instances",
* JsonConvert.SerializeObject(
* new
* {
* method = "info/instances",
* @params = new { },
* id = 123,
* }
* )
* );
*
* websocket.Send("test-instance/our_world/create_my_entry",
* JsonConvert.SerializeObject(
* new
* {
* method = "test-instance/our_world/create_my_entry",
* @params = new { entry = new MyEntry { content = "blah" } },
* id = 124,
* }
* )
* );
*
*
*
* };
*
*
* Action<string> s = Console.WriteLine;
*
* websocket.On("info/instances", s);
*
*/
// note: reconnection handling needed.
//var websocket = new WebSocket(holoChainServerURI, sslProtocols: SslProtocols.Tls12);
//var websocket = new WebSocket(holoChainServerURI, sslProtocols: SslProtocols.Default);
var websocket = new WebSocket4Net.WebSocket(holoChainServerURI);
websocket.Opened += (sender, e) =>
{
websocket.Send(
JsonConvert.SerializeObject(
new
{
method = "info/instances",
//@params = new { channel = channelName },
id = 123,
}
)
);
websocket.Send(
JsonConvert.SerializeObject(
new
{
method = "test-instance/our_world_core/create_my_entry",
@params = new { entry = new MyEntry {
content = "blah"
} },
id = 124,
}
)
);
};
websocket.MessageReceived += (sender, e) =>
{
Console.WriteLine("Message Received: " + e.Message);
dynamic data = JObject.Parse(e.Message);
if (data.id == 123)
{
Console.WriteLine("Instance Name Received");
}
if (data.@params != null)
{
Console.WriteLine([email protected] + " " + [email protected]);
}
//JObject data = JObject.Parse(e.Message);
//if (data["id"].v == 123)
//{
// Console.WriteLine("Instance Name Received");
//}
//if (data.@params != null)
//{
// Console.WriteLine([email protected] + " " + [email protected]);
//}
};
websocket.Open();
websocket.Close();
return(true);
//this.Connection = WebSocket.CreateClientBuffer(1024,1024)
}
public void Dispose()
{
webSocket.Close();
}
public bool Close()
{
m_WebSocketClient.Close();
m_WebSocketClient = null;
return(true);
}
private void TestClose()
{
webSocket.Close();
}
static void Main(string[] args)
{
const string httpScheme = "https://";
const string wsScheme = "wss://";
const string url = "websocket.btcchina.com/socket.io/";
#region handshake
string polling = string.Empty;
try
{
WebClient wc = new WebClient();
polling = wc.DownloadString(httpScheme + url + "?transport=polling");
if (string.IsNullOrEmpty(polling))
{
Console.WriteLine("failed to download config");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
string config = polling.Substring(polling.IndexOf('{'), polling.IndexOf('}') - polling.IndexOf('{') + 1);
wsConfigHelper wsc = JsonConvert.DeserializeObject<wsConfigHelper>(config);
#endregion handshake
//set timers
pingTimeoutTimer = new Timer(_ =>
{
if (pong)
{
pong = false; //waiting for another ping
}
else
{
Console.WriteLine("Ping Timeout!");
}
}, null, Timeout.Infinite, Timeout.Infinite);
pingIntervalTimer = new Timer(_ =>
{
btc.Send(string.Format("{0}", (int)engineioMessageType.PING));
pingTimeoutTimer.Change(wsc.pingTimeout, Timeout.Infinite);
pong = false;
}, null, wsc.pingInterval, wsc.pingInterval);
//setup websocket connections and events
btc = new WebSocket(wsScheme + url + "?transport=websocket&sid=" + wsc.sid);
btc.Opened += btc_Opened;
btc.Error += btc_Error;
btc.MessageReceived += btc_MessageReceived;
btc.DataReceived += btc_DataReceived;
btc.Closed += btc_Closed;
btc.Open();
Console.ReadKey();
//close the connection.
btc.Send(string.Format("{0}{1}", (int)engineioMessageType.MESSAGE, (int)socketioMessageType.DISCONNECT));
Console.ReadKey();
pingIntervalTimer.Dispose();
pingTimeoutTimer.Dispose();
btc.Close();
}
public override bool Register(string Username, string Password)
{
try
{
HttpWebRequest betrequest = (HttpWebRequest)HttpWebRequest.Create("https://www.bitdice.me/");
if (Prox != null)
betrequest.Proxy = Prox;
betrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
betrequest.CookieContainer = new CookieContainer();
HttpWebResponse EmitResponse = (HttpWebResponse)betrequest.GetResponse();
string sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd();
getcsrf(sEmitResponse);
getstream(sEmitResponse);
cookie = EmitResponse.Cookies["_csn_session"].Value;
if (Client != null)
Client.Close();
List<KeyValuePair<string, string>> headers = new List<KeyValuePair<string, string>>();
headers.Add(new KeyValuePair<string, string>("Cookie", "_csn_session=" + cookie));
Client = new WebSocket("wss://www.bitdice.me/stream/" + stream, "", null, headers, "dicebot", "http://bitdice.me", WebSocketVersion.Rfc6455);
Client.Opened += Client_Opened;
Client.Error += Client_Error;
Client.Closed += Client_Closed;
Client.MessageReceived += Client_MessageReceived;
Client.Open();
while (Client.State == WebSocketState.Connecting)
{
Thread.Sleep(100);
}
if (Client.State == WebSocketState.Open)
{
Client.Send("{\"jsonrpc\":\"2.0\",\"method\":\"user:update\",\"params\":{\"username\":\"" + Username + "\",\"user_seed\":\"1256e154283ea05b9538\",\"hide_bets_below\":\"0.0\",\"hide_other_bets\":false},\"id\":1}");
}
else
{
finishedlogin(false);
return false;
}
betrequest = (HttpWebRequest)HttpWebRequest.Create("https://www.bitdice.me/users/password");
betrequest.Method = "POST";
betrequest.CookieContainer = new CookieContainer();
string post = string.Format("user%5Bpassword%5D={0}&user%5Bpassword_confirmation%5D={0}", Password);
username = Username;
betrequest.ContentLength = post.Length;
if (Prox != null)
betrequest.Proxy = Prox;
betrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
betrequest.CookieContainer.Add(new Cookie("_csn_session", cookie, "/", "bitdice.me"));
betrequest.Headers.Add("X-CSRF-Token", csrf);
using (var writer = new StreamWriter(betrequest.GetRequestStream()))
{
writer.Write(post);
}
EmitResponse = (HttpWebResponse)betrequest.GetResponse();
sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd();
cookie = EmitResponse.Cookies["_csn_session"].Value;
betrequest = (HttpWebRequest)HttpWebRequest.Create("https://www.bitdice.me/");
if (Prox != null)
betrequest.Proxy = Prox;
betrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
betrequest.CookieContainer = new CookieContainer();
betrequest.CookieContainer.Add(new Cookie("_csn_session", cookie, "/", "bitdice.me"));
EmitResponse = (HttpWebResponse)betrequest.GetResponse();
sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd();
getDeposit(sEmitResponse);
getcsrf(sEmitResponse);
cookie = EmitResponse.Cookies["_csn_session"].Value;
getstream(sEmitResponse);
getcsrf(sEmitResponse);
getstream(sEmitResponse);
if (Client != null)
Client.Close();
headers = new List<KeyValuePair<string, string>>();
headers.Add(new KeyValuePair<string, string>("Cookie", "_csn_session=" + cookie));
Client = new WebSocket("wss://www.bitdice.me/stream/" + stream, "", null, headers, "dicebot", "http://bitdice.me", WebSocketVersion.Rfc6455);
Client.Opened += Client_Opened;
Client.Error += Client_Error;
Client.Closed += Client_Closed;
Client.MessageReceived += Client_MessageReceived;
Client.Open();
while (Client.State == WebSocketState.Connecting)
{
Thread.Sleep(100);
}
finishedlogin(Client.State == WebSocketState.Open);
return true;
}
catch
{
return false;
}
}
/// <summary>
/// Asynchronously closes the WebSocket connection for the specified reason.
/// </summary>
/// <param name="reason">The reason.</param>
protected override async Task CloseWebSocketAsyncCore(string reason)
{
if (!IsWebSocketOpen)
{
return;
}
Logger.Trace(Log("Closing web socket connection: {0}", reason));
bool result = false;
Exception ex = null;
var task = new Task <bool>(() => { if (ex != null)
{
throw ex;
}
return(result); });
EventHandler closedHandler = null;
EventHandler <ErrorEventArgs> errorHandler = null;
Action clearHandlers = () =>
{
_socket.Closed -= closedHandler;
_socket.Error -= errorHandler;
};
bool handled = false;
closedHandler = (s, e) =>
{
if (!handled)
{
handled = true;
clearHandlers();
handled = true;
OnWebSocketClosed(s, e);
result = true;
task.Start();
}
};
errorHandler = (s, e) =>
{
if (!handled)
{
handled = true;
clearHandlers();
if (e.Exception.ExceptionMeansConnectionTerminated())
{
result = true;
}
else
{
ex = e.Exception;
}
task.Start();
}
};
_socket.Closed += closedHandler;
_socket.Error += errorHandler;
UnsubscribeFromSocketEvents();
_socket.Close(reason);
await task.ConfigureAwait(CaptureAsyncContext);
}
public void ReconnectTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error);
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
for (var i = 0; i <2000; i++)
{
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(5000))
Assert.Fail("Failed to Opened session ontime at round {0}", i);
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(5000))
Assert.Fail("Failed to close session ontime");
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
}
public void Close()
{
m_WebSocketClient.Close();
m_WebSocketClient = null;
}
public void SendDataTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version);
if (!webSocketClient.SupportBinary)
return;
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.DataReceived += new EventHandler<DataReceivedEventArgs>(webSocketClient_DataReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(2000))
Assert.Fail("Failed to Opened session ontime");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++)
{
sb.Append(Guid.NewGuid().ToString());
}
string messageSource = sb.ToString();
Random rd = new Random();
for (int i = 0; i < 100; i++)
{
int startPos = rd.Next(0, messageSource.Length - 2);
int endPos = rd.Next(startPos + 1, messageSource.Length - 1);
string message = messageSource.Substring(startPos, endPos - startPos);
Console.WriteLine("Client:" + message);
var data = Encoding.UTF8.GetBytes(message);
webSocketClient.Send(data, 0, data.Length);
if (!m_MessageReceiveEvent.WaitOne(1000))
Assert.Fail("Cannot get response in time!");
Assert.AreEqual(message, m_CurrentMessage);
}
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
}
public void ConnectionTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, Port), subProtocol: "basic", version: m_Version);
webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error);
//webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne())
Assert.Fail("Failed to Opened session ontime");
Assert.AreEqual(WebSocketState.Open, webSocketClient.State);
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
Assert.AreEqual(WebSocketState.Closed, webSocketClient.State);
}
public void ConcurrentSendTest()
{
WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version);
webSocketClient.AllowUnstrustedCertificate = true;
webSocketClient.Opened += new EventHandler(webSocketClient_Opened);
webSocketClient.Closed += new EventHandler(webSocketClient_Closed);
webSocketClient.Open();
if (!m_OpenedEvent.WaitOne(2000))
Assert.Fail("Failed to Opened session ontime");
string[] lines = new string[100];
for (int i = 0; i < lines.Length; i++)
{
lines[i] = Guid.NewGuid().ToString();
}
var messDict = lines.ToDictionary(l => l);
webSocketClient.MessageReceived += (s, m) =>
{
messDict.Remove(m.Message);
Console.WriteLine("R: {0}", m.Message);
};
Parallel.For(0, lines.Length, (i) =>
{
webSocketClient.Send("ECHO " + lines[i]);
});
int waitRound = 0;
while (waitRound < 10)
{
if (messDict.Count <= 0)
break;
Thread.Sleep(500);
waitRound++;
}
if (messDict.Count > 0)
{
Assert.Fail("Failed to receive message on time.");
}
webSocketClient.Close();
if (!m_CloseEvent.WaitOne(1000))
Assert.Fail("Failed to close session ontime");
}
public void Disconnect()
{
_ws?.Close();
_ws = null;
}
public List<SniperInfo> FindAll()
{
List<SniperInfo> newSniperInfos = new List<SniperInfo>();
try
{
using (var client = new WebSocket(URL, "basic", WebSocketVersion.Rfc6455))
{
client.MessageReceived += (s, e) =>
{
try
{
var message = e.Message;
var match = Regex.Match(message, @"(1?\d+)+\[""helo"",(2?.*)\]");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfos = GetJsonList(match.Groups[2].Value);
if (sniperInfos != null && sniperInfos.Any())
{
newSniperInfos.AddRange(sniperInfos);
}
}
}
else
{
match = Regex.Match(message, @"(1?\d+)+\[""poke"",(2?.*)\]");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfo = GetJson(match.Groups[2].Value);
if (sniperInfo != null)
{
newSniperInfos.Add(sniperInfo);
}
}
}
}
}
catch (Exception ex)
{
Log.Debug("Error receiving message from PokemonGoIVClub", ex);
}
};
client.Open();
Thread.Sleep(Timeout);
client.Close();
}
}
catch (Exception e)
{
Log.Warn("Received error from Pokezz. More info the logs");
Log.Debug("Received error from Pokezz: ", e);
}
return newSniperInfos;
}
public void Close()
{
webSocketFeed.Close();
}
public List<SniperInfo> FindAll()
{
List<SniperInfo> newSniperInfos = new List<SniperInfo>();
try
{
string token = "";
using (var client = new HttpClient())
{
// Use the HttpClient as usual. Any JS challenge will be solved automatically for you.
var content = client.GetStringAsync(AuthUrl).Result;
token = GetToken(content)?.token;
}
string URL = $"ws://188.165.224.208:49001/socket.io/?EIO=3&transport=websocket&token={token}";
using (var client = new WebSocket(URL, "basic", null,
new List<KeyValuePair<string, string>>() {new KeyValuePair<string, string>("Referer","http://www.rarespawns.be/"), new KeyValuePair<string, string>("Host", "188.165.224.208:49001") },
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36", "http://www.rarespawns.be", WebSocketVersion.Rfc6455, null))
{
client.MessageReceived += (s, e) =>
{
try
{
var message = e.Message;
if (message == "40")
{
client.Send("40/pokes");
}
var match = Regex.Match(message, @"(1?\d+)+.*\[""helo"",(2?.*)\]");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfos = GetJsonList(match.Groups[2].Value);
if (sniperInfos != null && sniperInfos.Any())
{
newSniperInfos.AddRange(sniperInfos);
}
}
}
else
{
match = Regex.Match(message, @"(1?\d+)+.*\[""poke"",(2?.*)\]");
if (match.Success)
{
if (match.Groups[1].Value == "42")
{
var sniperInfo = GetJson(match.Groups[2].Value);
if (sniperInfo != null)
{
newSniperInfos.Add(sniperInfo);
}
}
}
}
}
catch (Exception ex)
{
Log.Debug("Error receiving message from RareSpawns", ex);
}
};
client.Open();
Thread.Sleep(Timeout);
client.Close();
}
}
catch (Exception e)
{
Log.Warn("Received error from Pokezz. More info the logs");
Log.Debug("Received error from Pokezz: ", e);
}
return newSniperInfos;
}
private void websocket_Opened(object sender, EventArgs e)
{
websocket.Send(this.data);
websocket.Close();
}
