private void dispose() { walk.release(); Display.getDefault().asyncExec(new Runnable() { public void run() { loadedCommits.dispose(); } }); }
Repository repository = ... ObjectId objectId = ObjectId.fromString( "a33a2d4dff046b3a19e36b3d1026fbcc5b806889" ); RevWalk revWalk = new RevWalk( repository ); RevTag revTag = revWalk.parseTag( objectId ); // do something with revTag revWalk.release();
/** * Call release method on walk. JGit 3 uses release(), JGit 4 uses close() to * release resources. * * This method should be removed once the code depends on git client 2.0.0. * @param walk object whose close or release method will be called * @throws IOException on IO error */ private static void releaseOrClose(RevWalk walk) throws IOException { if (walk == null) { return; } try { walk.release(); // JGit 3 } catch (NoSuchMethodError noMethod) { closeByReflection(walk); } }
@Override protected void advertise(HttpServletRequest req, PacketLineOutRefAdvertiser pck) throws IOException, ServiceNotEnabledException, ServiceNotAuthorizedException { ReceivePack rp = (ReceivePack) req.getAttribute(ATTRIBUTE_HANDLER); try { rp.sendAdvertisedRefs(pck); } finally { rp.getRevWalk().release(); } } }
@Override protected void advertise(HttpServletRequest req, PacketLineOutRefAdvertiser pck) throws IOException, ServiceNotEnabledException, ServiceNotAuthorizedException { UploadPack up = (UploadPack) req.getAttribute(ATTRIBUTE_HANDLER); try { up.setBiDirectionalPipe(false); up.sendAdvertisedRefs(pck); } finally { up.getRevWalk().release(); } } }
public static RevCommit getCommit(Repository repository, Ref ref) { RevWalk revWalk = new RevWalk(repository); try { return revWalk.parseCommit(firstNonNull(ref.getPeeledObjectId(), ref.getObjectId())); } catch (IOException e) { throw Throwables.propagate(e); } finally { revWalk.release(); } }
private RevCommit parseCommit(final Ref branch) throws MissingObjectException, IncorrectObjectTypeException, IOException { final RevWalk rw = new RevWalk(db); final RevCommit commit; try { commit = rw.parseCommit(branch.getObjectId()); } finally { rw.release(); } return commit; } }
private RevObject getTagTarget(Repository repo, ObjectId objectId) throws IOException { RevWalk rw = new RevWalk(repo); try { if (objectId == null) return rw.parseAny(repo.resolve(Constants.HEAD)); else return rw.parseAny(objectId); } finally { rw.release(); } } }
private RevCommit getLatestCommit(String branch) { ObjectId resolved; try { resolved = repo.resolve(branch); } catch (IOException e) { return null; } if (resolved == null) return null; RevWalk walk = new RevWalk(repo); walk.setRetainBody(true); try { return walk.parseCommit(resolved); } catch (IOException ignored) { return null; } finally { walk.release(); } }
private RevCommit getCommit(final ReflogEntry entry) { RevWalk walk = new RevWalk(getRepository()); walk.setRetainBody(true); RevCommit c = null; try { c = walk.parseCommit(entry.getNewId()); } catch (IOException ignored) { // ignore } finally { walk.release(); } return c; } });
private RevCommit getSelectedCommit() { IStructuredSelection selection = (IStructuredSelection) table .getSelection(); RevCommit commit = (RevCommit) selection.getFirstElement(); RevWalk walk = new org.eclipse.jgit.revwalk.RevWalk(input.getRepository()); try { return walk.parseCommit(commit.getId()); } catch (IOException e) { throw new RuntimeException( "Could not parse commit " + commit.getId(), e); //$NON-NLS-1$ } finally { walk.release(); } }
private RepositoryCommit getCommit(Repository repository, ObjectId objectId) { RevWalk walk = new RevWalk(repository); try { RevCommit commit = walk.parseCommit(objectId); for (RevCommit parent : commit.getParents()) walk.parseBody(parent); return new RepositoryCommit(repository, commit); } catch (IOException e) { Activator.showError(NLS.bind( UIText.GitProjectPropertyPage_UnableToGetCommit, objectId.name()), e); } finally { walk.release(); } return null; } /**
private RevObject getTagTarget(ObjectId objectId, Repository repo) throws ExecutionException { try { RevWalk rw = new RevWalk(repo); try { if (objectId == null) { return rw.parseAny(repo.resolve(Constants.HEAD)); } else { return rw.parseAny(objectId); } } finally { rw.release(); } } catch (IOException e) { throw new ExecutionException( UIText.TagAction_unableToResolveHeadObjectId, e); } } }
private void setExistingTagFromText(String tagName) { RevWalk revWalk = null; try { ObjectId tagObjectId = repo.resolve(Constants.R_TAGS + tagName); if (tagObjectId != null) { revWalk = new RevWalk(repo); RevObject tagObject = revWalk.parseAny(tagObjectId); setExistingTag(tagObject); return; } } catch (IOException e) { // See below } catch (RevisionSyntaxException e) { // See below } finally { if (revWalk != null) revWalk.release(); } setNoExistingTag(); }
/** * Get commit from memento and repository * * @param memento * @param repository * @return rev commit */ protected RevCommit getCommit(IMemento memento, Repository repository) { String id = memento.getString(COMMIT); if (id == null) return null; RevWalk walk = new RevWalk(repository); try { RevCommit commit = walk.parseCommit(ObjectId.fromString(id)); for (RevCommit parent : commit.getParents()) walk.parseBody(parent); return commit; } catch (IOException e) { return null; } finally { walk.release(); } }
@Rule public final TemporaryFolder tempFolder = new TemporaryFolder(); @Test public void testRevWalkDoesNotLeakResources() throws Exception { Git git = Git.init().setDirectory( tempFolder.getRoot() ).call(); git.commit().setMessage( "First commit" ).call(); git.tag().setName( "First-Tag" ).call(); Ref tagRef = git.getRepository().getRef( "refs/tags/First-Tag" ); RevWalk revWalk = new RevWalk( git.getRepository() ); RevTag tag = revWalk.parseTag( tagRef.getObjectId() ); revWalk.release(); git.getRepository().close(); tempFolder.delete(); assertNotNull( tag ); assertFalse( tempFolder.getRoot().exists() ); }
private void getRevCommits(Collection<RevCommit> commits) { final RevWalk revWalk = new RevWalk(repo); try { revWalk.sort(RevSort.COMMIT_TIME_DESC, true); revWalk.sort(RevSort.BOUNDARY, true); AnyObjectId headId = repo.resolve(Constants.HEAD); if (headId != null) revWalk.markStart(revWalk.parseCommit(headId)); // do the walk to get the commits long count = 0; RevCommit commit; while ((commit = revWalk.next()) != null && count < MAX_COMMIT_COUNT) { commits.add(commit); count++; } } catch (IOException e) { Activator.logError(UIText.TagAction_errorWhileGettingRevCommits, e); setErrorMessage(UIText.TagAction_errorWhileGettingRevCommits); } finally { revWalk.release(); } }
private RevCommit getLatestCommit(RepositoryTreeNode node) { Ref ref = (Ref) node.getObject(); ObjectId id; if (ref.isSymbolic()) id = ref.getLeaf().getObjectId(); else id = ref.getObjectId(); if (id == null) return null; RevWalk walk = new RevWalk(node.getRepository()); walk.setRetainBody(true); try { return walk.parseCommit(id); } catch (IOException ignored) { return null; } finally { walk.release(); } }
private static CompareEditorInput prepareCompareInput( Repository repository, String gitPath, ITypedElement base, String refName) throws IOException { final ObjectId destCommitId = repository.resolve(refName); RevWalk rw = new RevWalk(repository); RevCommit commit = rw.parseCommit(destCommitId); rw.release(); final ITypedElement destCommit = getFileRevisionTypedElement(gitPath, commit, repository); final ITypedElement commonAncestor; if (base != null && commit != null) { final ObjectId headCommitId = repository.resolve(Constants.HEAD); commonAncestor = getFileRevisionTypedElementForCommonAncestor( gitPath, headCommitId, destCommitId, repository); } else { commonAncestor = null; } final GitCompareFileRevisionEditorInput in = new GitCompareFileRevisionEditorInput( base, destCommit, commonAncestor, null); in.getCompareConfiguration().setRightLabel(refName); return in; }
protected void checkoutBranch(String branchName) throws IllegalStateException, IOException { RevWalk walk = new RevWalk(db); RevCommit head = walk.parseCommit(db.resolve(Constants.HEAD)); RevCommit branch = walk.parseCommit(db.resolve(branchName)); DirCacheCheckout dco = new DirCacheCheckout(db, head.getTree().getId(), db.lockDirCache(), branch.getTree().getId()); dco.setFailOnConflict(true); dco.checkout(); walk.release(); // update the HEAD RefUpdate refUpdate = db.updateRef(Constants.HEAD); refUpdate.setRefLogMessage("checkout: moving to " + branchName, false); refUpdate.link(branchName); }