/// <exception cref="System.IO.IOException"></exception> private Tree BuildTree(Dictionary <string, string> headEntries) { Tree tree = new Tree(db); if (headEntries == null) { return(tree); } FileTreeEntry fileEntry; Tree parent; ObjectInserter oi = db.NewObjectInserter(); try { foreach (KeyValuePair <string, string> e in headEntries.EntrySet()) { fileEntry = tree.AddFile(e.Key); fileEntry.SetId(GenSha1(e.Value)); parent = fileEntry.GetParent(); while (parent != null) { parent.SetId(oi.Insert(Constants.OBJ_TREE, parent.Format())); parent = parent.GetParent(); } } oi.Flush(); } finally { oi.Release(); } return(tree); }
/// <exception cref="System.IO.IOException"></exception> private void Commit(string commitMsg, PersonIdent author, PersonIdent committer) { NGit.CommitBuilder commit = new NGit.CommitBuilder(); commit.Author = author; commit.Committer = committer; commit.Message = commitMsg; ObjectInserter inserter = db.NewObjectInserter(); ObjectId id; try { commit.TreeId = inserter.Insert(new TreeFormatter()); id = inserter.Insert(commit); inserter.Flush(); } finally { inserter.Release(); } int nl = commitMsg.IndexOf('\n'); RefUpdate ru = db.UpdateRef(Constants.HEAD); ru.SetNewObjectId(id); ru.SetRefLogMessage("commit : " + ((nl == -1) ? commitMsg : Sharpen.Runtime.Substring (commitMsg, 0, nl)), false); ru.ForceUpdate(); }
/// <exception cref="System.IO.IOException"></exception> private ObjectId InsertTree(Tree tree) { ObjectInserter oi = db.NewObjectInserter(); try { ObjectId id = oi.Insert(Constants.OBJ_TREE, tree.Format()); oi.Flush(); return(id); } finally { oi.Release(); } }
/// <summary> /// Update this index entry with stat and SHA-1 information if it looks /// like the file has been modified in the workdir. /// </summary> /// <remarks> /// Update this index entry with stat and SHA-1 information if it looks /// like the file has been modified in the workdir. /// </remarks> /// <param name="f">file in work dir</param> /// <returns>true if a change occurred</returns> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual bool Update(FilePath f) { long lm = f.LastModified() * 1000000L; bool modified = this.mtime != lm; this.mtime = lm; if (this.size != f.Length()) { modified = true; } if (this._enclosing.Config_filemode()) { if (this._enclosing.File_canExecute(f) != FileMode.EXECUTABLE_FILE.Equals(this.mode )) { this.mode = FileMode.EXECUTABLE_FILE.GetBits(); modified = true; } } if (modified) { this.size = (int)f.Length(); ObjectInserter oi = this._enclosing.db.NewObjectInserter(); try { InputStream @in = new FileInputStream(f); try { ObjectId newsha1 = oi.Insert(Constants.OBJ_BLOB, f.Length(), @in); oi.Flush(); if (!newsha1.Equals(this.sha1)) { modified = true; } this.sha1 = newsha1; } finally { @in.Close(); } } finally { oi.Release(); } } return(modified); }
/// <exception cref="System.IO.IOException"></exception> internal Entry(GitIndex _enclosing, byte[] key, FilePath f, int stage, byte[] newContent ) { this._enclosing = _enclosing; this.ctime = f.LastModified() * 1000000L; this.mtime = this.ctime; // we use same here this.dev = -1; this.ino = -1; if (this._enclosing.Config_filemode() && this._enclosing.File_canExecute(f)) { this.mode = FileMode.EXECUTABLE_FILE.GetBits(); } else { this.mode = FileMode.REGULAR_FILE.GetBits(); } this.uid = -1; this.gid = -1; this.size = newContent.Length; ObjectInserter inserter = this._enclosing.db.NewObjectInserter(); try { InputStream @in = new FileInputStream(f); try { this.sha1 = inserter.Insert(Constants.OBJ_BLOB, newContent); } finally { @in.Close(); } inserter.Flush(); } finally { inserter.Release(); } this.name = key; this.flags = (short)((stage << 12) | this.name.Length); // TODO: fix flags this.stages = (1 >> this.GetStage()); }
internal virtual ObjectId GenSha1(string data) { ObjectInserter w = db.NewObjectInserter(); try { ObjectId id = w.Insert(Constants.OBJ_BLOB, Sharpen.Runtime.GetBytesForString(data )); w.Flush(); return(id); } catch (IOException e) { NUnit.Framework.Assert.Fail(e.ToString()); } finally { w.Release(); } return(null); }
/// <summary> /// Update this index entry with stat and SHA-1 information if it looks /// like the file has been modified in the workdir. /// </summary> /// <remarks> /// Update this index entry with stat and SHA-1 information if it looks /// like the file has been modified in the workdir. /// </remarks> /// <param name="f">file in work dir</param> /// <param name="newContent">the new content of the file</param> /// <returns>true if a change occurred</returns> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual bool Update(FilePath f, byte[] newContent) { bool modified = false; this.size = newContent.Length; ObjectInserter oi = this._enclosing.db.NewObjectInserter(); try { ObjectId newsha1 = oi.Insert(Constants.OBJ_BLOB, newContent); oi.Flush(); if (!newsha1.Equals(this.sha1)) { modified = true; } this.sha1 = newsha1; } finally { oi.Release(); } return(modified); }
/// <summary>Resets the index to represent exactly some filesystem content.</summary> /// <remarks> /// Resets the index to represent exactly some filesystem content. E.g. the /// following call will replace the index with the working tree content: /// <p> /// <code>resetIndex(new FileSystemIterator(db))</code> /// <p> /// This method can be used by testcases which first prepare a new commit /// somewhere in the filesystem (e.g. in the working-tree) and then want to /// have an index which matches their prepared content. /// </remarks> /// <param name="treeItr"> /// a /// <see cref="NGit.Treewalk.FileTreeIterator">NGit.Treewalk.FileTreeIterator</see> /// which determines which files should /// go into the new index /// </param> /// <exception cref="System.IO.FileNotFoundException">System.IO.FileNotFoundException /// </exception> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> protected internal virtual void ResetIndex(FileTreeIterator treeItr) { ObjectInserter inserter = db.NewObjectInserter(); DirCacheBuilder builder = db.LockDirCache().Builder(); DirCacheEntry dce; while (!treeItr.Eof) { long len = treeItr.GetEntryLength(); dce = new DirCacheEntry(treeItr.EntryPathString); dce.FileMode = treeItr.EntryFileMode; dce.LastModified = treeItr.GetEntryLastModified(); dce.SetLength((int)len); FileInputStream @in = new FileInputStream(treeItr.GetEntryFile()); dce.SetObjectId(inserter.Insert(Constants.OBJ_BLOB, len, @in)); @in.Close(); builder.Add(dce); treeItr.Next(1); } builder.Commit(); inserter.Flush(); inserter.Release(); }
/// <summary>Construct and write tree out of index.</summary> /// <remarks>Construct and write tree out of index.</remarks> /// <returns>SHA-1 of the constructed tree</returns> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual ObjectId WriteTree() { CheckWriteOk(); ObjectInserter inserter = db.NewObjectInserter(); try { Tree current = new Tree(db); Stack <Tree> trees = new Stack <Tree>(); trees.Push(current); string[] prevName = new string[0]; foreach (GitIndex.Entry e in entries.Values) { if (e.GetStage() != 0) { continue; } string[] newName = SplitDirPath(e.GetName()); int c = LongestCommonPath(prevName, newName); while (c < trees.Count - 1) { current.SetId(inserter.Insert(Constants.OBJ_TREE, current.Format())); trees.Pop(); current = trees.IsEmpty() ? null : (Tree)trees.Peek(); } while (trees.Count < newName.Length) { if (!current.ExistsTree(newName[trees.Count - 1])) { current = new Tree(current, Constants.Encode(newName[trees.Count - 1])); current.GetParent().AddEntry(current); trees.Push(current); } else { current = (Tree)current.FindTreeMember(newName[trees.Count - 1]); trees.Push(current); } } FileTreeEntry ne = new FileTreeEntry(current, e.sha1, Constants.Encode(newName[newName .Length - 1]), (e.mode & FileMode.EXECUTABLE_FILE.GetBits()) == FileMode.EXECUTABLE_FILE .GetBits()); current.AddEntry(ne); } while (!trees.IsEmpty()) { current.SetId(inserter.Insert(Constants.OBJ_TREE, current.Format())); trees.Pop(); if (!trees.IsEmpty()) { current = trees.Peek(); } } inserter.Flush(); return(current.GetId()); } finally { inserter.Release(); } }
/// <exception cref="System.Exception"></exception> private ObjectId Commit(ObjectInserter odi, DirCache treeB, ObjectId[] parentIds) { NGit.CommitBuilder c = new NGit.CommitBuilder(); c.TreeId = treeB.WriteTree(odi); c.Author = new PersonIdent("A U Thor", "a.u.thor", 1L, 0); c.Committer = c.Author; c.SetParentIds(parentIds); c.Message = "Tree " + c.TreeId.Name; ObjectId id = odi.Insert(c); odi.Flush(); return id; }