public void SetPath(string path, IAnalogyOfflineDataProvider dataProvider)
{
DataProvider = dataProvider;
startupDrive = path;
treeList1.ClearNodes();
treeList1.DataSource = new object();
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(IAnalogyOfflineDataProvider fileDataProvider, string filename, CancellationToken token)
{
FileName = filename;
if (string.IsNullOrEmpty(FileName))
{
return(new List <AnalogyLogMessage>());
}
if (!DataWindow.ForceNoFileCaching && FileProcessingManager.Instance.AlreadyProcessed(FileName) && Settings.EnableFileCaching) //get it from the cache
{
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
if (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
while (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
await Task.Delay(1000);
}
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
//otherwise read file:
try
{
FileProcessingManager.Instance.AddProcessingFile(FileName);
if (!DataWindow.DoNotAddToRecentHistory)
{
Settings.AddToRecentFiles(fileDataProvider.ID, FileName);
}
var messages = (await fileDataProvider.Process(filename, token, DataWindow).ConfigureAwait(false)).ToList();
FileProcessingManager.Instance.DoneProcessingFile(messages.ToList(), FileName);
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(messages);
}
catch (Exception e)
{
AnalogyLogger.Intance.LogCritical("Analogy", $"Error parsing file: {e}");
AnalogyLogMessage error = new AnalogyLogMessage($"Error reading file {filename}: Error: {e.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
}
public void SetPath(string path, IAnalogyOfflineDataProvider dataProvider)
{
DataProvider = dataProvider;
UserSettingsManager.UserSettings.AddToRecentFolders(dataProvider.Id, path);
startupDrive = path;
treeList1.ClearNodes();
treeList1.DataSource = new object();
}
public LocalLogFilesUC(IAnalogyOfflineDataProvider dataProvider, string[] fileNames = null, string initialSelectedPath = null) : this(initialSelectedPath)
{
DataProvider = dataProvider;
if (fileNames != null)
{
extrenalFiles.AddRange(fileNames);
}
ucLogs1.SetFileDataSource(dataProvider, dataProvider);
}
public OfflineUCLogs(IAnalogyOfflineDataProvider dataProvider, string[] fileNames = null, string initialSelectedPath = null) : this(initialSelectedPath)
{
DataProvider = dataProvider;
if (fileNames != null)
{
extrenalFiles.AddRange(fileNames);
}
ucLogs1.OnlineMode = false;
ucLogs1.SetFileDataSource(dataProvider);
}
public void SetFolder(string folder, IAnalogyOfflineDataProvider dataProvider)
{
this.DataProvider = dataProvider;
if (string.IsNullOrEmpty(folder) || !Directory.Exists(folder))
{
return;
}
SelectedPath = folder;
txtbFolder.Text = folder;
xtraUCFileSystem1.SetPath(folder, dataProvider);
}
public void SetFolder(string folder, IAnalogyOfflineDataProvider dataProvider)
{
DataProvider = dataProvider;
if (string.IsNullOrEmpty(folder) || !Directory.Exists(folder))
{
return;
}
SelectedPath = folder;
txtbFolder.Text = folder;
//todo
//directoryListing.SetPath(folder, dataProvider);
}
private async Task PopulateFolders(string folderText, IAnalogyOfflineDataProvider dataProvider)
{
if (Directory.Exists(folderText))
{
xtraUCFileSystem1.SetPath(folderText, dataProvider);
txtbFolder.Text = folderText;
FolderChanged?.Invoke(this, new FolderSelectionEventArgs(folderText));
}
else
{
await Task.CompletedTask;
}
}
public FilePoolingUCLogs(IAnalogyOfflineDataProvider offlineDataProvider, string fileName, string initialFolder)
{
InitializeComponent();
FileName = fileName;
ucLogs1.OnlineMode = false;
PoolingManager = new FilePoolingManager(FileName, offlineDataProvider);
ucLogs1.SetFileDataSource(offlineDataProvider);
PoolingManager.OnNewMessages += (s, data) =>
{
AppendMessages(data.messages, data.dataSource);
OnNewMessages(data.messages);
};
this.Disposed += FilePoolingUCLogs_Disposed;
}
private string UnzipFilesIntoTempFolder(string zipPath, IAnalogyOfflineDataProvider fileDataProvider)
{
string extractPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(extractPath);
if (zipPath.EndsWith("zip", StringComparison.InvariantCultureIgnoreCase))
{
UnzipZipFileIntoTempFolder(zipPath, extractPath, fileDataProvider);
}
else if (zipPath.EndsWith("gz", StringComparison.InvariantCultureIgnoreCase))
{
UnzipGzFileIntoTempFolder(zipPath, extractPath);
}
else
{
AnalogyLogger.Instance.LogError(nameof(UnzipFilesIntoTempFolder), $"Unsupported file: {zipPath}.");
return(string.Empty);
}
return(extractPath);
}
private void UnzipZipFileIntoTempFolder(string zipPath, string extractPath, IAnalogyOfflineDataProvider fileDataProvider)
{
using (FileStream zipToOpen = new FileStream(zipPath, FileMode.Open))
{
using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Read))
{
//build a list of files to be extracted
var entries = archive.Entries.Where(entry => !entry.FullName.EndsWith("/") && fileDataProvider.CanOpenFile(entry.FullName));
foreach (ZipArchiveEntry entry in entries)
{
entry.ExtractToFile(Path.Combine(extractPath, entry.Name));
}
if (!Directory.GetFiles(extractPath).Any())
{
AnalogyLogger.Instance.LogError(nameof(UnzipFilesIntoTempFolder),
"Zip file does not contain any supported files");
}
}
}
}
public void SetPath(string folderPath, IAnalogyOfflineDataProvider dataProvider)
{
FolderRoot = folderPath;
DataProvider = dataProvider;
var dir = new DirectoryInfo(folderPath);
TreeNodeAdvSubItem subitem1 = new TreeNodeAdvSubItem();
TreeNodeAdvSubItem subitem2 = new TreeNodeAdvSubItem();
subitem1.Text = dir.FullName;
subitem1.HelpText = subitem1.Text;
subitem2.Text = dir.LastWriteTime.ToString();
subitem2.HelpText = subitem2.Text;
TreeNodeAdv node = new TreeNodeAdv(dir.Name);
node.SubItems.AddRange(new[] { subitem1, subitem2 });
multiColumnTreeView1.Nodes.Clear();
multiColumnTreeView1.Nodes.Add(node);
multiColumnTreeView1.Nodes[0].Expanded = true;
multiColumnTreeView1.SelectedNode = multiColumnTreeView1.Nodes[0];
multiColumnTreeView1.Focus();
}
public FormCombineFiles(IAnalogyOfflineDataProvider offlineAnalogy) : this()
{
this.offlineAnalogy = offlineAnalogy;
combineFilesUC1.SetDataSource(offlineAnalogy);
}
public void SetPath(string folderPath, IAnalogyOfflineDataProvider dataProvider)
{
FolderRoot = folderPath;
DataProvider = dataProvider;
LoadFiles();
}
public FileComparerForm(IAnalogyOfflineDataProvider offlineAnalogy) : this()
{
this.offlineAnalogy = offlineAnalogy;
logsComparerUC1.SetDataSource(offlineAnalogy);
}
public void SetDataSource(IAnalogyOfflineDataProvider offlineAnalogy)
{
this.offlineAnalogy = offlineAnalogy;
fileSystemUC1.DataProvider = offlineAnalogy;
}
public void SetDataSource(IAnalogyOfflineDataProvider analogyOfflineDataProvider)
{
offlineAnalogy = analogyOfflineDataProvider;
fileSystemUC1.DataProvider = offlineAnalogy;
}
public SearchForm(IAnalogyOfflineDataProvider offlineAnalogy) : this()
{
this.offlineAnalogy = offlineAnalogy;
searchInFilesUC1.SetDataSource(offlineAnalogy);
}
public ClientServerUCLog(IAnalogyOfflineDataProvider dataProvider) : this()
{
DataProvider = dataProvider;
ucLogs1.SetFileDataSource(dataProvider, DataProvider);
}
public void SetDataSource(IAnalogyOfflineDataProvider offlineAnalogy)
{
OfflineAnalogy = offlineAnalogy;
}
public XtraFormLogGrid(List <AnalogyLogMessage> messages, string dataSource, IAnalogyDataProvider dataProvider, IAnalogyOfflineDataProvider fileProvider = null, string processOrModule = null)
{
InitializeComponent();
_messages = messages;
_dataSource = dataSource;
if (!string.IsNullOrEmpty(processOrModule))
{
ucLogs1.FilterResults(processOrModule);
}
ucLogs1.SetFileDataSource(dataProvider, fileProvider);
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(IAnalogyOfflineDataProvider fileDataProvider,
string filename, CancellationToken token, bool isReload = false)
{
//TODO in case of zip recursive call on all extracted files
FileName = filename;
if (string.IsNullOrEmpty(FileName))
{
return(new List <AnalogyLogMessage>());
}
if (!isReload && !DataWindow.ForceNoFileCaching &&
FileProcessingManager.Instance.AlreadyProcessed(FileName) &&
Settings.EnableFileCaching) //get it from the cache
{
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
if (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
while (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
await Task.Delay(1000);
}
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
//otherwise read file:
try
{
if (fileDataProvider.CanOpenFile(filename)) //if can open natively: add to processing and process
{
FileProcessingManager.Instance.AddProcessingFile(FileName);
if (!DataWindow.DoNotAddToRecentHistory)
{
Settings.AddToRecentFiles(fileDataProvider.ID, FileName);
}
var messages = (await fileDataProvider.Process(filename, token, DataWindow).ConfigureAwait(false))
.ToList();
FileProcessingManager.Instance.DoneProcessingFile(messages.ToList(), FileName);
if (messages.Any())
{
lastNewestMessage = messages.Select(m => m.Date).Max();
}
OnFileReadingFinished?.Invoke(this, EventArgs.Empty);
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(messages);
}
else //cannot open natively. is it compressed file?
{
if (Utils.IsCompressedArchive(filename))
{
var compressedMessages = new List <AnalogyLogMessage>();
string extractedPath = UnzipFilesIntoTempFolder(filename, fileDataProvider);
if (string.IsNullOrEmpty(extractedPath))
{
string msg = $"File is not supported by {fileDataProvider}. File: {filename}";
AnalogyLogger.Instance.LogCritical("Analogy", msg);
AnalogyLogMessage error = new AnalogyErrorMessage(msg, "Analogy");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
CleanupManager.Instance.AddFolder(extractedPath);
var files = Directory.GetFiles(extractedPath);
files.ForEach(async file =>
{
var messages = await Process(fileDataProvider, file, token, isReload);
compressedMessages.AddRange(messages);
});
return(compressedMessages);
}
else
{
string msg = $"File is not supported by {fileDataProvider}. File: {filename}";
AnalogyLogger.Instance.LogCritical("Analogy", msg);
AnalogyLogMessage error = new AnalogyErrorMessage(msg, "Analogy");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
}
}
catch (Exception e)
{
AnalogyLogger.Instance.LogCritical("Analogy", $"Error parsing file: {e}");
var error = new AnalogyErrorMessage($"Error reading file {filename}: Error: {e.Message}", "Analogy");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
}
