static async Task Main(string[] args)
{
var loggerFactory = LoggerFactory.Create(builder => builder.SetMinimumLevel(LogLevel.Debug).AddConsole());
var services = ServiceCollectionFactory.CreateDefaultServiceCollection(loggerFactory);
var provider = services.BuildServiceProvider();
var options = new WatcherOptions()
{
DirectoryToWatch = "D:\\ParserTest",
FileSearchPattern = "hello*.cs",
WorkingDirectoryPath = "D:\\WorkingDir",
BackupDirectoryPath = "D:\\BackupDir",
ParserName = "Parser_One",
PollingInterval = 5000,
DeleteSourceFileAfterParsing = false
};
var worker = provider.GetRequiredService <ParserWorker>();
var parserId = worker.RegisterWriteTimeParser <Logic>(options);
worker.StartParser(parserId);
await Task.Delay(60000);
worker.StopParser(parserId);
}
private static IFbWatcher <TModel> CreateWatcher <TModel>()
where TModel : IModel, new()
{
var tableName = typeof(TModel).GetCustomAttribute <DbTransferInfo>()?.MainTableName;
if (string.IsNullOrWhiteSpace(tableName))
{
throw new Exception($"Can't extract table name from: {typeof(TModel)}");
}
var triggersFileName = $"{tableName}_TRIGGERS.json";
var triggersFilePath = Path.Combine(AppSettings.DataDirectoryPath, triggersFileName);
var options = new WatcherOptions(GetMainDbConnectionString(),
GetTempDbConnectionString());
var factory = CreateWatcherFactory <TModel>();
var watcher = factory.CreateWatcher(options);
var schemeFactory = new SchemeFactory <TModel>(AppConfig.Main.ExternalDbSource,
AppConfig.Main.ExternalUser, AppConfig.Main.ExternalPassword);
watcher.AddTriggers(schemeFactory.CreateSchemes(TriggerType.Insert,
TriggerType.Delete, TriggerType.Update));
return(watcher);
}
private void SaveToOptions( WatcherOptions options )
{
options.RestartEnabled = cbRestartProcess.Checked;
options.CopyEnabled = cbCopyFile.Checked;
options.RestartParameters = tbRestartParameters.Text;
options.CopyPath = tbCopyPath.Text;
options.PlaySoundEnabled = cbPlaySound.Checked;
}
private void LoadFromOptions( WatcherOptions options )
{
cbRestartProcess.Checked = options.RestartEnabled;
cbCopyFile.Checked = options.CopyEnabled;
tbRestartParameters.Text = options.RestartParameters;
tbCopyPath.Text = options.CopyPath;
cbPlaySound.Checked = options.PlaySoundEnabled;
}
public EtlOptions(ArchiveOptions archiveOptions, EncryptionOptions encryptionOptions, LoggingOptions loggingOptions, MoveOptions moveOptions, MoveDbOptions moveDbOptions, WatcherOptions watcherOptions)
{
ArchiveOptions = archiveOptions;
EncryptionOptions = encryptionOptions;
LoggingOptions = loggingOptions;
MoveOptions = moveOptions;
MoveDbOptions = moveDbOptions;
WatcherOptions = watcherOptions;
}
/// <summary>
/// Set the options for the watcher
/// </summary>
/// <param name="options">The options which should be used by the watcher</param>
public void SetOptions(WatcherOptions options)
{
if (IsRunning)
{
throw new WatcherIsAlreadyRunningException(Options);
}
Options = options;
}
public IFbWatcher <TModel> CreateWatcher <TModel>()
where TModel : IModel, new()
{
var factory = new WatcherFactory <TModel>();
var watcherOptions = new WatcherOptions(TestsContext.MainDbConnectionString,
TestsContext.TempDbConnectionString);
return(factory.CreateWatcher(watcherOptions));
}
public EtlXmlOptions(ArchiveOptions archiveOptions, CryptingOptions cryptingOptions, LoggerOptions loggerOptions, WatcherOptions watcherOptions, Options defaultOptions)
{
ArchiveOptions = archiveOptions;
CryptingOptions = cryptingOptions;
LoggerOptions = loggerOptions;
WatcherOptions = watcherOptions;
DefaultOptions = defaultOptions;
SourceDirectory = DefaultOptions.SourceDirectory;
TargetDirectory = DefaultOptions.TargetDirectory;
IsLoggerEnable = DefaultOptions.IsLoggerEnable;
}
public Guid RegisterWriteTimeParser <T>(WatcherOptions watcherOptions) where T : IParser, new()
{
CheckOptions(watcherOptions);
var guid = Guid.NewGuid();
var watcherTask = _serviceProvider.GetRequiredService <WriteTimeWatcherTask <T> >();
watcherTask.SetOptions(watcherOptions);
_registrations.Add(guid, watcherTask);
return(guid);
}
public void EnqueueNewFilesForProcessing <T>(WatcherOptions options, IList <IFileInfo> newFiles) where T : IParser, new()
{
foreach (var file in newFiles)
{
var workingPath = $"{options.WorkingDirectoryPath}\\{Guid.NewGuid()}";
var workingFile = $"{workingPath}\\{file.Name}";
var backupPath = $"{options.BackupDirectoryPath}\\{DateTime.Today:yyyy}\\{DateTime.Today:MMMM}";
var copyJobId = BackgroundJob.Enqueue(() => CopyTask.CopyFileToDirectoryAsync(file.FullName, workingPath));
var parserJobId = BackgroundJob.ContinueJobWith(copyJobId, () => new T().ParseFile(workingFile));
var backupJobId = BackgroundJob.ContinueJobWith(parserJobId, () => CopyTask.CopyFileToDirectoryAsync(workingFile, backupPath));
var cleanupJobId = BackgroundJob.ContinueJobWith(backupJobId, () => CleanupTask.DeleteFolder(workingPath));
if (options.DeleteSourceFileAfterParsing)
{
BackgroundJob.ContinueJobWith(cleanupJobId, () => CleanupTask.DeleteFile(file.FullName));
}
}
_logger.LogInformation("{ParserName}: Enqueued {NewFilesCount} files for parsing...", options.ParserName, newFiles.Count);
}
private void CheckOptions(WatcherOptions watcherOptions)
{
if (IsWorkerRunning)
{
throw new WorkerAlreadyStartedException();
}
if (watcherOptions == null)
{
throw new ArgumentNullException(nameof(watcherOptions));
}
if (!watcherOptions.AreOptionsValid())
{
throw new ArgumentException(watcherOptions.ErrorMessages.FirstOrDefault());
}
if (!watcherOptions.IsParserUnique(_registrations.Values.Select(v => v.Options)))
{
throw new ParserNotUniqueException();
}
}
public Watcher(WatcherOptions options, ApplicationOptions applicationOptions, ITerminal terminal, ILogger log)
{
if (string.IsNullOrWhiteSpace(options.FolderPath))
{
throw new ArgumentNullException(nameof(options.FolderPath));
}
this._log = log;
this._options = options;
this._applicationOptions = applicationOptions;
this._terminal = terminal;
this.Name = options.GetName();
this._log.LogTrace("Watcher {Watcher}: checking commands", this.Name);
this._commands = options.Commands?.Where(c => !string.IsNullOrWhiteSpace(c)) ?? Enumerable.Empty <string>();
if (!this._commands.Any())
{
this._log.LogWarning("Watcher {Watcher}: no commands specified", this.Name);
}
this._log.LogTrace("Watcher {Watcher}: building exclusion filters", this.Name);
this._exclusions = options.Exclusions?.Select(f => ExclusionFilter.Build(f)) ?? Enumerable.Empty <ExclusionFilter>();
this._log.LogTrace("Watcher {Watcher}: determining working directory", this.Name);
this._workingDirectory = string.IsNullOrWhiteSpace(this._options.WorkingDirectory) ? this._options.FolderPath : this._options.WorkingDirectory;
this._log.LogTrace("Watcher {Watcher}: creating {Type}", this.Name, typeof(FileSystemWatcher).Name);
this._watch = new FileSystemWatcher(options.FolderPath);
this._watch.NotifyFilter = options.NotifyFilters;
foreach (string filter in options.FileFilters)
{
this._watch.Filters.Add(filter);
}
this._watch.IncludeSubdirectories = options.Recursive;
this._watch.Changed += OnFileChanged;
this._watch.Created += OnFileChanged;
this._watch.Renamed += OnFileChanged;
}
private static IFbWatcher <TModel> CreateWatcher <TModel>()
where TModel : IModel, new()
{
var tableName = typeof(TModel).GetCustomAttribute <DbTransferInfo>()?.MainTableName;
if (string.IsNullOrWhiteSpace(tableName))
{
throw new Exception($"Can't extract table name from: {typeof(TModel)}");
}
var options = new WatcherOptions(TestsContext.MainDbConnectionString,
TestsContext.TempDbConnectionString);
var factory = CreateWatcherFactory <TModel>();
var watcher = factory.CreateWatcher(options);
var schemeFactory = new SchemeFactory <TModel>(TestsContext.ExternalDbSource,
TestsContext.ExternalUser, TestsContext.ExternalPassword);
watcher.AddTriggers(schemeFactory.CreateSchemes(TriggerType.Insert,
TriggerType.Delete, TriggerType.Update));
return(watcher);
}
public WatcherIsAlreadyRunningException(WatcherOptions options) : base($"The parser \"{options?.ParserName}\" is already started.")
{
}
public IFbWatcher <TModel> CreateWatcher(WatcherOptions options)
{
var logger = _loggerFactory.CreateLogger <FbSqlWatcher <TModel> >();
return(new FbSqlWatcher <TModel>(options, _sqlBuilder, logger));
}
public WatcherIsNotRunningException(WatcherOptions options) : base($"The watcher for parser \"{options?.ParserName}\" is not started and can therefore not be stopped.")
{
}
public FbSqlWatcher(WatcherOptions options, ISqlBuilder sqlBuilder, ILogger logger)
{
InitializeInternal(options);
SqlBuilder = sqlBuilder;
Logger = logger;
}
private void InitializeInternal(WatcherOptions options)
{
_options = options;
_tempDbReader = new FbSqlReader(options.TempDbConnectionString);
Logger = new LoggerFactory().CreateLogger <FbSqlWatcher <ProcessEventsActionModel> >();
}
