public MonthlyHeuristicsExtractor(
LogFileInfo logFileInfo,
LogFileStreamReaderFactory logFileStreamReaderFactory,
IWurmApiLogger logger, [NotNull] IWurmApiConfig wurmApiConfig)
{
if (logFileInfo == null)
{
throw new ArgumentNullException(nameof(logFileInfo));
}
if (logFileStreamReaderFactory == null)
{
throw new ArgumentNullException(nameof(logFileStreamReaderFactory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (wurmApiConfig == null)
{
throw new ArgumentNullException(nameof(wurmApiConfig));
}
this.logFileInfo = logFileInfo;
this.logFileStreamReaderFactory = logFileStreamReaderFactory;
this.logger = logger;
this.wurmApiConfig = wurmApiConfig;
}
public WurmCharacterLogs(
[NotNull] IWurmCharacter character,
[NotNull] IWurmServerGroups serverGroups,
[NotNull] IWurmLogsHistory logsHistory,
[NotNull] IWurmServers wurmServers,
[NotNull] IWurmApiLogger logger)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
if (serverGroups == null)
{
throw new ArgumentNullException(nameof(serverGroups));
}
if (logsHistory == null)
{
throw new ArgumentNullException(nameof(logsHistory));
}
if (wurmServers == null)
{
throw new ArgumentNullException(nameof(wurmServers));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.character = character;
this.logsHistory = logsHistory;
this.logger = logger;
}
public CharacterLogsMonitorEngineFactory(
IWurmApiLogger logger,
SingleFileMonitorFactory singleFileMonitorFactory,
IWurmCharacterLogFiles wurmCharacterLogFiles,
[NotNull] IInternalEventAggregator internalEventAggregator)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (singleFileMonitorFactory == null)
{
throw new ArgumentNullException(nameof(singleFileMonitorFactory));
}
if (wurmCharacterLogFiles == null)
{
throw new ArgumentNullException(nameof(wurmCharacterLogFiles));
}
if (internalEventAggregator == null)
{
throw new ArgumentNullException(nameof(internalEventAggregator));
}
this.logger = logger;
this.singleFileMonitorFactory = singleFileMonitorFactory;
this.wurmCharacterLogFiles = wurmCharacterLogFiles;
this.internalEventAggregator = internalEventAggregator;
}
public LogsMonitorEngineManager(
[NotNull] CharacterName characterName,
[NotNull] CharacterLogsMonitorEngineFactory characterLogsMonitorEngineFactory,
[NotNull] IPublicEventInvoker publicEventInvoker,
[NotNull] IWurmApiLogger logger,
[NotNull] IInternalEventInvoker internalEventInvoker)
{
if (characterName == null)
{
throw new ArgumentNullException(nameof(characterName));
}
if (characterLogsMonitorEngineFactory == null)
{
throw new ArgumentNullException(nameof(characterLogsMonitorEngineFactory));
}
if (publicEventInvoker == null)
{
throw new ArgumentNullException(nameof(publicEventInvoker));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (internalEventInvoker == null)
{
throw new ArgumentNullException(nameof(internalEventInvoker));
}
this.characterName = characterName;
this.publicEventInvoker = publicEventInvoker;
this.logger = logger;
this.internalEventInvoker = internalEventInvoker;
engine = characterLogsMonitorEngineFactory.Create(characterName);
}
/// <summary>
/// Attempts to parse server name from a log entry.
/// Null if parsing failed.
/// </summary>
/// <param name="logEntry"></param>
/// <param name="logger">Optional, will log parsing errors.</param>
/// <param name="sourceCharacterName">Optional, will be appended to log message.</param>
/// <returns></returns>
public static ServerStamp TryGetServerFromLogEntry(this LogEntry logEntry, IWurmApiLogger logger = null, CharacterName sourceCharacterName = null)
{
ServerStamp result = null;
// attempt some faster matchers first, before trying actual parse
if (Regex.IsMatch(logEntry.Content, @"other players are online", RegexOptions.Compiled))
{
result = TryGetMatchResult(TryMatch1(logEntry), logEntry);
if (result == null)
{
result = TryGetMatchResult(TryMatch2(logEntry), logEntry);
}
if (result == null)
{
logger?.Log(
LogLevel.Warn,
string.Format(
"ServerHistoryProvider found 'other players are online' log line, but could not parse it. Character: {0} Entry: {1}",
sourceCharacterName,
logEntry),
"ServerParsingHelper",
null);
}
}
return(result);
}
public DataBuilderV2(string logFileName, DateTime today, IWurmApiLogger logger)
{
if (logFileName == null)
{
throw new ArgumentNullException(nameof(logFileName));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logFileName = logFileName;
this.today = today;
this.logger = logger;
var logDate = ParsingHelper.GetDateFromLogFileName(logFileName);
if (logDate.LogSavingType != LogSavingType.Monthly)
{
throw new WurmApiException("This builder can only be used for monthly log files, actual file name: " + logFileName);
}
ProcessedLogDate = logDate.DateTime;
DayCountInThisLogMonth = ParsingHelper.GetDaysInMonthForLogFile(logFileName);
ThisLogIsForCurrentMonth = ProcessedLogDate.Year == today.Year && ProcessedLogDate.Month == today.Month;
}
public SkillDumpsManager([NotNull] IWurmCharacter character, [NotNull] IWurmPaths wurmPaths, IWurmApiLogger logger)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
if (wurmPaths == null)
{
throw new ArgumentNullException(nameof(wurmPaths));
}
this.character = character;
this.logger = logger;
skillDumpsDirectory = new DirectoryInfo(wurmPaths.GetSkillDumpsFullPathForCharacter(character.Name));
skillDumpsDirectory.Create();
skillDumpFilesMonitor = new FileSystemWatcher()
{
Path = skillDumpsDirectory.FullName,
IncludeSubdirectories = false
};
skillDumpFilesMonitor.Created += SkillDumpFilesMonitorOnChanged;
skillDumpFilesMonitor.Changed += SkillDumpFilesMonitorOnChanged;
skillDumpFilesMonitor.Renamed += SkillDumpFilesMonitorOnChanged;
skillDumpFilesMonitor.Deleted += SkillDumpFilesMonitorOnChanged;
skillDumpFilesMonitor.EnableRaisingEvents = true;
}
public LogFileParserFactory(IWurmApiLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger;
}
public PersObjErrorHandlingStrategy([NotNull] IWurmApiLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger;
}
public SkillEntryParser([NotNull] IWurmApiLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger;
}
public ThreadPoolMarshaller([NotNull] IWurmApiLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger;
}
internal WurmLogFiles(IWurmCharacterDirectories wurmCharacterDirectories, IWurmApiLogger logger, IWurmLogDefinitions wurmLogDefinitions,
[NotNull] IInternalEventAggregator eventAggregator, [NotNull] IInternalEventInvoker internalEventInvoker,
[NotNull] TaskManager taskManager, [NotNull] IWurmPaths wurmPaths)
{
if (wurmCharacterDirectories == null)
{
throw new ArgumentNullException(nameof(wurmCharacterDirectories));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (wurmLogDefinitions == null)
{
throw new ArgumentNullException(nameof(wurmLogDefinitions));
}
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
if (internalEventInvoker == null)
{
throw new ArgumentNullException(nameof(internalEventInvoker));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
if (wurmPaths == null)
{
throw new ArgumentNullException(nameof(wurmPaths));
}
this.wurmCharacterDirectories = wurmCharacterDirectories;
this.logger = logger;
this.wurmLogDefinitions = wurmLogDefinitions;
this.eventAggregator = eventAggregator;
this.internalEventInvoker = internalEventInvoker;
this.taskManager = taskManager;
this.wurmPaths = wurmPaths;
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial WurmLogFiles refresh", this, exception);
}
eventAggregator.Subscribe(this);
taskHandle = new TaskHandle(Refresh, "WurmLogFiles refresh");
taskManager.Add(taskHandle);
taskHandle.Trigger();
}
void ClearDir(string directoryPath, IWurmApiLogger logger)
{
var di = new DirectoryInfo(directoryPath);
if (di.Exists)
{
di.Delete(recursive: true);
logger.Log(LogLevel.Info, "Clearing cache completed for dir " + directoryPath, this, null);
}
}
public ServerHistoryProvider(
[NotNull] CharacterName characterName,
[NotNull] IPersistent <PersistentModel.ServerHistory> persistentData,
[NotNull] IWurmLogsMonitorInternal logsMonitor,
[NotNull] IWurmLogsHistory logsSearcher,
[NotNull] IWurmServerList wurmServerList,
[NotNull] IWurmApiLogger logger,
[NotNull] IWurmCharacterLogFiles wurmCharacterLogFiles,
[NotNull] IInternalEventAggregator eventAggregator)
{
if (characterName == null)
{
throw new ArgumentNullException(nameof(characterName));
}
if (persistentData == null)
{
throw new ArgumentNullException(nameof(persistentData));
}
if (logsMonitor == null)
{
throw new ArgumentNullException(nameof(logsMonitor));
}
if (logsSearcher == null)
{
throw new ArgumentNullException(nameof(logsSearcher));
}
if (wurmServerList == null)
{
throw new ArgumentNullException(nameof(wurmServerList));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (wurmCharacterLogFiles == null)
{
throw new ArgumentNullException(nameof(wurmCharacterLogFiles));
}
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
this.characterName = characterName;
sortedServerHistory = new SortedServerHistory(persistentData);
this.persistentData = persistentData;
this.logsMonitor = logsMonitor;
this.logsSearcher = logsSearcher;
this.wurmServerList = wurmServerList;
this.logger = logger;
this.wurmCharacterLogFiles = wurmCharacterLogFiles;
this.eventAggregator = eventAggregator;
eventAggregator.Subscribe(this);
logsMonitor.SubscribeInternal(characterName, LogType.Event, HandleEventLogEntries);
}
public static IWurmApiLogger RedirectToTraceOut(this IWurmApiLogger logger, bool verbose = false)
{
logger.Arrange(
logger1 => logger1.Log(Arg.IsAny <LogLevel>(), Arg.AnyString, Arg.AnyObject, Arg.IsAny <Exception>())).DoInstead(
(LogLevel l, string m, object s, Exception e) =>
{
Trace.WriteLine(string.Format("Logged: {0}: {1}\r\nat {2} {3}", l, m, s,
FormatException(verbose, e)));
});
return(logger);
}
public TaskManager([NotNull] IWurmApiLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger;
CycleDelayMillis = 100;
runner = new Task(JobRunner, TaskCreationOptions.LongRunning);
runner.Start();
}
internal WurmConfigs(
[NotNull] IWurmConfigDirectories wurmConfigDirectories,
[NotNull] IWurmApiLogger logger, [NotNull] IPublicEventInvoker publicEventInvoker,
[NotNull] IInternalEventAggregator eventAggregator, [NotNull] TaskManager taskManager)
{
if (wurmConfigDirectories == null)
{
throw new ArgumentNullException(nameof(wurmConfigDirectories));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (publicEventInvoker == null)
{
throw new ArgumentNullException(nameof(publicEventInvoker));
}
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
this.wurmConfigDirectories = wurmConfigDirectories;
this.logger = logger;
this.publicEventInvoker = publicEventInvoker;
this.eventAggregator = eventAggregator;
this.taskManager = taskManager;
onAvailableConfigsChanged = publicEventInvoker.Create(
() => AvailableConfigsChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
onAnyConfigChanged = publicEventInvoker.Create(
() => AnyConfigChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial configs update", this, exception);
}
taskHandle = new TaskHandle(Refresh, "WurmConfigs update");
taskManager.Add(taskHandle);
eventAggregator.Subscribe(this);
taskHandle.Trigger();
}
public LogFileInfoFactory(IWurmLogDefinitions wurmLogDefinitions, IWurmApiLogger logger)
{
if (wurmLogDefinitions == null)
{
throw new ArgumentNullException(nameof(wurmLogDefinitions));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.wurmLogDefinitions = wurmLogDefinitions;
this.logger = logger;
}
public LogsScanner(
[NotNull] LogSearchParameters logSearchParameters,
[NotNull] JobCancellationManager cancellationManager,
[NotNull] IWurmLogFiles wurmLogFiles,
[NotNull] MonthlyLogFilesHeuristics monthlyHeuristics,
[NotNull] LogFileStreamReaderFactory streamReaderFactory,
[NotNull] IWurmApiLogger logger,
[NotNull] LogFileParserFactory logFileParserFactory,
[NotNull] IWurmApiConfig wurmApiConfig)
{
if (logSearchParameters == null)
{
throw new ArgumentNullException(nameof(logSearchParameters));
}
if (cancellationManager == null)
{
throw new ArgumentNullException(nameof(cancellationManager));
}
if (wurmLogFiles == null)
{
throw new ArgumentNullException(nameof(wurmLogFiles));
}
if (monthlyHeuristics == null)
{
throw new ArgumentNullException(nameof(monthlyHeuristics));
}
if (streamReaderFactory == null)
{
throw new ArgumentNullException(nameof(streamReaderFactory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (logFileParserFactory == null)
{
throw new ArgumentNullException(nameof(logFileParserFactory));
}
if (wurmApiConfig == null)
{
throw new ArgumentNullException(nameof(wurmApiConfig));
}
this.logSearchParameters = logSearchParameters;
this.cancellationManager = cancellationManager;
this.wurmLogFiles = wurmLogFiles;
this.monthlyHeuristics = monthlyHeuristics;
this.streamReaderFactory = streamReaderFactory;
this.logger = logger;
this.logFileParserFactory = logFileParserFactory;
this.wurmApiConfig = wurmApiConfig;
}
internal WurmConfig(string gameSettingsFullPath, [NotNull] IPublicEventInvoker publicEventMarshaller,
[NotNull] TaskManager taskManager, IWurmApiLogger logger)
{
if (gameSettingsFullPath == null)
{
throw new ArgumentNullException(nameof(gameSettingsFullPath));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
gameSettingsFileInfo = new FileInfo(gameSettingsFullPath);
if (gameSettingsFileInfo.Directory == null)
{
throw new WurmApiException("gameSettingsFileInfo.Directory is null, provided file raw path: "
+ gameSettingsFullPath);
}
Name = gameSettingsFileInfo.Directory.Name;
this.taskManager = taskManager;
onConfigChanged = publicEventMarshaller.Create(() => ConfigChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
configReader = new ConfigReader(this);
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial config update: " + Name, this, exception);
}
configFileWatcher = new FileSystemWatcher(gameSettingsFileInfo.Directory.FullName)
{
Filter = gameSettingsFileInfo.Name,
NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite
};
configFileWatcher.Changed += ConfigFileWatcherOnChanged;
configFileWatcher.Created += ConfigFileWatcherOnChanged;
configFileWatcher.Deleted += ConfigFileWatcherOnChanged;
configFileWatcher.Renamed += ConfigFileWatcherOnChanged;
configFileWatcher.EnableRaisingEvents = true;
taskHandle = new TaskHandle(Refresh, "WurmConfig update: " + Name);
taskManager.Add(taskHandle);
taskHandle.Trigger();
}
public WurmServerHistory(
[NotNull] string dataDirectoryFullPath,
[NotNull] IWurmLogsHistory wurmLogsHistory,
IWurmServerList wurmServerList,
IWurmApiLogger logger,
IWurmLogsMonitorInternal wurmLogsMonitor,
IWurmLogFiles wurmLogFiles,
IInternalEventAggregator internalEventAggregator,
[NotNull] IWurmServerGroups wurmServerGroups,
[NotNull] IWurmApiConfig wurmApiConfig)
{
if (dataDirectoryFullPath == null)
{
throw new ArgumentNullException(nameof(dataDirectoryFullPath));
}
if (wurmLogsHistory == null)
{
throw new ArgumentNullException(nameof(wurmLogsHistory));
}
if (wurmServerGroups == null)
{
throw new ArgumentNullException(nameof(wurmServerGroups));
}
if (wurmApiConfig == null)
{
throw new ArgumentNullException(nameof(wurmApiConfig));
}
this.wurmLogsHistory = wurmLogsHistory;
this.wurmServerGroups = wurmServerGroups;
this.wurmApiConfig = wurmApiConfig;
IPersistenceStrategy persistenceStrategy = new FlatFilesPersistenceStrategy(dataDirectoryFullPath);
var persistentLibrary =
new PersistentCollectionsLibrary(persistenceStrategy,
new PersObjErrorHandlingStrategy(logger));
var collection = persistentLibrary.GetCollection("serverhistory");
var providerFactory = new ServerHistoryProviderFactory(
collection,
wurmLogsHistory,
wurmServerList,
logger,
wurmLogsMonitor,
wurmLogFiles,
internalEventAggregator);
jobExecutor = new JobExecutor(providerFactory, persistentLibrary);
runner = new QueuedJobsSyncRunner <object, ServerName>(jobExecutor, logger);
}
public Blacklist([NotNull] IWurmApiLogger logger, [NotNull] string description, int issueTreshhold = 10)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (description == null)
{
throw new ArgumentNullException(nameof(description));
}
this.logger = logger;
this.description = description;
this.issueTreshhold = issueTreshhold;
}
public WurmCharacterSkills([NotNull] IWurmCharacter character, [NotNull] IPublicEventInvoker publicEventInvoker,
[NotNull] IWurmLogsMonitorInternal logsMonitor, [NotNull] IWurmLogsHistory logsHistory,
[NotNull] IWurmApiLogger logger, IWurmPaths wurmPaths,
[NotNull] IInternalEventAggregator internalEventAggregator)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
if (publicEventInvoker == null)
{
throw new ArgumentNullException(nameof(publicEventInvoker));
}
if (logsMonitor == null)
{
throw new ArgumentNullException(nameof(logsMonitor));
}
if (logsHistory == null)
{
throw new ArgumentNullException(nameof(logsHistory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (internalEventAggregator == null)
{
throw new ArgumentNullException(nameof(internalEventAggregator));
}
this.character = character;
this.publicEventInvoker = publicEventInvoker;
this.logsMonitor = logsMonitor;
this.logsHistory = logsHistory;
this.logger = logger;
skillsMap = new SkillsMap();
skillDumps = new SkillDumpsManager(character, wurmPaths, logger);
UpdateCurrentServer();
onSkillsChanged =
publicEventInvoker.Create(
InvokeOnSkillsChanged,
WurmApiTuningParams.PublicEventMarshallerDelay);
internalEventAggregator.Subscribe(this);
logsMonitor.SubscribeInternal(character.Name, LogType.Skills, EventHandler);
}
public InternalEventInvoker([NotNull] IInternalEventAggregator eventAggregator, [NotNull] IWurmApiLogger logger,
[NotNull] IWurmApiEventMarshaller eventMarshaller)
{
if (eventAggregator == null) throw new ArgumentNullException(nameof(eventAggregator));
if (logger == null) throw new ArgumentNullException(nameof(logger));
if (eventMarshaller == null) throw new ArgumentNullException(nameof(eventMarshaller));
this.eventAggregator = eventAggregator;
this.logger = logger;
this.eventMarshaller = eventMarshaller;
LoopDelayMillis = 100;
schedulingTask = new Task(RunSchedule, TaskCreationOptions.LongRunning);
schedulingTask.Start();
}
/// <summary>
/// Constructor for integration testing.
/// </summary>
internal WurmApiManager(
string dataDir,
IWurmClientInstallDirectory installDirectory,
IHttpWebRequests httpWebRequests,
IWurmApiLogger logger,
WurmApiConfig wurmApiConfig)
{
ConstructSystems(dataDir,
installDirectory,
httpWebRequests,
logger,
new SimpleMarshaller(),
new SimpleMarshaller(),
wurmApiConfig);
}
public WurmLogsHistory([NotNull] IWurmLogFiles wurmLogFiles, [NotNull] IWurmApiLogger logger,
[NotNull] string heuristicsDataDirectory, [NotNull] LogFileStreamReaderFactory logFileStreamReaderFactory,
[NotNull] IWurmApiConfig wurmApiConfig)
{
if (wurmLogFiles == null)
{
throw new ArgumentNullException(nameof(wurmLogFiles));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (heuristicsDataDirectory == null)
{
throw new ArgumentNullException(nameof(heuristicsDataDirectory));
}
if (logFileStreamReaderFactory == null)
{
throw new ArgumentNullException(nameof(logFileStreamReaderFactory));
}
if (wurmApiConfig == null)
{
throw new ArgumentNullException(nameof(wurmApiConfig));
}
IPersistenceStrategy persistenceStrategy = new FlatFilesPersistenceStrategy(heuristicsDataDirectory);
var persistentLibrary =
new PersistentCollectionsLibrary(persistenceStrategy,
new PersObjErrorHandlingStrategy(logger));
var heuristicsCollection = persistentLibrary.GetCollection("heuristics");
var logsScannerFactory = new LogsScannerFactory(
new LogFileParserFactory(logger),
logFileStreamReaderFactory,
new MonthlyLogFilesHeuristics(
heuristicsCollection,
wurmLogFiles,
new MonthlyHeuristicsExtractorFactory(logFileStreamReaderFactory, logger, wurmApiConfig)),
wurmLogFiles,
logger,
wurmApiConfig);
runner =
new QueuedJobsSyncRunner <LogSearchParameters, ScanResult>(
new ScanJobExecutor(logsScannerFactory, persistentLibrary, logger),
logger);
}
public RealSkillDump(ServerGroup serverGroup, [NotNull] SkillDumpInfo dumpInfo,
[NotNull] IWurmApiLogger logger)
: base(serverGroup)
{
if (dumpInfo == null)
{
throw new ArgumentNullException(nameof(dumpInfo));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.dumpInfo = dumpInfo;
this.logger = logger;
skillLevels = ParseDump();
}
public WurmConfigDirectories(IWurmPaths wurmPaths, [NotNull] IInternalEventAggregator eventAggregator,
TaskManager taskManager, IWurmApiLogger logger)
: base(
wurmPaths.ConfigsDirFullPath,
taskManager,
() => eventAggregator.Send(new ConfigDirectoriesChanged()),
logger,
ValidateDirectory,
wurmPaths)
{
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
this.eventAggregator = eventAggregator;
}
public ServerHistoryProviderFactory(
IPersistentCollection persistentCollection,
IWurmLogsHistory wurmLogsHistory,
IWurmServerList wurmServerList,
IWurmApiLogger logger,
IWurmLogsMonitorInternal wurmLogsMonitor,
IWurmLogFiles wurmLogFiles, [NotNull] IInternalEventAggregator internalEventAggregator)
{
if (persistentCollection == null)
{
throw new ArgumentNullException(nameof(persistentCollection));
}
if (wurmLogsHistory == null)
{
throw new ArgumentNullException(nameof(wurmLogsHistory));
}
if (wurmServerList == null)
{
throw new ArgumentNullException(nameof(wurmServerList));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (wurmLogsMonitor == null)
{
throw new ArgumentNullException(nameof(wurmLogsMonitor));
}
if (wurmLogFiles == null)
{
throw new ArgumentNullException(nameof(wurmLogFiles));
}
if (internalEventAggregator == null)
{
throw new ArgumentNullException(nameof(internalEventAggregator));
}
this.persistentCollection = persistentCollection;
this.wurmLogsHistory = wurmLogsHistory;
this.wurmServerList = wurmServerList;
this.logger = logger;
this.wurmLogsMonitor = wurmLogsMonitor;
this.wurmLogFiles = wurmLogFiles;
this.internalEventAggregator = internalEventAggregator;
}
public ScanJobExecutor([NotNull] LogsScannerFactory logsScannerFactory,
[NotNull] PersistentCollectionsLibrary persistentLibrary, [NotNull] IWurmApiLogger logger)
{
if (logsScannerFactory == null)
{
throw new ArgumentNullException(nameof(logsScannerFactory));
}
if (persistentLibrary == null)
{
throw new ArgumentNullException(nameof(persistentLibrary));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logsScannerFactory = logsScannerFactory;
this.persistentLibrary = persistentLibrary;
this.logger = logger;
}
