private Task StartConnectionAsync()
{
var server = ServerQuery.GetServerInstance(EngineType.Source, this.endpoint);
this.console = server.GetControl(this.password);
return(Task.FromResult(true));
}
private async Task ReconnectRcon()
{
await Task.Run(() =>
{
try
{
_rconServer?.Dispose();
_rconServer = null;
_rconServer = ServerQuery.GetServerInstance(QueryMaster.EngineType.Source, _config.Ip, (ushort)_config.RconPort, false, 2000, 5000, 1, true);
_rconServer?.GetControl(_config.RconPassword);
}
catch (SocketException)
{
_rconServer?.Dispose();
_rconServer = null;
}
catch (Exception ex)
{
_rconServer?.Dispose();
_rconServer = null;
Logging.LogException($"Error when connecting to server rcon ({_config.Ip}, {_config.RconPort})", ex, typeof(SteamManager), LogLevel.WARN, ExceptionLevel.Ignored);
}
});
}
private EmbedBuilder GetEmbedBuilder(string ip, ushort port)
{
var server = ServerQuery.GetServerInstance(EngineType.Source, ip, port, sendTimeout: 1000,
receiveTimeout: 1000, throwExceptions: true);
return(GetSourceServerReplyEmbed(server));
}
public static async void UpdateServerAsync()
{
await Task.Run(() =>
{
Server gta1 = ServerQuery.GetServerInstance(Game.Arma_3, "164.132.200.53", 2303, false, 1000, 1000, 0);
Server gta2 = ServerQuery.GetServerInstance(Game.Arma_3, "164.132.202.63", 2603, false, 1000, 1000, 0);
Server gta3 = ServerQuery.GetServerInstance(Game.Arma_3, "164.132.202.63", 2303, false, 1000, 1000, 0);
while (true)
{
ServerInfo info1 = gta1.GetInfo();
ServerInfo info2 = gta2.GetInfo();
ServerInfo info3 = gta3.GetInfo();
if (Application.Current != null)
{
Application.Current.Dispatcher.Invoke(async() =>
{
ShowServerInfo(info1, Win.TextBlockServer1, Win.JoinServer1Button);
ShowServerInfo(info2, Win.TextBlockServer2, Win.JoinServer2Button);
ShowServerInfo(info3, Win.TextBlockServer3, Win.JoinServer3Button);
await ScrapGTA(Win.TextBlockTs);
});
}
Task.Delay(15_000);
}
});
}
private void UpdateDataGrid()
{
ThreadPool.SetMinThreads(1, 1);
ThreadPool.SetMaxThreads(8, 8);
foreach (var item in server_config)
{
ThreadPool.QueueUserWorkItem(_ =>
{
Tuple <string, ushort> tp = item;
Server server = ServerQuery.GetServerInstance(EngineType.Source, tp.Item1, tp.Item2, false, 1000, 1000);
var server_info = server.GetInfo();
this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart) delegate()
{
if (server_info != null)
{
serverData.Add(new ServerInfoPreview()
{
Map = server_info.Map,
Name = server_info.Name,
Players = string.Format("{0}/{1}", server_info.Players, server_info.MaxPlayers),
Host = tp.Item1,
Port = tp.Item2,
Ping = server_info.Ping
});;
dataGrid.Items.Refresh();
}
});
});
}
}
public void WhitelistPlayers(ArenaStars.Models.Game _game)
{
try
{
ArenaStarsContext db = new ArenaStarsContext();
var findGame = from x in db.Games
where x.Id == _game.Id
select x;
Models.Game g = findGame.FirstOrDefault();
User playerA = g.Participants.FirstOrDefault();
User playerB = g.Participants.LastOrDefault();
//Add players to the whitelist
string playerAID = "\"" + playerA.SteamId + "\"";
string playerBID = "\"" + playerB.SteamId + "\"";
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
if (server.GetControl("lol"))
{
server.Rcon.SendCommand("sm_whitelist_add " + playerAID);
server.Rcon.SendCommand("sm_whitelist_add " + playerBID);
}
}
catch (Exception ex)
{
using (StreamWriter writer = new StreamWriter(errorsPath, true))
{
writer.WriteLine("Message :" + ex.Message + "<br/>" + Environment.NewLine + "StackTrace :" + ex.StackTrace + Environment.NewLine + "Innerexception :" + ex.InnerException +
"" + Environment.NewLine + "Date :" + DateTime.Now.ToString());
writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
}
}
}
public void WaitForPlayers()
{
try
{
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
server.ReceiveTimeout = 200;
bool stop = false;
while (!stop)
{
ServerInfo info = server.GetInfo();
if (info.Players == 2)
{
stop = true;
}
Thread.Sleep(10000);
}
}
catch (Exception ex)
{
using (StreamWriter writer = new StreamWriter(errorsPath, true))
{
writer.WriteLine("Message :" + ex.Message + "<br/>" + Environment.NewLine + "StackTrace :" + ex.StackTrace + Environment.NewLine + "Innerexception :" + ex.InnerException +
"" + Environment.NewLine + "Date :" + DateTime.Now.ToString());
writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
}
}
}
private bool Reconnect()
{
if (this.console != null)
{
this.console.Dispose();
this.console = null;
}
try
{
var endpoint = new IPEndPoint(IPAddress.Parse(this.snapshot.ServerIP), this.snapshot.RCONPort);
var server = ServerQuery.GetServerInstance(EngineType.Source, endpoint);
this.console = server.GetControl(this.snapshot.AdminPassword);
return(true);
}
catch (Exception ex)
{
_logger.Debug("Failed to connect to RCON at {0}:{1} with {2}: {3}\n{4}",
this.snapshot.ServerIP,
this.snapshot.RCONPort,
this.snapshot.AdminPassword,
ex.Message,
ex.StackTrace);
return(false);
}
}
public ServerInfo GetServerData()
{
using (QueryMaster.GameServer.Server s = ServerQuery.GetServerInstance(EngineType.Source, new IPEndPoint(this.serverConnectionInfo.ServerIP, this.serverConnectionInfo.ServerQueryPort)))
{
return(s.GetInfo());
}
}
// shared update code
#region UpdateServerAndDetails()
private void UpdateServerAndDetails(UpdateRequest request, ServerRow row, bool fireRefreshSingleServerComplete)
{
string status = "";
try
{
if (request.IsCancelled)
{
return;
}
using (Server server = ServerQuery.GetServerInstance(EngineType.Source, row.EndPoint, false, request.Timeout, request.Timeout))
{
row.Retries = 0;
server.SendFirstPacketTwice = this.sendFirstUdpPacketTwice;
server.Retries = 3;
status = "timeout";
if (this.UpdateServerInfo(request, row, server))
{
row.GameExtension = gameExtensions.Get((Game)(row.ServerInfo.Extra?.GameId ?? row.ServerInfo.Id));
this.UpdatePlayers(request, row, server);
this.UpdateRules(request, row, server);
status = "ok";
}
row.RequestTimestamp = request.Timestamp;
}
if (request.IsCancelled) // status might have changed
{
return;
}
if (row.Retries > 0)
{
status += " (" + row.Retries + ")";
}
}
catch
{
// this happens when you hibernate windows and the program resumes before the network connection has be reestablished
status = "network error";
}
finally
{
row.Status = status;
row.Update();
request.SetDataModified();
if (fireRefreshSingleServerComplete && !request.IsCancelled)
{
this.RefreshSingleServerComplete?.Invoke(this, new ServerEventArgs(row));
}
if (!request.PendingTasks.IsSet)
{
request.PendingTasks.Signal();
}
}
}
public void StartGame()
{
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
if (server.GetControl("lol"))
{
server.Rcon.SendCommand("1on1");
}
}
/// <summary>
/// Request current online players from the gameserver
/// <para>This includes players who are still in process of joining the server but aren't actually in the server yet e.g. loading the map</para>
/// </summary>
/// <param name="forceRetries">Amount of tries that should be attempted to retrieve playerlist from CSGO gameserver</param>
/// <returns></returns>
public List <PlayerInfo> GetPlayersForced(int forceRetries)
{
Config.Log("GetPlayersForced(): Called");
QueryMasterCollection <PlayerInfo> playerList = new QueryMasterCollection <PlayerInfo>(new List <PlayerInfo>());
CurrentServer = ServerQuery.GetServerInstance(EngineType.Source, Config.ServerIP, Config.ServerPort, false, serverSendTimeOut, serverReceiveTimeOut, requestAmount, throwExceptions);
int retries = 0;
int currentServerSendTimeOut = serverSendTimeOut;
int currentServerReceiveTimeOut = serverReceiveTimeOut;
int currentRequestAmount = requestAmount;
while (playerList.Count < 1 && retries < forceRetries)
{
try
{
playerList = CurrentServer.GetPlayers();
}
catch (Exception ex)
{
Config.Log("Exception in request:");
Config.Log(ex.Message);
Config.Log("");
}
if (playerList == null)
{
playerList = new QueryMasterCollection <PlayerInfo>(new List <PlayerInfo>());
}
CurrentServer.Dispose();
CurrentServer = ServerQuery.GetServerInstance(EngineType.Source, Config.ServerIP, Config.ServerPort, false, currentServerSendTimeOut, currentServerReceiveTimeOut, currentRequestAmount, throwExceptions);
retries++;
Config.Log($"GetPlayersForced(): List count: {playerList.Count} Try: {retries} RequestAmount: {currentRequestAmount} SendTimeOut: {currentServerSendTimeOut} ReceiveTimeOut: {currentServerReceiveTimeOut}");
}
List <PlayerInfo> sortedList = new List <PlayerInfo>();
if (playerList.Count > 1)
{
Config.Log("GetPlayers(): Sorting list...SUCCESS");
sortedList = playerList.ToList();
sortedList = sortedList.OrderBy(playerInfo => playerInfo.Name).ToList();
}
else
{
Config.Log("GetPlayers(): FAILED");
}
Config.Log($"GetPlayersForced(): DONE {retries} retries needed");
return(sortedList);
}
// This method is used by our background worker to query each server on the
// background thread and update the server info in the list
public static List <UpdatesModel> bgUpdater(List <string> addresses)
{
List <UpdatesModel> results = new List <UpdatesModel>();
string pw = decryptRcon();
foreach (string address in addresses)
{
Tuple <string, UInt16> addr = splitAddr(address);
string addrIP = addr.Item1;
string score;
UInt16 port = addr.Item2;
using (var server = ServerQuery.GetServerInstance(
(Game)appId,
addrIP,
port,
throwExceptions: false,
retries: 0,
sendTimeout: timeout,
receiveTimeout: timeout))
{
var serverInfo = server.GetInfo();
// If score check is disabled, skip it
if (Properties.Settings.Default.disableScore)
{
score = "Disabled";
results.Add(new UpdatesModel(serverInfo, score));
}
else if (!String.IsNullOrEmpty(pw))
{
score = getPugScore(server, pw);
if (score.Contains("Bad"))
{
score = "Bad password..";
Console.WriteLine("Bad pass..");
rconFailCount++;
results.Add(new UpdatesModel(serverInfo, score));
}
else
{
results.Add(new UpdatesModel(serverInfo, score));
}
}
else
{
score = "No RCON PW";
results.Add(new UpdatesModel(serverInfo, score));
}
}
}
return(results);
}