public static async Task Main(string[] args)
{
_timer = new Timer(OnTickAsync, null, 2000, 1);
RESTART:
var socketOptions = new PureWebSocketOptions()
{
DebugMode = true,
SendDelay = 100,
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(3000, 6000)
};
_ws = new PureWebSocket("wss://demos.kaazing.com/echo", socketOptions);
_ws.OnStateChanged += Ws_OnStateChanged;
_ws.OnMessage += Ws_OnMessage;
_ws.OnClosed += Ws_OnClosed;
_ws.OnSendFailed += Ws_OnSendFailed;
try
{
await _ws.ConnectAsync();
}
catch (Exception e) {
_ws.Dispose();
goto RESTART;
}
Console.ReadLine();
_ws.Dispose(true);
goto RESTART;
}
public async void Start()
{
var socketOptions = new PureWebSocketOptions()
{
DebugMode = false,
SendDelay = 100,
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20)
};
ws = new PureWebSocket("ws://" + _url + "/websocket", socketOptions);
ws.OnStateChanged += Ws_OnStateChanged;
ws.OnMessage += Ws_OnMessage;
ws.OnClosed += Ws_OnClosed;
ws.OnSendFailed += Ws_OnSendFailed;
await ws.ConnectAsync();
Console.WriteLine("SENDING WEBSOCKET MESSAGE");
string[] s = new string[1];
s[0] = "1";
WebSocket.ConnectMsg c = new WebSocket.ConnectMsg()
{
msg = "connect",
version = "1",
support = s
};
await ws.SendAsync(JsonConvert.SerializeObject(c));
Console.ReadLine();
ws.Dispose(true);
await ws.ConnectAsync();
}
public static async Task Main(string[] args)
{
// this is just a timer to send data for us (simulate activity)
_timer = new Timer(OnTickAsync, null, 4000, 1);
RESTART:
var socketOptions = new PureWebSocketOptions
{
DebugMode = false, // set this to true to see a ton O' logging
SendDelay = 100, // the delay in ms between sending messages
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20) // automatic reconnect if connection is lost
};
_ws = new PureWebSocket("wss://demos.kaazing.com/echo", socketOptions, "MyOptionalInstanceName1");
_ws.OnStateChanged += Ws_OnStateChanged;
_ws.OnMessage += Ws_OnMessage;
_ws.OnClosed += Ws_OnClosed;
_ws.OnSendFailed += Ws_OnSendFailed;
await _ws.ConnectAsync();
Console.ReadLine();
_ws.Dispose(true);
goto RESTART;
}
public static void Main(string[] args)
{
_timer = new Timer(OnTick, null, 2000, 1);
RESTART:
var socketOptions = new PureWebSocketOptions()
{
DebugMode = true,
SendDelay = 100,
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20)
};
_ws = new PureWebSocket("wss://echo.websocket.org", socketOptions);
_ws.OnStateChanged += Ws_OnStateChanged;
_ws.OnMessage += Ws_OnMessage;
_ws.OnClosed += Ws_OnClosed;
_ws.OnSendFailed += Ws_OnSendFailed;
_ws.Connect();
Console.ReadLine();
_ws.Dispose(true);
goto RESTART;
}
public HubitatClient(HubitatOptions options, ILogger logger)
{
_options = options;
_logger = logger;
var socketOptions = new PureWebSocketOptions()
{
DebugMode = true,
SendDelay = 100,
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(options.MinReconnectInterval, options.MaxReconnectInterval, options.MaxReconnectAttempts)
};
_webSocket = new PureWebSocket(_options.WebSocketURL, socketOptions);
_webSocket.OnOpened += (sender) => SocketOpen();
_webSocket.OnStateChanged += (sender, newState, previousState) => SocketStateChanged(newState, previousState);
_webSocket.OnMessage += (sender, message) => MessageReceived(message);
_webSocket.OnClosed += (sender, reason) => SocketClosed(reason);
_webSocket.OnSendFailed += (sender, data, ex) => SocketSendFailed(data, ex);
_webSocket.OnError += (sender, e) => SocketError(e);
_collector = Metrics.Collector = new CollectorConfiguration()
.Batch.AtInterval(TimeSpan.FromSeconds(options.BatchInterval))
.WriteTo.InfluxDB(options.InfluxDbURL, options.InfluxDbDatabase, options.InfluxDbUsername, options.InfluxDbPassword)
.CreateCollector();
CollectorLog.RegisterErrorHandler((string message, Exception ex) =>
{
_logger.Error(ex, "Failed to write metrics to InfluxDB: {Message}", message);
});
}
public void Connect()
{
if (IsConnected())
{
return;
}
Disconnect(() =>
{
var opts = new PureWebSocketOptions
{
MyReconnectStrategy = new ReconnectStrategy(1000, 30000)
};
_conn = new PureWebSocket(_endPoint, opts);
_conn.OnOpened += OnConnOpen;
_conn.OnError += OnConnError;
_conn.OnMessage += OnConnMessage;
_conn.OnClosed += OnConnClose;
try
{
_conn.Connect();
_reconnectTimer.Stop();
}
catch (Exception ex)
{
_reconnectTimer.Start();
}
});
}
public SocketV2Client(SocketOptions opt)
{
options = opt;
_options = new PureWebSocketOptions
{
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20)
};
Init();
}
internal async Task <JsonZKill.Killmail> GetSocketResponce()
{
try
{
if (_webSocket == null || _webSocket.State != WebSocketState.Open)
{
if (_webSocket?.State == WebSocketState.Connecting)
{
return(null);
}
var o = new PureWebSocketOptions();
_webSocket?.Dispose();
_webSocket = new PureWebSocket(SettingsManager.Settings.Config.ZKillboardWebSocketUrl, o);
_webSocket.OnMessage += _webSocket_OnMessage;
_webSocket.OnError += async exception => { await LogHelper.LogEx("_webSocket.OnError", exception, LogCat.ZKill); };
if (!_webSocket.Connect())
{
_webSocket?.Dispose();
_webSocket = null;
return(null);
}
else
{
if (!_webSocket.Send("{\"action\":\"sub\",\"channel\":\"killstream\"}"))
{
_webSocket?.Dispose();
_webSocket = null;
return(null);
}
await LogHelper.LogInfo("ZKB feed core WebSocket connect successful!", LogCat.ZKill);
}
}
if (!_webMailsQueue.IsEmpty && _webMailsQueue.TryDequeue(out var km))
{
return(km);
}
}
catch (Exception ex)
{
await LogHelper.LogEx("GetSocketResponce", ex, LogCat.ZKill);
_webSocket?.Dispose();
_webSocket = null;
}
return(null);
}
public LoxoneMiniserverConnection(string address, int port, string username, string password)
{
_keepAliveTimer = new Timer(TimeSpan.FromMinutes(4).TotalMilliseconds);
Address = address;
Port = port;
Username = username;
this.password = password;
webApi = new LoxoneWebApi($"http://{address}:{port}", username, password);
var socketOptions = new PureWebSocketOptions()
{
DebugMode = false
};
_webSocket = new PureWebSocket($"ws://{address}:{port}/ws/rfc6455", socketOptions);
_keepAliveTimer.Elapsed += _keepAliveTimer_Elapsed;
}
/// <summary>
/// Constructor used by the DI
/// </summary>
/// <param name="storeEvents">The service used to store the data</param>
/// <param name="optionsWebScoket">The IOptions that contains the web socket configurations</param>
/// <param name="logger">The injected logger</param>
public WebSocketService(IStoreData storeEvents, IOptions <WebSocketConfiguration> optionsWebScoket, ILogger <WebSocketService> logger)
{
this.logger = logger;
webSocketConfiguration = optionsWebScoket.Value;
//with these options the socket will never go over the 60 seconds timeout
socketOptions = new PureWebSocketOptions()
{
DebugMode = webSocketConfiguration.DebugMode,
SendDelay = webSocketConfiguration.SendDelay,
MyReconnectStrategy = new ReconnectStrategy(
webSocketConfiguration.MinReconnectInterval,
webSocketConfiguration.MaxReconnectInterval,
null
)
};
this.storeEvents = storeEvents;
}
protected override async Task GetExchangeDataAsync(CancellationToken ct)
{
var options = new PureWebSocketOptions
{
DebugMode = false
};
using (var ws = new PureWebSocket(TickerUrl, options))
{
var closed = false;
ws.OnMessage += WsOnMessage;
ws.OnClosed += reason =>
{
Logger.Info($"Binance closed: {reason}");
closed = true;
};
ws.OnError += exception =>
{
Logger.Error(exception);
closed = true;
};
if (!ws.Connect( ))
{
Logger.Error("Couldn't connect to Binance");
}
while (ws.State != WebSocketState.Closed)
{
if (UpTime > LastUpdateDuration &&
LastUpdateDuration > TimeSpan.FromHours(1) ||
closed)
{
ws.Disconnect( );
break;
}
await Task.Delay(PollingRate, ct).ConfigureAwait(false);
}
}
}
public JadiscoApi()
{
try
{
PureWebSocketOptions socketOptions = new PureWebSocketOptions()
{
DebugMode = false,
MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20)
};
webSocket = new PureWebSocket(WebSocketUrl, socketOptions);
webSocket.OnMessage += WebSocket_OnMessage;
webSocket.OnOpened += WebSocket_OnOpened;
webSocket.OnClosed += WebSocket_OnClosed;
webSocket.OnError += WebSocket_OnError;
}
catch (Exception ex)
{
Debug.WriteLine($"[WS] Error: {ex.Message}");
}
}
protected override void DoOpen()
{
Logger.Log("DoOpen uri =" + Uri());
var myheaders = new List <Tuple <string, string> >();
myheaders.AddRange(_myExtraHeaders);
myheaders.Add(new Tuple <string, string>("Cookie", _cookies));
var options = new PureWebSocketOptions
{
Headers = myheaders
};
Ws = new PureWebSocket(Uri(), options);
Ws.OnOpened += Ws_OnOpened;
Ws.OnClosed += Ws_OnClosed;
Ws.OnData += Ws_OnData;
Ws.OnMessage += Ws_OnMessage;
Ws.OnError += Ws_OnError;
Ws.Connect();
}
public static async Task Connect(String chaveServicos, String codMotorista)
{
// _timer = new Timer(OnTickAsync, null, 2000, 1);
if (_ws != null && _ws.State == WebSocketState.Open)
{
return;
}
//Verifico se servidor está disponível
var client = new HttpClient
{
Timeout = TimeSpan.FromMilliseconds(8000),
BaseAddress = new Uri("http://" + ViewModelBase.GetUrlBase() + "/motorapido/wes/")
};
client.DefaultRequestHeaders.Add("Authentication", chaveServicos);
try
{
var response = await client.GetAsync("motorista/ping");
Tuple <String, String> tupla = new Tuple <string, string>("Authentication", chaveServicos);
List <Tuple <String, String> > lista = new List <Tuple <String, String> >();
lista.Add(tupla);
tupla = new Tuple <string, string>("CodMotorista", codMotorista);
lista.Add(tupla);
IEnumerable <Tuple <String, String> > en = lista;
var socketOptions = new PureWebSocketOptions()
{
DebugMode = true,
SendDelay = 100,
IgnoreCertErrors = true,
MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20),
Headers = en
};
_ws = new PureWebSocket("ws://" + ViewModelBase.GetUrlBase() + "/motorapido/socket", socketOptions);
_ws.OnStateChanged += Ws_OnStateChanged;
_ws.OnMessage += Ws_OnMessage;
_ws.OnClosed += Ws_OnClosed;
_ws.OnSendFailed += Ws_OnSendFailed;
var res = await _ws.ConnectAsync();
Console.ReadLine();
CrossSettings.Current.Remove("ServidorFora");
BackgroundAggregatorService.StopBackgroundService();
}
catch (Exception e)
{
Crashes.TrackError(e);
if (!CrossSettings.Current.Contains("ServidorFora"))
{
CrossSettings.Current.Set("ServidorFora", true);
MessagingCenter.Send(new MensagemRespostaSocket()
{
msg = "Servidor indisponível!"
}, "ErroPosicaoArea");
BackgroundAggregatorService.Add(() => new ChecagemServidorDisponivel());
BackgroundAggregatorService.StartBackgroundService();
}
}
}
