public void RunScript(string feedtoken, string clientcode, string script, string task)
{
string strwatchlistscrips = "";
if (feedtoken != "" && clientcode != "")
{
if (_ws.IsStarted)
{
try
{
if (task != null && task != "")
{
if (task == "mw" || task == "sfi" || task == "dp")
{
strwatchlistscrips = script; //"nse_cm|2885&nse_cm|1594&nse_cm|11536";
string scriptReq = "{\"task\":\"mw\",\"channel\":\"" + strwatchlistscrips + "\",\"token\":\"" + feedtoken + "\",\"user\": \"" + clientcode + "\",\"acctid\":\"" + clientcode + "\"}";
_ws.Send(scriptReq);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
}
}
public async Task <ConnectionCode> CreateGame(Player player, ImmutableArray <Ship> ships)
{
var completionSource = new TaskCompletionSource <ConnectionCode>();
IDisposable subscription = null;
subscription = _socket.MessageReceived.Subscribe(msg => {
var connectionResult = _serializer.DeserializeDynamic(msg.Text);
switch ((string)connectionResult["message_type"])
{
case "connection_code":
var connectionCode = _serializer.DeserializeObject <ConnectionCode>(connectionResult);
completionSource.SetResult(connectionCode);
break;
case "game_connected":
var result = _serializer.DeserializeObject <ConnectionToGameResult>(connectionResult);
subscription.Dispose();
_reconnectSubscription.Dispose();
GameCreated?.Invoke(this, new(_socket, result.Go, result.Enemy));
break;
default:
throw new("Unexpected message type");
}
});
await Connect();
var message = new CreateGameMessage(new(player, ships, null));
var text = _serializer.Serialize(message);
_socket.Send(text);
return(await completionSource.Task);
}
static void Main(string[] args)
{
ManualResetEvent ExitEvent = new ManualResetEvent(false);
Console.WriteLine("Hello World!");
// basic object parser
var testOject = new {
worker = "me"
};
var testString = Parser.ToMessage(MessageType.INFO, testOject);
Console.WriteLine(testString);
// Exception parser
var testExceptString = Parser.ToMessage(MessageType.INFO, new Exception("A Exception Occur"));
// try the real one
// try {
// var testCli = new WSConnecter("ws://127.0.0.1:9002");
// testCli.Info("test message in string");
// testCli.Info(new { message = "test message in string" });
// testCli.Error(new Exception("A Exception Occur"));
// testCli.Disconect();
// } catch (Exception e) {
// Console.WriteLine(e);
// }
var url = "ws://127.0.0.1:9002";
try {
using (var ws_client = new WebsocketClient(new Uri(url))) {
ws_client.ReconnectTimeout = TimeSpan.FromSeconds(30);
ws_client.Start().Wait();
Task.Run(() => {
ws_client.Send(
Parser.ToMessage(MessageType.INFO, "incomes single msg")
);
ExitEvent.WaitOne();
});
Task.Run(() => {
ws_client.Send(
Parser.ToMessage(MessageType.INFO, testString)
);
ExitEvent.WaitOne();
});
Task.Run(() => {
ws_client.Send(
Parser.ToMessage(MessageType.INFO, testExceptString)
);
ExitEvent.WaitOne();
});
ExitEvent.WaitOne();
ws_client.Dispose();
}
ExitEvent.Dispose();
} catch (Exception excep) {
Console.WriteLine(excep);
}
}
private async Task CheckConfig()
{
string token = TokenTextBox.Text;
var output = false;
var received = 0;
Exception exception = null;
try
{
CheckButton.IsEnabled = false;
SaveButton.IsEnabled = false;
WebsocketClient client = new WebsocketClient(new Uri(GetUrl()));
var authMessage = $"{{\"type\": \"auth\",\"access_token\": \"{token}\"}}";
client.Start();
client.MessageReceived.Subscribe(msg =>
{
var type = (string)JObject.Parse(msg.Text)["type"];
if (type == "auth_required")
{
client.Send(authMessage);
return;
}
output = type == "auth_ok";
received = -10;
client.Stop(WebSocketCloseStatus.NormalClosure, "");
client.Dispose();
});
client.Send(authMessage);
while (received < 10 && received >= 0)
{
received++;
await Task.Delay(50);
}
}
catch (Exception e)
{
exception = e;
}
if (exception != null)
{
ConsoleWriter.WriteLine($"Error while connecting: {exception.Message}", ConsoleColor.Red);
}
else if (!output && received == 10)
{
ConsoleWriter.WriteLine("Unable to connect", ConsoleColor.Red);
}
else
{
ConsoleWriter.WriteLine("Invalid credentials", ConsoleColor.Red);
}
SaveButton.IsEnabled = output;
UrlTextBox.Background = output ? _normalColor : InvalidColor;
TokenTextBox.Background = output ? _normalColor : InvalidColor;
CheckButton.IsEnabled = true;
}
static void Main(string[] args)
{
const int BUFFER_SIZE = 16000;
string baseUrl = "wss://api.amerandish.com/v1";
string actionUrl = "/speech/asrlive";
string authKey = "<YOUR_API_KEY>";
string filePath = @"<YOUR_WAV_FILE_PATH>";
string url = baseUrl + actionUrl + "?jwt=" + authKey;
var bytes = File.ReadAllBytes(filePath);
var base64 = Convert.ToBase64String(bytes);
var exitEvent = new ManualResetEvent(false);
var factory = new Func <ClientWebSocket>(() =>
{
var client = new ClientWebSocket
{
Options =
{
KeepAliveInterval = TimeSpan.FromSeconds(5),
}
};
return(client);
});
using (var client = new WebsocketClient(new Uri(url), factory)){
client.ReconnectTimeout = TimeSpan.FromSeconds(30);
client.MessageReceived.Subscribe(msg => {
try
{
var model = ResponseModel.FromJson(msg.ToString());
Console.WriteLine(model.ToJson());
}
catch (System.Exception e)
{
Console.WriteLine(e);
}
});
client.Start().Wait();
for (int index = 0; index < base64.Length; index += BUFFER_SIZE)
{
if (index + BUFFER_SIZE < base64.Length)
{
Console.WriteLine(string.Format("send {0} -> {1}", index, index + BUFFER_SIZE));
client.Send(Encoding.UTF8.GetBytes(base64.Substring(index, BUFFER_SIZE)));
}
else
{
Console.WriteLine(string.Format("send {0} -> {1}", index, base64.Length));
client.Send(Encoding.UTF8.GetBytes(base64.Substring(index)));
}
}
exitEvent.WaitOne();
}
}
public void ScanDevices()
{
_ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "GET",
path = "/devices/list"
}));
}
internal Task SendFetchAsync(IDocumentInternal doc)
{
var msg = new JObject(
new JProperty("a", "f"),
new JProperty("c", doc.Collection),
new JProperty("d", doc.Id),
new JProperty("v", doc.Version < 0 ? null : (int?)doc.Version));
return(_socket.Send(msg.ToString()));
}
private async Task InitialiseWS()
{
var url = new Uri("ws://localhost:9010");
var factory = new Func <ClientWebSocket>(() =>
{
var client = new ClientWebSocket();
client.Options.UseDefaultCredentials = false;
client.Options.SetRequestHeader("Origin", "file://");
client.Options.SetRequestHeader("Pragma", "no-cache");
client.Options.SetRequestHeader("Cache-Control", "no-cache");
client.Options.SetRequestHeader("Sec-WebSocket-Extensions", "permessage-deflate; client_max_window_bits");
client.Options.SetRequestHeader("Sec-WebSocket-Protocol", "json");
client.Options.AddSubProtocol("json");
return(client);
});
_ws?.Dispose();
_ws = new WebsocketClient(url, factory);
_ws.MessageReceived.Subscribe(ParseSocketMsg);
_ws.ErrorReconnectTimeout = TimeSpan.FromMilliseconds(500);
_ws.ReconnectTimeout = null;
Debug.WriteLine($"Trying to connect to LGHUB_agent, at {url}");
try
{
await _ws.StartOrFail();
}
catch (Websocket.Client.Exceptions.WebsocketException)
{
Debug.WriteLine("Failed to connect to LGHUB_agent");
_ws?.Dispose();
_ws = null;
return;
}
Debug.WriteLine($"Connected to LGHUB_agent");
_ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "SUBSCRIBE",
path = "/devices/state/changed"
}));
_ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "SUBSCRIBE",
path = "/battery/state/changed"
}));
}
private void DiscordBotLogin()
{
try
{
if (discordWebSocket.IsRunning)
{
discordWebSocket.Send("login|" + AppSettingsSerializer.Instance.AppSettings.DiscordBotToken);
}
}
catch (Exception e)
{
ErrorLogger.Append(e);
}
}
public static void Check(int port, Action <OverlayResponse> callback)
{
OverlayResponse response = new OverlayResponse(port);
WebsocketClient overlay = new WebsocketClient(new Uri($"ws://127.0.0.1:{port}/?v=1&encoding=json"), () =>
{
ClientWebSocket ws = new ClientWebSocket();
ws.Options.SetRequestHeader("Origin", "https://discordapp.com");
return(ws);
})
{
IsReconnectionEnabled = false
};
overlay.DisconnectionHappened.Subscribe(disconnect =>
{
if (disconnect.Exception != null)
{
response.Success = false;
callback(response);
}
});
overlay.MessageReceived.Subscribe(message =>
{
JsonElement msg = JsonDocument.Parse(message.Text).RootElement;
if (msg.GetProperty("cmd").GetString() == "DISPATCH" && msg.GetProperty("evt").GetString() == "READY")
{
response.ReleaseChannel = OverlayResponse.ReleaseChannels[msg.GetProperty("data").GetProperty("config").GetProperty("api_endpoint").GetString()];
overlay.Send("{\"cmd\":\"SUBSCRIBE\",\"args\":{},\"evt\":\"OVERLAY\",\"nonce\":\"discord-fix-your-software\"}");
}
else if (msg.GetProperty("cmd").GetString() == "SUBSCRIBE" && msg.GetProperty("data").GetProperty("evt").GetString() == "OVERLAY")
{
overlay.Send("{\"cmd\":\"OVERLAY\",\"args\":{\"type\":\"CONNECT\",\"pid\":-1},\"nonce\":\"pid-validation-and-blocking-overlay-connections-if-overlay-is-disabled\"}");
}
else if (msg.GetProperty("cmd").GetString() == "DISPATCH" && msg.GetProperty("data").GetProperty("type").GetString() == "STORAGE_SYNC")
{
// there's a few small bits of interesting information here but nothing worth a lot
response.StorageStates = msg.GetProperty("data").GetProperty("states");
}
else if (msg.GetProperty("cmd").GetString() == "DISPATCH" && msg.GetProperty("data").GetProperty("type").GetString() == "DISPATCH" && msg.GetProperty("data").GetProperty("payloads")[0].GetProperty("type").GetString() == "OVERLAY_INITIALIZE")
{
// quality software
response.Success = true;
response.InitializePayload = msg.GetProperty("data").GetProperty("payloads")[0];
overlay.Stop(WebSocketCloseStatus.EndpointUnavailable, "");
callback(response);
}
});
overlay.Start();
}
public void Connect()
{
if (!config.UseIntroducer)
{
Log.Debug($"Introducer peer discovery service will not be used.");
return;
}
client.Name = "Introducer";
client.ReconnectTimeoutMs = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
client.ErrorReconnectTimeoutMs = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
client.ReconnectionHappened.Subscribe(async type =>
{
Log.Information($"Reconnection happened, type: {type}, url: {client.Url}");
Log.Debug($"[Introducer] Connected: {type} {client.Url}");
var command = $"update-role|interpreter|{GetLanIpAddress().MapToIPv4().ToString()}";
Log.Debug($"[Introducer] Sending message: {command}");
await client.Send(command);
});
client.DisconnectionHappened.Subscribe(type => {
Log.Debug($"[Introducer] Disconnected, type {type}.");
});
client.MessageReceived.Subscribe(msg =>
{
Log.Debug($"[Introducer] Message received: {msg}");
});
client.Start().Wait();
}
static void Ping(dynamic Message, WebsocketClient Client)
{
Console.WriteLine("Got a ping");
Ping ping = new Ping();
Client.Send(JsonConvert.SerializeObject(ping));
}
static void OnCommand(dynamic Message, WebsocketClient Client)
{
Console.WriteLine("Got a command");
string data = Message.data;
List <string> argus = Library.stringParse(data);
Console.WriteLine(argus);
if (argus.Count == 3)
{
if (argus[2] == "uri")
{
argus[1] = Library.PathToURI(argus[1]);
}
}
string message = null;
try
{
Process.Start(argus[0], argus[1]);
message = "The Command Was Successful";
}catch (Exception err)
{
message = $"The Command UnSuccessful \n {err}";
}
Message msg = new Message {
message = message, from = "shell"
};
Client.Send(JsonConvert.SerializeObject(msg));
}
public void ConnectforStockQuote(string feedtoken, string clientcode)
{
try
{
//ServicePointManager.SecurityProtocol = (SecurityProtocolType)48 | (SecurityProtocolType)192 | (SecurityProtocolType)768 | (SecurityProtocolType)3072;
if (feedtoken != "" && clientcode != "")
{
string ConnectionMsg = "{\"task\":\"cn\",\"channel\":\"\",\"token\":\"" + feedtoken + "\",\"user\": \"" + clientcode + "\",\"acctid\":\"" + clientcode + "\"}";
var url = new Uri(_url2);
_ws = new WebsocketClient(url);
_ws.MessageReceived.Subscribe(msg => Receive2(msg.Text));
_ws.Start();
_ws.Send(ConnectionMsg);
int i = 0;
do
{
HeartBeat(feedtoken, clientcode);
Thread.Sleep(60);
i++;
} while (i < 10);
}
}
catch (Exception ex)
{
throw ex;
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var exitEvent = new ManualResetEvent(false);
var url = new Uri("wss://echo.websocket.org");
var loop = 1;
using (var client = new WebsocketClient(url))
{
client.ReconnectTimeoutMs = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
client.ReconnectionHappened.Subscribe(type => Console.WriteLine($"Reconnection happened, type: {type}"));
client.MessageReceived.Subscribe(async msg =>
{
Console.WriteLine($"Message received: {msg}");
await SendMessage(client, loop);
loop++;
});
await client.Start();
await Task.Run(() => client.Send($"sawasdee first time"));
exitEvent.WaitOne();
}
}
public async Task SendBinaryMessage_ShouldWork()
{
using (IWebsocketClient client = new WebsocketClient(WebsocketUrl))
{
string received = null;
var receivedEvent = new ManualResetEvent(false);
client.MessageReceived.Subscribe(msg =>
{
var msgText = msg.Text ?? string.Empty;
if (msgText.Contains("Unrecognized request"))
{
received = msgText;
receivedEvent.Set();
}
});
await client.Start();
client.Send(new byte[] { 10, 14, 15, 16 });
receivedEvent.WaitOne(TimeSpan.FromSeconds(30));
Assert.NotNull(received);
}
}
public void SendMessage(Sensor sensor)
{
LoriotDTO msg = new LoriotDTO();
msg.cmd = "tx";
msg.EUI = sensor.sensorEUID;
msg.data = sensor.servoSetting;
msg.port = 3;
msg.confirmed = false;
clientWS.Send(JsonConvert.SerializeObject(msg));
Console.WriteLine("Message sent");
var log = new SensorLog();
sensor = _context.Sensor.AsQueryable().First(s => s.sensorEUID == sensor.sensorEUID);
log.servoSetting = sensor.servoSetting;
log.timestamp = DateTime.Now;
log.sensorID = sensor.sensorID;
slc.PostSensorLog(log).Wait();
_context.SaveChanges();
}
public async void ConnectToGHUB_async()
{
var url = new Uri("ws://localhost:9010");
var factory = new Func<ClientWebSocket>(() =>
{
var client = new ClientWebSocket();
client.Options.UseDefaultCredentials = false;
client.Options.SetRequestHeader("Origin", "file://");
client.Options.SetRequestHeader("Pragma", "no-cache");
client.Options.SetRequestHeader("Cache-Control", "no-cache");
client.Options.SetRequestHeader("Sec-WebSocket-Extensions", "permessage-deflate; client_max_window_bits");
client.Options.SetRequestHeader("Sec-WebSocket-Protocol", "json");
return client;
});
_ws?.Dispose();
_ws = new WebsocketClient(url, factory);
_ws.MessageReceived.Subscribe(ParseSocketMsg);
_ws.ErrorReconnectTimeout = TimeSpan.FromMilliseconds(500);
_ws.ReconnectTimeout = null;
Console.WriteLine($"Trying to connect to LGHUB_agent, at {url}");
while (!_ws.IsRunning)
{
await _ws.Start();
}
Console.WriteLine($"Connected to LGHUB_agent");
_ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "SUBSCRIBE",
path = "/devices/state/changed"
}));
_ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "SUBSCRIBE",
path = "/battery/state/changed"
}));
ScanDevices();
}
static void Main(string[] args)
{
var url = new Uri("ws://localhost:9010");
Directory.CreateDirectory(OUTPUT_FOLDER);
var factory = new Func <ClientWebSocket>(() =>
{
var client = new ClientWebSocket();
client.Options.UseDefaultCredentials = false;
client.Options.SetRequestHeader("Origin", "file://");
client.Options.SetRequestHeader("Pragma", "no-cache");
client.Options.SetRequestHeader("Cache-Control", "no-cache");
client.Options.SetRequestHeader("Sec-WebSocket-Extensions", "permessage-deflate; client_max_window_bits");
client.Options.SetRequestHeader("Sec-WebSocket-Protocol", "json");
return(client);
});
using (var ws = new WebsocketClient(url, factory))
{
ws.MessageReceived.Subscribe(msg => MessageParse(ws, msg));
Console.WriteLine($"Trying to connect to LGHUB_agent, at {url}");
try
{
ws.StartOrFail().Wait();
}
catch (Exception)
{
Console.WriteLine("Failed to connect to LGHUB_agent, is Logitech G HUB running?");
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
return;
}
Console.WriteLine("LGHUB_agent connected.");
Console.WriteLine("");
ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "GET",
path = "/updates/info"
}));
startTime = DateTime.Now;
while ((DateTime.Now - startTime).Milliseconds < 500)
{
Thread.Sleep(100);
}
Console.WriteLine("");
Console.WriteLine("Found all .xml files");
Console.WriteLine("Press any key to quit.");
Console.ReadKey();
}
}
static void OnBulkRequest(dynamic Message, WebsocketClient Client)
{
string time = Message.time;
ClientBulk bulk = new ClientBulk {
time = time
};
Client.Send(JsonConvert.SerializeObject(bulk));
}
private void SendWsMessage(string cmd, JsonMessageData data)
{
var msg = new JsonMessage {
command = cmd, data = data
};
var msgStr = JsonUtility.ToJson(msg);
ws.Send(msgStr);
}
/// <summary>
/// Start streaming
/// </summary>
/// <returns></returns>
public override async Task Subscribe()
{
await Unsubscribe();
// Orders
var orderSubscription = OrderSenderStream.Subscribe(message =>
{
switch (message.Action)
{
case ActionEnum.Create: CreateOrders(message.Next); break;
case ActionEnum.Update: UpdateOrders(message.Next); break;
case ActionEnum.Delete: DeleteOrders(message.Next); break;
}
});
_subscriptions.Add(orderSubscription);
// Streaming
var client = new WebsocketClient(new Uri(StreamSource + "/markets/events"), _streamOptions)
{
Name = Account.Name,
ReconnectTimeout = TimeSpan.FromSeconds(30),
ErrorReconnectTimeout = TimeSpan.FromSeconds(30)
};
var connectionSubscription = client.ReconnectionHappened.Subscribe(message => { });
var disconnectionSubscription = client.DisconnectionHappened.Subscribe(message => { });
var messageSubscription = client.MessageReceived.Subscribe(message =>
{
dynamic input = JObject.Parse(message.Text);
var inputStream = $"{ input.type }";
switch (inputStream)
{
case "quote": break;
}
});
_subscriptions.Add(messageSubscription);
_subscriptions.Add(connectionSubscription);
_subscriptions.Add(disconnectionSubscription);
await client.Start();
var query = new
{
linebreak = true,
symbols = Account.Instruments.Values.Select(o => o.Name)
};
client.Send(ConversionManager.Serialize(query));
}
private static async Task StartSendingPing(WebsocketClient client)
{
while (true)
{
await Task.Delay(1000);
await client.Send("ping");
}
}
/// <summary>
/// Send message to exchange.
/// </summary>
/// <param name="message">Byte message in proto format. <see cref="DigitexWire.Message"/></param>
/// <returns></returns>
public bool Send(byte[] message)
{
if (OrderSocket == null || !OrderSocket.IsRunning)
{
return(false);
}
OrderSocket.Send(message);
return(true);
}
void SendPayload(Opcode op, JsonObject data)
{
using (MemoryStream ms = new MemoryStream()) {
JSON.WriteNodeToStream(new JsonObject {
["op"] = new JsonValue(op),
["d"] = data
}, ms);
socket.Send(ms.ToArray());
}
}
protected override void WndProc(ref Message m)
{
base.WndProc(ref m);
Console.WriteLine(m);
if (m.Msg == 0x31d && wsclient != null && Properties.Settings.Default.autoset == CheckState.Checked)
{
var req = new CloudTextPackage(0, null, null, "Set", Clipboard.GetText());
wsclient.Send(JsonConvert.SerializeObject(req));
}
}
public async Task Send(IWsMessage message, CancellationToken cancellationToken = default)
{
await EnsureSocketConnection();
await Task.Run(() => _client.Send(JSerializer.Serialize(message)), cancellationToken);
if (_configuration.ReconnectEnabled && _configuration.ResubscribeOnReconnect)
{
_subscriptions.Push(message);
}
}
private Task Send(string message)
{
if (_options.debugMode)
{
Console.WriteLine(
$"***WebSocket outgoing message ({DateTime.Now.ToString(CultureInfo.CurrentCulture)}): ***" +
$"\n{JsonConvert.SerializeObject(JsonConvert.DeserializeObject(message), Formatting.Indented)}" +
"\n******");
}
return(Task.Run(() => _ws.Send(message)));
}
public override async Task LoadDevicesAsync()
{
if (_ws == null)
{
// Check if LGHUB_agent is back
await InitialiseWS();
}
if (_ws == null)
{
// LGHUB_agent is not back
return;
}
_ws.Send(JsonConvert.SerializeObject(new
{
msgId = "",
verb = "GET",
path = "/devices/list"
}));
}
private async void connectWs()
{
Console.WriteLine(Properties.Settings.Default.wsuri);
var ws = new WebsocketClient(new Uri(Properties.Settings.Default.wsuri));
_ = Task.Run(async() =>
{
await Task.Delay(1000);
if (!ws.IsRunning)
{
new ConfigForm("无法连接到websocket").ShowDialog();
}
});
ws.MessageReceived.Subscribe(action => {
var message = action.Text;
Console.WriteLine(message);
var response = JsonConvert.DeserializeObject <CloudTextPackage>(message);
switch (response.action)
{
case "Auth":
if (response.data != "success")
{
new ConfigForm("账号登录失败").ShowDialog();
}
else
{
this.wsclient = ws;
}
break;
case "Set":
var t = new Thread(() => {
try
{
if (Clipboard.GetText() != response.data && Properties.Settings.Default.autoget == CheckState.Checked)
{
Clipboard.SetText(response.data);
}
}
catch (Exception e) { }
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
break;
}
});
var req = new CloudTextPackage(0, Properties.Settings.Default.username, Properties.Settings.Default.password, "Auth", null);
await ws.Start();
await ws.Send(JsonConvert.SerializeObject(req));
}