public async Task TestDirectMatchIsIgnoredWhenGameFolderFilesOverrideExists() { var profile = utils.AddProfile(); var mod = utils.AddMod(); var test_pex = utils.AddGameFile(@"enbstuff\test.pex", 10); utils.Configure(); Directory.CreateDirectory(Path.Combine(utils.MO2Folder, Consts.GameFolderFilesDir)); utils.AddManualDownload( new Dictionary <string, byte[]> { { "/baz/biz.pex", File.ReadAllBytes(test_pex) } }); await CompileAndInstall(profile); Assert.IsFalse(File.Exists(Path.Combine(utils.InstallFolder, Consts.GameFolderFilesDir, @"enbstuff\test.pex"))); }
private async Task ExtractTrack(AbsolutePath source, AbsolutePath destFolder, Track track) { var process = new ProcessHelper { Path = FFMpegPath, Arguments = new object[] { "-threads", 1, "-i", source, "-ss", track.Start, "-t", track.End - track.Start, track.Name.RelativeTo(destFolder).WithExtension(WAVExtension) }, ThrowOnNonZeroExitCode = true }; var ffmpegLogs = process.Output.Where(arg => arg.Type == ProcessHelper.StreamType.Output) .ForEachAsync(val => { Utils.Status($"Extracting {track.Name} - {val.Line}"); }); await process.Start(); if (track.Format == Track.FormatEnum.WAV) { return; } process = new ProcessHelper() { Path = xWMAEncodePath, Arguments = new object[] { "-b", 192000, track.Name.RelativeTo(destFolder).WithExtension(WAVExtension), track.Name.RelativeTo(destFolder).WithExtension(XWMExtension) }, ThrowOnNonZeroExitCode = true }; var xwmLogs = process.Output.Where(arg => arg.Type == ProcessHelper.StreamType.Output) .ForEachAsync(val => { Utils.Status($"Encoding {track.Name} - {val.Line}"); }); await process.Start(); if (File.Exists($"{destFolder}\\{track.Name}.wav")) { File.Delete($"{destFolder}\\{track.Name}.wav"); } }
public static string ExtractToTempFile(GrepSearchResult searchResult) { if (searchResult == null) { throw new ArgumentNullException(nameof(searchResult)); } string tempFolder = Path.Combine(Utils.GetTempFolder(), "dnGREP-Archive", Utils.GetHash(searchResult.FileNameReal)); string[] parts = searchResult.FileNameDisplayed.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); if (!searchResult.FileNameDisplayed.Contains(ArchiveSeparator) || parts.Length < 2) { return(string.Empty); } string innerFileName = parts.Last(); string[] intermediateFiles = parts.Skip(1).Take(parts.Length - 2).ToArray(); string filePath = Path.Combine(tempFolder, innerFileName); if (!File.Exists(filePath)) { // use the directory name to also include folders within the archive string directory = Path.GetDirectoryName(filePath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } string zipFile = searchResult.FileNameReal; if (zipFile.Length > 260 && !zipFile.StartsWith(@"\\?\", StringComparison.InvariantCulture)) { zipFile = @"\\?\" + zipFile; } using (FileStream input = File.Open(zipFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { ExtractToTempFile(input, filePath, searchResult.FileNameReal, innerFileName, intermediateFiles); } } return(filePath); }
public string ExtractToTempFile(GrepSearchResult searchResult) { string tempFolder = Path.Combine(Utils.GetTempFolder(), "dnGREP-Archive", Utils.GetHash(searchResult.FileNameReal)); string innerFileName = searchResult.FileNameDisplayed.Substring(searchResult.FileNameReal.Length).TrimStart(Path.DirectorySeparatorChar); string filePath = Path.Combine(tempFolder, innerFileName); if (!File.Exists(filePath)) { // use the directory name to also include folders within the archive string directory = Path.GetDirectoryName(filePath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } string zipFile = searchResult.FileNameReal; if (zipFile.Length > 260 && !zipFile.StartsWith(@"\\?\")) { zipFile = @"\\?\" + zipFile; } using (SevenZipExtractor extractor = new SevenZipExtractor(zipFile)) { if (extractor.ArchiveFileData.Where(r => r.FileName == innerFileName && !r.IsDirectory).Any()) { using (FileStream stream = File.Open(filePath, FileMode.Create, FileAccess.Write, FileShare.None)) { try { extractor.ExtractFile(innerFileName, stream); } catch (Exception ex) { logger.Log <Exception>(LogLevel.Error, string.Format("Failed extract file {0} from archive '{1}'", innerFileName, searchResult.FileNameReal), ex); } } } } } return(filePath); }
public LuceneIndex(string LIBRARY_INDEX_BASE_PATH) { this.LIBRARY_INDEX_BASE_PATH = LIBRARY_INDEX_BASE_PATH; CheckIndexVersion(); // Write the version of the index Directory.CreateDirectory(LIBRARY_INDEX_BASE_PATH); File.WriteAllText(VersionFilename, INDEX_VERSION); // Delete any old locks if (File.Exists(LuceneWriteLockFilename)) { Logging.Warn("The lucene file lock was still there (bad shutdown perhaps) - so deleting it"); File.Delete(LuceneWriteLockFilename); } // Create our common parts analyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29, new Hashtable()); }
private void LoadKnownWebLibraries(string filename, bool only_load_those_libraries_which_are_actually_present) { Logging.Info("+Loading known Web Libraries"); try { if (File.Exists(filename)) { KnownWebLibrariesFile known_web_libraries_file = SerializeFile.ProtoLoad <KnownWebLibrariesFile>(filename); if (null != known_web_libraries_file.web_library_details) { //... } } } catch (Exception ex) { Logging.Error(ex, "There was a problem loading the known Web Libraries from config file {0}", filename); } Logging.Info("-Loading known Web Libraries"); }
private async Task InstallIncludedFiles() { Info("Writing inline files"); await ModList.Directives.OfType <InlineFile>() .PMap(Queue, directive => { if (directive.To.EndsWith(Consts.MetaFileExtension)) { return; } Info($"Writing included file {directive.To}"); var outPath = Path.Combine(OutputFolder, directive.To); if (File.Exists(outPath)) { File.Delete(outPath); } File.WriteAllBytes(outPath, LoadBytesFromPath(directive.SourceDataID)); }); }
internal static string FindValidStyleFilename(string style_filename) { // If this filename no longer exists, check if we can find the same filename in the default directory if (File.Exists(style_filename)) { return(style_filename); } else { string new_style_filename = Path.GetFullPath(Path.Combine(BASE_STYLE_DIRECTORY, Path.GetFileName(style_filename))); if (File.Exists(new_style_filename)) { return(new_style_filename); } else { return(null); } } }
public static void Rotate(string filenameBase) { if (File.Exists(filenameBase)) { for (int i = 8; i >= 0; i--) { string fn = filenameBase + "." + i; if (File.Exists(fn)) { string fn2 = filenameBase + "." + (i + 1); if (File.Exists(fn2)) { File.Delete(fn2); } File.Move(fn, fn2); } } File.Copy(filenameBase, filenameBase + ".0"); } }
public List <GrepLine> GetLinesWithContext(int linesBefore, int linesAfter) { if (searchResults == null) { if (File.Exists(FileNameReal)) { EOL = Utils.GetEOL(FileNameReal, Encoding); using (FileStream reader = File.Open(FileNameReal, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (StreamReader streamReader = new StreamReader(reader, Encoding)) { searchResults = Utils.GetLinesEx(streamReader, Matches, linesBefore, linesAfter); } } else { searchResults = new List <GrepLine>(); } } return(searchResults); }
public void SyncToDisk() { if (!_disableDiskCache) { Utils.Status("Syncing VFS Cache"); lock (this) { try { _isSyncing = true; if (File.Exists("vfs_cache.bin_new")) { File.Delete("vfs_cache.bin_new"); } using (var fs = File.OpenWrite("vfs_cache.bin_new")) using (var bw = new BinaryWriter(fs)) { Utils.Log($"Syncing VFS to Disk: {_files.Count} entries"); foreach (var f in _files.Values) { f.Write(bw); } } if (File.Exists("vfs_cache.bin")) { File.Delete("vfs_cache.bin"); } File.Move("vfs_cache.bin_new", "vfs_cache.bin"); } finally { _isSyncing = false; } } } }
public List <GrepLine> GetLinesWithContext(int linesBefore, int linesAfter) { if (searchResults == null) { if (File.Exists(FileNameReal)) { if (Utils.IsArchive(FileNameReal)) { searchResults = ArchiveDirectory.GetLinesWithContext(this, linesBefore, linesAfter); } else { EOL = Utils.GetEOL(FileNameReal, Encoding); using (FileStream reader = File.Open(FileNameReal, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { if (IsHexFile) { using (BinaryReader readStream = new BinaryReader(reader)) { searchResults = Utils.GetLinesHexFormat(readStream, Matches, linesBefore, linesAfter); } } else { using (StreamReader streamReader = new StreamReader(reader, Encoding)) { searchResults = Utils.GetLinesEx(streamReader, Matches, linesBefore, linesAfter); } } } } } else { searchResults = new List <GrepLine>(); } } return(searchResults); }
public void TestDefaultDictionariesMatch() { string solutionPath = Directory.GetParent(GetDllPath()) .Parent.Parent.Parent.FullName; var path1 = Path.Combine(solutionPath, @"dnGREP.WPF\Themes\LightBrushes.xaml"); var path2 = Path.Combine(solutionPath, @"dnGREP.WPF\Themes\DarkBrushes.xaml"); Assert.True(File.Exists(path1)); Assert.True(File.Exists(path2)); ResourceDictionary dict1 = LoadXaml(path1); ResourceDictionary dict2 = LoadXaml(path2); Assert.NotNull(dict1); Assert.NotNull(dict2); Assert.Equal(dict1.Count, dict2.Count); foreach (var key in dict1.Keys) { Assert.True(dict2.Contains(key)); object value1 = dict1[key]; object value2 = dict2[key]; if (value1 is Brush) { Assert.True(value2 is Brush); } else if (value1 is DropShadowEffect) { Assert.True(value2 is DropShadowEffect); } else if (value1 is bool) { Assert.True(value2 is bool); } } }
public static object LoadRedundant(string filename) { try { return(Load(filename)); } catch { // Check if there is a redundant file to fall back on string redundant_filename = filename + REDUNDANT; if (File.Exists(redundant_filename)) { File.Delete(filename); File.Move(redundant_filename, filename); return(Load(filename)); } else { throw; } } }
public AITagManager(Library library) { this.library = new TypedWeakReference <Library>(library); current_ai_tags_record = new AITags(); // Attempt to load the existing tags try { if (File.Exists(Filename_Store)) { Stopwatch clk = Stopwatch.StartNew(); Logging.Info("+Loading AutoTags"); current_ai_tags_record = SerializeFile.ProtoLoad <AITags>(Filename_Store); Logging.Info("-Loading AutoTags (time spent: {0} ms)", clk.ElapsedMilliseconds); } } catch (Exception ex) { Logging.Warn(ex, "There was a problem loading existing AutoTags"); } }
private static void DoDirectCopy(string vmBackupPath, string snapshotPath, int volumePathLength, string vmPath) { var srcPath = Path.Combine(snapshotPath, vmPath.Substring(volumePathLength)); if (Directory.Exists(srcPath)) { foreach (var srcChildPath in Directory.GetFileSystemEntries(srcPath)) { var srcChildPathRel = srcChildPath.Substring(snapshotPath.EndsWith(Path.PathSeparator.ToString(), StringComparison.CurrentCultureIgnoreCase) ? snapshotPath.Length : snapshotPath.Length + 1); var childPath = Path.Combine(vmPath.Substring(0, volumePathLength), srcChildPathRel); DoDirectCopy(vmBackupPath, snapshotPath, volumePathLength, childPath); } } else if (File.Exists(srcPath)) { var outputName = Path.Combine(vmBackupPath, vmPath.Substring(volumePathLength)); var s = File.OpenRead(srcPath); var folder = Path.GetDirectoryName(outputName); if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } var ns = File.Create(outputName); s.CopyTo(ns); } else { var lowerPath = srcPath.ToLowerInvariant(); var isIgnorable = lowerPath.EndsWith(".avhdx") || lowerPath.EndsWith(".vmrs") || lowerPath.EndsWith(".bin") || lowerPath.EndsWith(".vsv"); if (!isIgnorable) { throw new Exception($"Entry \"{srcPath}\" not found in snapshot"); } } }
public override bool Initialize(GrepEngineInitParams param, FileFilter filter) { base.Initialize(param, filter); try { // Make sure pdftotext.exe exists pathToPdfToText = Utils.GetCurrentPath(typeof(GrepEnginePdf)) + "\\pdftotext.exe"; if (File.Exists(pathToPdfToText)) { return(true); } else { return(false); } } catch (Exception ex) { logger.Error(ex, "Failed to find pdftotext.exe."); return(false); } }
private void IgnoredItems_ContextMenuItem_Click(object sender, RoutedEventArgs e) { try { foreach (var junk in IgnoredItems.SelectedItems.OfType <string>().ToList()) { switch ((string)(sender as MenuItem)?.Tag) { case "Explorer": if (File.Exists(junk) || Directory.Exists(junk)) { Process.Start(junk); } break; case "Ignore": Definitions.List.IgnoredJunkItems.Remove(junk); break; case "Delete": if (File.Exists(junk)) { File.Delete(junk); } else if (Directory.Exists(junk)) { Directory.Delete(junk, true); } Definitions.List.IgnoredJunkItems.Remove(junk); break; } } } catch (Exception ex) { Logger.Fatal(ex); } }
public static T ProtoLoad <T>(string filename) { try { return(ProtoLoad_NotRedundant <T>(filename)); } catch (Exception ex) { // Check if there is a redundant file to fall back on string redundant_filename = filename + REDUNDANT; if (File.Exists(redundant_filename)) { File.Delete(filename); File.Move(redundant_filename, filename); return(ProtoLoad_NotRedundant <T>(filename)); } else { throw ex; } } }
/// <summary> /// Remove any orphaned files in the DB. /// </summary> private void CleanDB() { Utils.Log("Cleaning VFS cache"); lock (this) { _files.Values .Where(f => { if (f.IsConcrete) { return(!File.Exists(f.StagedPath)); } if (f.Hash == null) { return(true); } while (f.ParentPath != null) { if (Lookup(f.ParentPath) == null) { return(true); } if (f.Hash == null) { return(true); } f = Lookup(f.ParentPath); } return(false); }) .ToList() .Do(f => { _files.Remove(f.FullPath); }); SyncToDisk(); } }
private void LoadFromDisk() { try { Utils.Log("Loading VFS Cache"); if (!File.Exists("vfs_cache.bin")) { return; } _files = new Dictionary <string, VirtualFile>(); try { using (var fs = File.OpenRead("vfs_cache.bin")) using (var br = new BinaryReader(fs)) { while (true) { var fr = VirtualFile.Read(br); _files.Add(fr.FullPath, fr); } } } catch (EndOfStreamException ex) { } CleanDB(); } catch (Exception ex) { Utils.Log($"Purging cache due to {ex}"); File.Delete("vfs_cache.bson"); _isDirty = true; _files.Clear(); } }
private void CheckIndexVersion() { string version = String.Empty; try { if (File.Exists(VersionFilename)) { string[] index_version_lines = File.ReadAllLines(VersionFilename); version = index_version_lines[0].Trim(); } } catch (Exception ex) { Logging.Error(ex, $"There was a problem while trying to check the index version (path: '{LIBRARY_INDEX_BASE_PATH}')"); } if (0 != String.Compare(version, INDEX_VERSION)) { Logging.Warn("This index is out of date (it's version is {0}), so deleting the index.", version); DeleteIndex(); } }
private void Load() { // Utilities.LockPerfTimer l1_clk = Utilities.LockPerfChecker.Start(); lock (tokens_lock) { // l1_clk.LockPerfTimerStop(); try { if (File.Exists(FILENAME)) { string[] lines = File.ReadAllLines(FILENAME); foreach (var line in lines) { tokens.Add(line); } } } catch (Exception ex) { Logging.Warn(ex, "There was a problem loading {0}", FILENAME); } } }
public void VerifyInstalledFile(string mod, string file) { var src = Path.Combine(MO2Folder, "mods", mod, file); Assert.IsTrue(File.Exists(src), src); var dest = Path.Combine(InstallFolder, "mods", mod, file); Assert.IsTrue(File.Exists(dest), dest); var src_data = File.ReadAllBytes(src); var dest_data = File.ReadAllBytes(dest); Assert.AreEqual(src_data.Length, dest_data.Length); for (int x = 0; x < src_data.Length; x++) { if (src_data[x] != dest_data[x]) { Assert.Fail($"Index {x} of {mod}\\{file} are not the same"); } } }
public static void StoreIcon(string extension, string path, string mimeType) { if (!File.Exists(path)) { try { if (!Directory.Exists(Path.GetDirectoryName(path))) { Directory.CreateDirectory(Path.GetDirectoryName(path)); } Bitmap image = IconHandler.IconFromExtension(extension, IconSize.Small); System.Drawing.Imaging.Encoder qualityEncoder = System.Drawing.Imaging.Encoder.Quality; long quality = 100; EncoderParameter ratio = new EncoderParameter(qualityEncoder, quality); EncoderParameters codecParams = new EncoderParameters(1); codecParams.Param[0] = ratio; ImageCodecInfo mimeCodecInfo = null; foreach (ImageCodecInfo codecInfo in ImageCodecInfo.GetImageEncoders()) { if (codecInfo.MimeType == mimeType) { mimeCodecInfo = codecInfo; break; } } if (mimeCodecInfo != null) { image.Save(path, mimeCodecInfo, codecParams); // Save to JPG } } catch (Exception ex) { logger.Log <Exception>(LogLevel.Error, "Failed to create icon", ex); } } }
private static KeyValue LoadFromFile(string path, bool asBinary) { if (!File.Exists(path)) { return(null); } try { using (var input = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { var kv = new KeyValue(); if (asBinary) { if (!kv.TryReadAsBinary(input)) { return(null); } } else { if (!kv.ReadAsText(input)) { return(null); } } return(kv); } } catch (Exception) { return(null); } }
public static LocaleTable Load(string filename) { try { if (File.Exists(filename)) { LocaleTable locale_table = new LocaleTable(); string[] lines = File.ReadAllLines(filename); foreach (string line in lines) { string[] parts = line.Split(LINE_SPLITTER_ARRAY, 2); if (2 == parts.Length) { parts[1] = parts[1].Replace("\\n", Environment.NewLine); locale_table[parts[0]] = String.Format(parts[1]); } else { if (!String.IsNullOrWhiteSpace(line)) { Logging.Warn("Ignoring locale line: " + line); } } } return(locale_table); } } catch (Exception ex) { Logging.Error(ex, "Error loading locale file " + filename); } return(null); }
public static void Load() { try { BookmarkEntity bookmarkLib; XmlSerializer serializer = new XmlSerializer(typeof(BookmarkEntity)); if (!File.Exists(Utils.GetDataFolderPath() + "\\bookmarks.xml")) { bookmarks = new BookmarkEntity(); } else { using (TextReader reader = new StreamReader(Utils.GetDataFolderPath() + "\\bookmarks.xml")) { bookmarkLib = (BookmarkEntity)serializer.Deserialize(reader); bookmarks = bookmarkLib; } } } catch { bookmarks = new BookmarkEntity(); } }
private static void AddPathToCompressionList(IDictionary <string, Stream> files, ICollection <Stream> streams, string snapshotPath, int volumePathLength, string vmPath) { var srcPath = Path.Combine(snapshotPath, vmPath.Substring(volumePathLength)); if (Directory.Exists(srcPath)) { foreach (var srcChildPath in Directory.GetFileSystemEntries(srcPath)) { var srcChildPathRel = srcChildPath.Substring(snapshotPath.EndsWith(Path.PathSeparator.ToString(), StringComparison.CurrentCultureIgnoreCase) ? snapshotPath.Length : snapshotPath.Length + 1); var childPath = Path.Combine(vmPath.Substring(0, volumePathLength), srcChildPathRel); AddPathToCompressionList(files, streams, snapshotPath, volumePathLength, childPath); } } else if (File.Exists(srcPath)) { var s = File.OpenRead(srcPath); files.Add(vmPath.Substring(volumePathLength), s); streams.Add(s); } else { var lowerPath = srcPath.ToLowerInvariant(); var isIgnorable = lowerPath.EndsWith(".avhdx") || lowerPath.EndsWith(".vmrs") || lowerPath.EndsWith(".bin") || lowerPath.EndsWith(".vsv"); if (!isIgnorable) { throw new Exception($"Entry \"{srcPath}\" not found in snapshot"); } } }
public static void Load() { try { BookmarkEntity bookmarkLib; XmlSerializer serializer = new XmlSerializer(typeof(BookmarkEntity)); if (!File.Exists(BookmarksFile)) { bookmarks = new BookmarkEntity(); } else { using (TextReader reader = new StreamReader(BookmarksFile)) { bookmarkLib = (BookmarkEntity)serializer.Deserialize(reader); bookmarks = bookmarkLib; } } } catch { bookmarks = new BookmarkEntity(); } }