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.ZKBSettingsModule.ZKillboardWebSocketUrl, o);
_webSocket.OnMessage += WebSocket_OnMessage;
_webSocket.OnError += async(sender, 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);
}
internal static int InvokeHubMethod(PureWebSocket socket, string hubName, string methodName,
params object[] parameters)
{
// Transport: ws
// exmaple which should not be encoded before sending
// {"H":"chatHub","M":"getOnlineCount","A":[],"I":319104157}
var msgId = int.Parse(DateTime.Now.ToString("MMddhhmmss"));
var sb = new StringBuilder();
sb.Append($"{{\"H\":\"{hubName}\",\"M\":\"{methodName}\",\"A\":[");
if (parameters.Length > 0)
{
for (var i = 0; i < parameters.Length; i++)
{
var cobj = parameters[i];
if (cobj is short || cobj is int || cobj is long || cobj is ushort || cobj is uint || cobj is ulong ||
cobj is double || cobj is decimal || cobj is float)
{
sb.Append(parameters[i]);
}
else if (cobj is bool)
{
if ((bool)parameters[i])
{
sb.Append(1);
}
else
{
sb.Append(0);
}
}
else
{
sb.Append($"\"{parameters[i]}\"");
}
if (i < parameters.Length - 1)
{
sb.Append(",");
}
}
}
sb.Append($"],\"I\":{msgId}}}");
if (socket.Send(sb.ToString()))
{
return(msgId);
}
return(-1);
}
private void Socket_OnOpened(object sender)
{
Log("OnOpened invoked.");
_counter = 0;
var authObject = new Dictionary <string, object>
{
{ "event", "#handshake" },
{ "data", new Dictionary <string, object> {
{ "authToken", _authToken }
} },
{ "cid", Interlocked.Increment(ref _counter) }
};
var json = _options.Serializer.Serialize(authObject);
_socket.Send(json);
if (_options.Creds != null)
{
Emit("auth", _options.Creds);
Task.Delay(500).Wait();
}
OnOpened?.Invoke(this);
}
public void Push(Envelope envelope)
{
var push = new JArray(
envelope.JoinRef,
envelope.Ref,
envelope.Topic,
envelope.Event,
envelope.Payload);
void Callback() => _conn.Send(push.ToString());
if (IsConnected())
{
Callback();
}
else
{
_sendBuffer.Add(Callback);
}
}
private static void Send(string message)
{
Console.WriteLine("[<--] " + message);
_ws.Send(message);
}
public void Write(string text)
{
ws.Send(text);
}
private void WebSocket_OnMessage(string message)
{
ApiMessage data = JsonConvert.DeserializeObject <ApiMessage>(message);
switch (data.Type)
{
case "status":
{
localStorage = data;
OnTopicChanged?.Invoke(data.Data.Topic);
OnStreamViewersChanged?.Invoke(data.Data.Stream.Viewers);
foreach (Service stream in data.Data.Stream.Services)
{
if (stream.Status == true)
{
OnStreamWentOnline?.Invoke(stream);
}
}
}
break;
case "update":
{
// wait for status
if (localStorage is null)
{
break;
}
if (data.Data.Topic != null)
{
if (localStorage.Data.Topic.Id != data.Data.Topic.Id)
{
OnTopicChanged?.Invoke(data.Data.Topic);
}
localStorage.Data.Topic = data.Data.Topic;
}
if (data.Data.Stream != null)
{
// invoke viewers change event only when stream is online
if (localStorage.Data.Stream.Status == true && localStorage.Data.Stream.Viewers != data.Data.Stream.Viewers)
{
OnStreamViewersChanged?.Invoke(data.Data.Stream.Viewers);
localStorage.Data.Stream.Viewers = data.Data.Stream.Viewers;
}
else if (localStorage.Data.Stream.Status == false)
{
localStorage.Data.Stream.Viewers = 0;
}
if (data.Data.Stream.Services != null)
{
for (int i = 0; i < data.Data.Stream.Services.Length; i++)
{
Service localService = localStorage.Data.Stream.Services[i];
Service remoteService = data.Data.Stream.Services[i];
if (localService.Status != remoteService.Status)
{
if (remoteService.Status == true)
{
OnStreamWentOnline?.Invoke(remoteService);
}
else
{
OnStreamWentOffline?.Invoke(remoteService);
}
}
}
localStorage.Data.Stream.Status = data.Data.Stream.Status;
localStorage.Data.Stream.Services = data.Data.Stream.Services;
if (localStorage.Data.Stream.Status == true)
{
localStorage.Data.Stream.OnlineAt = data.Data.Stream.OnlineAt;
}
else
{
localStorage.Data.Stream.OfflineAt = data.Data.Stream.OfflineAt;
}
}
}
if (data.Data.Streamers != null)
{
localStorage.Data.Streamers = data.Data.Streamers;
}
}
break;
case "ping":
{
webSocket.Send(JsonConvert.SerializeObject("{type:'pong'}"));
}
break;
}
}
public static void Send(PureWebSocket ws, string message)
{
Console.WriteLine($@"{ws.InstanceName} > {message}");
ws.Send(message);
}
/// <summary> /// Sends the data directly over the socket /// </summary> /// <param name="data">the data to send</param> /// <returns></returns> public bool Send(string data) => _webSocket.Send(data);
private void Socket_OnMessage(string message)
{
Log($"Received message: {message}");
OnMessage?.Invoke(message);
//TODO: this can be optimized more
if (message == "#1")
{
_socket.Send("#2");
return;
}
if (message == "1")
{
_socket.Send("2");
return;
}
var dict = _options.Serializer.Deserialize <Dictionary <string, object> >(message);
if (!dict.TryGetValue("data", out dynamic dataobject))
{
return;
}
dict.TryGetValue("rid", out var trid);
dict.TryGetValue("cid", out var tcid);
dict.TryGetValue("event", out var tstrEvent);
var rid = Convert.ToInt64(trid);
var cid = Convert.ToInt64(tcid);
var strEvent = (string)tstrEvent;
switch (Parser.Parse(rid, strEvent))
{
case Parser.ParseResult.ISAUTHENTICATED:
Id = dataobject["id"];
//_listener.OnAuthentication(this, (bool)((JObject)dataobject).GetValue("isAuthenticated"));
SubscribeChannels();
break;
case Parser.ParseResult.PUBLISH:
HandlePublish(dataobject["channel"].ToString(), dataobject["data"]);
break;
case Parser.ParseResult.REMOVETOKEN:
SetAuthToken(null);
break;
case Parser.ParseResult.SETTOKEN:
SetAuthToken(dataobject["token"]);
break;
case Parser.ParseResult.EVENT:
if (HasEventAck(strEvent))
{
HandleEmitAck(strEvent, dataobject, Ack(cid));
}
else
{
HandleEmit(strEvent, dataobject);
}
break;
case Parser.ParseResult.ACKRECEIVE:
if (_acks.TryGetValue(rid, out var value))
{
_acks.Remove(rid);
if (value != null)
{
var fn = (Ackcall)value[1];
if (fn != null)
{
dict.TryGetValue("error", out var err);
dict.TryGetValue("data", out var dat);
fn((string)value[0], err, dat);
}
else
{
Console.WriteLine("Ack function is null");
}
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
internal bool Send(string message) => _websocket.Send(message);
