public RecordingModel(Settings Settings,
ILocalizationProvider Loc,
ISystemTray SystemTray,
WebcamOverlay WebcamOverlay,
IPreviewWindow PreviewWindow,
IAudioSource AudioSource,
WebcamModel WebcamModel,
KeymapViewModel Keymap,
TimerModel TimerModel,
IMessageProvider MessageProvider,
IFFmpegViewsProvider FFmpegViewsProvider) : base(Settings, Loc)
{
_systemTray = SystemTray;
_webcamOverlay = WebcamOverlay;
_previewWindow = PreviewWindow;
_audioSource = AudioSource;
_webcamModel = WebcamModel;
_keymap = Keymap;
_timerModel = TimerModel;
_messageProvider = MessageProvider;
_ffmpegViewsProvider = FFmpegViewsProvider;
SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
TimerModel.CountdownElapsed += InternalStartRecording;
socketClient = new SocketIoClient();
socketClient.Start();
}
/// <summary>
/// Checks Oif Version
/// Returns true if Version greater/equal than Server Version
/// Returns false if Version smaller than Server Version
/// </summary>
/// <returns></returns>
public bool CheckOidVersion(out string oidServerVersion)
{
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient", "CheckOidVersion");
if (Config.GetInstance().Directory.TryGetValue("OidVersion", out string instVer))
{
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
" CheckOidVersion TryGetValue done");
var ver = SocketIoClient.RetrieveSingleValue <VersionWrapper>(_url,
"OidVersionOffer", "OidVersionRequest", null, timeout: 30000);
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"OidVersionOffer received");
if (System.Version.TryParse(instVer, out Version instVersion) &&
System.Version.TryParse(ver.Version, out Version version))
{
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"before assigning out");
oidServerVersion = ver.Version;
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"CheckOidVersion Complete");
return(instVersion.CompareTo(version) >= 0);
}
}
FnLog.GetInstance().AddToLogList(FnLog.LogType.CriticalError, "OpenMPSClient",
"Missing Directory OidVersion Value");
throw new QueryFailedException();
}
/// <summary>
/// Activates a License
/// the License must be valid and non activated
/// there can only be one activation of a SerialNumber
/// If the Activation is successful the SerialNumber and ActivationKey will be inserted into the local database.
/// It will throw a ActivationFailedException if the ManastoneServer delivers no or an empty Offer.
/// </summary>
/// <param name="req">an ActivationRequest containing the SerialNumber and the CPU1 ID</param>
private void Activate(ActivationRequest req)
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "req " + req.SerialNumber +
" " + req.ProductUUID + " " + req.HardwareId); //DEBUG
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Start");
var activationKey =
SocketIoClient.RetrieveSingleValue <ActivationOffer>(_url, "ActivationOffer", "ActivationRequest",
req.Serialize(), timeout: _timeout);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "ActivationOffer " + activationKey.ActivationKey.Length);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "ActivationOffer " + activationKey.Serialize());
if (activationKey.ActivationKey.Length == 0)
{
throw new ActivationFailedException("Length == 0");
}
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Before SerialInsertion");
_database.InsertSerialNumber(req.SerialNumber);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Before ActivationKeyInsertion");
_database.InsertActivationKey(req.SerialNumber, activationKey.ActivationKey);
RetrieveToken(new TokenRequest(activationKey.ActivationKey));
RetrieveCustomerReference(new CustomerReferenceRequest(activationKey.ActivationKey));
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "Activate", "Complete");
_database.Log.ProcessLogList();
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on ACTIVATE", e.Message);
_database.Log.ProcessLogList();
throw new ActivationFailedException();
}
}
private static async Task BaseTest(Func <SocketIoClient, CancellationToken, Task> func, params string[] additionalEvents)
{
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
await using var client = new SocketIoClient();
client.Connected += (sender, args) => Console.WriteLine($"Connected: {args.Namespace}");
client.Disconnected += (sender, args) => Console.WriteLine($"Disconnected. Reason: {args.Reason}, Status: {args.Status:G}");
client.EventReceived += (sender, args) => Console.WriteLine($"EventReceived: Namespace: {args.Namespace}, Value: {args.Value}, IsHandled: {args.IsHandled}");
client.HandledEventReceived += (sender, args) => Console.WriteLine($"HandledEventReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.UnhandledEventReceived += (sender, args) => Console.WriteLine($"UnhandledEventReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.ErrorReceived += (sender, args) => Console.WriteLine($"ErrorReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.ExceptionOccurred += (sender, args) => Console.WriteLine($"ExceptionOccurred: {args.Value}");
var results = await client.WaitAllEventsAsync <EventArgs>(async cancellationToken =>
{
await func(client, cancellationToken);
}, cancellationTokenSource.Token, new [] { nameof(client.Connected), nameof(client.Disconnected) }.Concat(additionalEvents).ToArray());
Console.WriteLine();
Console.WriteLine($"WebSocket State: {client.EngineIoClient.WebSocketClient.Socket.State}");
Console.WriteLine($"WebSocket CloseStatus: {client.EngineIoClient.WebSocketClient.Socket.CloseStatus}");
Console.WriteLine($"WebSocket CloseStatusDescription: {client.EngineIoClient.WebSocketClient.Socket.CloseStatusDescription}");
foreach (var pair in results)
{
Assert.IsNotNull(pair.Value, $"Client event(\"{pair.Key}\") did not happen");
}
}
/// <summary>
/// Checks for the minimum openMPS server version
/// </summary>
/// <returns></returns>
private bool CheckMinClientVersion()
{
try
{
FnLog.GetInstance()
.AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient", "CheckMinClientVersion");
var ver = SocketIoClient.RetrieveSingleValue <VersionWrapper>(_url,
"MPSMinClientVersionOffer", "MPSMinClientVersionRequest", null, timeout: 30000);
var progVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
if (System.Version.TryParse(progVersion, out Version programVersion) &&
System.Version.TryParse(ver.Version, out Version minversion))
{
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"CheckMinClientVersion Complete");
return(programVersion.CompareTo(minversion) >= 0);
}
FnLog.GetInstance().AddToLogList(FnLog.LogType.Error, "OpenMPSClient",
"CheckMinClientVersion ResultNullOrNotReceivedException");
throw new ResultNullOrNotReceivedException();
}
catch (Exception e)
{
FnLog.GetInstance().AddToLogList(FnLog.LogType.Error, "OpenMPSClient",
"CheckMinClientVersion" + e.Message);
MessageBox.Show("Could not reach the openMPS Server");
throw new ResultNullOrNotReceivedException();
}
}
public static async Task JoinRoomAsync(this SocketIoClient client, string roomName)
{
using var called = client.Emit("join", roomName).SubscribeCalled(e =>
{
Assert.Equal("joined", e.Data[0].ToString());
});
await called.AssertOnceAsync(TimeSpan.FromMilliseconds(100));
}
/// <summary>
/// sends the oid data
/// </summary>
/// <param name="data"></param>
public void SendOidData(List <OidData> data)
{
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient", "SendOidData");
var dataStr = JsonConvert.SerializeObject(data, Formatting.Indented).Trim()
.Replace(System.Environment.NewLine, "");
var res = SocketIoClient.RetrieveSingleValue <SimpleResult>(_url,
"closer", "SendData", dataStr, timeout: 30000);
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient", "SendOidData sent");
}
/// <summary>
/// Sends a log
/// </summary>
private void Sender()
{
try
{
SocketIoClient.RetrieveSingleValue <SimpleResult>(_serverUrl,
"closer", _senderEventName, _logSerialized);
}
catch (System.Exception)
{
// ignored
}
}
/// <summary>
/// Downloads and updates the oid table
/// </summary>
/// <param name="oidVersion"></param>
private void DownloadAndUpdateOidTable(string oidVersion)
{
ManastoneClient.GetInstance().CheckToken();
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"DownloadAndUpdateOidTable - " + ManastoneClient.GetInstance().Token);
var oid = SocketIoClient.RetrieveSingleValue <List <Oid> >(_url,
"OidOffer", "OidRequest", new OidRequest(ManastoneClient.GetInstance().Token).Serialize(),
timeout: 30000);
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"DownloadAndUpdateOidTable received" + oid.Count);
Config.GetInstance().UpdateOids(oidVersion, oid);
FnLog.GetInstance().AddToLogList(FnLog.LogType.MajorRuntimeInfo, "OpenMPSClient",
"DownloadAndUpdateOidTable Complete");
}
/// <summary>
/// Retrieves the Customer Reference from the Manastone Server and saves it to the Local database
/// </summary>
/// <param name="req">an CustomerReferenceRequest containing the ActivationKey</param>
private void RetrieveCustomerReference(CustomerReferenceRequest req)
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "RetrieveCustomerReference", "Start");
var offer =
SocketIoClient.RetrieveSingleValue <CustomerReferenceOffer>(_url, "CustomerReferenceOffer",
"CustomerReferenceRequest", req.Serialize(), timeout: _timeout);
_database.InsertCustomerReference(req.ActivationKey, offer.CustomerReference);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "RetrieveCustomerReference", "Complete");
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on RetrieveCustomerReference", e.Message);
throw new ManastoneOfferNotReceivedCorrectlyException();
}
}
// Use this for initialization
void Start()
{
socketBoy = FindObjectOfType <SocketIoClient>();
playerController = FindObjectOfType <PlayerController>();
theMainCamera = Camera.main;
possiblePieces = new Dictionary <char, Piece>
{
{ 'P', Pawn },
{ 'R', Rook },
{ 'B', Bishop },
{ 'N', Knight },
{ 'Q', Queen },
{ 'K', King },
};
players = new List <Piece>();
}
/// <summary>
/// Returns the Version of the Manastone Server
/// if this fails it will throw a ManastoneOfferNotReceivedCorrectlyException
/// </summary>
/// <returns></returns>
private Version RetrieveManastoneServerVersion()
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MinorDrmLog, "RetrieveManastoneServerVersion", "Start");
var serVer = Version.Parse(SocketIoClient.RetrieveSingleValue <VersionWrapper>(_url, "ManastoneVersion",
"ManastoneVersionRequest", null, timeout: _timeout).Version);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MinorDrmLog, "RetrieveManastoneServerVersion", "Complete");
_database.Log.ProcessLogList();
return(serVer);
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on RetrieveManastoneServerVersion", e.Message);
_database.Log.ProcessLogList();
throw new ManastoneOfferNotReceivedCorrectlyException();
}
}
/// <summary>
/// Checks if the Token is valid
/// this will contact the Manastone server and check if the token is valid
/// a token check has to be Online only because the token is to authenticate a program client to a program server or service
/// if the server doesn't answer it will throw a ManastoneOfferNotReceivedCorrectlyException
/// </summary>
/// <param name="req">CheckTokenRequest</param>
/// <returns></returns>
public bool CheckToken(CheckTokenRequest req)
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmLog, "CheckToken", "Start");
var offer = SocketIoClient.RetrieveSingleValue <CheckTokenOffer>(_url, "CheckTokenOffer",
"CheckTokenRequest", req.Serialize(), timeout: _timeout);
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmLog, "CheckToken", "Complete");
_database.Log.ProcessLogList();
return(offer.IsValid);
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on CheckToken", e.Message);
_database.Log.ProcessLogList();
throw new ManastoneOfferNotReceivedCorrectlyException();
}
}
public static void EnableDebug(SocketIoClient client)
{
client.EngineIoClient.Opened += (sender, args) => Console.WriteLine("EngineIoClient.Opened");
client.EngineIoClient.Closed += (sender, args) => Console.WriteLine($"EngineIoClient.Closed. Reason: {args.Reason}, Status: {args.Status:G}");
client.EngineIoClient.Upgraded += (sender, args) => Console.WriteLine($"EngineIoClient.Upgraded: {args.Value}");
client.EngineIoClient.ExceptionOccurred += (sender, args) => Console.WriteLine($"EngineIoClient.ExceptionOccurred: {args.Value}");
client.EngineIoClient.MessageReceived += (sender, args) => Console.WriteLine($"EngineIoClient.MessageReceived: {args.Value}");
client.EngineIoClient.NoopReceived += (sender, args) => Console.WriteLine($"EngineIoClient.NoopReceived: {args.Value}");
client.EngineIoClient.PingReceived += (sender, args) => Console.WriteLine($"EngineIoClient.PingReceived: {args.Value}");
client.EngineIoClient.PongReceived += (sender, args) => Console.WriteLine($"EngineIoClient.PongReceived: {args.Value}");
client.EngineIoClient.PingSent += (sender, args) => Console.WriteLine($"EngineIoClient.PingSent: {args.Value}");
client.EngineIoClient.WebSocketClient.Connected += (sender, args) => Console.WriteLine("WebSocketClient.Connected");
client.EngineIoClient.WebSocketClient.Disconnected += (sender, args) => Console.WriteLine($"WebSocketClient.Disconnected. Reason: {args.Reason}, Status: {args.Status:G}");
client.EngineIoClient.WebSocketClient.TextReceived += (sender, args) => Console.WriteLine($"WebSocketClient.TextReceived: {args.Value}");
client.EngineIoClient.WebSocketClient.ExceptionOccurred += (sender, args) => Console.WriteLine($"WebSocketClient.ExceptionOccurred: {args.Value}");
client.EngineIoClient.WebSocketClient.BytesReceived += (sender, args) => Console.WriteLine($"WebSocketClient.BytesReceived: {args.Value.Count}");
}
/// <summary>
/// Returns the DateTime of the Manastone Server
/// Currently unused, will be used later to locally check the Token expiry date
/// </summary>
/// <returns></returns>
private DateTime RetrieveServerTime()
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MinorDrmLog, "RetrieveServerTime", "Start");
var serTime = SocketIoClient
.RetrieveSingleValue <DateTimeWrapper>(_url, "ServerTime", "ServerTimeRequest", null)
.Time;
_database.Log.AddToLogList(FnLog.FnLog.LogType.MinorDrmLog, "RetrieveServerTime", "Complete");
_database.Log.ProcessLogList();
return(serTime);
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on RetrieveServerTime", e.Message);
_database.Log.ProcessLogList();
throw new ManastoneOfferNotReceivedCorrectlyException();
}
}
/// <summary>
/// Retrieves the Token and saves it to the Local database
/// </summary>
/// <param name="req">an TokenRequest containing the ActivationKey</param>
private void RetrieveToken(TokenRequest req)
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "RetrieveToken", "Start");
var token =
SocketIoClient.RetrieveSingleValue <TokenOffer>(_url, "TokenOffer", "TokenRequest",
req.Serialize(), timeout: _timeout);
if (token.Token.Length == 0)
{
throw new FailedToRetrieveTokenException();
}
_database.InsertToken(req.ActivationKey, token.Token);
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "RetrieveToken", "Complete");
_database.Log.ProcessLogList();
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on RetrieveToken", e.Message);
_database.Log.ProcessLogList();
throw new ManastoneOfferNotReceivedCorrectlyException();
}
}
/// <summary>
/// Checks Activation status Online.
/// this will contact the Manastone server and check if the activation is valid
/// </summary>
/// <param name="req">ActivationOnlineCheckRequest</param>
/// <returns>if valid returns true</returns>
private bool CheckLicenseStatusOnline(ActivationOnlineCheckRequest req)
{
try
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "CheckLicenseStatusOnline", "Start");
var offer = SocketIoClient.RetrieveSingleValue <ActivationOnlineCheckOffer>(_url,
"ActivationOnlineCheckOffer",
"ActivationOnlineCheckRequest", req.Serialize(), timeout: _timeout);
if (offer.IsActivated)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "CheckLicenseStatusOnline", "ACTIVATION Confirmed");
RetrieveCustomerReference(new CustomerReferenceRequest(req.ActivationKey));
}
_database.Log.AddToLogList(FnLog.FnLog.LogType.MajorDrmLog, "CheckLicenseStatusOnline", "Complete");
_database.Log.ProcessLogList();
return(offer.IsActivated);
}
catch (Exception e)
{
_database.Log.AddToLogList(FnLog.FnLog.LogType.DrmError, "ERROR on CheckLicenseStatusOnline", e.Message);
_database.Log.ProcessLogList();
return(false);
}
}
public static async Task BaseTestAsync(
Func <SocketIoClient, Task> func,
CancellationToken cancellationToken = default,
params string[] additionalEvents)
{
#if NETCOREAPP3_1 || NETCOREAPP3_0 || NET5_0
await using var client = new SocketIoClient();
#else
using var client = new SocketIoClient();
#endif
client.Connected += (_, args) => Console.WriteLine($"Connected: {args.Namespace}");
client.Disconnected += (_, args) => Console.WriteLine($"Disconnected. Reason: {args.Reason}, Status: {args.Status:G}");
client.EventReceived += (_, args) => Console.WriteLine($"EventReceived: Namespace: {args.Namespace}, Value: {args.Value}, IsHandled: {args.IsHandled}");
client.HandledEventReceived += (_, args) => Console.WriteLine($"HandledEventReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.UnhandledEventReceived += (_, args) => Console.WriteLine($"UnhandledEventReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.ErrorReceived += (_, args) => Console.WriteLine($"ErrorReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.ExceptionOccurred += (_, args) => Console.WriteLine($"ExceptionOccurred: {args.Value}");
var results = await client.WaitAllEventsAsync <EventArgs>(
async() => await func(client),
cancellationToken,
new [] { nameof(client.Connected), nameof(client.Disconnected) }
.Concat(additionalEvents)
.ToArray());
Console.WriteLine();
Console.WriteLine($"WebSocket State: {client.EngineIoClient.WebSocketClient.Socket.State}");
Console.WriteLine($"WebSocket CloseStatus: {client.EngineIoClient.WebSocketClient.Socket.CloseStatus}");
Console.WriteLine($"WebSocket CloseStatusDescription: {client.EngineIoClient.WebSocketClient.Socket.CloseStatusDescription}");
foreach (var pair in results)
{
pair.Value.Should().NotBeNull(because: $"Client event(\"{pair.Key}\") did not happen");
}
}
public void setEventHandler(SocketIoClient eventHandler) {
this.eventHandler = eventHandler;
}
public SocketIoClientReceiver(SocketIoClientConnection SocketIoClient)
{
this.SocketIoClient = SocketIoClient;
this.eventHandler = SocketIoClient.getEventHandler();
}
public IObservable <Dictionary <string, object> > Connect(
IObservable <string> input,
ICollection <IMessageUnpacker> unpackers)
{
return(Observable.Defer(() => Observable.Create <Dictionary <string, object> >(async(sink, token) =>
{
SocketIoClient socket = new SocketIoClient();
Uri connectionUri = null;
try
{
connectionUri = new Uri("https://streamer.cryptocompare.com");
await socket.ConnectAsync(connectionUri);
_logger.LogInformation("[EXTERNAL-SERVICE] Connecting to CryptoCompare.com ...");
}
catch (UriFormatException e)
{
sink.OnError(e);
return;
}
Func <Task> closeSocket = async() => {
await socket.DisconnectAsync();
_logger.LogInformation("[EXTERNAL-SERVICE] Connection to CryptoCompare.com closed");
};
socket.Connected += (sender, args) =>
{
input.Subscribe(v =>
{
string[] subscription = { v };
Dictionary <string, object> subs = new Dictionary <string, object>();
subs.Add("subs", subscription);
socket.Emit("SubAdd", subs);
},
onError: e => sink.OnError(e));
};
socket.On("m", async args =>
{
string message = args;
string messageType = message.Substring(0, message.IndexOf("~"));
foreach (IMessageUnpacker unpacker in unpackers)
{
if (unpacker.Supports(messageType))
{
try
{
sink.OnNext(unpacker.Unpack(message));
}
catch (Exception e)
{
sink.OnError(e);
await closeSocket.Invoke();
}
break;
}
}
});
socket.ErrorReceived += (sender, args) => sink.OnError(new Exception(args.Value));
socket.Disconnected += (sender, args) => sink.OnCompleted();
token.Register(async() => await closeSocket());
await socket.ConnectAsync(connectionUri);
})));
}
public SocketIoClientReceiver(SocketIoClientConnection SocketIoClient) {
this.SocketIoClient = SocketIoClient;
this.eventHandler = SocketIoClient.getEventHandler();
}
public void setEventHandler(SocketIoClient eventHandler)
{
this.eventHandler = eventHandler;
}
// Use this for initialization
void Start()
{
socketBoy = FindObjectOfType <SocketIoClient>();
AddSquares();
}
public async Task NoAcksOrHandlerNotifications()
{
// Arrange
var serializer = new NewtonSoftJsonSerializer();
var logger = new NullLogger <SocketIoClient>();
var opts = new SocketIoClientOptions(
serializer,
logger,
Encoding.UTF8
);
var client = new SocketIoClient(opts);
client.Events.OnConnect.Subscribe(
args => Log($"[1] Connected: {args}"));
client.Events.OnPacket.Subscribe(packet =>
{
Log($"[1] Received packet: {packet}");
});
string clientId1 = null;
client.Events.OnHandshake.Subscribe(res =>
{
clientId1 = res.Sid;
});
// Act
await client.OpenAsync(new Uri("http://localhost:3300"));
var data1 = new Payload()
{
Id = 42,
Name = "Douglas Adams"
};
var data2 = new Payload()
{
Id = 86,
Name = "Carl Sagan"
};
while (clientId1 is null)
{
Thread.Sleep(50);
}
client.On("/consume")
.Subscribe(message =>
{
Log($"Received notification: {message.EventName}, data: {message.Data}");
});
Log($"- subscribe to 'test' topic {clientId1} -");
client.Emit("/subscribe", new SubscribeRequest(
clientId1,
"test",
0,
10,
0
)
).Subscribe(ack =>
{
Log($"subscribe ack: {ack}");
});
Log("- about to publish - ");
client.Emit("/publish", new PublishRequest
{
Topic = "test",
Channel = 1,
Message = JsonConvert.SerializeObject(data1)
}
).Subscribe(ack =>
{
Log($"publish ack: {JsonConvert.SerializeObject(ack)}");
});
client.Emit("/publish", new PublishRequest
{
Topic = "test",
Channel = 1,
Message = JsonConvert.SerializeObject(data1)
}
).Subscribe(ack =>
{
Log($"publish ack: {JsonConvert.SerializeObject(ack)}");
});
// Assert
Log("- waiting for 2s just in case -");
await Task.Delay(2000);
Log("- test ends -");
}
public static Task OpenTestAsync(this SocketIoClient client, Uri uri = null, string path = "some-path")
{
uri ??= new Uri("http://localhost:8764");
return(client.OpenAsync(uri, new SocketIoOpenOptions(path)));
}
/// <summary>
/// testing atm!
/// retrieves logs from the fnLog server
/// </summary>
/// <param name="logRequest"></param>
/// <param name="serverUrl"></param>
/// <param name="acceptSelfSigned"></param>
/// <returns></returns>
public static List <Log> RetrieveLog(LogRequest logRequest, string serverUrl, bool acceptSelfSigned = true)
{
return(SocketIoClient.RetrieveSingleValue <List <Log> >(serverUrl,
"logRequestResult", "logRequest", logRequest.Serialize()));
}
public WebSocket(string url_)
{
url = url_;
GetPayload();
if (title == "Toonation")
{
webSocket = new WebSocketSharp.WebSocket("wss://toon.at:8071/" + payload);
webSocket.OnMessage += Ws_OnMessage;
webSocket.OnClose += Ws_OnClose;
webSocket.Connect();
}
else if (title == "Twip AlertBox")
{
string ioUrl = $"https://io.mytwip.net?alertbox_key={key}&version={version}&token={encodeURIComponent(token)}";
var client = new SocketIoClient();
client.Connected += (sender, args) => Debug.WriteLine($"Connected: {args.Namespace}");
client.Disconnected += (sender, args) => Debug.WriteLine($"Disconnected. Reason: {args.Reason}, Status: {args.Status:G}");
client.EventReceived += (sender, args) => Debug.WriteLine($"EventReceived: Namespace: {args.Namespace}, Value: {args.Value}, IsHandled: {args.IsHandled}");
client.HandledEventReceived += (sender, args) => Debug.WriteLine($"HandledEventReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.UnhandledEventReceived += (sender, args) => Debug.WriteLine($"UnhandledEventReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.ErrorReceived += (sender, args) => Debug.WriteLine($"ErrorReceived: Namespace: {args.Namespace}, Value: {args.Value}");
client.ExceptionOccurred += (sender, args) => Debug.WriteLine($"ExceptionOccurred: {args.Value}");
client.On("new donate", message =>
{
eCurrentMessageKind = EMessageKind.donate;
Console.WriteLine(message);
var obj = JsonConvert.DeserializeObject <TwipObject>(message);
if (obj.effect != null)
{
if (obj.slotmachine_data != null)
{
eCurrentMessageKind = EMessageKind.roulette;
}
OnTwipObject?.Invoke(obj);
}
});
client.On("new cheer", message =>
{
eCurrentMessageKind = EMessageKind.cheer;
Console.WriteLine(message);
var obj = JsonConvert.DeserializeObject <TwipObject>(message);
if (obj.effect != null)
{
OnTwipObject?.Invoke(obj);
}
});
client.On("new follow", message =>
{
eCurrentMessageKind = EMessageKind.follow;
Console.WriteLine(message);
var obj = JsonConvert.DeserializeObject <TwipObject>(message);
if (obj.effect != null)
{
OnTwipObject?.Invoke(obj);
}
});
client.On("new sub", message =>
{
eCurrentMessageKind = EMessageKind.sub;
Console.WriteLine(message);
var obj = JsonConvert.DeserializeObject <TwipObject>(message);
if (obj.effect != null)
{
OnTwipObject?.Invoke(obj);
}
});
client.On("new hosting", message =>
{
eCurrentMessageKind = EMessageKind.hosting;
Console.WriteLine(message);
var obj = JsonConvert.DeserializeObject <TwipObject>(message);
if (obj.effect != null)
{
OnTwipObject?.Invoke(obj);
}
});
client.On("new redemption", message =>
{
eCurrentMessageKind = EMessageKind.redemption;
Console.WriteLine(message);
var obj = JsonConvert.DeserializeObject <TwipObject>(message);
if (obj.effect != null)
{
OnTwipObject?.Invoke(obj);
}
});
client.ConnectAsync(new Uri(ioUrl)).Wait();
}
jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
}
