private async Task Connect(GameServer server)
{
var log = new LogReceiver(
server.ServerConfiguration.LogPort,
server.ServerConfiguration.EndPoint
);
log.Listen <ChatMessage>(server.ChatReceived);
log.Listen <KillFeed>(server.KillReceived);
log.Listen <PlayerConnected>(connected =>
{
server.Players.Add(connected.Player);
server.ServerInfoUpdated();
});
log.Listen <PlayerDisconnected>(disconnected =>
{
var player = server.Players.FirstOrDefault(p => p.ClientId == disconnected.Player.ClientId);
if (player == null)
{
return;
}
server.Players.Remove(player);
server.ServerInfoUpdated();
});
log.Listen <NameChange>(change =>
{
var player = server.Players.FirstOrDefault(p => p.ClientId == change.Player.ClientId);
if (player == null)
{
return;
}
player.Name = change.NewName;
server.ServerInfoUpdated();
});
server.Connected = true;
server.ServerInfoUpdated();
await Task.Delay(-1);
}
private async void Start()
{
//Let's start the listener on our listen port. Allow all IPs from the server list.
_ = _logHandler.LogMessage($"Starting SRCDSLogService on {_port}", channel: false);
_logReceiver = new LogReceiver(_port, CreateIpEndPoints());
await Task.Run(() =>
{
if (_dataService.RSettings.ProgramSettings.Debug)
{
_logReceiver.ListenRaw(msg => { Console.WriteLine($"RAW LOG FROM {_logReceiver.lastServer.Address}: " + msg); });
}
_logReceiver.Listen <GenericCommand>(genericCommand => { HandleIngameCommand(_logReceiver.lastServer, genericCommand); });
});
//We are going to use this loop to make sure log services are still running. Should they fail, we will tear
//down and rebuild.
while (true)
{
bool portBound = IPGlobalProperties.GetIPGlobalProperties()
.GetActiveUdpListeners().Any(p => p.Port == _port);
if (!portBound)
{
if (_restartCount < RESTART_LIMIT)
{
try
{
_logReceiver.Dispose();
}
catch (Exception e)
{
await _logHandler.LogMessage($"Attempted dispose, but had an issue.\n{e}", alert : true, color : LOG_COLOR);
}
_restartCount++;
//Restart the service
Start();
await _logHandler.LogMessage($"Log service has been restarted {_restartCount} times!", color : LOG_COLOR);
//Reset the retry count in 15 minutes after the first issue
//I expect the log service to die sometimes for whatever reason.
if (_restartCount == 0)
{
_ = Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMinutes(15));
_restartCount = 0;
});
}
}
else
{
await _logHandler.LogMessage($"The SrcdsLogService has restarted over {RESTART_LIMIT} in the last 15 minutes. " +
$"I will not restart the service again.", alert : true, color : LOG_COLOR);
}
return;
}
//Hol up for a bit before rechecking
await Task.Delay(5000);
}
}
/// <summary>
/// Example program for CoreRCON.
/// </summary>
internal static void Main(string[] args)
{
var task = Task.Run(async() =>
{
var ip = "192.168.1.8"; // "162.248.93.211"; //
var endpoint = new IPEndPoint(
IPAddress.Parse(ip),
27015
);
var rcon = new RCON(endpoint, "rcon");
var log = new LogReceiver(0, endpoint);
var players = await ServerQuery.Players(endpoint);
var info = await ServerQuery.Info(endpoint, ServerQuery.ServerType.Source) as SourceQueryInfo;
Console.WriteLine($"Connected to server with {players.Length} players. Map is {info.Map} in game {info.Game} running on {info.Environment}");
// Tell the server to send logs here
await rcon.SendCommandAsync($"logaddress_add 192.168.1.8:{log.ResolvedPort}");
rcon.OnDisconnected += () =>
{
Console.WriteLine("Server closed connection!");
};
var status = await rcon.SendCommandAsync <Status>("status");
Console.WriteLine($"Got status, hostname is: {status.Hostname}");
// Listen for chat messages
log.Listen <ChatMessage>(chat =>
{
Console.WriteLine($"Chat message: {chat.Player.Name} said {chat.Message} on channel {chat.Channel}");
});
// Listen for kills
log.Listen <KillFeed>(kill =>
{
Console.WriteLine($"Player {kill.Killer.Name} ({kill.Killer.Team}) killed {kill.Killed.Name} ({kill.Killed.Team}) with {kill.Weapon}");
});
log.Listen <PlayerConnected>(connection =>
{
Console.WriteLine($"Player {connection.Player.Name} connected with host {connection.Host}");
});
log.Listen <PlayerDisconnected>(dis =>
{
Console.WriteLine($"Player {dis.Player.Name} disconnected");
});
log.Listen <NameChange>(name =>
{
Console.WriteLine($"{name.Player.Name} changed name to {name.NewName}");
});
// Never stop
await Task.Delay(-1);
});
// .Wait() puts exceptions into an AggregateException, while .GetResult() doesn't
task.GetAwaiter().GetResult();
}
private void StartListeners(LogReceiver logReceiver)
{
logReceiver.Listen <ChatMessage>(chat =>
{
ProcessChatMessage(chat);
});
logReceiver.Listen <RoundEndScores>(roundEndScore =>
{
if (Match.IsLive)
{
Match.CTScore = roundEndScore.CTScore + Match.CtSwapScore;
Match.TScore = roundEndScore.TScore + Match.TSwapScore;
if (Match.CTScore + Match.TScore == 15 || ((Match.CTScore + Match.TScore) > 29 && (Match.CTScore + Match.TScore) % 3 == 0))
{
Match.CtSwapScore = Match.TScore;
Match.TSwapScore = Match.CTScore;
}
if ((Match.CTScore + Match.TScore) == 15 || Match.ShouldSwapSides(Match.CTScore + Match.TScore))
{
Match.SwapSides();
Match.Paused = true;
ProcessSwapSides();
}
ProcessScoreUpdate();
}
});
logReceiver.ListenRaw(result => { ProcessRaw(result); });
logReceiver.Listen <KillFeed>(e =>
{
});
logReceiver.Listen <MatchLive>(live =>
{
Match.MapName = live.MapName;
Match.IsLive = true;
ProcessMatchStarting(Match);
});
logReceiver.Listen <CTTeamName>(ctSide =>
{
Match.CTName = ctSide.CTName;
});
logReceiver.Listen <TTeamName>(tSide =>
{
Match.TName = tSide.TName;
});
logReceiver.Listen <StartFreezeTime>(startfreezeTime =>
{
Match.IsFreezeTime = true;
});
logReceiver.Listen <EndFreezeTime>(endFreezeTime =>
{
if (Match.Paused == true)
{
ProcessUnpauseMatch();
}
Match.IsFreezeTime = false;
Match.Paused = false;
});
logReceiver.Listen <MatchEnd>(matchEnd =>
{
Console.WriteLine(matchEnd.MatchId);
ProcessMatchEnd(matchEnd.MatchId);
Match.EndMatch();
});
}
