public void AddJsonServer(JsonServer arg_json_server)
{
list_json_server.Add(arg_json_server);
ServerConnection server_connection = new ServerConnection(arg_json_server.ServerURL, arg_json_server.ServerId);
list_server_connection.Add(server_connection);
}
private async Task CallBuiltinVersionServiceCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
// event handlers
var connected = 0;
var disconnected = 0;
js.ClientConnected += (s, e) => connected++;
js.ClientDisconnected += (s, e) => disconnected++;
js.UnhandledException += (s, e) => Assert.Fail($"Unhandled server exception: {e.Exception}. Connected: {connected}, disconnected: {disconnected}.");
jc.UnhandledException += (s, e) => Assert.Fail($"Unhandled client exception: {e.Exception}. Connected: {connected}, disconnected: {disconnected}.");
// start json server and connect the client
js.Start();
Assert.IsNull(jc.SessionId);
var sessionId = await jc.ConnectAsync(credentials);
Assert.IsNotNull(jc.SessionId);
Assert.AreEqual(sessionId, jc.SessionId);
// call Version
var msg = new VersionRequest();
var result = await Assert_NotTimedOut(jc.Call(msg), "jc.Call(VersionRequest)");
Assert.NotNull(result);
Assert.AreEqual(nameof(JsonServices), result.ProductName);
Assert.NotNull(result.ProductVersion);
Assert.NotNull(result.EngineVersion);
// make sure all incoming messages are processed
Assert.AreEqual(0, jc.PendingMessages.Count);
}
protected async Task CallDisconnectAndReconnectCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
js.ProductName = "My awesome server";
js.ProductVersion = "1.2.3.4";
js.Start();
// connect, call, disconnect
await Assert_NotTimedOut(jc.ConnectAsync(credentials), "connect");
var result = await Assert_NotTimedOut(jc.Call(new VersionRequest()), "jc.Call(VersionRequest)");
Assert.NotNull(result);
Assert.AreEqual(js.ProductName, result.ProductName);
Assert.AreEqual(js.ProductVersion, result.ProductVersion);
await Assert_NotTimedOut(jc.DisconnectAsync(), "disconnect");
// reconnect, call, disconnect
await Assert_NotTimedOut(jc.ConnectAsync(credentials), "reconnect");
result = await Assert_NotTimedOut(jc.Call(new VersionRequest()), "jc.Call(VersionRequest) after reconnect");
Assert.NotNull(result);
Assert.AreEqual(js.ProductName, result.ProductName);
Assert.AreEqual(js.ProductVersion, result.ProductVersion);
await Assert_NotTimedOut(jc.DisconnectAsync(), "disconnect completely");
Assert.AreEqual(0, jc.PendingMessages.Count);
}
protected async Task CallUnregisteredServiceCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
// event handlers
var connected = 0;
var disconnected = 0;
js.ClientConnected += (s, e) => connected++;
js.ClientDisconnected += (s, e) => disconnected++;
js.UnhandledException += (s, e) => Assert.Fail($"Unhandled server exception: {e.Exception}. Connected: {connected}, disconnected: {disconnected}.");
jc.UnhandledException += (s, e) => Assert.Fail($"Unhandled client exception: {e.Exception}. Connected: {connected}, disconnected: {disconnected}.");
// start json server and connect the client
js.Start();
await jc.ConnectAsync(credentials);
// call UnregisteredService
var msg = new UnregisteredService();
var ex = Assert.ThrowsAsync <MethodNotFoundException>(async() =>
await Assert_NotTimedOut(jc.Call(msg), "jc.Call(UnregisteredService)"));
Assert.AreEqual(MethodNotFoundException.ErrorCode, ex.Code);
// make sure all incoming messages are processed
Assert.AreEqual(0, jc.PendingMessages.Count);
}
public async Task JsonClientSupportsFilteredSubscriptionsAndUnsubscriptionsUsingFleckServer()
{
// fake transport and serializer
var server = new StubServer();
var serverSerializer = new Serializer();
var serverProvider = new StubMessageTypeProvider();
var executor = new StubExecutor();
var client = new StubClient(server, "jc");
var clientProvider = new StubMessageTypeProvider();
var clientSerializer = new Serializer();
var secondClient = new StubClient(server, "sc");
var secondClientProvider = new StubMessageTypeProvider();
var secondClientSerializer = new Serializer();
// json server and client
using (var js = new JsonServer(server, serverProvider, serverSerializer, executor, AuthProvider))
using (var jc = new JsonClient(client, clientProvider, clientSerializer))
using (var sc = new JsonClient(secondClient, secondClientProvider, secondClientSerializer))
{
// set names for easier debugging
jc.DebugName = "First";
sc.DebugName = "Second";
// execute core test
await TestFilteredSubscriptionsAndUnsubscriptionsCore(js, jc, sc, Credentials);
}
}
protected async Task CallGenericMessagesCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
js.Start();
await jc.ConnectAsync();
var intMsg = new GenericRequest <int> {
Value = 1
};
var intResult = await jc.Call(intMsg);
Assert.AreEqual(2, intResult.Result);
var dtMsg = new GenericRequest <DateTime> {
Value = new DateTime(2018, 12, 18)
};
var dtResult = await jc.Call(dtMsg);
Assert.AreEqual(new DateTime(2019, 12, 18), dtResult.Result);
var strMsg = new GenericRequest <string> {
Value = "World"
};
var strResult = await jc.Call(strMsg);
Assert.AreEqual("Hello World!", strResult.Result);
var boolMsg = new GenericRequest <bool> {
Value = true
};
Assert.ThrowsAsync <MethodNotFoundException>(async() => await jc.Call(boolMsg));
// make sure all incoming messages are processed
Assert.AreEqual(0, jc.PendingMessages.Count);
}
public void SrpAuthenticationFailsOnBadCredentials()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
// json server and client
using (var js = new JsonServer(server, provider, serializer, executor, AuthProvider))
using (var jc = new JsonClient(client, provider, serializer))
{
// default credentials
var ex = Assert.ThrowsAsync <AuthFailedException>(async() =>
await CallGetVersionServiceCore(js, jc));
Assert.AreEqual("No credentials specified", ex.Message);
// invalid credentials
ex = Assert.ThrowsAsync <AuthFailedException>(async() =>
await CallGetVersionServiceCore(js, jc, new SrpCredentials("root", "beer")));
Assert.AreEqual("Authentication failed", ex.Message);
// invalid credentials
ex = Assert.ThrowsAsync <AuthFailedException>(async() =>
await CallGetVersionServiceCore(js, jc, new SrpCredentials("hacker", "password")));
Assert.AreEqual("Authentication failed", ex.Message);
}
}
async public Task <string> RconCommand(string command, JsonServer server)
{
string reply = null;
string botIP = new WebClient().DownloadString("http://icanhazip.com").Trim();
IPHostEntry iPHostEntry = null;
try
{
iPHostEntry = Dns.GetHostEntry(server.Address);
}
catch
{
return("HOST_NOT_FOUND");
}
var rcon = new RCON(IPAddress.Parse($"{iPHostEntry.AddressList[0]}"), 27015, server.Password, 1000);
reply = await rcon.SendCommandAsync(command);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"RCON COMMAND: {server.Address}\nCommand: {command}\n");
Console.ResetColor();
//If you re-set the rcon_password all RCON connections are closed.
//By not awaiting this, we are able to set the rcon password back to the same value closing the connection.
//This will automatically timeout and dispose of the rcon connection when it tries to conncect again.
Task fireAndForget = rcon.SendCommandAsync($"rcon_password {server.Password}");
reply = reply.Replace($"{botIP}", "69.420.MLG.1337"); //Remove the Bot's public IP from the string.
return(reply);
}
public async Task JsonServerHandlesDeserializationErrors()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var provider = new StubMessageTypeProvider();
var serverSerializer = new BrokenSerializer();
var clientSerializer = new Serializer();
var executor = new StubExecutor();
using (var js = new JsonServer(server, provider, serverSerializer, executor))
using (var jc = new JsonClient(client, provider, clientSerializer))
{
js.Start();
var tcs = new TaskCompletionSource <bool>();
js.UnhandledException += (s, e) => tcs.TrySetException(e.Exception);
// TODO: can we have something better than a timeout here?
await Assert_TimedOut(jc.ConnectAsync(), timeout : Task.Delay(200));
// the server should have got an unhandled exception
Assert.ThrowsAsync <NotImplementedException>(async() => await Assert_NotTimedOut(tcs.Task));
}
}
public void Start(IReadOnlyList <string> testInfo, JsonServer server)
{
if (!worker.IsBusy)
{
// RunWorkerAsync raises the DoWork event.
worker.RunWorkerAsync((testInfo, server));
}
}
public void RunInServiceMode()
{
var server = new JsonServer {
Service = new CompilerService()
};
server.Run();
}
public SftpDownloader(IReadOnlyList <string> testInfo,
JsonServer server,
DataServices dataSvc) :
base(testInfo, server, dataSvc)
{
Client =
new SftpClient(testInfo[10], server.FTPUser, server.FTPPass);
}
protected override JsonClient CreateClient(JsonServer server)
{
var client = new StubClient(server.Server as StubServer);
var serializer = new Serializer();
var provider = new StubMessageTypeProvider();
return(new JsonClient(client, provider, serializer));
}
protected virtual JsonClient CreateClient(JsonServer server)
{
// fake transport and serializer
var client = new StubClient((StubServer)server.Server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
return(new JsonClient(client, provider, serializer));
}
public AdvancedConfig()
{
Browser = new JsonBrowser();
Server = new JsonServer();
Easy = new JsonMode();
Normal = new JsonMode();
Hard = new JsonMode();
}
public Boolean IsServerOpen(JsonServer server)
{
foreach (UserData u in userData.ToList())
{
if (u.Server == server)
{
return(false);
}
}
return(true);
}
protected Downloader(IReadOnlyList <string> testInfo, JsonServer server, DataServices dataSvc)
{
DataSvc = dataSvc;
DateTime time = Convert.ToDateTime(testInfo[1]);
string title = testInfo[2].Substring(0, testInfo[2].IndexOf(" "));
DemoName = $"{time:MM_dd_yyyy}_{title}";
FtpPath = server.FTPPath;
LocalPath = $"{DataSvc.DemoPath}\\{time:yyyy}\\{time:MM} - " + $"{time:MMMM}\\{DemoName}";
WorkshopId = Regex.Match(testInfo[6], @"\d+$").Value;
}
public FtpDownloader(IReadOnlyList <string> testInfo, JsonServer server, DataServices dataSvc) : base(testInfo, server, dataSvc)
{
gamemode = testInfo[7];
Client = new FtpClient(server.Address, server.FTPUser, server.FTPPass);
if (server.FTPType == "ftps")
{
Client.EncryptionMode = FtpEncryptionMode.Explicit;
Client.SslProtocols = SslProtocols.Tls;
Client.ValidateCertificate += (control, e) => { e.Accept = true; };
}
}
protected async Task CallDelayServiceAndAbortConnectionCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
js.Start();
await jc.ConnectAsync(credentials);
var call = jc.Call(new DelayRequest {
Milliseconds = 1000
});
await Task.Delay(100); // make sure that the call was actually sent
await jc.Client.DisconnectAsync(); // should fire Disconnected event
Assert.ThrowsAsync <ClientDisconnectedException>(async() =>
await Assert_NotTimedOut(call, "jc.Call(Delay 1000)", Task.Delay(2000)));
}
protected virtual async Task CallDelayServiceCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
js.Start();
await jc.ConnectAsync(credentials);
await Assert_NotTimedOut(jc.Call(new DelayRequest {
Milliseconds = 10
}), "jc.Call(Delay 10)");
await Assert_TimedOut(jc.Call(new DelayRequest {
Milliseconds = 200
}), "jc.Call(Delay 200)", Task.Delay(10));
// make sure that await completes before the server is disposed (affects NetMQ server)
await Task.Delay(300);
}
public async Task CallGetVersionService()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
using (var js = new JsonServer(server, provider, serializer, executor))
using (var jc = new JsonClient(client, provider, serializer))
{
await CallGetVersionServiceCore(js, jc);
}
}
public async Task JsonClientRejectsPendingMessagesWhenConnectionIsAborted()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
// json server and client
using (var js = new JsonServer(server, provider, serializer, executor))
using (var jc = new JsonClient(client, provider, serializer))
{
await CallDelayServiceAndAbortConnectionCore(js, jc);
}
}
public async Task JsonServerCanExecuteGenericMessages()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new GenericServiceExecutor();
var provider = new GenericMessageTypeProvider();
// json server and client
using (var js = new JsonServer(server, provider, serializer, executor))
using (var jc = new JsonClient(client, provider, serializer))
{
await CallGenericMessagesCore(js, jc);
}
}
public async Task CallCalculateServiceUsingSrpAuthentication()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
// json server and client
using (var js = new JsonServer(server, provider, serializer, executor, AuthProvider))
using (var jc = new JsonClient(client, provider, serializer))
{
await CallCalculateServiceCore(js, jc, Credentials);
}
}
public async Task JsonClientCanDisconnectAndReconnect()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
// json server and client
using (var js = new JsonServer(server, provider, serializer, executor))
using (var jc = new JsonClient(client, provider, serializer))
{
await CallDisconnectAndReconnectCore(js, jc);
}
}
public async Task ReleasePublicTestCommandAsync([Remainder] string command = null)
{
if (Context.IsPrivate)
{
await ReplyAsync("***This command can not be used in a DM***");
return;
}
if ((Context.User as SocketGuildUser).Roles.Contains(_dataServices.ActiveRole))
{
JsonServer server = null;
if (!_levelTesting.canReserve)
{
await ReplyAsync($"```Servers cannot be reserved at this time." +
$"\nServer reservation is blocked 1 hour before a scheduled test, and resumes once the calendar event has passed.```");
return;
}
Boolean hasServer = false;
foreach (UserData u in _levelTesting.userData)
{
if (u.User == Context.Message.Author)
{
server = u.Server;
hasServer = true;
}
}
if (hasServer)
{
await ReplyAsync("```Releasing Server reservation.```");
await _levelTesting.ClearServerReservations(server.Name);
}
else
{
await ReplyAsync("```I could not locate a server reservation for your account.```");
}
}
else
{
await _dataServices.ChannelLog($"{Context.User} is trying to use public playtest commands without permission.");
await ReplyAsync($"```You cannot use this command with your current permission level! You need {_dataServices.ActiveRole.Name} role.```");
}
}
public async Task JsonServerHasEvents()
{
var server = new StubServer();
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
var js = new JsonServer(server, provider, serializer, executor);
var connectCounter = 0;
void connectEventHandler(object sender, MessageEventArgs e) => connectCounter++;
js.ClientConnected += connectEventHandler;
js.ClientDisconnected += connectEventHandler;
var serviceCounter = 0;
void serviceEventHandler(object sender, EventArgs e) => serviceCounter++;
js.InitializeRequestContext += serviceEventHandler;
js.BeforeExecuteService += serviceEventHandler;
js.AfterExecuteService += serviceEventHandler;
var client = new StubClient(server);
var jc = new JsonClient(client, provider, serializer);
Assert.AreEqual(1, connectCounter);
Assert.AreEqual(0, serviceCounter);
// connect makes one service call and fires three events:
// InitializeRequestContext, BeforeExecuteService, AfterExecuteService
await jc.ConnectAsync();
Assert.AreEqual(3, serviceCounter);
js.Dispose();
Assert.AreEqual(2, connectCounter);
// unsubscribe
js.ClientDisconnected -= connectEventHandler;
js.ClientConnected -= connectEventHandler;
js.AfterExecuteService -= serviceEventHandler;
js.BeforeExecuteService -= serviceEventHandler;
js.InitializeRequestContext -= serviceEventHandler;
}
public void SrpAuthenticationFailsOnIncompatibleAuthProvider()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
// json server without authentication vs SRP client
using (var js = new JsonServer(server, provider, serializer, executor))
using (var jc = new JsonClient(client, provider, serializer))
{
var ex = Assert.ThrowsAsync <AuthFailedException>(async() =>
await CallGetVersionServiceCore(js, jc, Credentials));
Assert.AreEqual("Server doesn't support SRP authentication protocol", ex.Message);
}
}
public async Task CallServiceBeforeConnectingShouldFail()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var serializer = new Serializer();
var executor = new StubExecutor();
var provider = new StubMessageTypeProvider();
var js = new JsonServer(server, provider, serializer, executor);
var jc = new JsonClient(client, provider, serializer);
js.Start();
Assert.ThrowsAsync <AuthRequiredException>(async() =>
await Assert_NotTimedOut(jc.Call(new GetVersion()), "jc.Call(GetVersion) before Connect"));
await Assert_NotTimedOut(jc.ConnectAsync(), "jc.ConnectAsync()");
await Assert_NotTimedOut(jc.Call(new GetVersion()), "jc.Call(GetVersion) after connect");
}
public void JsonServerHandlesMessageTypeProvidersErrors()
{
// fake transport and serializer
var server = new StubServer();
var client = new StubClient(server);
var provider = new BrokenMessageTypeProvider();
var serverSerializer = new Serializer();
var clientSerializer = new Serializer();
var executor = new StubExecutor();
using (var js = new JsonServer(server, provider, serverSerializer, executor))
using (var jc = new JsonClient(client, provider, clientSerializer))
{
js.Start();
var ex = Assert.ThrowsAsync <InvalidRequestException>(() => Assert_NotTimedOut(jc.ConnectAsync(), timeout: Task.Delay(200)));
// note: JsonServicesException.MessageId is lost
// when an exception is translated to Error and back again
Assert.IsNull(ex.MessageId);
}
}
