public GuaranteedRateController(IRecordParser parser, IGenderSorter genderSorter, IDateOfBirthSorter dateOfBirthSorter, ILastNameSorter lastNameSorter)
{
_parser = parser;
_genderSorter = genderSorter;
_dateOfBirthSorter = dateOfBirthSorter;
_lastNameSorter = lastNameSorter;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="directory">Path of the directory to monitor</param>
/// <param name="filterSpec">File name filter</param>
/// <param name="logger">Logger</param>
public DirectorySource(
string directory,
string filterSpec,
int interval,
IPlugInContext context,
IRecordParser <TData, TContext> recordParser
) : base(new DirectoryDependency(directory), context)
{
Guard.ArgumentNotNullOrEmpty(directory, nameof(directory));
_directory = directory;
_filterSpec = filterSpec;
_fileFilters = ParseFilterSpec(filterSpec);
if (_fileFilters.Length > 1)
{
_fileFilterRegexs = _fileFilters.Select(ff => new Regex(Utility.WildcardToRegex(ff, true)))
.ToArray();
}
_interval = interval;
_recordParser = recordParser;
if (_config != null)
{
_skipLines = Utility.ParseInteger(_config["SkipLines"], 0);
_encoding = _config["Encoding"];
}
_timer = new Timer(OnTimer, null, Timeout.Infinite, Timeout.Infinite);
DelayBetweenDependencyPoll = TimeSpan.FromSeconds(5);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="directory">Path of the directory to monitor</param>
/// <param name="filter">File name filter</param>
/// <param name="logger">Logger</param>
public DirectorySource(
string directory,
string filter,
int interval,
IPlugInContext context,
IRecordParser <TData, TContext> recordParser,
Func <string, long, TContext> logSourceInfoFactory
) : base(context)
{
Guard.ArgumentNotNullOrEmpty(directory, nameof(directory));
_directory = directory;
_filter = filter ?? "";
_interval = interval;
_recordParser = recordParser;
_logSourceInfoFactory = logSourceInfoFactory;
if (_config != null)
{
_skipLines = Utility.ParseInteger(_config["SkipLines"], 0);
}
_timer = new Timer(OnTimer, null, Timeout.Infinite, Timeout.Infinite);
_watcher = new FileSystemWatcher();
_watcher.Path = directory;
_watcher.Filter = filter;
_watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Size;
_watcher.Changed += new FileSystemEventHandler(this.OnChanged);
_watcher.Created += new FileSystemEventHandler(this.OnChanged);
_watcher.Deleted += new FileSystemEventHandler(this.OnChanged);
_watcher.Renamed += new RenamedEventHandler(this.OnRenamed);
}
public void TestNonGenericCreateEventSourceWithDelimitedParser()
{
var config = TestUtility.GetConfig("Sources", "DHCPParsed");
string timestampField = config["TimestampField"];
PluginContext context = new PluginContext(config, null, null);
IRecordParser parser = DirectorySourceFactory.CreateDelimitedLogParser(context, timestampField, DateTimeKind.Utc);
var source = DirectorySourceFactory.CreateEventSource(context, parser);
Assert.NotNull(source);
Assert.IsType <DirectorySource <DelimitedLogRecord, DelimitedLogContext> >(source);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="directory">Path of the directory to monitor</param>
/// <param name="filterSpec">File name filter</param>
/// <param name="logger">Logger</param>
public DirectorySource(
string directory,
string filterSpec,
int interval,
IPlugInContext context,
IRecordParser <TData, TContext> recordParser
) : base(new DirectoryDependency(directory), context)
{
Guard.ArgumentNotNullOrEmpty(directory, nameof(directory));
_directory = directory;
_filterSpec = filterSpec;
_fileFilters = ParseFilterSpec(filterSpec);
if (_fileFilters.Length > 1)
{
_fileFilterRegexs = _fileFilters.Select(ff => new Regex(Utility.WildcardToRegex(ff, true)))
.ToArray();
}
_interval = interval;
_recordParser = recordParser;
if (_config != null)
{
_skipLines = Utility.ParseInteger(_config["SkipLines"], 0);
_encoding = _config["Encoding"];
bool.TryParse(this._config["IncludeSubdirectories"], out bool result);
this.includeSubdirectories = result ? bool.Parse(this._config["IncludeSubdirectories"]) : false;
if (this.includeSubdirectories)
{
this.includeDirectoryFilter = _config["IncludeDirectoryFilter"]?.Split(';');
}
if (bool.TryParse(_config["BookmarkOnBufferFlush"] ?? "false", out bool bookmarkOnBufferFlush))
{
this.bookmarkOnBufferFlush = bookmarkOnBufferFlush;
}
}
this.bookmarkDir = Path.GetDirectoryName(GetBookmarkFilePath());
if (!Directory.Exists(this.bookmarkDir))
{
Directory.CreateDirectory(this.bookmarkDir);
}
_timer = new Timer(OnTimer, null, Timeout.Infinite, Timeout.Infinite);
DelayBetweenDependencyPoll = TimeSpan.FromSeconds(5);
}
/// <summary>
/// A generic version of the Factory method to create directory source
/// </summary>
/// <typeparam name="TData">Parser output type</typeparam>
/// <typeparam name="TLogContext">Log context</typeparam>
/// <param name="context">Plug-in Context</param>
/// <param name="recordParser">Record Parser</param>
/// <returns>Event Source</returns>
public static IEventSource <TData> CreateEventSource <TData, TLogContext>(
IPlugInContext context,
IRecordParser <TData, TLogContext> recordParser
) where TLogContext : LogContext, new()
{
IConfiguration config = context.Configuration;
GetDirectorySourceParameters(config, out string directory, out string filter, out int interval);
DirectorySource <TData, TLogContext> source = new DirectorySource <TData, TLogContext>(
directory,
filter,
interval * 1000, //milliseconds
context,
recordParser);
source.NumberOfConsecutiveIOExceptionsToLogError = 3;
EventSource <TData> .LoadCommonSourceConfig(config, source);
source.Id = config[ConfigConstants.ID] ?? Guid.NewGuid().ToString();
return(source);
}
internal ParserProvider()
{
var parsers = new IRecordParser[]
{
new GeneralRecordParser <HeaderRecord>(RecordType.HeaderRecord),
new GeneralRecordParser <EbcdicHeaderRecord>(RecordType.EbcdicHeaderRecord),
new GeneralRecordParser <VariableRecord>(RecordType.VariableRecord),
new GeneralRecordParser <ValueLabelRecord>(RecordType.ValueLabelRecord),
new GeneralRecordParser <DocumentRecord>(RecordType.DocumentRecord),
new InfoRecordParser(new List <KeyValuePair <int, Type> >
{
RegisterInfoRecord <MachineIntegerInfoRecord>(InfoRecordType.MachineInteger),
RegisterInfoRecord <MachineFloatingPointInfoRecord>(InfoRecordType.MachineFloatingPoint),
RegisterInfoRecord <VariableDisplayParameterRecord>(InfoRecordType.VariableDisplayParameter),
RegisterInfoRecord <LongVariableNamesRecord>(InfoRecordType.LongVariableNames),
RegisterInfoRecord <VeryLongStringRecord>(InfoRecordType.VeryLongString),
RegisterInfoRecord <CharacterEncodingRecord>(InfoRecordType.CharacterEncoding),
}.ToDictionary(p => p.Key, p => p.Value)),
new GeneralRecordParser <DictionaryTerminationRecord>(RecordType.End),
};
_parsers = parsers.ToDictionary(p => p.Accepts, p => p);
}
/// <summary>
/// This is the non-generic version of the CreateEventSource relying on reflection to instantiate generic methods.
/// </summary>
/// <param name="context">Plug-in context</param>
/// <param name="recordParser">Record Parser. Must implement IRecordParser<TData,LogContext></param>
/// <param name="logSourceInfoFactory">Factory method for generating LogContext</param>
/// <returns>Generated Directory Source</returns>
internal static ISource CreateEventSource(IPlugInContext context,
IRecordParser recordParser)
{
Guard.ArgumentNotNull(recordParser, "recordParser");
IConfiguration config = context.Configuration;
GetDirectorySourceParameters(config, out string directory, out string filter, out int interval);
var recordParserType = recordParser.GetType().GetTypeInfo().ImplementedInterfaces
.FirstOrDefault(t => t.GetTypeInfo().IsGenericType&& t.GetGenericTypeDefinition() == typeof(IRecordParser <,>));
if (recordParserType == null)
{
throw new ConfigurationException("recordParser must implement generic interface IRecordParser<,>");
}
var directorySourceType = typeof(DirectorySource <,>);
var genericDirectorySourceType = directorySourceType.MakeGenericType(recordParserType.GenericTypeArguments);
var source = (ISource)Activator.CreateInstance(genericDirectorySourceType,
directory,
filter,
interval * 1000, //milliseconds
context,
recordParser);
((dynamic)source).NumberOfConsecutiveIOExceptionsToLogError = 3;
//The following is the translation of EventSource<TData>.LoadCommonSourceConfig(config, source);
typeof(EventSource <>)
.MakeGenericType(recordParserType.GenericTypeArguments[0])
.GetMethod("LoadCommonSourceConfig", BindingFlags.Static | BindingFlags.Public)
.Invoke(null, new object[] { config, source });
source.Id = config[ConfigConstants.ID] ?? Guid.NewGuid().ToString();
return(source);
}
public static IEventSource <TData> CreateEventSource <TData, TContext>(
IPlugInContext context,
IRecordParser <TData, TContext> recordParser,
Func <string, long, TContext> logSourceInfoFactory
) where TContext : LogContext
{
IConfiguration config = context.Configuration;
string directory = config["Directory"];
string filter = config["FileNameFilter"];
string intervalSetting = config["Interval"];
int interval = 0; //Seconds
if (!string.IsNullOrEmpty(intervalSetting))
{
int.TryParse(intervalSetting, out interval);
}
if (interval == 0)
{
interval = 1;
}
DirectorySource <TData, TContext> source = new DirectorySource <TData, TContext>(
directory,
filter,
interval * 1000, //milliseconds
context,
recordParser,
logSourceInfoFactory);
source.NumberOfConsecutiveIOExceptionsToLogError = 3;
EventSource <TData> .LoadCommonSourceConfig(config, source);
source.Id = config[ConfigConstants.ID] ?? Guid.NewGuid().ToString();
return(source);
}
public OriginalFileParser(IRecordParser recordParser)
{
_recordParser = recordParser;
}
public RecordsController(IRecordParser recordParser, IRecordRepository recordRepository)
{
_recordParser = recordParser;
_recordRepository = recordRepository;
}
private async Task CreateAndRunWatcher <TData>(string testName, string filter, IConfiguration config, Func <List <IEnvelope>, Task> testBody, IRecordParser <TData, LogContext> recordParser, TestDirectory directory = null)
{
await this.CreateAndRunWatcher(testName, filter, config, testBody, recordParser, NullLogger.Instance, directory);
}
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="args">Arguments to the program containing three filenames and optional sort criteria</param>
/// <param name="recordParser">Service that is used to parse data in files</param>
/// <param name="recordSorter">Service that is used to sort data</param>
///
/// Modified after submission to use interface types as arguments - accidently used concrete types originally
/// (same for related fields)
///
public Application(string[] args, IRecordParser recordParser, IRecordSorter recordSorter)
{
_args = args;
_recordParser = recordParser;
_recordSorter = recordSorter;
}
private async Task CreateAndRunWatcher <TData>(string filter, IConfiguration config, Func <List <IEnvelope>, Task> testBody, IRecordParser <TData, LogContext> recordParser)
{
ListEventSink logRecords = new ListEventSink();
DirectorySource <TData, LogContext> watcher = new DirectorySource <TData, LogContext>
(TestUtility.GetTestHome(), filter, 1000, new PluginContext(config, NullLogger.Instance, null), recordParser, DirectorySourceFactory.CreateLogSourceInfo);
watcher.Subscribe(logRecords);
watcher.Start();
await testBody(logRecords);
watcher.Stop();
}
public FileParser(IRecordParser recordParser, bool skipHeader)
{
this.recordParser = recordParser;
this.skipHeader = skipHeader;
}
public FileParser(IRecordParser recordParser)
{
_recordParser = recordParser;
}
public MakeTestableParser(IRecordParser recordParser)
: base(recordParser)
{
}
public PassengerNameListController()
{
_recordParser = new RecordParser();
}
private async Task CreateAndRunWatcher <TData>(string testName, string filter, IConfiguration config, Func <List <IEnvelope>, Task> testBody, IRecordParser <TData, LogContext> recordParser, ILogger logger, TestDirectory directory = null)
{
//Create a distinct directory based on testName so that tests can run in parallel
string testDir = Path.Combine(TestUtility.GetTestHome(), testName);
if (directory == null)
{
//The following will creates all directories and subdirectories in the specified path unless they already exist.
Directory.CreateDirectory(testDir);
//Clean up before the test rather than after so that we can inspect the files
DeleteFiles(testDir, "*.*");
}
else
{
this.SetUpTestDirectory(directory, TestUtility.GetTestHome());
}
ListEventSink logRecords = new ListEventSink();
DirectorySource <TData, LogContext> watcher = new DirectorySource <TData, LogContext>
(testDir, filter, 1000, new PluginContext(config, logger, null), recordParser);
watcher.Subscribe(logRecords);
watcher.Start();
await testBody(logRecords);
watcher.Stop();
}
public DataFileParser(IParser headerParser, IParser recordParser)
{
_headerParser = headerParser as IParser <DataMeta>;
_recordParser = recordParser as IRecordParser <T>;
}
