public static PrintDiagnostics ( string v ) : void | ||
v | string | |
Résultat | void |
private LocalDB(string path, SQLite.SQLiteOpenFlags flags) : base(new FileInfo(path).GetFullNameWithCorrectCase(), flags) { Printer.PrintDiagnostics("Local DB Open."); if ((flags & SQLite.SQLiteOpenFlags.Create) != 0) { PrepareTables(); } }
private bool UniquenessCheck() { Workspace ws = Workspace; if (ws.ComputerName != Environment.MachineName) { Printer.PrintDiagnostics("Uniqueness check: Machine name has changed (was: \"{0}\" now \"{1}\")!", ws.ComputerName, Environment.MachineName); return(false); } if (new FileInfo(ws.LocalWorkspacePath).GetFullNameWithCorrectCase() != new FileInfo(DatabasePath).GetFullNameWithCorrectCase()) { Printer.PrintDiagnostics("Uniqueness check: Patch changed (was: \"{0}\" now \"{1}\")!", ws.LocalWorkspacePath, new FileInfo(DatabasePath).GetFullNameWithCorrectCase()); return(false); } return(true); }
private void BuildTree() { Root = new FileTreeFolder(); Dictionary <Entry, FileTreeEntry> mapping = new Dictionary <Entry, FileTreeEntry>(); int files = 0; foreach (var x in Entries) { var fte = GetEntry(mapping, x); if (!fte.IsDirectory) { files++; } } foreach (var x in mapping) { x.Value.Initialize(); } Printer.PrintDiagnostics("Current working directory has {0} file{1} in {2} director{3}.", files, files == 1 ? "" : "s", Entries.Count - files, (Entries.Count - files) == 1 ? "y" : "ies"); }
internal static string CheckHash(FileInfo info) { #if SHOW_HASHES Printer.PrintDiagnostics("Hashing: {0}", info.FullName); #endif using (var hasher = System.Security.Cryptography.SHA1.Create()) using (var fs = info.OpenRead()) { byte[] hashBytes = hasher.ComputeHash(fs); char[] chararray = new char[hashBytes.Length * 2]; for (int i = 0; i < hashBytes.Length; i++) { chararray[i * 2] = s_Base16NibbleTable[hashBytes[i] >> 4]; chararray[i * 2 + 1] = s_Base16NibbleTable[hashBytes[i] & 0xF]; } return(new string(chararray)); } }
public List <Objects.Version> GetHistory(Objects.Version version, int?limit = null) { System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); //List<Objects.Version> result = new List<Objects.Version>(); //result.Add(version); //var results = Query<Objects.Version>( // @"WITH RECURSIVE // ancestors(n) AS ( // VALUES(?) // UNION // SELECT Parent FROM ancestors, Version // WHERE ancestors.n = Version.ID // ) // SELECT Version.* FROM Version INNER JOIN ancestors ON ancestors.n = Version.ID;", version.Parent); //result.AddRange(results); var result = Query <Objects.Version>(string.Format( @"WITH RECURSIVE ancestors(rowid, ID, Author, Message, Published, Branch, Parent, Timestamp, Snapshot, AlterationList) AS ( SELECT rowid, * FROM Version WHERE Version.ID = ? UNION ALL SELECT Version.rowid, Version.* FROM ancestors, Version WHERE ancestors.Parent = Version.ID {0} ) SELECT * FROM ancestors;", limit.HasValue ? "LIMIT " + limit.Value.ToString() : ""), version.ID); // Naive version // var ver = version; // while (ver != null) // { // result.Add(ver); // ver = Find<Objects.Version>(ver.Parent); // } sw.Stop(); Printer.PrintDiagnostics("History determined in {0} ms", sw.ElapsedMilliseconds); return(result); }
private void SetUniqueData() { try { Printer.PrintDiagnostics("LocalDB has been moved or is missing uniqueness data. Regenerating."); Workspace ws = Workspace; BeginTransaction(); ws.ComputerName = Environment.MachineName; ws.LocalWorkspacePath = new FileInfo(DatabasePath).GetFullNameWithCorrectCase(); ws.MakeUnique(); Printer.PrintDiagnostics("WS MachineName {0}, StashCode: {1}, Journal ID: {2}.", ws.ComputerName, ws.StashCode, ws.JournalID); Configuration conf = Configuration; conf.WorkspaceID = ws.ID; Update(conf); Update(ws); Commit(); } catch { Rollback(); throw; } }
private static List <Entry> GetEntryList(Area area, DirectoryInfo root, DirectoryInfo adminFolder) { System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Restart(); try { Func <string, List <FlatFSEntry> > nativeGenerator = null; if (!Utilities.MultiArchPInvoke.IsRunningOnMono) { if (GetFSFast == null) { var asm = System.Reflection.Assembly.LoadFrom(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + "/x64/VersionrCore.Win32.dll"); GetFSFast = asm.GetType("Versionr.Win32.FileSystem").GetMethod("EnumerateFileSystem").CreateDelegate(typeof(Func <string, List <FlatFSEntry> >)) as Func <string, List <FlatFSEntry> >; } nativeGenerator = GetFSFast; } else { nativeGenerator = PosixFS.GetFlatEntries; } List <FlatFSEntry> flatEntries = null; if (!Utilities.MultiArchPInvoke.IsRunningOnMono) { } if (nativeGenerator != null) { string fn = root.FullName.Replace('\\', '/'); if (fn[fn.Length - 1] != '/') { fn += '/'; } System.Net.Sockets.Socket socket = new System.Net.Sockets.Socket(System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp); if (flatEntries == null) { Printer.PrintDiagnostics("#q#Using native file scanner...##"); sw.Restart(); flatEntries = nativeGenerator(fn); if (area.GetLocalPath(fn) != "") { flatEntries.Insert(0, new FlatFSEntry() { Attributes = (int)root.Attributes, ChildCount = flatEntries.Count, Length = -1, FileTime = root.LastWriteTimeUtc.Ticks, FullName = fn }); } sw.Restart(); } } if (flatEntries != null) { FSScan scan = new FSScan(); scan.FRIgnores = area?.Directives?.Ignore?.RegexFilePatterns; scan.FRIncludes = area?.Directives?.Include?.RegexFilePatterns; scan.ExtIgnores = area?.Directives?.Ignore?.Extensions; scan.ExtIncludes = area?.Directives?.Include?.Extensions; List <Entry> e2 = new List <Entry>(flatEntries.Count); System.Collections.Concurrent.ConcurrentBag <Entry> entries2 = new System.Collections.Concurrent.ConcurrentBag <Entry>(); System.Threading.CountdownEvent ce2 = new System.Threading.CountdownEvent(1); ProcessListFast(scan, area, flatEntries, area.RootDirectory.FullName, ce2, entries2, 0, flatEntries.Count, null); ce2.Signal(); ce2.Wait(); var ea = entries2.ToArray(); e2.Capacity = ea.Length; e2.AddRange(ea); return(e2); } } catch (System.Exception e) { // try again with the slow mode Printer.PrintDiagnostics("#q#Couldn't use fast scanners {0}##", e); } Printer.PrintDiagnostics("#q#Using fallback file scanner...##"); sw.Restart(); System.Collections.Concurrent.ConcurrentBag <Entry> entries = new System.Collections.Concurrent.ConcurrentBag <Entry>(); System.Threading.CountdownEvent ce = new System.Threading.CountdownEvent(1); PopulateList(entries, ce, area, null, root, area.GetLocalPath(root.FullName), adminFolder, false); ce.Signal(); ce.Wait(); Entry[] entryArray = entries.ToArray(); Array.Sort(entryArray, (Entry x, Entry y) => { return(string.CompareOrdinal(x.CanonicalName, y.CanonicalName)); }); return(entryArray.ToList()); }
public List <Record> GetRecords(Objects.Version version, out List <Record> baseList, out List <Alteration> alterations, bool testFailure = false) { System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); Printer.PrintDiagnostics("Getting records for version {0}.", version.ID); long?snapshotID = null; bool readtrans = false; try { BeginTransaction(); readtrans = true; } catch (InvalidOperationException) { // not an issue } List <Objects.Version> parents = new List <Objects.Version>(); Objects.Version snapshotVersion = version; while (!snapshotID.HasValue) { parents.Add(snapshotVersion); if (snapshotVersion.Snapshot.HasValue) { snapshotID = snapshotVersion.Snapshot; } else { if (!snapshotVersion.Parent.HasValue) { break; } snapshotVersion = Get <Objects.Version>(snapshotVersion.Parent); } } if (!snapshotID.HasValue) { Printer.PrintDiagnostics(" - No snapshot."); baseList = new List <Record>(); } else { Printer.PrintDiagnostics(" - Last snapshot version: {0}", snapshotVersion.ID); var sslist = Query <RecordRef>("SELECT * FROM RecordRef WHERE RecordRef.SnapshotID = ?", snapshotID.Value).Select(x => x.RecordID).ToList(); CacheRecords(sslist); baseList = sslist.Select(x => GetCachedRecord(x)).ToList(); Printer.PrintDiagnostics(" - Snapshot {0} has {1} records.", snapshotID, baseList.Count); } alterations = GetAlterationsInternal(parents); if (readtrans) { Commit(); } Printer.PrintDiagnostics(" - Target has {0} alterations.", alterations.Count); List <Record> finalList = null; try { finalList = Consolidate(baseList, alterations, null); } catch { if (testFailure) { throw; } Printer.PrintError("Error during database operation. Deleting cached snapshots."); BeginExclusive(true); RunConsistencyCheck(); Commit(); Printer.PrintError("Please retry this operation."); throw; } Printer.PrintDiagnostics("Record list resolved in {0} ticks.", sw.ElapsedTicks); if (testFailure) { return(finalList); } if (baseList.Count < alterations.Count || (alterations.Count > 4096 && parents.Count > 128)) { Printer.PrintDiagnostics(" - Attempting to build new snapshot ({0} records in base list, {1} alterations over {2} revisions)", baseList.Count, alterations.Count, parents.Count); try { BeginTransaction(); try { Objects.Snapshot snapshot = new Snapshot(); this.InsertSafe(snapshot); foreach (var z in finalList) { Objects.RecordRef rref = new RecordRef(); rref.RecordID = z.Id; rref.SnapshotID = snapshot.Id; this.InsertSafe(rref); } version.Snapshot = snapshot.Id; this.UpdateSafe(version); Commit(); } catch { Rollback(); } } catch { // Already in a transaction Objects.Snapshot snapshot = new Snapshot(); this.InsertSafe(snapshot); foreach (var z in finalList) { Objects.RecordRef rref = new RecordRef(); rref.RecordID = z.Id; rref.SnapshotID = snapshot.Id; this.InsertSafe(rref); } version.Snapshot = snapshot.Id; this.UpdateSafe(version); } } return(finalList); }
private void RunConsistencyCheck() { Printer.PrintMessage(" - Upgrading database - running full consistency check."); var objNames = Table <ObjectName>().ToList(); Dictionary <long, long> nameMapping = new Dictionary <long, long>(); Dictionary <string, long> nameIndexes = new Dictionary <string, long>(); DropTable <ObjectName>(); DropTable <RecordRef>(); CreateTable <ObjectName>(); int duplicateObjs = 0; foreach (var x in objNames) { if (nameIndexes.ContainsKey(x.CanonicalName)) { nameMapping[x.NameId] = nameIndexes[x.CanonicalName]; duplicateObjs++; } else { ObjectName oname = new ObjectName() { CanonicalName = x.CanonicalName }; Insert(oname); nameMapping[x.NameId] = oname.NameId; nameIndexes[x.CanonicalName] = oname.NameId; } } foreach (var x in Table <Record>().ToList()) { x.CanonicalNameId = nameMapping[x.CanonicalNameId]; Update(x); } Printer.PrintMessage(" - Cleaned {0} duplicate canonical names.", duplicateObjs); CreateTable <RecordRef>(); Dictionary <Tuple <string, long, DateTime>, Record> records = new Dictionary <Tuple <string, long, DateTime>, Record>(); foreach (var x in Table <Objects.Record>().ToList()) { var key = new Tuple <string, long, DateTime>(x.UniqueIdentifier, x.CanonicalNameId, x.ModificationTime); if (records.ContainsKey(key)) { var other = records[key]; Printer.PrintDiagnostics("Found duplicate records {0} ==> {1}", x.Id, other.Id); Printer.PrintDiagnostics(" - UID: {0}", x.UniqueIdentifier); Printer.PrintDiagnostics(" - Time: {0}", x.ModificationTime); Printer.PrintDiagnostics(" - Name: {0}", Get <ObjectName>(x.CanonicalNameId).CanonicalName); int updates = 0; foreach (var s in Table <Alteration>().Where(z => z.PriorRecord == x.Id || z.NewRecord == x.Id)) { if (s.NewRecord.HasValue && s.NewRecord.Value == x.Id) { s.NewRecord = other.Id; } if (s.PriorRecord.HasValue && s.PriorRecord.Value == x.Id) { s.PriorRecord = other.Id; } Update(s); updates++; } Delete(x); Printer.PrintDiagnostics("Deleted record and updated {0} links.", updates); } else { records[key] = x; } } int missingParents = 0; int bonusDeletions = 0; HashSet <long> allRecordIDs = new HashSet <long>(); var allRecords = Table <Objects.Record>().ToList(); foreach (var x in allRecords) { allRecordIDs.Add(x.Id); } foreach (var x in allRecords) { if (x.Parent.HasValue && !allRecordIDs.Contains(x.Parent.Value)) { missingParents++; x.Parent = null; Update(x); } } Printer.PrintDiagnostics("Removed {0} phantom record parents.", missingParents); foreach (var x in Table <Objects.Version>().ToList()) { x.Snapshot = null; Update(x); var alterations = Table <Objects.Alteration>().Where(z => z.Owner == x.AlterationList); HashSet <long> moveAdds = new HashSet <long>(); HashSet <long> moveDeletes = new HashSet <long>(); foreach (var s in alterations) { if (s.Type == AlterationType.Move) { moveAdds.Add(s.NewRecord.Value); moveDeletes.Add(s.PriorRecord.Value); } if (s.Type == AlterationType.Delete) { if (Find <Record>(s.PriorRecord.Value) == null) { bonusDeletions++; Delete(s); } } } foreach (var s in alterations) { if (s.Type == AlterationType.Add && moveAdds.Contains(s.NewRecord.Value)) { Delete(s); Printer.PrintDiagnostics("Cleaned up extra add in v{0} for \"{1}\"", x.ShortName, Get <ObjectName>(Get <Record>(s.NewRecord.Value).CanonicalNameId).CanonicalName); } if (s.Type == AlterationType.Delete && moveDeletes.Contains(s.PriorRecord.Value)) { Delete(s); Printer.PrintDiagnostics("Cleaned up extra delete in v{0} for \"{1}\"", x.ShortName, Get <ObjectName>(Get <Record>(s.PriorRecord.Value).CanonicalNameId).CanonicalName); } } } if (bonusDeletions >= 0) { Printer.PrintDiagnostics("Erased {0} unreconcilable deletions.", bonusDeletions); } }
private WorkspaceDB(string path, SQLite.SQLiteOpenFlags flags, LocalDB localDB) : base(path, flags) { Printer.PrintDiagnostics("Metadata DB Open."); EnableWAL = true; LocalDatabase = localDB; if (ExecuteScalar <string>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'FormatInfo';") != "FormatInfo") { CreateTable <Objects.FormatInfo>(); } if (flags.HasFlag(SQLite.SQLiteOpenFlags.Create)) { ExecuteDirect("PRAGMA main.page_size = 4096;"); ExecuteDirect("PRAGMA main.cache_size = 10240;"); ExecuteDirect("PRAGMA temp_store = MEMORY;"); ExecuteDirect("PRAGMA threads = 2;"); EnableWAL = true; PrepareTables(); return; } if (!ValidForUpgrade) { return; } if (Format.InternalFormat < InternalDBVersion) { try { var fmt = Format; int priorFormat = fmt.InternalFormat; if (priorFormat < 42) { ExecuteDirect("DROP TABLE Annotation"); ExecuteDirect("DROP TABLE AnnotationJournal"); ExecuteDirect("DROP TABLE TagJournal"); ExecuteDirect("DROP TABLE Tag"); } BeginExclusive(true); Printer.PrintMessage("Updating workspace database version from v{0} to v{1}", Format.InternalFormat, InternalDBVersion); PrepareTables(); if (priorFormat < 42) { RunConsistencyCheck(); } if (priorFormat < 33) { foreach (var x in Table <Record>().ToList()) { if (x.Parent.HasValue) { Record rp = Find <Record>(x.Parent.Value); if (rp == null) { Printer.PrintMessage("Found missing parent for record ID {0} - parent ID: {1}, attempting to fix.", x.Id, x.Parent.Value); Printer.PrintMessage(" - Record {0} - {1}", Find <ObjectName>(x.CanonicalNameId).CanonicalName, x.Fingerprint); var alterations = Query <Alteration>("SELECT * from Alteration where Alteration.NewRecord = ?", x.Id); var possibleParents = alterations.Where(z => z.PriorRecord.HasValue).Select(z => z.PriorRecord.Value).Distinct().ToList(); Printer.PrintMessage(" - Found {0} possible parents for this record.", possibleParents.Count); if (possibleParents.Count == 1) { Printer.PrintMessage(" - Updating parent record to ID {0}", possibleParents[0]); x.Parent = possibleParents[0]; } else { if (possibleParents.Count > 0) { Printer.PrintMessage(" - Data is ambiguous, removing parent record."); } else { Printer.PrintMessage(" - No parents found, removing parent record."); } x.Parent = null; } Update(x); } } } } if (priorFormat < 32) { int count = 0; foreach (var x in Table <Objects.Version>()) { if (x.Message != null && x.Message.StartsWith("Automatic merge of")) { var mergeInfos = Table <MergeInfo>().Where(y => y.DestinationVersion == x.ID).ToList(); if (mergeInfos.Count == 1) { mergeInfos[0].Type = MergeType.Automatic; Update(mergeInfos[0]); count++; } } } Printer.PrintMessage("Updated #b#{0}## merge info records.", count); } if (priorFormat < 31) { Dictionary <long, Record> recordMap = new Dictionary <long, Record>(); foreach (var x in Table <Record>().ToList()) { recordMap[x.Id] = x; } foreach (var x in Table <Record>().ToList()) { if (x.Parent.HasValue && !recordMap.ContainsKey(x.Parent.Value)) { x.Parent = null; Update(x); } } } if (priorFormat < 30) { foreach (var x in Table <Objects.Version>().ToList()) { x.Snapshot = null; Update(x); var alterations = Table <Objects.Alteration>().Where(z => z.Owner == x.AlterationList); Dictionary <long, bool> moveDeletes = new Dictionary <long, bool>(); HashSet <long> deletions = new HashSet <long>(); int counter = 0; foreach (var s in alterations) { if (s.Type == AlterationType.Move) { if (moveDeletes.ContainsKey(s.PriorRecord.Value)) { moveDeletes[s.PriorRecord.Value] = false; } else { moveDeletes[s.PriorRecord.Value] = true; } } } foreach (var s in alterations) { if (s.Type == AlterationType.Move) { if (moveDeletes[s.PriorRecord.Value] == false) { s.Type = AlterationType.Copy; Update(s); deletions.Add(s.PriorRecord.Value); counter++; } } } foreach (var s in deletions) { Alteration alt = new Alteration() { PriorRecord = s, Type = AlterationType.Delete, Owner = x.AlterationList }; Insert(alt); } if (counter > 0) { Printer.PrintDiagnostics("Version {0} had {1} multiple-moves that have been fixed.", x.ShortName, counter); } } } if (priorFormat < 30) { foreach (var x in Table <Objects.Version>().ToList()) { x.Snapshot = null; Update(x); var alterations = Table <Objects.Alteration>().Where(z => z.Owner == x.AlterationList); HashSet <Tuple <AlterationType, long?, long?> > duplicateAlterations = new HashSet <Tuple <AlterationType, long?, long?> >(); int counter = 0; foreach (var s in alterations) { var key = new Tuple <AlterationType, long?, long?>(s.Type, s.NewRecord, s.PriorRecord); if (duplicateAlterations.Contains(key)) { Delete(s); counter++; } else { duplicateAlterations.Add(key); } } if (counter > 0) { Printer.PrintDiagnostics("Version {0} had {1} duplicated alterations that have been fixed.", x.ShortName, counter); } } } DropTable <Objects.FormatInfo>(); fmt.InternalFormat = InternalDBVersion; CreateTable <Objects.FormatInfo>(); Insert(fmt); Commit(); Vacuum(); } catch (Exception e) { Rollback(); Printer.PrintError("Couldn't update DB: {0}", e.ToString()); } PrepareTables(); } }