/* WS */
public ScarletMetrics()
{
metricsws = new WebSocket("ws://" + MetricsWSURL + ":" + MetricsWSPort);
metricsws.Connect();
metricsws.OnOpen += (sender, e) =>
{
// Metrics - On Connection to the Metrics WS Reporting Server
// Need to include username / IP in here as well.
JsonObject jsonMessage = new JsonObject()
.add("type", "metrics")
.add("message", "connected");
metricsws.Send(jsonMessage.ToString());
};
metricsws.OnMessage += (sender, e) =>
{
};
metricsws.OnClose += (sender, e ) =>
metricsws.Connect();
metricsws.OnError += (sender, e) =>
metricsws.Connect();
}
public static void pushSocket(string socketUrl, JObject socketObj)
{
if (ws == null)
{
ws = new WebSocketSharp.WebSocket(socketUrl);
}
if (ws.IsAlive == false)
{
LogClasses.LogProperties.info("WebSocket Is Alive : " + ws.IsAlive.ToString());
ws.Connect();
}
if (ws.IsAlive == true)
{
LogClasses.LogProperties.info("socket data send: " + socketObj.ToString());
ws.Send(socketObj.ToString());
}
ws.OnMessage += (sender, e) =>
{
LogClasses.LogProperties.info("WebSocket OnMessage : " + e.Data.ToString());
};
ws.OnClose += (sender, e) =>
{
LogClasses.LogProperties.error("WebSocket OnClose : CODE IS " + e.Code.ToString() + " reason is " + e.Reason.ToString());
ws.Connect();
};
ws.OnError += (sender, e) =>
{
LogClasses.LogProperties.error("WebSocket OnError exception : " + e.Exception.ToString() + " message is : " + e.Message.ToString());
};
}
static void Main(string[] args)
{
ws.OnMessage += Ws_OnMessage;
ws.OnClose += Ws_OnClose;
ws.OnError += Ws_OnError;
while (ws.IsAlive != true)
{
ws.Connect();
Console.WriteLine("Is Alive : {0}", ws.IsAlive);
}
Console.ReadKey(true);
}
void ConnectWS()
{
if (m_isWSConnected)
{
return;
}
m_Message = "No data.";
var URL = "ws://bede6bd8.ngrok.io";
//var URL = "ws://" + m_URL + ":" + m_Port;
using (m_ws = new WebSocket(URL))
{
//m_ws.Log.Level = WebSocketSharp.LogLevel.TRACE;
//m_ws.Log.File = "D:\\ws_log.txt";
m_ws.OnOpen += (sender, e) =>
{
m_ws.Send(String.Format("Hello server."));
Debug.Log("Connection opened.");
m_isWSConnected = true;
};
m_ws.OnMessage += (sender, e) =>
{
m_Message = e.Data;
//Debug.Log(m_Message);
};
m_ws.OnClose += (sender, e) =>
{
m_ws.Connect(); // This is a hack, but whatever
m_isWSConnected = false;
};
m_ws.OnError += (sender, e) =>
{
// NOT PRINTING ERRORS
//Debug.LogError(e.Message);
m_isWSConnected = false;
};
m_ws.Connect();
if (m_isWSConnected != true)
{
Debug.LogWarning("Unable to connect to:" + URL);
}
}
}
public int Connect(string node_url = "")
{
var connectionString = node_url.Equals(string.Empty) ? Consts.WssConnectionString : node_url;
var certList = GetCertificatesFromPem(Consts.CertFileName);
_wss = new WebSocketSharp.WebSocket(connectionString);
_wss.SslConfiguration.EnabledSslProtocols = System.Security.Authentication.SslProtocols.Tls12;
_wss.SslConfiguration.ClientCertificates = new X509CertificateCollection(certList);
_wss.SslConfiguration.ServerCertificateValidationCallback =
(sender, certificate, chain, sslPolicyErrors) => {
// If the server certificate is valid.
return(sslPolicyErrors == SslPolicyErrors.None);
};
_wss.OnMessage += (sender, e) => {
var payload = e.Data;
_logger.Info($"WS Received Message: {payload}");
foreach (var item in _observers)
{
item.HandleMessage(payload);
}
};
_wss.Connect();
_logger.Info($"Connected to {connectionString}");
return(0);
}
public static void Main(string[] args)
{
if (args.Length != 1) {
Console.Error.WriteLine ("ERROR: need a valid Websocket URL");
Environment.Exit (-1);
}
using (var ws = new WebSocket (args[0])) {
Int64 syncCtr = 0;
ws.OnMessage += (sender, e) => {
Console.WriteLine (e.Data);
Interlocked.Decrement (ref syncCtr);
};
ws.Connect ();
if (!ws.IsAlive) {
Console.Error.WriteLine ("ERROR: Could not connect to Websocket Server {0}", args[0]);
Environment.Exit(-2);
}
var input = "";
while (string.Compare (input.Trim (), "shutdown", true) != 0) {
if (!string.IsNullOrWhiteSpace (input)) {
ws.Send (input.Trim());
Interlocked.Increment (ref syncCtr);
while (Interlocked.Read (ref syncCtr) > 0) {
Thread.Sleep (1);
}
}
Console.Write ("Type in a message or 'shutdown' to quit: ");
input = Console.ReadLine ();
} // Longevity loop
} // using
}
private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
Excel.Worksheet activeWorksheet = ((Excel.Worksheet)Application.ActiveSheet);
Excel.Range firstRow = activeWorksheet.get_Range("A1");
firstRow.EntireRow.Insert(Excel.XlInsertShiftDirection.xlShiftDown);
Excel.Range newFirstRow = activeWorksheet.get_Range("A1");
newFirstRow.Value2 = "lETS START THIS THING";
//lets start this thing
using (var ws = new WebSocket("ws://dumbsocket.herokuapp.com"))
{
ws.OnError += (error_sender, error_e) => {
Console.Write("socket error");
//SOME BROKE SHIT
};
ws.OnOpen += (open_sender, open_e) => {
Console.Write("sockets open");
//windows open
};
ws.OnClose += (close_sender, close_e) => {
Console.Write("socket closed");
};
ws.OnMessage += (socket_sender, socket_e) =>
{
newFirstRow.Value2 = "This is coming from the websocket" + socket_e.Data;
};
ws.Connect();
}
}
private void BeginWebSocketClient(string stream, ICollection <ISymbol> symbols)
{
var newStreams = symbols.Select(s => $"{(Exchange.GetCurrencyCode(s.BaseCurrencyCode) + Exchange.GetCurrencyCode(s.QuoteCurrencyCode)).ToLower()}@{stream}");
Streams.UnionWith(newStreams);
if (WebSocketClient != null)
{
WebSocketClient = null;
}
WebSocketClient = new WebSocketSharp.WebSocket($"{Url}/stream?streams={string.Join('/', Streams)}");
WebSocketClient.OnOpen += OnOpen;
WebSocketClient.OnMessage += OnMessage;
WebSocketClient.OnClose += delegate(object sender, WebSocketSharp.CloseEventArgs e)
{
OnClose?.Invoke(sender, new CloseEventArgs
{
Code = e.Code,
Reason = e.Reason
});
};
WebSocketClient.Connect();
}
public void Websock_Client_Node()
{
if (Connect_Disconnect == false)
{
try
{
WebSocketClient = new WebSocketSharp.WebSocket(serverUri.ToString());
WebSocketClient.OnMessage += wsServer_NewDataReceived;
WebSocketClient.OnOpen += wsServer_NewSessionConnected;
WebSocketClient.OnError += wsServer_OnError;
WebSocketClient.OnClose += wsServer_Disconnect;
WebSocketClient.Connect();
Console.WriteLine("Connection Open");
Connect_Disconnect = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Connect_Disconnect = false;
}
}
else
{
WebSocketClient.Send("User is already connected");
}
}
public void InitServerInfo(string serverIp, string serverPort)
{
IsOpenned = false;
L4Logger.Info("BCR InitServerInfo");
if (_WebSocket != null)
{
_WebSocket.Close();
_WebSocket.OnMessage -= _WebSocket_OnMessage;
}
this.ServerIP = serverIp;
this.ServerPort = serverPort;
_WebSocket = new WebSocketSharp.WebSocket(string.Format("ws://{0}:{1}/XfsCommandBehavior", ServerIP, ServerPort));
_WebSocket.OnMessage += _WebSocket_OnMessage;
_WebSocket.OnClose += _WebSocket_OnClose;
_WebSocket.OnError += _WebSocket_OnError;
_WebSocket.Connect();
ReadDataCompleted = null;
ReadDataError = null;
OpenCompleted = null;
RegisterCompleted = null;
OpenError = null;
RegisterError = null;
}
static void TryConnect(int maxAttempts = -1)
{
Logger.Trace("Entering Command_Server TryConnect()");
bool infAttempts = (maxAttempts == -1) ? true : false;
conAttempts = 1;
Timer timer = new Timer(1);
timer.AutoReset = false;
timer.Elapsed += (source, e) => {
Logger.Info($"Attempting to connect to Beat Saber ({conAttempts})...");
ws.Connect();
if (!ws.IsAlive && ((conAttempts <= maxAttempts) || infAttempts))
{
conAttempts++;
((Timer)source).Interval = 3000;
((Timer)source).Start();
}
if (ws.IsAlive)
{
ws.OnClose += onDisconnect;
Logger.Info("Connected to Beat Saber!");
}
};
timer.Start();
}
//needs to implemented from API
/// <summary>
///
/// </summary>
/// <param name="MessageReceived"></param>
public ChatController(Model m)
{
ws = new WebSocket("ws://127.0.0.1:8005/chat");
ws.OnMessage += (s, e) => GotPacket(e.Data);
ws.Connect();
this.m = m;
}
public static void Connect(string url)
{
if (_webSocket == null)
{
_webSocket = new WebSocketSharp.WebSocket("ws://" + url + "/Echo");
// Set the WebSocket events.
_webSocket.OnMessage += (sender, e) =>
{
_instance.OnMessageReceived(e.Data);
};
_webSocket.OnError += (sender, e) =>
{
_instance.OnError(e.Message);
};
_webSocket.OnClose += (sender, e) =>
{
_instance.OnClosed();
};
_webSocket.Connect();
}
}
/// <summary>
/// Connect in background
/// </summary>
private static void ConnectBackground()
{
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
while (Program.client == null)
{
try
{
WS.WebSocket client = new WS.WebSocket(Program.appSettings.WebsocketServerAddress);
client.WaitTime = new TimeSpan(0, 0, 30);
client.Connect();
if (client.ReadyState != WS.WebSocketState.Open)
{
Program.client = null;
}
else
{
client.OnClose += (sender, e) => Program.ConnectBackground();
Program.client = client;
}
}
catch (Exception ex)
{
Program.client = null;
ex.ToString();
}
}
}).Start();
}
public void Start(string address, int port, string path)
{
// IPAddress ipaddr = new IPAddress(address.Split('.').Select(a => (byte)a.to_i()).ToArray());
// WebSocketServer wss = new WebSocketServer(ipaddr, port, this);
wsc = new WebSocket(address + ":"+port+path, this);
wsc.OnMessage += OnMessage;
wsc.Connect();
}
public void Connect()
{
m_Socket = new WebSocketSharp.WebSocket(mUrl.ToString());
m_Socket.OnMessage += (sender, e) => { lock (m_Messages) { m_Messages.Enqueue(e.RawData); } };
m_Socket.OnOpen += (sender, e) => m_IsConnected = true;
m_Socket.OnError += (sender, e) => m_Error = e.Message;
m_Socket.Connect();
}
public void connect()
{
// Connect to the server.
if (webSocket != null)
{
webSocket.Connect();
}
}
public void getObjectsData(string checkNum)
{
Debug.Log("start getting data");
ws.OnMessage += OnMessage;
ws.Connect();
ws.Send(checkNum);
}
public bool Connect()
{
socket.Connect();
isConnected = socket.ReadyState == WebSocketState.Open;
checkTimer.Start();
return(isConnected);
}
public void ConnectWebSocket(string Address)
{
Socket = new WebSocket(Address, "connection");
Socket.OnOpen += ServerToClientConnected;
Socket.OnMessage += ServerToClientOnMessage;
Socket.OnClose += ServerToClientDisconnected;
Socket.Connect();
}
public WebSocketRestClient(string endPoint, string contentType)
{
_endPoint = endPoint;
_contentType = contentType;
_socket = new WebSocket(_endPoint);
_socket.Connect();
_socket.OnMessage += OnMessage;
}
private void StartWebSocket ()
{
webSocket = new WebSocket (wsUri.AbsoluteUri);
webSocket.Connect ();
webSocket.OnOpen += WebSocket_OnOpen;
webSocket.OnMessage += WebSocket_OnMessage;
webSocket.OnClose += WebSocket_OnClose;
webSocket.OnError += WebSocket_OnError;
}
private void button1_Click(object sender, EventArgs e)
{
ws = new WebSocket("ws://localhost:8080/?id=" + txtName.Text);
ws.OnOpen += new EventHandler(ws_OnOpen);
ws.OnMessage += new EventHandler<MessageEventArgs>(ws_OnMessage);
ws.OnError += new EventHandler<ErrorEventArgs>(ws_OnError);
ws.OnClose += new EventHandler<CloseEventArgs>(ws_OnClose);
ws.Connect();
}
private WebsocketManager()
{
UIFrontendLoadingScreen.Get().StartDisplayError("trying to connect to bridge server ", "at address: " + BridgeServerAddress);
ws = new WebSocketSharp.WebSocket(BridgeServerAddress);
ws.OnMessage += Ws_OnMessage;
ws.OnError += Ws_OnError;
ws.OnOpen += Ws_OnOpen;
ws.Connect();
}
private static void Ws_OnError(object sender, ErrorEventArgs e)
{
Console.WriteLine("Exception on socket stream : {0}", e.Message);
ws.Close();
ws = new WebSocketSharp.WebSocket("ws://localhost:1346/CandleMarket");
ws.Connect();
ws.OnMessage += Ws_OnMessage;
ws.OnClose += Ws_OnClose;
ws.OnError += Ws_OnError;
}
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;
_webSocket = new WebSocketSharp.WebSocket(uri.ToString());
_webSocket.EmitOnPing = true;
_webSocket.WaitTime = TimeSpan.FromSeconds(30);
_webSocket.OnMessage += WebSocket_OnMessage;
_webSocket.OnError += WebSocket_OnError;
_webSocket.OnClose += WebSocket_OnClose;
try
{
try
{
_webSocket.Connect();
if (_webSocket.ReadyState == WebSocketState.Open)
{
RaiseOpenEvent();
}
}
catch (OperationCanceledException) { }
catch (Exception e)
{
if (!token.IsCancellationRequested)
{
_logger?.LogError(e, $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket connect exception.");
throw;
}
}
}
finally
{
IsStreaming = false;
// NOTE: WebSocketState.CloseSent should not be encountered since CloseOutputAsync is not used.
if (_webSocket.ReadyState == WebSocketState.Open || _webSocket.ReadyState == WebSocketState.Closing)
{
_webSocket.Close();
}
RaiseCloseEvent();
}
}
internal async Task ConnectAsync()
{
WebSocketClient = new WebSocketSharp.WebSocket(
$"{Client.ClientOptions.WsOptions.GatewayUrl}?v={Client.ClientOptions.WsOptions.GatewayVersion}&encoding={Client.ClientOptions.WsOptions.EncodingType}");
WebSocketClient.OnMessage += async(sender, msg) => { await _onWsMessage(sender, msg); };
WebSocketClient.OnClose += _onWsClose;
WebSocketClient.Connect();
}
public void KlineWebSocket()
{
webSocket = new WebSocketSharp.WebSocket($"wss://stream.binance.com:9443/ws/ethbtc@kline_1m");
webSocket.OnMessage += (sender, e) =>
{
string jsonLine = e.Data.Replace(",[]", "");
Console.WriteLine(jsonLine);
};
webSocket.OnError += (sender, e) => Console.WriteLine(e.Message);
webSocket.Connect();
}
public static void Connect()
{
Console.Title = "Bot is starting";
var ws = new WebSocketSharp.WebSocket(GetWSConnectionString());
ws.OnMessage += (sender, e) => new RTMParseIncoming().OnIncomingMessage(sender, e);
ws.OnOpen += (sender, e) => OnOpen(sender, e);
ws.Connect();
ConnectedSocket = ws;
Console.Title = "Bot is running";
}
public static void Main(string[] args)
{
//using (WebSocket ws = new WebSocket("ws://localhost:8000/"))
using (WebSocket ws = new WebSocket("ws://localhost:8000/", "chat"))
{
/*ws.OnOpen += (o, e) =>
{
//Do something.
};
*/
ws.OnMessage += (o, s) =>
{
#if NOTIFY
Notification nf = new Notification("[WebSocket] Message",
s,
"notification-message-im");
nf.AddHint("append", "allowed");
nf.Show();
#else
Console.WriteLine("[WebSocket] Message: {0}", s);
#endif
};
ws.OnError += (o, s) =>
{
Console.WriteLine("[WebSocket] Error : {0}", s);
};
/*ws.OnClose += (o, e) =>
{
//Do something.
};
*/
ws.Connect();
Thread.Sleep(500);
Console.WriteLine("\nType \"exit\" to exit.\n");
string data;
while (true)
{
Thread.Sleep(500);
Console.Write("> ");
data = Console.ReadLine();
if (data == "exit")
{
break;
}
ws.Send(data);
}
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
client.Connect();
}
catch
{
chatBox.Items.Add("Cannot connect to server!");
}
}
static void TestClient()
{
using (var ws = new WebSocket("ws://localhost:8080/test1"))
{
ws.OnMessage += (sender, e) =>
Console.WriteLine("Laputa says: " + e.Data);
ws.Connect();
ws.Send("BALUS");
Console.ReadKey(true);
}
}
public bool Connect(string url, string session)
{
socket = new WebSocket(url);
socket.WaitTime = TimeSpan.FromSeconds(5);
socket.OnOpen += Socket_OnOpen;
socket.OnError += Socket_OnError;
socket.OnMessage += Socket_OnMessage;
socket.OnClose += Socket_OnClose;
socket.Connect();
reset.WaitOne();
return IsConnected;
}
private void ConnectWebSocket(RtmStartResponse rtmStartResponse)
{
if (rtmStartResponse == null || string.IsNullOrEmpty(rtmStartResponse.RtmUrl))
{
return;
}
WebSocketSharp.WebSocket socket = new WebSocketSharp.WebSocket(rtmStartResponse.RtmUrl);
socket.OnMessage += socket_OnMessage;
socket.OnOpen += socket_OnOpen;
socket.Connect();
}
void Start()
{
Adress += Ip + ":" + Port;
m_Socket = new WebSocketSharp.WebSocket(Adress);
m_Socket.OnMessage += (sender, e) => m_Messages.Enqueue(e.RawData);
m_Socket.OnOpen += (sender, e) => m_IsConnected = true;
m_Socket.OnClose += (sender, e) => m_IsConnected = false;
m_Socket.OnError += (sender, e) => m_Error = e.Message;
m_Socket.ConnectAsync();
Debug.Log("Init WebSocket");
m_Socket.Connect();
}
public async Task ClientCannotUseWrongProtolToConnectServer()
{
//Arrange
const string clientAddress = "ws://localhost:54222/ws";
const string serverAddress = "https://localhost:54222";
var config = NetCoreWebSocketHelper.CreateConfigWithUrl(serverAddress);
var clientTestPassed = false;
var serverAction = new Func <HttpContext, Task>(async httpContext =>
{
if (httpContext.Request.Path == "/ws")
{
throw new Exception("Should not be able to create web socket connection successfully");
}
});
var logger = new Logger(LogLevel.Debug, null, (logData, _) =>
{
var msg = logData.Message;
_testOutputHelper.WriteLine(msg);
if ("An exception has occurred while reading an HTTP request/response.".Equals(msg))
{
clientTestPassed = true;
}
});
//Act
using (var server = NetCoreWebSocketHelper.CreateTestServer(config, _testOutputHelper, serverAction, true))
{
await server.StartAsync();
using (var ws = new WebSocketSharp.WebSocket(clientAddress, logger))
{
var testCompleted = false;
ws.OnError += (sender, args) =>
{
testCompleted = true;
Assert.True(args.Exception != null);
};
ws.OnOpen += (sender, args) =>
{
testCompleted = true;
Assert.True(false, "The connection doesn't use wss url should failed!");
};
ws.Connect();
SpinWait.SpinUntil(() => testCompleted, new TimeSpan(0, 0, 5));
}
}
Assert.True(clientTestPassed);
}
void ConnectWS()
{
if (m_isWSConnected)
{
return;
}
m_Message = "No data.";
using (m_ws = new WebSocket("ws://a9dd09be.ngrok.io"))
{
//m_ws.Log.Level = WebSocketSharp.LogLevel.TRACE;
//m_ws.Log.File = "D:\\ws_log.txt";
m_ws.OnOpen += (sender, e) =>
{
m_ws.Send(String.Format("Hello server."));
Debug.Log("Connection opened.");
m_isWSConnected = true;
};
m_ws.OnMessage += (sender, e) =>
{
m_Message = e.Data;
//Debug.Log(m_Message);
};
m_ws.OnClose += (sender, e) =>
{
m_ws.Connect(); // This is a hack, but whatever
m_isWSConnected = false;
};
m_ws.OnError += (sender, e) =>
{
// NOT PRINTING ERRORS
//Debug.LogError(e.Message);
m_isWSConnected = false;
};
m_ws.Connect();
}
}
public void OpenClient()
{
if (_client != null)
{
_client.OnMessage -= OnRecievedMessage;
_client.OnError -= OnError;
_client.Close();
}
_client = new WebSocket(Settings.Default.Url);
_client.OnMessage += OnRecievedMessage;
_client.OnError += OnError;
_client.Connect();
}
public static void InternalConnect(String ipAddress)
{
try
{
webClient = new WebSocket("wss://" + ipAddress + ":3001");
webClient.OnMessage += webClient_OnMessage;
webClient.Connect();
}
catch (Exception ex)
{
Log.Error("Auto3D: " + ex.Message);
}
}
private void Connect_1(string addr)
{
if (sock != null && sock.IsConnected)
{
MessageEventManager.instance.BroadcastMessage(MessageType.ReLogin);
return;
}
sock = new WebSocketSharp.WebSocket(addr);
sock.OnOpen += OnPen_1;
sock.OnMessage += OnMessage_1;
sock.OnClose += OnClose_1;
sock.Connect();
}
public void Connect()
{
lock (subscriptionLock)
{
Socket = new WebSocket(BaseAddress);
}
Socket.Log.Level = LogLevel.Info;
Socket.OnClose += SocketClosed;
Socket.OnError += SocketError;
Socket.OnOpen += SocketOpened;
Socket.OnMessage += SocketMessage;
Socket.Connect();
}
/// <summary>
/// Makes this object and sets all it's needed properties
/// </summary>
/// <param name="url">The url</param>
internal Connection(string url)
{
Url = url;
WebSocket = new WebSocket(url)
{
EmitOnPing = false,
EnableRedirection = true
};
WebSocket.OnMessage += Websocket_OnMessage;
WebSocket.OnClose += Websocket_OnClose;
WebSocket.OnError += Websocket_OnError;
WebSocket.Connect();
}
public void Connect(string accessToken, string apiKey, string region)
{
var url = Constants.URLs.GetWebsocketUrl(region);
websocket = new WebSocketSharp.WebSocket(url);
websocket.OnMessage += Websocket_OnMessage;
websocket.Connect();
IsConnected = true;
var wsCredentialsPayload = new WsCredentialsPayload(accessToken, apiKey);
websocket.Send(wsCredentialsPayload.AsJson());
}
private void Connect(string url)
{
if (_webSocket != null)
{
_webSocket.Close();
_webSocket.OnMessage -= OnSocketMessage;
_webSocket.OnClose -= OnSocketClose;
_webSocket = null;
}
_webSocket = new WebSocket(url);
_webSocket.OnMessage += OnSocketMessage;
_webSocket.OnClose += OnSocketClose;
_webSocket.Connect();
}
public WebSocketSharpServer(ServerSettings settings) {
Settings = settings;
Server = new WebSocketServer(Settings.Port);
BaseUri = new Uri($"ws://localhost:{Server.Port}");
Server.Start();
Server.AddWebSocketService<Heartbeat>($"/{HeartbeatEndpoint}");
Heartbeat = new WebSocket($"{BaseUri}{HeartbeatEndpoint}");
Heartbeat.Connect();
Task.Factory.StartNew(() => {
while (!_isDisposing) {
Heartbeat.Send("Heartbeat OK");
Task.Delay(5000).Wait();
}
});
}
public WebSocketClientConnection(string host, int port, int timeoutMillis)
: base(new WebSocketDevice(port, host))
{
this.timeout = timeoutMillis;
socket = new WebSocket("ws://" + host + ":" + port + "/");
socket.Log.Output = OnLog;
socket.OnMessage += OnMessageReceived;
socket.Connect();
CheckError();
// Say hi!
socket.Send("HI:" + uuid);
// Wait for hello...
WaitMessage();
}
//initializes the server
private void btnConnect_Click(object sender, EventArgs e)
{
if (!connected)
{
client = new WebSocket(textBoxAddress.Text);
client.OnOpen += (sender2, e2) =>
connected = true;
client.OnClose += (sender2, e2) =>
connected = false;
client.OnMessage += (sender2, e2) =>
Recievedlist.Add(e2.Data);
client.OnError += (sender2, e2) =>
MessageBox.Show(((ErrorEventArgs)e2).Message);
client.Connect();
}
}
public void BindAndAuthenticate(string token,
EventHandler OnOpen,
EventHandler<MessageEventArgs> OnMessage,
EventHandler<CloseEventArgs> OnClose,
EventHandler<ErrorEventArgs> OnError)
{
if (ws != null && ws.IsAlive)
{
ws.Close();
}
ws = new WebSocket(WebSocketServiceEndpointUrl);//ws://localhost:8080/?name=
if (token == null) token = "";
ws.SetCookie(new WebSocketSharp.Net.Cookie("token", token));
ws.OnOpen += new EventHandler(OnOpen);
ws.OnMessage += new EventHandler<MessageEventArgs>(OnMessage);
ws.OnClose += new EventHandler<CloseEventArgs>(OnClose);
ws.OnError += new EventHandler<ErrorEventArgs>(OnError);
ws.Connect();
}
public void Connect()
{
if(websocket != null || websocket.IsAlive) { return; }
if(websocket != null)
{
websocket.Close();
websocket = null;
}
using (websocket = new WebSocket(BaseAddress, new String[] { "lgpp-v1.0" }))
{
websocket.OnOpen += Websocket_OnOpen;
websocket.OnMessage += Websocket_OnMessage;
websocket.OnError += Websocket_OnError;
websocket.OnClose += Websocket_OnClose;
websocket.Connect();
}
}
static void Main(string[] args)
{
using (var ws = new WebSocket("ws://localhost:8080/spring-websocket-stomp-apollo/chat/websocket"))
{
ws.OnMessage += ws_OnMessage;
ws.OnOpen += ws_OnOpen;
ws.OnError += ws_OnError;
ws.Connect();
Thread.Sleep(1000);
StompMessageSerializer serializer = new StompMessageSerializer();
var connect = new StompMessage("CONNECT");
connect["accept-version"] = "1.2";
connect["host"] = "";
ws.Send(serializer.Serialize(connect));
var clientId = RandomString(5);
Console.WriteLine("Client Id :" + clientId);
Thread.Sleep(1000);
var sub = new StompMessage("SUBSCRIBE");
sub["id"] = "sub-0";
sub["destination"] = "/topic/broadcast";
ws.Send(serializer.Serialize(sub));
var sub1 = new StompMessage("SUBSCRIBE");
sub1["id"] = "sub-1";
sub1["destination"] = "/queue/message-" + clientId;
ws.Send(serializer.Serialize(sub1));
Thread.Sleep(1000);
var content = new Content(){ Subject ="Stomp client", Message = "Hello World!!"};
var broad = new StompMessage("SEND", JsonConvert.SerializeObject(content));
broad["content-type"] = "application/json";
broad["destination"] = "/app/broadcast";
ws.Send(serializer.Serialize(broad));
Console.ReadKey(true);
}
}
public AgarioClient()
{
Console.WriteLine(BitConverter.IsLittleEndian);
state = new WorldState();
credentials = Servers.GetFFAServer();
Console.WriteLine("Server {0}", credentials.Server);
Console.WriteLine("Key {0}", credentials.Key);
var uri = "ws://" + credentials.Server;
Console.WriteLine(uri);
ws = new WebSocket(uri);
ws.Origin = "http://agar.io";
ws.OnOpen += OnOpen;
ws.OnError += OnError;
ws.OnMessage += OnMessageReceived;
ws.OnClose += OnClose;
ws.Connect();
}
static void EchoBack()
{
string res = null;
using (var ws = new WebSocket ("ws://echo.websocket.org"))
//using (var ws = new WebSocket ("ws://localhost:4649/Echo"))
{
var ver = Application.unityVersion;
ws.OnOpen += (sender, e) =>
ws.Send (String.Format ("Hello, Unity {0}!", ver));
ws.OnMessage += (sender, e) =>
res = e.Data;
ws.OnError += (sender, e) =>
Debug.LogError (e.Message);
ws.Connect ();
}
if (!res.IsNullOrEmpty())
EditorUtility.DisplayDialog ("Echo Back Successfully!", res, "OK");
}
public ChatClient(string url, string nick, string channel) {
webSocket = new WebSocket(url);
webSocket.OnOpen += (sender, e) =>
webSocket.Send("{\"cmd\":\"join\",\"channel\":\"" + channel + "\",\"nick\":\"" + nick + "\"}");
webSocket.OnMessage += (sender, args) => {
var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(args.Data);
if ((data["cmd"] as string == "chat") && (data["nick"] as string != nick)) {
System.Diagnostics.Debug.WriteLine(args.Data);
var chatArgs = new ChatEventArgs();
chatArgs.Text = data["text"] as string;
chatArgs.SenderNick = data["nick"] as string;
chatArgs.SenderTrip = data["trip"] as string;
//Console.WriteLine($"({data["trip"]}) {data["nick"]}: {data["text"]}");
OnChat?.Invoke(this, chatArgs);
}
};
webSocket.Connect();
}
public Client(string identifier, Config configManager)
: base(identifier, configManager)
{
// Create the bot user
ServerUser = new User {
Id = -1,
Username = "******"
};
// Fetch server address from the config
string server = Config.Get("Chat.Protocols.SockChat", "Address", "ws://enter_server_address_here");
// Create the websocket object
Socket = new WebSocket(server);
// Assign the event listeners
Socket.OnOpen += OnOpen;
Socket.OnClose += OnClose;
Socket.OnError += OnError;
Socket.OnMessage += OnMessage;
// Connect
Socket.Connect();
}
public EtzelClient(string host)
{
ws=new WebSocket (host);
using ( ws ) {
ws.OnMessage += (sender, e) => {
//Console.WriteLine (e.Data);
stupid s=JsonConvert.DeserializeObject<stupid>(e.Data);
if(s.cmd=="nomsg"){
this.isleep(s.qname);
}
if(s.cmd=="awk"){
this.fetch(s.qname);
}
if(s.cmd=="msg"){
this.qbacks[s.qname](s);
this.fetch(s.qname);
}
};
}
ws.Connect ();
}
public static void main()
{
log.Debug("D2MP starting...");
ourDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var iconThread = new Thread(delegate()
{
using (icon = new ProcessIcon())
{
icon.Display();
Application.Run();
}
});
iconThread.SetApartmentState(ApartmentState.STA);
iconThread.Start();
try
{
var steam = new SteamFinder();
var steamDir = steam.FindSteam(true);
dotaDir = steam.FindDota(true);
if (steamDir == null || dotaDir == null)
{
log.Fatal("Steam/dota was not found!");
return;
}
else
{
log.Debug("Steam found: " + steamDir);
log.Debug("Dota found: " + dotaDir);
}
addonsDir = Path.Combine(dotaDir, "dota/addons/");
d2mpDir = Path.Combine(dotaDir, "dota/d2moddin/");
modDir = Path.Combine(addonsDir, "d2moddin");
if (!Directory.Exists(addonsDir))
Directory.CreateDirectory(addonsDir);
if (!Directory.Exists(d2mpDir))
Directory.CreateDirectory(d2mpDir);
if (!Directory.Exists(modDir))
Directory.CreateDirectory(modDir);
{
var dirs = Directory.GetDirectories(d2mpDir);
modNames = new string[dirs.Length];
int i = 0;
foreach (var dir in dirs)
{
var modName = Path.GetFileName(dir);
log.Debug("Found mod: " + modName + " detecting version...");
var infoPath = Path.Combine(d2mpDir, modName + "/addoninfo.txt");
string versionFile = "";
if (File.Exists(infoPath))
{
versionFile = File.ReadAllText(infoPath);
}
var match = Regex.Match(versionFile, @"(addonversion)(\s+)(\d+\.)?(\d+\.)?(\d+\.)?(\*|\d+)",
RegexOptions.IgnoreCase);
if (match.Success)
{
string version = match.Groups.Cast<Group>()
.ToList()
.Skip(3)
.Aggregate("", (current, part) => current + part.Value);
log.Debug(modName + "=" + version);
modNames[i] = modName + "=" + version;
}
else
{
log.Error("Can't find version info for mod: " + modName + ", not including");
modNames[i] = modName + "=?";
}
i++;
}
}
//Detect user
var config = File.ReadAllText(Path.Combine(steamDir, @"config\config.vdf"));
var matches = Regex.Matches(config, "\"\\d{17}\"");
string steamid;
List<string> steamids = new List<string>();
if (matches.Count > 0)
{
foreach (Match match in matches)
{
steamid = match.Value.Substring(1).Substring(0, match.Value.Length - 2);
log.Debug("Steam ID detected: " + steamid);
steamids.Add(steamid);
}
}
else
{
log.Fatal("Could not detect steam ID.");
return;
}
//Modify gameinfo.txt
ModGameInfo();
log.Debug("Starting shutdown file watcher...");
string pathToShutdownFile = Path.Combine(ourDir, "d2mp.pid");
File.WriteAllText(pathToShutdownFile, "Delete this file to shutdown D2MP.");
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = ourDir;
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName;
watcher.Filter = "d2mp.pid";
watcher.Deleted += (sender, args) =>
{
shutDown = true;
};
watcher.EnableRaisingEvents = true;
shutDown = false;
int tryCount = 0;
while (tryCount < 30 && !shutDown)
{
using (ws = new WebSocket(server))
{
ws.OnMessage += (sender, e) =>
{
log.Debug("server: " + e.Data);
if (e.Data == "invalidid")
{
log.Debug("Invalid ID!");
shutDown = true;
return;
}
if (e.Data == "close")
{
log.Debug("Shutting down due to server request.");
shutDown = true;
return;
}
if (e.Data == "uninstall")
{
log.Debug("Uninstalling due to server request...");
Uninstall();
shutDown = true;
return;
}
var msgParts = e.Data.Split(':');
switch (msgParts[0])
{
case "installmod":
ThreadPool.QueueUserWorkItem(InstallMod, msgParts);
break;
case "deletemod":
ThreadPool.QueueUserWorkItem(DeleteMod, msgParts);
break;
case "setmod":
ThreadPool.QueueUserWorkItem(SetMod, msgParts);
break;
case "dconnect":
ThreadPool.QueueUserWorkItem(ConnectDota, msgParts);
break;
case "launchdota":
ThreadPool.QueueUserWorkItem(LaunchDota, msgParts);
break;
case "dspectate":
ThreadPool.QueueUserWorkItem(SpectateGame, msgParts);
break;
default:
log.Error("Command not recognized: " + msgParts[0]);
break;
}
};
ws.OnOpen += (sender, e) => log.Debug("Connected");
ws.OnClose += (sender, args) => log.Debug("Disconnected");
ws.Connect();
tryCount++;
if (!ws.IsAlive)
{
if (tryCount == 1)
{
icon.DisplayBubble("Disconnected, attempting to reconnect...");
}
log.Debug("Can't connect to server, tries: " + tryCount);
Thread.Sleep(500);
continue;
}
if (tryCount > 1)
{
icon.DisplayBubble("Reconnected!");
}
else
{
icon.DisplayBubble("Connected and ready to begin installing mods.");
}
try
{
var ver =
File.ReadAllText(
Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"version.txt"));
log.Debug("sending version: " + ver);
ws.Send("init:" + String.Join(",", steamids.ToArray(), 0, steamids.Count) + ":" + ver +
":" + String.Join(",", modNames));
}
catch (Exception ex)
{
log.Debug("Can't detect ID from version.txt, : " + ex);
return;
}
tryCount = 0;
while (ws.IsAlive && !shutDown)
{
Thread.Sleep(100);
}
}
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
log.Fatal("Overall error in the program: " + ex);
}
UnmodGameInfo();
Application.Exit();
}
public async Task Connect(string slackKey)
{
this.SlackKey = slackKey;
// disconnect in case we're already connected like a crazy person
Disconnect();
// kill the regex for our bot's name - we'll rebuild it upon request with some of the info we get here
BotNameRegex = string.Empty;
NoobWebClient client = new NoobWebClient();
string json = await client.DownloadString("https://slack.com/api/rtm.start", RequestMethod.Post, "token", this.SlackKey);
JObject jData = JObject.Parse(json);
TeamID = jData["team"]["id"].Value<string>();
TeamName = jData["team"]["name"].Value<string>();
UserID = jData["self"]["id"].Value<string>();
UserName = jData["self"]["name"].Value<string>();
string webSocketUrl = jData["url"].Value<string>();
UserNameCache.Clear();
foreach (JObject userObject in jData["users"]) {
UserNameCache.Add(userObject["id"].Value<string>(), userObject["name"].Value<string>());
}
// load the channels, groups, and DMs that margie's in
Dictionary<string, SlackChatHub> hubs = new Dictionary<string, SlackChatHub>();
ConnectedHubs = hubs;
// channelz
if (jData["channels"] != null) {
foreach (JObject channelData in jData["channels"]) {
if (!channelData["is_archived"].Value<bool>() && channelData["is_member"].Value<bool>()) {
SlackChatHub channel = new SlackChatHub() {
ID = channelData["id"].Value<string>(),
Name = "#" + channelData["name"].Value<string>(),
Type = SlackChatHubType.Channel
};
hubs.Add(channel.ID, channel);
}
}
}
// groupz
if (jData["groups"] != null) {
foreach (JObject groupData in jData["groups"]) {
if (!groupData["is_archived"].Value<bool>() && groupData["members"].Values<string>().Contains(UserID)) {
SlackChatHub group = new SlackChatHub() {
ID = groupData["id"].Value<string>(),
Name = groupData["name"].Value<string>(),
Type = SlackChatHubType.Group
};
hubs.Add(group.ID, group);
}
}
}
// dmz
if (jData["ims"] != null) {
foreach (JObject dmData in jData["ims"]) {
string userID = dmData["user"].Value<string>();
SlackChatHub dm = new SlackChatHub() {
ID = dmData["id"].Value<string>(),
Name = "@" + (UserNameCache.ContainsKey(userID) ? UserNameCache[userID] : userID),
Type = SlackChatHubType.DM
};
hubs.Add(dm.ID, dm);
}
}
// set up the websocket and connect
WebSocket = new WebSocket(webSocketUrl);
WebSocket.OnOpen += (object sender, EventArgs e) => {
// set connection-related properties
ConnectedSince = DateTime.Now;
};
WebSocket.OnMessage += async (object sender, MessageEventArgs args) => {
await ListenTo(args.Data);
};
WebSocket.OnClose += (object sender, CloseEventArgs e) => {
// set connection-related properties
ConnectedSince = null;
TeamID = null;
TeamName = null;
UserID = null;
UserName = null;
};
WebSocket.Connect();
}
public void Connect()
{
CurrentGatewayURL = GetGatewayUrl();
DebugLogger.Log("Gateway retrieved: " + CurrentGatewayURL);
ws = new WebSocket(CurrentGatewayURL);
ws.EnableRedirection = true;
ws.Log.File = "websocketlog.txt";
ws.OnMessage += (sender, e) =>
{
var message = JObject.Parse(e.Data);
switch(message["t"].ToString())
{
case ("READY"):
if(WriteLatestReady)
using (var sw = new StreamWriter("READY_LATEST.txt"))
sw.Write(message);
//Me = new DiscordMember(this)
//{
// user = new DiscordUser(this)
// {
// username = message["d"]["user"]["username"].ToString(),
// id = message["d"]["user"]["id"].ToString(),
// verified = message["d"]["user"]["verified"].ToObject<bool>(),
// avatar = message["d"]["user"]["avatar"].ToString(),
// discriminator = message["d"]["user"]["discriminator"].ToString(),
// email = message["d"]["user"]["email"].ToString()
// }
//};
Me = JsonConvert.DeserializeObject<DiscordMember>(message["d"]["user"].ToString());
ClientPrivateInformation.avatar = Me.Avatar;
ClientPrivateInformation.username = Me.Username;
HeartbeatInterval = int.Parse(message["d"]["heartbeat_interval"].ToString());
GetChannelsList(message);
if (Connected != null)
Connected(this, new DiscordConnectEventArgs { user = Me }); //Since I already know someone will ask for it.
break;
case ("GUILD_MEMBER_REMOVE"):
GuildMemberRemoveEvents(message);
break;
case ("GUILD_MEMBER_ADD"):
GuildMemberAddEvents(message);
break;
case ("GUILD_DELETE"):
GuildDeleteEvents(message);
break;
case ("GUILD_CREATE"):
GuildCreateEvents(message);
break;
case ("GUILD_MEMBER_UPDATE"):
GuildMemberUpdateEvents(message);
break;
case ("GUILD_UPDATE"):
GuildUpdateEvents(message);
break;
case ("GUILD_ROLE_DELETE"):
GuildRoleDeleteEvents(message);
break;
case ("GUILD_ROLE_UPDATE"):
GuildRoleUpdateEvents(message);
break;
case ("PRESENCE_UPDATE"):
PresenceUpdateEvents(message);
break;
case ("MESSAGE_UPDATE"):
MessageUpdateEvents(message);
break;
case ("TYPING_START"):
DiscordServer server = ServersList.Find(x => x.channels.Find(y => y.id == message["d"]["channel_id"].ToString()) != null);
if (server != null)
{
DiscordChannel channel = server.channels.Find(x => x.id == message["d"]["channel_id"].ToString());
DiscordMember uuser = server.members.Find(x => x.ID == message["d"]["user_id"].ToString());
if (UserTypingStart != null)
UserTypingStart(this, new DiscordTypingStartEventArgs { user = uuser, channel = channel, timestamp = int.Parse(message["d"]["timestamp"].ToString()) });
}
break;
case ("MESSAGE_CREATE"):
MessageCreateEvents(message);
break;
case ("CHANNEL_CREATE"):
ChannelCreateEvents(message);
break;
case ("VOICE_STATE_UPDATE"):
VoiceStateUpdateEvents(message);
break;
case ("VOICE_SERVER_UPDATE"):
VoiceServerUpdateEvents(message);
break;
case ("MESSAGE_DELETE"):
MessageDeletedEvents(message);
break;
case ("USER_UPDATE"):
UserUpdateEvents(message);
break;
case ("CHANNEL_UPDATE"):
ChannelUpdateEvents(message);
break;
case ("CHANNEL_DELETE"):
ChannelDeleteEvents(message);
break;
case("MESSAGE_ACK"): //ignore this message, it's irrelevant
break;
default:
if (UnknownMessageTypeReceived != null)
UnknownMessageTypeReceived(this, new UnknownMessageEventArgs { RawJson = message });
break;
}
};
ws.OnOpen += (sender, e) =>
{
DiscordInitObj initObj = new DiscordInitObj();
initObj.op = 2;
initObj.d.token = token;
string json = initObj.AsJson();
ws.Send(json);
if (SocketOpened != null)
SocketOpened(this, null);
KeepAliveTaskToken = KeepAliveTaskTokenSource.Token;
KeepAliveTask = new Task(() =>
{
while (true)
{
DebugLogger.Log("Hello from inside KeepAliveTask! Sending..");
KeepAlive();
Thread.Sleep(HeartbeatInterval);
if (KeepAliveTaskToken.IsCancellationRequested)
KeepAliveTaskToken.ThrowIfCancellationRequested();
}
}, KeepAliveTaskToken, TaskCreationOptions.LongRunning);
KeepAliveTask.Start();
DebugLogger.Log("Began keepalive task..");
};
ws.OnClose += (sender, e) =>
{
DiscordSocketClosedEventArgs scev = new DiscordSocketClosedEventArgs();
scev.Code = e.Code;
scev.Reason = e.Reason;
scev.WasClean = e.WasClean;
if (SocketClosed != null)
SocketClosed(this, scev);
};
ws.Connect();
DebugLogger.Log("Connecting..");
}
#pragma warning disable 1998
public async Task Initiate()
{
VoiceDebugLogger.LogMessageReceived += (sender, e) =>
{
if (DebugMessageReceived != null)
DebugMessageReceived(this, e);
};
VoiceWebSocket = new WebSocket("wss://" + VoiceEndpoint.Replace(":80", ""));
VoiceWebSocket.OnClose += (sender, e) =>
{
if (e.WasClean)
return; //for now, till events are hooked up
VoiceDebugLogger.Log($"VoiceWebSocket Closed: (Code: {e.Code}) {e.Reason}", MessageLevel.Critical);
Dispose();
};
VoiceWebSocket.OnError += (sender, e) =>
{
VoiceDebugLogger.Log($"VoiceWebSocket Error: {e.Message}", MessageLevel.Error);
Dispose();
};
VoiceWebSocket.OnMessage += async (sender, e) =>
{
VoiceDebugLogger.Log(e.Data);
JObject message = JObject.Parse(e.Data);
if (message["op"].Value<int>() == 2)
{
Params = new VoiceConnectionParameters();
Params.ssrc = message["d"]["ssrc"].Value<int>();
Params.port = message["d"]["port"].Value<int>();
JArray __modes = (JArray)message["d"]["modes"];
List<string> dynModes = new List<string>();
foreach (var mode in __modes)
{
dynModes.Add(mode.ToString());
}
Params.modes = dynModes.ToArray();
Params.heartbeat_interval = message["d"]["heartbeat_interval"].Value<int>();
await InitialConnection().ConfigureAwait(false);
}
else if (message["op"].Value<int>() == 4)
{
string speakingJson = JsonConvert.SerializeObject(new { op = 5, d = new { speaking = true, delay = 0 } });
VoiceDebugLogger.Log("Sending initial speaking json..(" + speakingJson + ")");
VoiceWebSocket.Send(speakingJson);
Connected = true;
keepAliveTask = new Thread(() =>
{
if (Connected)
{
while (true)
{
//cancelToken.ThrowIfCancellationRequested();
SendKeepAlive().ConfigureAwait(false);
Thread.Sleep(Params.heartbeat_interval);
}
}
});
udpKeepAliveTask = new Thread(() =>
{
while (true)
{
SendUDPKeepAlive().ConfigureAwait(false);
Thread.Sleep(5000); //5 seconds
}
});
udpReceiveTask = new Thread(async () =>
{
try
{
while (_udp.Available > 0)
{
//byte[] packet = new byte[1920];
VoiceDebugLogger.Log("Received packet!!!!!! Length: " + _udp.Available);
//UdpReceiveResult d = await _udp.ReceiveAsync();
//packet = d.Buffer;
//VoiceDebugLogger.Log("sending speaking..");
//DiscordAudioPacket echo = DiscordAudioPacket.EchoPacket(packet, Params.ssrc);
//await _udp.SendAsync(echo.AsRawPacket(), echo.AsRawPacket().Length).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Console.Beep(32767, 1000);
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
});
keepAliveTask.Start();
//udpKeepAliveTask.Start();
udpReceiveTask.Start();
}
else if (message["op"].Value<int>() == 5)
{
if(Connected) //if not connected, don't worry about it
{
DiscordVoiceUserSpeakingEventArgs __args = new DiscordVoiceUserSpeakingEventArgs { Guild = _parent.GetServersList().Find(x=>x.id == this.Guild.id)};
__args.UserSpeaking = __args.Guild.members.Find(x => x.ID == message["d"]["user_id"].ToString());
__args.Speaking = message["d"]["speaking"].Value<bool>();
if (UserSpeaking != null)
UserSpeaking(this, __args);
}
}
};
VoiceWebSocket.OnOpen += (sender, e) =>
{
VoiceDebugLogger.Log("VoiceWebSocket opened, sending initial json.");
string initMsg = JsonConvert.SerializeObject(new
{
op = 0,
d = new
{
user_id = Me.ID,
server_id = Guild.id,
session_id = SessionID,
token = Token
}
});
VoiceWebSocket.Send(initMsg);
};
VoiceWebSocket.Connect();
}
public static void Main(string[] args)
{
ThreadState ts = new ThreadState();
WaitCallback notifyMsg = state =>
{
while (ts.Enabled)
{
Thread.Sleep(500);
if (_msgQ.Count > 0)
{
NfMessage msg = (NfMessage)_msgQ.Dequeue();
#if NOTIFY
Notification nf = new Notification(msg.Summary,
msg.Body,
msg.Icon);
nf.AddHint("append", "allowed");
nf.Show();
#else
Console.WriteLine("{0}: {1}", msg.Summary, msg.Body);
#endif
}
}
ts.Notification.Set();
};
ThreadPool.QueueUserWorkItem(notifyMsg);
//using (WebSocket ws = new WebSocket("ws://echo.websocket.org", "echo"))
//using (WebSocket ws = new WebSocket("wss://echo.websocket.org", "echo"))
using (WebSocket ws = new WebSocket("ws://localhost:4649"))
{
ws.OnOpen += (sender, e) =>
{
ws.Send("Hi, all!");
};
ws.OnMessage += (sender, e) =>
{
if (!String.IsNullOrEmpty(e.Data))
{
enNfMessage("[WebSocket] Message", e.Data, "notification-message-im");
}
};
ws.OnError += (sender, e) =>
{
enNfMessage("[WebSocket] Error", e.Message, "notification-message-im");
};
ws.OnClose += (sender, e) =>
{
enNfMessage(
String.Format("[WebSocket] Close({0}:{1})", (ushort)e.Code, e.Code),
e.Reason,
"notification-message-im");
};
ws.Connect();
Thread.Sleep(500);
Console.WriteLine("\nType \"exit\" to exit.\n");
string data;
while (true)
{
Thread.Sleep(500);
Console.Write("> ");
data = Console.ReadLine();
if (data == "exit")
//if (data == "exit" || !ws.IsConnected)
{
break;
}
ws.Send(data);
}
}
ts.Enabled = false;
ts.Notification.WaitOne();
}