public virtual void TestRefsCacheAfterUpdate() { // Do not use the defalt repo for this case. IDictionary <string, Ref> allRefs = db.GetAllRefs(); ObjectId oldValue = db.Resolve("HEAD"); ObjectId newValue = db.Resolve("HEAD^"); // first make HEAD refer to loose ref RefUpdate updateRef = db.UpdateRef(Constants.HEAD); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(newValue); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); // now update that ref updateRef = db.UpdateRef(Constants.HEAD); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(oldValue); update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update); allRefs = db.GetAllRefs(); Ref master = allRefs.Get("refs/heads/master"); Ref head = allRefs.Get("HEAD"); NUnit.Framework.Assert.AreEqual("refs/heads/master", master.GetName()); NUnit.Framework.Assert.AreEqual("HEAD", head.GetName()); NUnit.Framework.Assert.IsTrue(head.IsSymbolic(), "is symbolic reference"); NUnit.Framework.Assert.AreSame(master, head.GetTarget()); }
public virtual void DeleteMergedBranch_historyNotPruned() { RevCommit parent = tr.Commit().Create(); RevCommit b1Tip = tr.Branch("b1").Commit().Parent(parent).Add("x", "x").Create(); RevCommit b2Tip = tr.Branch("b2").Commit().Parent(parent).Add("y", "y").Create(); // merge b1Tip and b2Tip and update refs/heads/b1 to the merge commit Merger merger = ((ThreeWayMerger)MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.NewMerger(repo )); merger.Merge(b1Tip, b2Tip); NGit.Junit.CommitBuilder cb = tr.Commit(); cb.Parent(b1Tip).Parent(b2Tip); cb.SetTopLevelTree(merger.GetResultTreeId()); RevCommit mergeCommit = cb.Create(); RefUpdate u = repo.UpdateRef("refs/heads/b1"); u.SetNewObjectId(mergeCommit); u.Update(); RefUpdate update = repo.UpdateRef("refs/heads/b2"); update.SetForceUpdate(true); update.Delete(); gc.SetExpireAgeMillis(0); gc.Prune(Collections.EmptySet <ObjectId>()); NUnit.Framework.Assert.IsTrue(repo.HasObject(b2Tip)); }
public virtual void TestDeleteLooseAndItsDirectory() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/z/c"); updateRef.SetNewObjectId(pid); updateRef.SetForceUpdate(true); updateRef.SetRefLogMessage("new test ref", false); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); // internal NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, Constants.R_HEADS + "z") .Exists()); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "logs/refs/heads/z").Exists ()); // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/z/c"); updateRef2.SetForceUpdate(true); RefUpdate.Result delete = updateRef2.Delete(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, delete); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/z/c")); NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, Constants.R_HEADS + "z" ).Exists()); NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, "logs/refs/heads/z").Exists ()); }
public virtual void TestUpdateRefDetachedUnbornHead() { ObjectId ppid = db.Resolve("refs/heads/master^"); WriteSymref("HEAD", "refs/heads/unborn"); RefUpdate updateRef = db.UpdateRef("HEAD", true); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(ppid); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); NUnit.Framework.Assert.AreEqual(ppid, db.Resolve("HEAD")); Ref @ref = db.GetRef("HEAD"); NUnit.Framework.Assert.AreEqual("HEAD", @ref.GetName()); NUnit.Framework.Assert.IsTrue([email protected](), "is detached"); // the branch HEAD referred to is left untouched NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/unborn")); ReflogReader reflogReader = new ReflogReader(db, "HEAD"); ReflogEntry e = reflogReader.GetReverseEntries()[0]; NUnit.Framework.Assert.AreEqual(ObjectId.ZeroId, e.GetOldId()); NUnit.Framework.Assert.AreEqual(ppid, e.GetNewId()); NUnit.Framework.Assert.AreEqual("GIT_COMMITTER_EMAIL", e.GetWho().GetEmailAddress ()); NUnit.Framework.Assert.AreEqual("GIT_COMMITTER_NAME", e.GetWho().GetName()); NUnit.Framework.Assert.AreEqual(1250379778000L, e.GetWho().GetWhen().GetTime()); }
public virtual void TestDeleteForce() { RefUpdate @ref = db.UpdateRef("refs/heads/b"); @ref.SetNewObjectId(db.Resolve("refs/heads/a")); Delete(@ref, RefUpdate.Result.REJECTED, true, false); @ref.SetForceUpdate(true); Delete(@ref, RefUpdate.Result.FORCED); }
/// <exception cref="System.Exception"></exception> public virtual void TestPullEmptyRepository() { Repository empty = CreateWorkRepository(); RefUpdate delete = empty.UpdateRef(Constants.HEAD, true); delete.SetForceUpdate(true); delete.Delete(); Git.Wrap(empty).Pull().Call(); }
/// <exception cref="System.IO.IOException"></exception> private RefUpdate CreateRefUpdate(Ref stashRef) { RefUpdate update = repo.UpdateRef(Constants.R_STASH); update.DisableRefLog(); update.SetExpectedOldObjectId(stashRef.GetObjectId()); update.SetForceUpdate(true); return(update); }
/// <exception cref="System.IO.IOException"></exception> internal TrackingRefUpdate(Repository db, string localName, string remoteName, bool forceUpdate, AnyObjectId nv, string msg) { this.remoteName = remoteName; update = db.UpdateRef(localName); update.SetForceUpdate(forceUpdate); update.SetNewObjectId(nv); update.SetRefLogMessage(msg, true); }
/// <summary>Construct remote ref update request by providing an update specification. /// </summary> /// <remarks> /// Construct remote ref update request by providing an update specification. /// Object is created with default /// <see cref="Status.NOT_ATTEMPTED">Status.NOT_ATTEMPTED</see> /// status and no /// message. /// </remarks> /// <param name="localDb">local repository to push from.</param> /// <param name="srcRef"> /// source revision to label srcId with. If null srcId.name() will /// be used instead. /// </param> /// <param name="srcId"> /// The new object that the caller wants remote ref to be after /// update. Use null or /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// for delete /// request. /// </param> /// <param name="remoteName"> /// full name of a remote ref to update, e.g. "refs/heads/master" /// (no wildcard, no short name). /// </param> /// <param name="forceUpdate"> /// true when caller want remote ref to be updated regardless /// whether it is fast-forward update (old object is ancestor of /// new object). /// </param> /// <param name="localName"> /// optional full name of a local stored tracking branch, to /// update after push, e.g. "refs/remotes/zawir/dirty" (no /// wildcard, no short name); null if no local tracking branch /// should be updated. /// </param> /// <param name="expectedOldObjectId"> /// optional object id that caller is expecting, requiring to be /// advertised by remote side before update; update will take /// place ONLY if remote side advertise exactly this expected id; /// null if caller doesn't care what object id remote side /// advertise. Use /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// when expecting no /// remote ref with this name. /// </param> /// <exception cref="System.IO.IOException"> /// when I/O error occurred during creating /// <see cref="TrackingRefUpdate">TrackingRefUpdate</see> /// for local tracking branch or srcRef /// can't be resolved to any object. /// </exception> /// <exception cref="System.ArgumentException">if some required parameter was null</exception> public RemoteRefUpdate(Repository localDb, string srcRef, ObjectId srcId, string remoteName, bool forceUpdate, string localName, ObjectId expectedOldObjectId) { if (remoteName == null) { throw new ArgumentException(JGitText.Get().remoteNameCantBeNull); } if (srcId == null && srcRef != null) { throw new IOException(MessageFormat.Format(JGitText.Get().sourceRefDoesntResolveToAnyObject , srcRef)); } if (srcRef != null) { this.srcRef = srcRef; } else { if (srcId != null && !srcId.Equals(ObjectId.ZeroId)) { this.srcRef = srcId.Name; } else { this.srcRef = null; } } if (srcId != null) { this.newObjectId = srcId; } else { this.newObjectId = ObjectId.ZeroId; } this.remoteName = remoteName; this.forceUpdate = forceUpdate; if (localName != null && localDb != null) { localUpdate = localDb.UpdateRef(localName); localUpdate.SetForceUpdate(true); localUpdate.SetRefLogMessage("push", true); localUpdate.SetNewObjectId(newObjectId); trackingRefUpdate = new TrackingRefUpdate(true, remoteName, localName, localUpdate .GetOldObjectId() != null ? localUpdate.GetOldObjectId() : ObjectId.ZeroId, newObjectId ); } else { trackingRefUpdate = null; } this.localDb = localDb; this.expectedOldObjectId = expectedOldObjectId; this.status = RemoteRefUpdate.Status.NOT_ATTEMPTED; }
/// <summary>Execute this command during a receive-pack session.</summary> /// <remarks> /// Execute this command during a receive-pack session. /// <p> /// Sets the status of the command as a side effect. /// </remarks> /// <param name="rp">receive-pack session.</param> /// <since>2.0</since> public virtual void Execute(BaseReceivePack rp) { try { RefUpdate ru = rp.GetRepository().UpdateRef(GetRefName()); ru.SetRefLogIdent(rp.GetRefLogIdent()); switch (GetType()) { case ReceiveCommand.Type.DELETE: { if (!ObjectId.ZeroId.Equals(GetOldId())) { // We can only do a CAS style delete if the client // didn't bork its delete request by sending the // wrong zero id rather than the advertised one. // ru.SetExpectedOldObjectId(GetOldId()); } ru.SetForceUpdate(true); SetResult(ru.Delete(rp.GetRevWalk())); break; } case ReceiveCommand.Type.CREATE: case ReceiveCommand.Type.UPDATE: case ReceiveCommand.Type.UPDATE_NONFASTFORWARD: { ru.SetForceUpdate(rp.IsAllowNonFastForwards()); ru.SetExpectedOldObjectId(GetOldId()); ru.SetNewObjectId(GetNewId()); ru.SetRefLogMessage("push", true); SetResult(ru.Update(rp.GetRevWalk())); break; } } } catch (IOException err) { Reject(err); } }
public virtual void DeleteBranch_historyPruned() { RevCommit tip = CommitChain(10); tr.Branch("b").Update(tip); RefUpdate update = repo.UpdateRef("refs/heads/b"); update.SetForceUpdate(true); update.Delete(); gc.SetExpireAgeMillis(0); gc.Prune(Collections.EmptySet <ObjectId>()); NUnit.Framework.Assert.IsTrue(gc.GetStatistics().numberOfLooseObjects == 0); }
public virtual void TestDeleteLoosePacked() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.SetNewObjectId(pid); updateRef.SetForceUpdate(true); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); // internal // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/c"); updateRef2.SetForceUpdate(true); RefUpdate.Result delete = updateRef2.Delete(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, delete); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/c")); }
public static void HardReset(NGit.Repository repo, ObjectId newHead) { DirCache dc = null; try { // Reset head to upstream RefUpdate ru = repo.UpdateRef(Constants.HEAD); ru.SetNewObjectId(newHead); ru.SetForceUpdate(true); RefUpdate.Result rc = ru.Update(); switch (rc) { case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.NEW: case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.FORCED: break; case RefUpdate.Result.REJECTED: case RefUpdate.Result.LOCK_FAILURE: throw new ConcurrentRefUpdateException(JGitText.Get().couldNotLockHEAD, ru.GetRef(), rc); default: throw new JGitInternalException("Reference update failed: " + rc); } dc = repo.LockDirCache(); RevWalk rw = new RevWalk(repo); RevCommit c = rw.ParseCommit(newHead); DirCacheCheckout checkout = new DirCacheCheckout(repo, null, dc, c.Tree); checkout.Checkout(); } catch { if (dc != null) { dc.Unlock(); } throw; } }
public virtual void TestRenameBranchAlsoInPack() { ObjectId rb = db.Resolve("refs/heads/b"); ObjectId rb2 = db.Resolve("refs/heads/b~1"); NUnit.Framework.Assert.AreEqual(RefStorage.PACKED, db.GetRef("refs/heads/b").GetStorage ()); RefUpdate updateRef = db.UpdateRef("refs/heads/b"); updateRef.SetNewObjectId(rb2); updateRef.SetForceUpdate(true); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update, "internal check new ref is loose" ); NUnit.Framework.Assert.AreEqual(RefStorage.LOOSE, db.GetRef("refs/heads/b").GetStorage ()); WriteReflog(db, rb, "Just a message", "refs/heads/b"); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "logs/refs/heads/b").Exists (), "log on old branch"); RefRename renameRef = db.RenameRef("refs/heads/b", "refs/heads/new/name"); RefUpdate.Result result = renameRef.Rename(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.RENAMED, result); NUnit.Framework.Assert.AreEqual(rb2, db.Resolve("refs/heads/new/name")); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/b")); NUnit.Framework.Assert.AreEqual("Branch: renamed b to new/name", db.GetReflogReader ("new/name").GetLastEntry().GetComment()); NUnit.Framework.Assert.AreEqual(3, db.GetReflogReader("refs/heads/new/name").GetReverseEntries ().Count); NUnit.Framework.Assert.AreEqual("Branch: renamed b to new/name", db.GetReflogReader ("refs/heads/new/name").GetReverseEntries()[0].GetComment()); NUnit.Framework.Assert.AreEqual(0, db.GetReflogReader("HEAD").GetReverseEntries() .Count); // make sure b's log file is gone too. NUnit.Framework.Assert.IsFalse(new FilePath(db.Directory, "logs/refs/heads/b").Exists ()); // Create new Repository instance, to reread caches and make sure our // assumptions are persistent. Repository ndb = new FileRepository(db.Directory); NUnit.Framework.Assert.AreEqual(rb2, ndb.Resolve("refs/heads/new/name")); NUnit.Framework.Assert.IsNull(ndb.Resolve("refs/heads/b")); }
public virtual void TestUpdateRefForward() { ObjectId ppid = db.Resolve("refs/heads/master^"); ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(ppid); updateRef.SetForceUpdate(true); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); NUnit.Framework.Assert.AreEqual(ppid, db.Resolve("refs/heads/master")); // real test RefUpdate updateRef2 = db.UpdateRef("refs/heads/master"); updateRef2.SetNewObjectId(pid); RefUpdate.Result update2 = updateRef2.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update2); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public override void SetUp() { base.SetUp(); git = new Git(db); // checkout master git.Commit().SetMessage("initial commit").Call(); // commit something WriteTrashFile("Test.txt", "Hello world"); git.Add().AddFilepattern("Test.txt").Call(); initialCommit = git.Commit().SetMessage("Initial commit").Call(); WriteTrashFile("Test.txt", "Some change"); git.Add().AddFilepattern("Test.txt").Call(); secondCommit = git.Commit().SetMessage("Second commit").Call(); // create a master branch RefUpdate rup = db.UpdateRef("refs/heads/master"); rup.SetNewObjectId(initialCommit.Id); rup.SetForceUpdate(true); rup.Update(); }
public virtual void TestDeleteHEADreferencedRef() { ObjectId pid = db.Resolve("refs/heads/master^"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(pid); updateRef.SetForceUpdate(true); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); // internal RefUpdate updateRef2 = db.UpdateRef("refs/heads/master"); RefUpdate.Result delete = updateRef2.Delete(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.REJECTED_CURRENT_BRANCH, delete); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); NUnit.Framework.Assert.AreEqual(1, db.GetReflogReader("refs/heads/master").GetReverseEntries ().Count); NUnit.Framework.Assert.AreEqual(0, db.GetReflogReader("HEAD").GetReverseEntries() .Count); }
public virtual void TestUpdateRefForwardWithCheck2() { ObjectId ppid = db.Resolve("refs/heads/master^"); ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.SetNewObjectId(ppid); updateRef.SetForceUpdate(true); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update); NUnit.Framework.Assert.AreEqual(ppid, db.Resolve("refs/heads/master")); // real test RevCommit old = new RevWalk(db).ParseCommit(ppid); RefUpdate updateRef2 = db.UpdateRef("refs/heads/master"); updateRef2.SetExpectedOldObjectId(old); updateRef2.SetNewObjectId(pid); RefUpdate.Result update2 = updateRef2.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FAST_FORWARD, update2); NUnit.Framework.Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public virtual void TestRefsCacheAfterUpdateLooseOnly() { // Do not use the defalt repo for this case. IDictionary <string, Ref> allRefs = db.GetAllRefs(); ObjectId oldValue = db.Resolve("HEAD"); WriteSymref(Constants.HEAD, "refs/heads/newref"); RefUpdate updateRef = db.UpdateRef(Constants.HEAD); updateRef.SetForceUpdate(true); updateRef.SetNewObjectId(oldValue); RefUpdate.Result update = updateRef.Update(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.NEW, update); allRefs = db.GetAllRefs(); Ref head = allRefs.Get("HEAD"); Ref newref = allRefs.Get("refs/heads/newref"); NUnit.Framework.Assert.AreEqual("refs/heads/newref", newref.GetName()); NUnit.Framework.Assert.AreEqual("HEAD", head.GetName()); NUnit.Framework.Assert.IsTrue(head.IsSymbolic(), "is symbolic reference"); NUnit.Framework.Assert.AreSame(newref, head.GetTarget()); }
public virtual void TestRenameRefNameColission2avoided() { // setup ObjectId rb = db.Resolve("refs/heads/b"); WriteSymref(Constants.HEAD, "refs/heads/prefix/a"); RefUpdate updateRef = db.UpdateRef("refs/heads/prefix/a"); updateRef.SetNewObjectId(rb); updateRef.SetRefLogMessage("Setup", false); updateRef.SetForceUpdate(true); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, updateRef.Update()); ObjectId oldHead = db.Resolve(Constants.HEAD); NUnit.Framework.Assert.AreEqual(oldHead, rb); // assumption for this test WriteReflog(db, rb, "Just a message", "refs/heads/prefix/a"); NUnit.Framework.Assert.IsTrue(new FilePath(db.Directory, "logs/refs/heads/prefix/a" ).Exists(), "internal check, we have a log"); // Now this is our test RefRename renameRef = db.RenameRef("refs/heads/prefix/a", "refs/heads/prefix"); RefUpdate.Result result = renameRef.Rename(); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.RENAMED, result); NUnit.Framework.Assert.IsNull(db.Resolve("refs/heads/prefix/a")); NUnit.Framework.Assert.AreEqual(rb, db.Resolve("refs/heads/prefix")); NUnit.Framework.Assert.AreEqual(3, db.GetReflogReader("prefix").GetReverseEntries ().Count); NUnit.Framework.Assert.AreEqual("Branch: renamed prefix/a to prefix", db.GetReflogReader ("prefix").GetReverseEntries()[0].GetComment()); NUnit.Framework.Assert.AreEqual("Just a message", db.GetReflogReader("prefix").GetReverseEntries ()[1].GetComment()); NUnit.Framework.Assert.AreEqual("Setup", db.GetReflogReader("prefix").GetReverseEntries ()[2].GetComment()); NUnit.Framework.Assert.AreEqual("Branch: renamed prefix/a to prefix", db.GetReflogReader ("HEAD").GetReverseEntries()[0].GetComment()); }
/// <exception cref="NGit.Api.Errors.NotMergedException"> /// when trying to delete a branch which has not been merged into /// the currently checked out branch without force /// </exception> /// <exception cref="NGit.Api.Errors.CannotDeleteCurrentBranchException">NGit.Api.Errors.CannotDeleteCurrentBranchException /// </exception> /// <returns>the list with the (full) names of the deleted branches</returns> /// <exception cref="NGit.Api.Errors.GitAPIException"></exception> public override IList <string> Call() { CheckCallable(); IList <string> result = new AList <string>(); if (branchNames.IsEmpty()) { return(result); } try { string currentBranch = repo.GetFullBranch(); if (!force) { // check if the branches to be deleted // are all merged into the current branch RevWalk walk = new RevWalk(repo); RevCommit tip = walk.ParseCommit(repo.Resolve(Constants.HEAD)); foreach (string branchName in branchNames) { if (branchName == null) { continue; } Ref currentRef = repo.GetRef(branchName); if (currentRef == null) { continue; } RevCommit @base = walk.ParseCommit(repo.Resolve(branchName)); if (!walk.IsMergedInto(@base, tip)) { throw new NotMergedException(); } } } SetCallable(false); foreach (string branchName_1 in branchNames) { if (branchName_1 == null) { continue; } Ref currentRef = repo.GetRef(branchName_1); if (currentRef == null) { continue; } string fullName = currentRef.GetName(); if (fullName.Equals(currentBranch)) { throw new CannotDeleteCurrentBranchException(MessageFormat.Format(JGitText.Get(). cannotDeleteCheckedOutBranch, branchName_1)); } RefUpdate update = repo.UpdateRef(fullName); update.SetRefLogMessage("branch deleted", false); update.SetForceUpdate(true); RefUpdate.Result deleteResult = update.Delete(); bool ok = true; switch (deleteResult) { case RefUpdate.Result.IO_FAILURE: case RefUpdate.Result.LOCK_FAILURE: case RefUpdate.Result.REJECTED: { ok = false; break; } default: { break; break; } } if (ok) { result.AddItem(fullName); if (fullName.StartsWith(Constants.R_HEADS)) { string shortenedName = Sharpen.Runtime.Substring(fullName, Constants.R_HEADS.Length ); // remove upstream configuration if any StoredConfig cfg = repo.GetConfig(); cfg.UnsetSection(ConfigConstants.CONFIG_BRANCH_SECTION, shortenedName); cfg.Save(); } } else { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().deleteBranchUnexpectedResult , deleteResult.ToString())); } } return(result); } catch (IOException ioe) { throw new JGitInternalException(ioe.Message, ioe); } }
/// <summary> /// Executes the /// <code>tag</code> /// command with all the options and parameters /// collected by the setter methods of this class. Each instance of this /// class should only be used for one invocation of the command (means: one /// call to /// <see cref="Call()">Call()</see> /// ) /// </summary> /// <returns> /// a /// <see cref="NGit.Ref">NGit.Ref</see> /// a ref pointing to a tag /// </returns> /// <exception cref="NGit.Api.Errors.NoHeadException">when called on a git repo without a HEAD reference /// </exception> /// <since>2.0</since> /// <exception cref="NGit.Api.Errors.GitAPIException"></exception> /// <exception cref="NGit.Api.Errors.ConcurrentRefUpdateException"></exception> /// <exception cref="NGit.Api.Errors.InvalidTagNameException"></exception> public override Ref Call() { CheckCallable(); RepositoryState state = repo.GetRepositoryState(); ProcessOptions(state); try { // create the tag object TagBuilder newTag = new TagBuilder(); newTag.SetTag(name); newTag.SetMessage(message); newTag.SetTagger(tagger); // if no id is set, we should attempt to use HEAD if (id == null) { ObjectId objectId = repo.Resolve(Constants.HEAD + "^{commit}"); if (objectId == null) { throw new NoHeadException(JGitText.Get().tagOnRepoWithoutHEADCurrentlyNotSupported ); } newTag.SetObjectId(objectId, Constants.OBJ_COMMIT); } else { newTag.SetObjectId(id); } // write the tag object ObjectInserter inserter = repo.NewObjectInserter(); try { ObjectId tagId = inserter.Insert(newTag); inserter.Flush(); RevWalk revWalk = new RevWalk(repo); try { string refName = Constants.R_TAGS + newTag.GetTag(); RefUpdate tagRef = repo.UpdateRef(refName); tagRef.SetNewObjectId(tagId); tagRef.SetForceUpdate(forceUpdate); tagRef.SetRefLogMessage("tagged " + name, false); RefUpdate.Result updateResult = tagRef.Update(revWalk); switch (updateResult) { case RefUpdate.Result.NEW: case RefUpdate.Result.FORCED: { return(repo.GetRef(refName)); } case RefUpdate.Result.LOCK_FAILURE: { throw new ConcurrentRefUpdateException(JGitText.Get().couldNotLockHEAD, tagRef.GetRef (), updateResult); } default: { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().updatingRefFailed , refName, newTag.ToString(), updateResult)); } } } finally { revWalk.Release(); } } finally { inserter.Release(); } } catch (IOException e) { throw new JGitInternalException(JGitText.Get().exceptionCaughtDuringExecutionOfTagCommand , e); } }
/// <exception cref="NGit.Api.Errors.RefAlreadyExistsException"> /// when trying to create (without force) a branch with a name /// that already exists /// </exception> /// <exception cref="NGit.Api.Errors.RefNotFoundException">if the start point or branch can not be found /// </exception> /// <exception cref="NGit.Api.Errors.InvalidRefNameException"> /// if the provided name is <code>null</code> or otherwise /// invalid /// </exception> /// <returns>the newly created branch</returns> /// <exception cref="NGit.Api.Errors.JGitInternalException"></exception> public override Ref Call() { CheckCallable(); ProcessOptions(); try { if (createBranch) { Git git = new Git(repo); CreateBranchCommand command = git.BranchCreate(); command.SetName(name); command.SetStartPoint(GetStartPoint().Name); if (upstreamMode != null) { command.SetUpstreamMode(upstreamMode); } command.Call(); } Ref headRef = repo.GetRef(Constants.HEAD); string refLogMessage = "checkout: moving from " + headRef.GetTarget().GetName(); ObjectId branch = repo.Resolve(name); if (branch == null) { throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved , name)); } RevWalk revWalk = new RevWalk(repo); AnyObjectId headId = headRef.GetObjectId(); RevCommit headCommit = headId == null ? null : revWalk.ParseCommit(headId); RevCommit newCommit = revWalk.ParseCommit(branch); RevTree headTree = headCommit == null ? null : headCommit.Tree; DirCacheCheckout dco = new DirCacheCheckout(repo, headTree, repo.LockDirCache(), newCommit.Tree); dco.SetFailOnConflict(true); try { dco.Checkout(); } catch (NGit.Errors.CheckoutConflictException e) { status = new CheckoutResult(CheckoutResult.Status.CONFLICTS, dco.GetConflicts()); throw; } Ref @ref = repo.GetRef(name); if (@ref != null && [email protected]().StartsWith(Constants.R_HEADS)) { @ref = null; } RefUpdate refUpdate = repo.UpdateRef(Constants.HEAD, @ref == null); refUpdate.SetForceUpdate(force); refUpdate.SetRefLogMessage(refLogMessage + " to " + newCommit.GetName(), false); RefUpdate.Result updateResult; if (@ref != null) { updateResult = refUpdate.Link(@ref.GetName()); } else { refUpdate.SetNewObjectId(newCommit); updateResult = refUpdate.ForceUpdate(); } SetCallable(false); bool ok = false; switch (updateResult) { case RefUpdate.Result.NEW: { ok = true; break; } case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.FORCED: { ok = true; break; } default: { break; break; } } if (!ok) { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().checkoutUnexpectedResult , updateResult.ToString())); } if (!dco.GetToBeDeleted().IsEmpty()) { status = new CheckoutResult(CheckoutResult.Status.NONDELETED, dco.GetToBeDeleted( )); } else { status = CheckoutResult.OK_RESULT; } return(@ref); } catch (IOException ioe) { throw new JGitInternalException(ioe.Message, ioe); } finally { if (status == null) { status = CheckoutResult.ERROR_RESULT; } } }
/// <returns>the list with the full names of the deleted tags</returns> /// <exception cref="NGit.Api.Errors.GitAPIException"></exception> public override IList <string> Call() { CheckCallable(); IList <string> result = new AList <string>(); if (tags.IsEmpty()) { return(result); } try { SetCallable(false); foreach (string tagName in tags) { if (tagName == null) { continue; } Ref currentRef = repo.GetRef(tagName); if (currentRef == null) { continue; } string fullName = currentRef.GetName(); RefUpdate update = repo.UpdateRef(fullName); update.SetForceUpdate(true); RefUpdate.Result deleteResult = update.Delete(); bool ok = true; switch (deleteResult) { case RefUpdate.Result.IO_FAILURE: case RefUpdate.Result.LOCK_FAILURE: case RefUpdate.Result.REJECTED: { ok = false; break; } default: { break; break; } } if (ok) { result.AddItem(fullName); } else { throw new JGitInternalException(MessageFormat.Format(JGitText.Get().deleteTagUnexpectedResult , deleteResult.ToString())); } } return(result); } catch (IOException ioe) { throw new JGitInternalException(ioe.Message, ioe); } }