public async Task <StartTlsResult> TryStartTls(Stream networkStream)
{
try
{
using (IStreamReader streamReader =
new StreamReaderWrapper(networkStream, Encoding.ASCII, true, 1024, true))
{
using (IStreamWriter streamWriter =
new StreamWriterWrapper(networkStream, Encoding.ASCII, 1024, true)
{
AutoFlush = true,
NewLine = LineEnding
})
{
SmtpResponse response1 = await _smtpDeserializer.Deserialize(streamReader);
_log.Debug($"<: {response1}");
if (response1.Responses.FirstOrDefault()?.ResponseCode != ResponseCode.ServiceReady)
{
return(new StartTlsResult(false, response1.Responses.Select(_ => _.ToString()).ToList(),
"The server did not present a service ready response code (220)."));
}
EhloCommand ehloCommand = new EhloCommand(_mxSecurityTesterConfig.SmtpHostName);
_log.Debug($">: {ehloCommand.CommandString}");
await _smtpSerializer.Serialize(ehloCommand, streamWriter);
SmtpResponse response2 = await _smtpDeserializer.Deserialize(streamReader);
_log.Debug($"<: {response2}");
if (!response2.Responses.Any(_ =>
_.Value.ToLower() == Starttls && _.ResponseCode == ResponseCode.Ok))
{
return(new StartTlsResult(false, response2.Responses.Select(_ => _.ToString()).ToList(),
"The server did not present a STARTTLS command with a response code (250)."));
}
StartTlsCommand startTlsCommand = new StartTlsCommand();
_log.Debug($">: {startTlsCommand.CommandString}");
await _smtpSerializer.Serialize(startTlsCommand, streamWriter);
SmtpResponse response3 = await _smtpDeserializer.Deserialize(streamReader);
_log.Debug($"<: {response3}");
return(new StartTlsResult(
response3.Responses.FirstOrDefault()?.ResponseCode == ResponseCode.ServiceReady,
response3.Responses.Select(_ => _.Value).ToList(), string.Empty));
}
}
}
catch (Exception e)
{
_log.Error(
$"SMTP session initalization failed with error: {e.Message} {Environment.NewLine} {e.StackTrace}");
return(new StartTlsResult(false, null, e.Message));
}
}
public virtual IEnumerable <Playerstatistic> GetPlayerStatisticFromFiles(IEnumerable <string> files)
{
if (files == null)
{
throw new ArgumentNullException(nameof(files));
}
foreach (var file in files)
{
var rwLock = GetLock(file);
rwLock.EnterUpgradeableReadLock();
try
{
RestoreBackupFile(file, rwLock);
using (var sr = new StreamReaderWrapper(file))
{
string line = null;
while (sr != null && ((line = sr.ReadLine()) != null))
{
Playerstatistic stat = null;
try
{
if (string.IsNullOrWhiteSpace(line))
{
LogProvider.Log.Warn(this, $"Empty line in {file}");
}
/* replace '-' and '_' characters in order to convert back from Modified Base64 (https://en.wikipedia.org/wiki/Base64#Implementations_and_history) */
byte[] byteAfter64 = Convert.FromBase64String(line.Replace('-', '+').Replace('_', '/').Trim());
using (var ms = new MemoryStream(byteAfter64))
{
stat = Serializer.Deserialize <Playerstatistic>(ms);
}
}
catch (Exception ex)
{
LogProvider.Log.Error($@"Could not process the file: {file}{Environment.NewLine}Error at line: {line}{Environment.NewLine}", ex);
}
if (stat != null)
{
yield return(stat);
}
}
}
}
finally
{
rwLock.ExitUpgradeableReadLock();
}
}
}
private void InitializeParserService()
{
List <FileFormatGetter> formatGetters = GetFormatGetters();
Dictionary <FormatEnum, char> delimiters = GetDelimiters();
IStreamReader streamReader = new StreamReaderWrapper();
IFileSystem fileSystemWrapper = new FileSystemWrapper();
ParserService = new ParserService(streamReader, fileSystemWrapper, formatGetters, delimiters);
}
private static T Read <T>(StreamReaderWrapper reader)
where T : struct
{
return(Enum.TryParse(
#if NETSTANDARD2_1_OR_GREATER
new string(reader.Read()),
#else
reader.Read(),
#endif
out T value) ? value : throw StreamReaderWrapper.GetException <T>());
}
private void DeletePlayerStatisticFromFile(string file, HashSet <long> handNumbers)
{
if (!File.Exists(file))
{
return;
}
var rwLock = GetLock(file);
rwLock.EnterWriteLock();
try
{
CreateBackupFile(file);
var lines = new List <string>();
using (var sr = new StreamReaderWrapper(file))
{
string line = null;
while (sr != null && ((line = sr.ReadLine()) != null))
{
if (!TryParsePlayerStatistic(line, file, out Playerstatistic stat))
{
continue;
}
if (!handNumbers.Contains(stat.GameNumber))
{
lines.Add(line);
}
}
}
File.WriteAllLines(file, lines);
DeleteBackupFile(file);
}
catch
{
LogProvider.Log.Error(this, $"Could not delete player statistic from file '{file}'");
throw;
}
finally
{
rwLock.ExitWriteLock();
}
}
private static Guid Read(StreamReaderWrapper reader) => Guid.Parse(reader.ReadString());
protected virtual IEnumerable <Playerstatistic> GetAllPlayerStatisticFromFiles(IEnumerable <string> files, short?pokerSite)
{
if (files == null)
{
throw new ArgumentNullException(nameof(files));
}
var maxThreads = Environment.ProcessorCount + 1;
var runningTasks = new List <Task>();
var fileQueue = new Queue <string>(files);
var stats = new BlockingCollection <Playerstatistic>();
while (fileQueue.Count > 0)
{
while (runningTasks.Count < maxThreads && fileQueue.Count > 0)
{
var file = fileQueue.Dequeue();
runningTasks.Add(Task.Run(() =>
{
var rwLock = GetLock(file);
rwLock.EnterUpgradeableReadLock();
try
{
RestoreBackupFile(file, rwLock);
using (var sr = new StreamReaderWrapper(file))
{
string line = null;
while (sr != null && ((line = sr.ReadLine()) != null))
{
Playerstatistic stat = null;
try
{
if (string.IsNullOrWhiteSpace(line))
{
LogProvider.Log.Warn(this, $"Empty line in {file}");
}
/* replace '-' and '_' characters in order to convert back from Modified Base64 (https://en.wikipedia.org/wiki/Base64#Implementations_and_history) */
byte[] byteAfter64 = Convert.FromBase64String(line.Replace('-', '+').Replace('_', '/').Trim());
using (var ms = new MemoryStream(byteAfter64))
{
stat = Serializer.Deserialize <Playerstatistic>(ms);
}
}
catch (Exception ex)
{
LogProvider.Log.Error($@"Could not process the file: {file}{Environment.NewLine}Error at line: {line}{Environment.NewLine}", ex);
}
if (stat != null &&
(pokerSite.HasValue && stat.PokersiteId == pokerSite || !pokerSite.HasValue))
{
stats.Add(stat);
}
}
}
}
finally
{
rwLock.ExitUpgradeableReadLock();
}
}));
}
var completedTask = Task.WhenAny(runningTasks).Result;
runningTasks.Remove(completedTask);
}
Task.WhenAll(runningTasks).Wait();
return(stats.ToList());
}
public virtual IDictionary <string, T> GetPlayersIndicators <T>(string[] playerNames, short?pokersiteId)
where T : Indicators, IThreadSafeIndicators
{
try
{
Players[] players;
// get players ids
using (var session = ModelEntities.OpenStatelessSession())
{
players = session.Query <Players>()
.Where(x => playerNames.Contains(x.Playername) && x.PokersiteId == pokersiteId)
.ToArray();
}
var playersStatFiles = (from player in players
from file in GetPlayerFiles(player.PlayerId)
select new PlayerStatFile {
Player = player, File = file
}).ToArray();
var maxThreads = Environment.ProcessorCount + 1;
var runningTasks = new List <Task>();
var fileQueue = GetPlayerStatFileQueue(playersStatFiles);
var playersIndicators = (from playersStatFile in playersStatFiles
group playersStatFile by playersStatFile.Player.Playername into grouped
where grouped.Any()
let indicators = Activator.CreateInstance <T>()
select new { grouped.Key, Indicators = indicators }).ToDictionary(x => x.Key, x => x.Indicators);
while (fileQueue.Count > 0)
{
while (runningTasks.Count < maxThreads && fileQueue.Count > 0)
{
var playerStatFile = fileQueue.Dequeue();
runningTasks.Add(Task.Run(() =>
{
var rwLock = GetLock(playerStatFile.File);
rwLock.EnterUpgradeableReadLock();
try
{
RestoreBackupFile(playerStatFile.File, rwLock);
using (var sr = new StreamReaderWrapper(playerStatFile.File))
{
string line = null;
while (sr != null && ((line = sr.ReadLine()) != null))
{
if (!TryParsePlayerStatistic(line, playerStatFile.File, out Playerstatistic stat) || stat == null)
{
continue;
}
var indicators = playersIndicators[playerStatFile.Player.Playername];
indicators.AddStatistic(stat);
}
}
}
catch (Exception ex)
{
LogProvider.Log.Error(this, $"Failed to build indicators for {string.Join(", ", playerNames)} by reading '{playerStatFile.File}' [{pokersiteId}]", ex);
}
finally
{
rwLock.ExitUpgradeableReadLock();
}
}));
}
var completedTask = Task.WhenAny(runningTasks).Result;
runningTasks.Remove(completedTask);
}
Task.WhenAll(runningTasks).Wait();
return(playersIndicators);
}
catch (Exception e)
{
LogProvider.Log.Error(this, $"Could not build indicators for {string.Join(", ", playerNames)} [{pokersiteId}]", e);
}
return(null);
}
public void Set(World world, StreamReaderWrapper reader) => world.Set(_converter(Converter <TIn> .Read(reader)));
