public Logger()
{
string appDirectory = AppDomain.CurrentDomain.BaseDirectory;
optionsManager = new OptionsManager(appDirectory, this);
ETLOptions options = optionsManager.GetOptions <ETLOptions>(this) as ETLOptions;
Validator.Validate(options, this);
sourceDirectory = options.DirectoryOptions.SourceDirectory;
logFile = options.DirectoryOptions.LogFile;
targetDirectory = options.DirectoryOptions.TargetDirectory;
archiveDirectory = options.DirectoryOptions.ArchiveDirectory;
using (StreamReader sr = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "\\Filelog.txt"))
{
string logs = sr.ReadToEnd();
using (StreamWriter writer = new StreamWriter(logFile, false))
{
writer.WriteLine(logs);
writer.Flush();
}
}
File.Delete(AppDomain.CurrentDomain.BaseDirectory + "\\Filelog.txt");
watcher = new FileSystemWatcher(sourceDirectory)
{
Filter = "*.txt"
};
watcher.Created += Watcher_Created;
}
private void ValidateParsedOptions()
{
var configs = new ETLOptions[] { xmlConfig, jsonConfig };
foreach (var config in configs)
{
foreach (var configProperty in config.GetType().GetProperties())
{
foreach (var option in configProperty.PropertyType.GetProperties())
{
if (option.PropertyType == typeof(string))
{
var obj = configProperty.GetValue(config);
var attrs = option.GetCustomAttributes(false);
foreach (var attr in attrs)
{
if (attr is PathAttribute)
{
var path = option.GetValue(configProperty.GetValue(config)) as string;
if (!Directory.Exists(path) && !File.Exists(path))
{
option.SetValue(obj,
option.GetValue(configProperty.GetValue(defaultConfig)));
}
}
}
}
}
}
}
}
internal static void Validate(ETLOptions options, Logger logger)
{
DirectoryOptions directoryOptions = options.DirectoryOptions;
if (!MakeValidDir(directoryOptions.SourceDirectory))
{
directoryOptions.SourceDirectory = @"C:\FileWatcher\SourceDirectory";
MakeValidDir(directoryOptions.SourceDirectory);
logger.Log("Using default directory. Error in creating sourseDirectory ", true);
}
if (!MakeValidDir(directoryOptions.TargetDirectory))
{
directoryOptions.TargetDirectory = @"C:\FileWatcher\TargetDirectory";
MakeValidDir(directoryOptions.TargetDirectory);
logger.Log("Using default directory. Error in creating targetDirectory", true);
}
if (!MakeValidDir(directoryOptions.ArchiveDirectory))
{
directoryOptions.ArchiveDirectory = @"C:\FileWatcher\TargetDirectory\archive";
MakeValidDir(directoryOptions.ArchiveDirectory);
logger.Log("The access to archive directory is denied, using default directory.", true);
}
if (!MakeValidFile(directoryOptions.LogFile))
{
directoryOptions.LogFile = @"C:\FileWtcher\TargetDirectory\Logfile.txt";
MakeValidFile(directoryOptions.LogFile);
logger.Log("The access to log file is denied, using default log file.", true);
}
ArchiveOptions archivationOptions = options.ArchiveOptions;
if ((int)archivationOptions.CompressionLevel < 0 || (int)archivationOptions.CompressionLevel > 2)
{
archivationOptions.CompressionLevel = System.IO.Compression.CompressionLevel.Optimal;
logger.Log("Incorrect value of compression level. Default value is set.", true);
}
}
private Options GetExactConfiguration <T>(ETLOptions options)
{
if (typeof(T) == typeof(ETLOptions))
{
return(options);
}
string name = typeof(T).Name;
try
{
return(options.GetType().GetProperty(name).GetValue(options, null) as Options);
}
catch
{
throw new NotImplementedException();
}
}
Options.Options FindOption <T>(ETLOptions options, Logger logger)
{
if (typeof(T) == typeof(ETLOptions))
{
return(options);
}
try
{
return(options.GetType().GetProperty(typeof(T).Name).GetValue(options, null) as Options.Options);
}
catch
{
logger.Log("FindOption didn't find the needed option and throw a NotImplementedException.", true);
throw new NotImplementedException();
}
}
public OptionsManager(string path, Logger logger)
{
string options;
try
{
using (StreamReader sr = new StreamReader($"{path}\\appsettings.json"))
{
options = sr.ReadToEnd();
}
jsonOptions = new ETLJSONOptions(options);
isJsonConnected = true;
logger.Log("appsettings.json is loaded.", false);
}
catch (Exception ex)
{
isJsonConnected = false;
logger.Log(ex.Message, false);
}
try
{
using (StreamReader sr = new StreamReader($"{path}\\config.xml"))
{
options = sr.ReadToEnd();
}
xmlOptions = new ETLXMLOptions(options);
isXmlConnected = true;
logger.Log("config.xml is loaded.", true);
}
catch (Exception ex)
{
isXmlConnected = false;
logger.Log(ex.Message, true);
}
if (!isJsonConnected && !isXmlConnected)
{
defaultOptions = new ETLOptions();
logger.Log("Default options is used.", true);
}
}
public ConfigManager(string mainPath)
{
defaultConfig = new ETLOptions();
string config;
try
{
using (var stream = new StreamReader($"{mainPath}\\appsettings.json"))
{
config = stream.ReadToEnd();
}
jsonConfig = new ETLJSONOptions(config);
jsonConfigParsed = true;
ConfigManagingInfo += " JSON configuration parsed.";
}
catch
{
ConfigManagingInfo += " Couldn't parse JSON.";
}
try
{
using (var stream = new StreamReader($"{mainPath}\\config.xml"))
{
config = stream.ReadToEnd();
}
xmlConfig = new ETLXMLOptions(config);
xmlConfigParsed = true;
ConfigManagingInfo += " XML configuration parsed.";
}
catch
{
ConfigManagingInfo += " Couldn't parse XML.";
}
ValidateParsedOptions();
}
