Use AutoClosable to close resources in bundle org.eclipse.jgit
- use try-with-resource where possible - replace use of deprecated release() by close() Change-Id: I0f139c3535679087b7fa09649166bca514750b81 Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
This commit is contained in:
parent
6424dcd694
commit
0e73d39506
|
@ -124,8 +124,7 @@ public Ref call() throws GitAPIException, RefAlreadyExistsException,
|
|||
RefNotFoundException, InvalidRefNameException {
|
||||
checkCallable();
|
||||
processOptions();
|
||||
RevWalk revWalk = new RevWalk(repo);
|
||||
try {
|
||||
try (RevWalk revWalk = new RevWalk(repo)) {
|
||||
Ref refToCheck = repo.getRef(name);
|
||||
boolean exists = refToCheck != null
|
||||
&& refToCheck.getName().startsWith(Constants.R_HEADS);
|
||||
|
@ -270,8 +269,6 @@ else if (upstreamMode == SetupUpstreamMode.NOTRACK)
|
|||
return result;
|
||||
} catch (IOException ioe) {
|
||||
throw new JGitInternalException(ioe.getMessage(), ioe);
|
||||
} finally {
|
||||
revWalk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -108,18 +108,21 @@ public List<String> call() throws GitAPIException,
|
|||
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));
|
||||
for (String branchName : branchNames) {
|
||||
if (branchName == null)
|
||||
continue;
|
||||
Ref currentRef = repo.getRef(branchName);
|
||||
if (currentRef == null)
|
||||
continue;
|
||||
try (RevWalk walk = new RevWalk(repo)) {
|
||||
RevCommit tip = walk
|
||||
.parseCommit(repo.resolve(Constants.HEAD));
|
||||
for (String branchName : 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();
|
||||
RevCommit base = walk
|
||||
.parseCommit(repo.resolve(branchName));
|
||||
if (!walk.isMergedInto(base, tip)) {
|
||||
throw new NotMergedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -139,8 +139,7 @@ private Collection<Ref> filterRefs(Collection<Ref> refs)
|
|||
if (containsCommitish == null)
|
||||
return refs;
|
||||
|
||||
RevWalk walk = new RevWalk(repo);
|
||||
try {
|
||||
try (RevWalk walk = new RevWalk(repo)) {
|
||||
ObjectId resolved = repo.resolve(containsCommitish);
|
||||
if (resolved == null)
|
||||
throw new RefNotFoundException(MessageFormat.format(
|
||||
|
@ -149,8 +148,6 @@ private Collection<Ref> filterRefs(Collection<Ref> refs)
|
|||
RevCommit containsCommit = walk.parseCommit(resolved);
|
||||
return RevWalkUtils.findBranchesReachableFrom(containsCommit, walk,
|
||||
refs);
|
||||
} finally {
|
||||
walk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -80,9 +80,8 @@ protected ListNotesCommand(Repository repo) {
|
|||
public List<Note> call() throws GitAPIException {
|
||||
checkCallable();
|
||||
List<Note> notes = new ArrayList<Note>();
|
||||
RevWalk walk = new RevWalk(repo);
|
||||
NoteMap map = NoteMap.newEmptyMap();
|
||||
try {
|
||||
try (RevWalk walk = new RevWalk(repo)) {
|
||||
Ref ref = repo.getRef(notesRef);
|
||||
// if we have a notes ref, use it
|
||||
if (ref != null) {
|
||||
|
@ -95,8 +94,6 @@ public List<Note> call() throws GitAPIException {
|
|||
notes.add(i.next());
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(e.getMessage(), e);
|
||||
} finally {
|
||||
walk.release();
|
||||
}
|
||||
|
||||
return notes;
|
||||
|
|
|
@ -78,16 +78,13 @@ public List<Ref> call() throws GitAPIException {
|
|||
checkCallable();
|
||||
Map<String, Ref> refList;
|
||||
List<Ref> tags = new ArrayList<Ref>();
|
||||
RevWalk revWalk = new RevWalk(repo);
|
||||
try {
|
||||
try (RevWalk revWalk = new RevWalk(repo)) {
|
||||
refList = repo.getRefDatabase().getRefs(Constants.R_TAGS);
|
||||
for (Ref ref : refList.values()) {
|
||||
tags.add(ref);
|
||||
}
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(e.getMessage(), e);
|
||||
} finally {
|
||||
revWalk.release();
|
||||
}
|
||||
Collections.sort(tags, new Comparator<Ref>() {
|
||||
public int compare(Ref o1, Ref o2) {
|
||||
|
|
|
@ -369,9 +369,11 @@ public MergeResult call() throws GitAPIException, NoHeadException,
|
|||
mergeStatus = MergeStatus.MERGED_NOT_COMMITTED;
|
||||
}
|
||||
if (commit && !squash) {
|
||||
newHeadId = new Git(getRepository()).commit()
|
||||
.setReflogComment(refLogMessage.toString())
|
||||
.call().getId();
|
||||
try (Git git = new Git(getRepository())) {
|
||||
newHeadId = git.commit()
|
||||
.setReflogComment(refLogMessage.toString())
|
||||
.call().getId();
|
||||
}
|
||||
mergeStatus = MergeStatus.MERGED;
|
||||
}
|
||||
if (commit && squash) {
|
||||
|
@ -416,7 +418,7 @@ public MergeResult call() throws GitAPIException, NoHeadException,
|
|||
e), e);
|
||||
} finally {
|
||||
if (revWalk != null)
|
||||
revWalk.release();
|
||||
revWalk.close();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -405,11 +405,12 @@ private boolean autoStashApply() throws IOException, GitAPIException {
|
|||
.call();
|
||||
} catch (StashApplyFailureException e) {
|
||||
conflicts = true;
|
||||
RevWalk rw = new RevWalk(repo);
|
||||
ObjectId stashId = repo.resolve(stash);
|
||||
RevCommit commit = rw.parseCommit(stashId);
|
||||
updateStashRef(commit, commit.getAuthorIdent(),
|
||||
commit.getShortMessage());
|
||||
try (RevWalk rw = new RevWalk(repo)) {
|
||||
ObjectId stashId = repo.resolve(stash);
|
||||
RevCommit commit = rw.parseCommit(stashId);
|
||||
updateStashRef(commit, commit.getAuthorIdent(),
|
||||
commit.getShortMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
return conflicts;
|
||||
|
@ -518,21 +519,23 @@ private RebaseResult cherryPickCommitFlattening(RevCommit commitToPick)
|
|||
// here we should skip this step in order to avoid
|
||||
// confusing pseudo-changed
|
||||
String ourCommitName = getOurCommitName();
|
||||
CherryPickResult cherryPickResult = new Git(repo).cherryPick()
|
||||
try (Git git = new Git(repo)) {
|
||||
CherryPickResult cherryPickResult = git.cherryPick()
|
||||
.include(commitToPick).setOurCommitName(ourCommitName)
|
||||
.setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy)
|
||||
.call();
|
||||
switch (cherryPickResult.getStatus()) {
|
||||
case FAILED:
|
||||
if (operation == Operation.BEGIN)
|
||||
return abort(RebaseResult.failed(cherryPickResult
|
||||
.getFailingPaths()));
|
||||
else
|
||||
switch (cherryPickResult.getStatus()) {
|
||||
case FAILED:
|
||||
if (operation == Operation.BEGIN)
|
||||
return abort(RebaseResult
|
||||
.failed(cherryPickResult.getFailingPaths()));
|
||||
else
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case CONFLICTING:
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case CONFLICTING:
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case OK:
|
||||
newHead = cherryPickResult.getNewHead();
|
||||
case OK:
|
||||
newHead = cherryPickResult.getNewHead();
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
|
@ -563,62 +566,67 @@ private RebaseResult cherryPickCommitPreservingMerges(RevCommit commitToPick)
|
|||
// Use the cherry-pick strategy if all non-first parents did not
|
||||
// change. This is different from C Git, which always uses the merge
|
||||
// strategy (see below).
|
||||
if (otherParentsUnchanged) {
|
||||
boolean isMerge = commitToPick.getParentCount() > 1;
|
||||
String ourCommitName = getOurCommitName();
|
||||
CherryPickCommand pickCommand = new Git(repo).cherryPick()
|
||||
.include(commitToPick).setOurCommitName(ourCommitName)
|
||||
.setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy);
|
||||
if (isMerge) {
|
||||
pickCommand.setMainlineParentNumber(1);
|
||||
// We write a MERGE_HEAD and later commit explicitly
|
||||
pickCommand.setNoCommit(true);
|
||||
writeMergeInfo(commitToPick, newParents);
|
||||
}
|
||||
CherryPickResult cherryPickResult = pickCommand.call();
|
||||
switch (cherryPickResult.getStatus()) {
|
||||
case FAILED:
|
||||
if (operation == Operation.BEGIN)
|
||||
return abort(RebaseResult.failed(cherryPickResult
|
||||
.getFailingPaths()));
|
||||
else
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case CONFLICTING:
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case OK:
|
||||
try (Git git = new Git(repo)) {
|
||||
if (otherParentsUnchanged) {
|
||||
boolean isMerge = commitToPick.getParentCount() > 1;
|
||||
String ourCommitName = getOurCommitName();
|
||||
CherryPickCommand pickCommand = git.cherryPick()
|
||||
.include(commitToPick)
|
||||
.setOurCommitName(ourCommitName)
|
||||
.setReflogPrefix(REFLOG_PREFIX)
|
||||
.setStrategy(strategy);
|
||||
if (isMerge) {
|
||||
// Commit the merge (setup above using writeMergeInfo())
|
||||
CommitCommand commit = new Git(repo).commit();
|
||||
pickCommand.setMainlineParentNumber(1);
|
||||
// We write a MERGE_HEAD and later commit explicitly
|
||||
pickCommand.setNoCommit(true);
|
||||
writeMergeInfo(commitToPick, newParents);
|
||||
}
|
||||
CherryPickResult cherryPickResult = pickCommand.call();
|
||||
switch (cherryPickResult.getStatus()) {
|
||||
case FAILED:
|
||||
if (operation == Operation.BEGIN)
|
||||
return abort(RebaseResult.failed(
|
||||
cherryPickResult.getFailingPaths()));
|
||||
else
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case CONFLICTING:
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
case OK:
|
||||
if (isMerge) {
|
||||
// Commit the merge (setup above using
|
||||
// writeMergeInfo())
|
||||
CommitCommand commit = git.commit();
|
||||
commit.setAuthor(commitToPick.getAuthorIdent());
|
||||
commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
|
||||
+ commitToPick.getShortMessage());
|
||||
newHead = commit.call();
|
||||
} else
|
||||
newHead = cherryPickResult.getNewHead();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
// Use the merge strategy to redo merges, which had some of
|
||||
// their non-first parents rewritten
|
||||
MergeCommand merge = git.merge()
|
||||
.setFastForward(MergeCommand.FastForwardMode.NO_FF)
|
||||
.setCommit(false);
|
||||
for (int i = 1; i < commitToPick.getParentCount(); i++)
|
||||
merge.include(newParents.get(i));
|
||||
MergeResult mergeResult = merge.call();
|
||||
if (mergeResult.getMergeStatus().isSuccessful()) {
|
||||
CommitCommand commit = git.commit();
|
||||
commit.setAuthor(commitToPick.getAuthorIdent());
|
||||
commit.setMessage(commitToPick.getFullMessage());
|
||||
commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
|
||||
+ commitToPick.getShortMessage());
|
||||
newHead = commit.call();
|
||||
} else
|
||||
newHead = cherryPickResult.getNewHead();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
// Use the merge strategy to redo merges, which had some of
|
||||
// their non-first parents rewritten
|
||||
MergeCommand merge = new Git(repo).merge()
|
||||
.setFastForward(MergeCommand.FastForwardMode.NO_FF)
|
||||
.setCommit(false);
|
||||
for (int i = 1; i < commitToPick.getParentCount(); i++)
|
||||
merge.include(newParents.get(i));
|
||||
MergeResult mergeResult = merge.call();
|
||||
if (mergeResult.getMergeStatus().isSuccessful()) {
|
||||
CommitCommand commit = new Git(repo).commit();
|
||||
commit.setAuthor(commitToPick.getAuthorIdent());
|
||||
commit.setMessage(commitToPick.getFullMessage());
|
||||
commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
|
||||
+ commitToPick.getShortMessage());
|
||||
newHead = commit.call();
|
||||
} else {
|
||||
if (operation == Operation.BEGIN
|
||||
&& mergeResult.getMergeStatus() == MergeResult.MergeStatus.FAILED)
|
||||
return abort(RebaseResult.failed(mergeResult
|
||||
.getFailingPaths()));
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
} else {
|
||||
if (operation == Operation.BEGIN && mergeResult
|
||||
.getMergeStatus() == MergeResult.MergeStatus.FAILED)
|
||||
return abort(RebaseResult
|
||||
.failed(mergeResult.getFailingPaths()));
|
||||
return stop(commitToPick, Status.STOPPED);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -758,24 +766,25 @@ private RevCommit squashIntoPrevious(boolean sequenceContainsSquash,
|
|||
String commitMessage = rebaseState
|
||||
.readFile(MESSAGE_SQUASH);
|
||||
|
||||
if (nextStep == null
|
||||
|| ((nextStep.getAction() != Action.FIXUP) && (nextStep
|
||||
.getAction() != Action.SQUASH))) {
|
||||
// this is the last step in this sequence
|
||||
if (sequenceContainsSquash) {
|
||||
commitMessage = interactiveHandler
|
||||
.modifyCommitMessage(commitMessage);
|
||||
}
|
||||
retNewHead = new Git(repo).commit()
|
||||
.setMessage(stripCommentLines(commitMessage))
|
||||
.setAmend(true).setNoVerify(true).call();
|
||||
rebaseState.getFile(MESSAGE_SQUASH).delete();
|
||||
rebaseState.getFile(MESSAGE_FIXUP).delete();
|
||||
try (Git git = new Git(repo)) {
|
||||
if (nextStep == null || ((nextStep.getAction() != Action.FIXUP)
|
||||
&& (nextStep.getAction() != Action.SQUASH))) {
|
||||
// this is the last step in this sequence
|
||||
if (sequenceContainsSquash) {
|
||||
commitMessage = interactiveHandler
|
||||
.modifyCommitMessage(commitMessage);
|
||||
}
|
||||
retNewHead = git.commit()
|
||||
.setMessage(stripCommentLines(commitMessage))
|
||||
.setAmend(true).setNoVerify(true).call();
|
||||
rebaseState.getFile(MESSAGE_SQUASH).delete();
|
||||
rebaseState.getFile(MESSAGE_FIXUP).delete();
|
||||
|
||||
} else {
|
||||
// Next step is either Squash or Fixup
|
||||
retNewHead = new Git(repo).commit().setMessage(commitMessage)
|
||||
.setAmend(true).setNoVerify(true).call();
|
||||
} else {
|
||||
// Next step is either Squash or Fixup
|
||||
retNewHead = git.commit().setMessage(commitMessage)
|
||||
.setAmend(true).setNoVerify(true).call();
|
||||
}
|
||||
}
|
||||
return retNewHead;
|
||||
}
|
||||
|
@ -917,10 +926,10 @@ private RevCommit checkoutCurrentHead() throws IOException, NoHeadException {
|
|||
} finally {
|
||||
dc.unlock();
|
||||
}
|
||||
RevWalk rw = new RevWalk(repo);
|
||||
RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
|
||||
rw.release();
|
||||
return commit;
|
||||
try (RevWalk rw = new RevWalk(repo)) {
|
||||
RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
|
||||
return commit;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -936,27 +945,29 @@ private RevCommit continueRebase() throws GitAPIException, IOException {
|
|||
throw new UnmergedPathsException();
|
||||
|
||||
// determine whether we need to commit
|
||||
TreeWalk treeWalk = new TreeWalk(repo);
|
||||
treeWalk.reset();
|
||||
treeWalk.setRecursive(true);
|
||||
treeWalk.addTree(new DirCacheIterator(dc));
|
||||
ObjectId id = repo.resolve(Constants.HEAD + "^{tree}"); //$NON-NLS-1$
|
||||
if (id == null)
|
||||
throw new NoHeadException(
|
||||
JGitText.get().cannotRebaseWithoutCurrentHead);
|
||||
boolean needsCommit;
|
||||
try (TreeWalk treeWalk = new TreeWalk(repo)) {
|
||||
treeWalk.reset();
|
||||
treeWalk.setRecursive(true);
|
||||
treeWalk.addTree(new DirCacheIterator(dc));
|
||||
ObjectId id = repo.resolve(Constants.HEAD + "^{tree}"); //$NON-NLS-1$
|
||||
if (id == null)
|
||||
throw new NoHeadException(
|
||||
JGitText.get().cannotRebaseWithoutCurrentHead);
|
||||
|
||||
treeWalk.addTree(id);
|
||||
treeWalk.addTree(id);
|
||||
|
||||
treeWalk.setFilter(TreeFilter.ANY_DIFF);
|
||||
|
||||
boolean needsCommit = treeWalk.next();
|
||||
treeWalk.release();
|
||||
treeWalk.setFilter(TreeFilter.ANY_DIFF);
|
||||
|
||||
needsCommit = treeWalk.next();
|
||||
}
|
||||
if (needsCommit) {
|
||||
CommitCommand commit = new Git(repo).commit();
|
||||
commit.setMessage(rebaseState.readFile(MESSAGE));
|
||||
commit.setAuthor(parseAuthor());
|
||||
return commit.call();
|
||||
try (Git git = new Git(repo)) {
|
||||
CommitCommand commit = git.commit();
|
||||
commit.setMessage(rebaseState.readFile(MESSAGE));
|
||||
commit.setAuthor(parseAuthor());
|
||||
return commit.call();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
@ -979,9 +990,10 @@ private RebaseResult stop(RevCommit commitToPick, RebaseResult.Status status)
|
|||
rebaseState.createFile(AUTHOR_SCRIPT, authorScript);
|
||||
rebaseState.createFile(MESSAGE, commitToPick.getFullMessage());
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
DiffFormatter df = new DiffFormatter(bos);
|
||||
df.setRepository(repo);
|
||||
df.format(commitToPick.getParent(0), commitToPick);
|
||||
try (DiffFormatter df = new DiffFormatter(bos)) {
|
||||
df.setRepository(repo);
|
||||
df.format(commitToPick.getParent(0), commitToPick);
|
||||
}
|
||||
rebaseState.createFile(PATCH, new String(bos.toByteArray(),
|
||||
Constants.CHARACTER_ENCODING));
|
||||
rebaseState.createFile(STOPPED_SHA,
|
||||
|
@ -1124,9 +1136,11 @@ else if (!isInteractive() && walk.isMergedInto(headCommit, upstream)) {
|
|||
|
||||
private List<RevCommit> calculatePickList(RevCommit headCommit)
|
||||
throws GitAPIException, NoHeadException, IOException {
|
||||
LogCommand cmd = new Git(repo).log().addRange(upstreamCommit,
|
||||
headCommit);
|
||||
Iterable<RevCommit> commitsToUse = cmd.call();
|
||||
Iterable<RevCommit> commitsToUse;
|
||||
try (Git git = new Git(repo)) {
|
||||
LogCommand cmd = git.log().addRange(upstreamCommit, headCommit);
|
||||
commitsToUse = cmd.call();
|
||||
}
|
||||
List<RevCommit> cherryPickList = new ArrayList<RevCommit>();
|
||||
for (RevCommit commit : commitsToUse) {
|
||||
if (preserveMerges || commit.getParentCount() == 1)
|
||||
|
@ -1312,7 +1326,7 @@ private RebaseResult abort(RebaseResult result) throws IOException,
|
|||
}
|
||||
dco.setFailOnConflict(false);
|
||||
dco.checkout();
|
||||
walk.release();
|
||||
walk.close();
|
||||
} finally {
|
||||
monitor.endTask();
|
||||
}
|
||||
|
@ -1387,7 +1401,7 @@ private boolean checkoutCommit(String headName, RevCommit commit)
|
|||
throw new IOException("Could not rewind to upstream commit");
|
||||
}
|
||||
} finally {
|
||||
walk.release();
|
||||
walk.close();
|
||||
monitor.endTask();
|
||||
}
|
||||
return true;
|
||||
|
|
|
@ -81,11 +81,10 @@ protected RemoveNoteCommand(Repository repo) {
|
|||
|
||||
public Note call() throws GitAPIException {
|
||||
checkCallable();
|
||||
RevWalk walk = new RevWalk(repo);
|
||||
ObjectInserter inserter = repo.newObjectInserter();
|
||||
NoteMap map = NoteMap.newEmptyMap();
|
||||
RevCommit notesCommit = null;
|
||||
try {
|
||||
try (RevWalk walk = new RevWalk(repo);
|
||||
ObjectInserter inserter = repo.newObjectInserter()) {
|
||||
NoteMap map = NoteMap.newEmptyMap();
|
||||
RevCommit notesCommit = null;
|
||||
Ref ref = repo.getRef(notesRef);
|
||||
// if we have a notes ref, use it
|
||||
if (ref != null) {
|
||||
|
@ -98,9 +97,6 @@ public Note call() throws GitAPIException {
|
|||
return map.getNote(id);
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(e.getMessage(), e);
|
||||
} finally {
|
||||
inserter.release();
|
||||
walk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -234,17 +234,12 @@ else if (repo.readSquashCommitMsg() != null)
|
|||
}
|
||||
|
||||
private RevCommit parseCommit(final ObjectId commitId) {
|
||||
RevCommit commit;
|
||||
RevWalk rw = new RevWalk(repo);
|
||||
try {
|
||||
commit = rw.parseCommit(commitId);
|
||||
try (RevWalk rw = new RevWalk(repo)) {
|
||||
return rw.parseCommit(commitId);
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(MessageFormat.format(
|
||||
JGitText.get().cannotReadCommit, commitId.toString()), e);
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
return commit;
|
||||
}
|
||||
|
||||
private ObjectId resolveRefToCommitId() {
|
||||
|
@ -305,11 +300,10 @@ private String getRefOrHEAD() {
|
|||
|
||||
private void resetIndexForPaths(ObjectId commitTree) {
|
||||
DirCache dc = null;
|
||||
try {
|
||||
try (final TreeWalk tw = new TreeWalk(repo)) {
|
||||
dc = repo.lockDirCache();
|
||||
DirCacheBuilder builder = dc.builder();
|
||||
|
||||
final TreeWalk tw = new TreeWalk(repo);
|
||||
tw.addTree(new DirCacheBuildIterator(builder));
|
||||
if (commitTree != null)
|
||||
tw.addTree(commitTree);
|
||||
|
@ -342,11 +336,9 @@ private void resetIndexForPaths(ObjectId commitTree) {
|
|||
|
||||
private void resetIndex(ObjectId commitTree) throws IOException {
|
||||
DirCache dc = repo.lockDirCache();
|
||||
TreeWalk walk = null;
|
||||
try {
|
||||
try (TreeWalk walk = new TreeWalk(repo)) {
|
||||
DirCacheBuilder builder = dc.builder();
|
||||
|
||||
walk = new TreeWalk(repo);
|
||||
if (commitTree != null)
|
||||
walk.addTree(commitTree);
|
||||
else
|
||||
|
@ -380,8 +372,6 @@ private void resetIndex(ObjectId commitTree) throws IOException {
|
|||
builder.commit();
|
||||
} finally {
|
||||
dc.unlock();
|
||||
if (walk != null)
|
||||
walk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -126,8 +126,7 @@ public RevCommit call() throws NoMessageException, UnmergedPathsException,
|
|||
RevCommit newHead = null;
|
||||
checkCallable();
|
||||
|
||||
RevWalk revWalk = new RevWalk(repo);
|
||||
try {
|
||||
try (RevWalk revWalk = new RevWalk(repo)) {
|
||||
|
||||
// get the head commit
|
||||
Ref headRef = repo.getRef(Constants.HEAD);
|
||||
|
@ -182,9 +181,11 @@ public RevCommit call() throws NoMessageException, UnmergedPathsException,
|
|||
merger.getResultTreeId());
|
||||
dco.setFailOnConflict(true);
|
||||
dco.checkout();
|
||||
newHead = new Git(getRepository()).commit()
|
||||
.setMessage(newMessage)
|
||||
.setReflogComment("revert: " + shortMessage).call(); //$NON-NLS-1$
|
||||
try (Git git = new Git(getRepository())) {
|
||||
newHead = git.commit().setMessage(newMessage)
|
||||
.setReflogComment("revert: " + shortMessage) //$NON-NLS-1$
|
||||
.call();
|
||||
}
|
||||
revertedRefs.add(src);
|
||||
headCommit = newHead;
|
||||
} else {
|
||||
|
@ -220,8 +221,6 @@ public RevCommit call() throws NoMessageException, UnmergedPathsException,
|
|||
MessageFormat.format(
|
||||
JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
|
||||
e), e);
|
||||
} finally {
|
||||
revWalk.release();
|
||||
}
|
||||
return newHead;
|
||||
}
|
||||
|
|
|
@ -144,10 +144,9 @@ public DirCache call() throws GitAPIException,
|
|||
checkCallable();
|
||||
DirCache dc = null;
|
||||
|
||||
try {
|
||||
try (final TreeWalk tw = new TreeWalk(repo)) {
|
||||
dc = repo.lockDirCache();
|
||||
DirCacheBuilder builder = dc.builder();
|
||||
final TreeWalk tw = new TreeWalk(repo);
|
||||
tw.reset(); // drop the first empty tree, which we do not need here
|
||||
tw.setRecursive(true);
|
||||
tw.setFilter(PathFilterGroup.createFromStrings(filepatterns));
|
||||
|
|
|
@ -76,10 +76,9 @@ protected ShowNoteCommand(Repository repo) {
|
|||
|
||||
public Note call() throws GitAPIException {
|
||||
checkCallable();
|
||||
RevWalk walk = new RevWalk(repo);
|
||||
NoteMap map = NoteMap.newEmptyMap();
|
||||
RevCommit notesCommit = null;
|
||||
try {
|
||||
try (RevWalk walk = new RevWalk(repo)) {
|
||||
Ref ref = repo.getRef(notesRef);
|
||||
// if we have a notes ref, use it
|
||||
if (ref != null) {
|
||||
|
@ -89,8 +88,6 @@ public Note call() throws GitAPIException {
|
|||
return map.getNote(id);
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(e.getMessage(), e);
|
||||
} finally {
|
||||
walk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -166,9 +166,8 @@ public ObjectId call() throws GitAPIException,
|
|||
JGitText.get().stashApplyOnUnsafeRepository,
|
||||
repo.getRepositoryState()));
|
||||
|
||||
ObjectReader reader = repo.newObjectReader();
|
||||
try {
|
||||
RevWalk revWalk = new RevWalk(reader);
|
||||
try (ObjectReader reader = repo.newObjectReader();
|
||||
RevWalk revWalk = new RevWalk(reader)) {
|
||||
|
||||
ObjectId headCommit = repo.resolve(Constants.HEAD);
|
||||
if (headCommit == null)
|
||||
|
@ -250,8 +249,6 @@ public ObjectId call() throws GitAPIException,
|
|||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(JGitText.get().stashApplyFailed, e);
|
||||
} finally {
|
||||
reader.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -286,11 +283,9 @@ public void setApplyUntracked(boolean applyUntracked) {
|
|||
|
||||
private void resetIndex(RevTree tree) throws IOException {
|
||||
DirCache dc = repo.lockDirCache();
|
||||
TreeWalk walk = null;
|
||||
try {
|
||||
try (TreeWalk walk = new TreeWalk(repo)) {
|
||||
DirCacheBuilder builder = dc.builder();
|
||||
|
||||
walk = new TreeWalk(repo);
|
||||
walk.addTree(tree);
|
||||
walk.addTree(new DirCacheIterator(dc));
|
||||
walk.setRecursive(true);
|
||||
|
@ -321,15 +316,13 @@ private void resetIndex(RevTree tree) throws IOException {
|
|||
builder.commit();
|
||||
} finally {
|
||||
dc.unlock();
|
||||
if (walk != null)
|
||||
walk.release();
|
||||
}
|
||||
}
|
||||
|
||||
private void resetUntracked(RevTree tree) throws CheckoutConflictException,
|
||||
IOException {
|
||||
TreeWalk walk = new TreeWalk(repo); // maybe NameConflictTreeWalk;
|
||||
try {
|
||||
// TODO maybe NameConflictTreeWalk ?
|
||||
try (TreeWalk walk = new TreeWalk(repo)) {
|
||||
walk.addTree(tree);
|
||||
walk.addTree(new FileTreeIterator(repo));
|
||||
walk.setRecursive(true);
|
||||
|
@ -359,8 +352,6 @@ private void resetUntracked(RevTree tree) throws CheckoutConflictException,
|
|||
|
||||
checkoutPath(entry, reader);
|
||||
}
|
||||
} finally {
|
||||
walk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -187,8 +187,9 @@ public StashCreateCommand setIncludeUntracked(boolean includeUntracked) {
|
|||
|
||||
private RevCommit parseCommit(final ObjectReader reader,
|
||||
final ObjectId headId) throws IOException {
|
||||
final RevWalk walk = new RevWalk(reader);
|
||||
return walk.parseCommit(headId);
|
||||
try (final RevWalk walk = new RevWalk(reader)) {
|
||||
return walk.parseCommit(headId);
|
||||
}
|
||||
}
|
||||
|
||||
private CommitBuilder createBuilder() {
|
||||
|
@ -239,14 +240,13 @@ public RevCommit call() throws GitAPIException {
|
|||
checkCallable();
|
||||
|
||||
Ref head = getHead();
|
||||
ObjectReader reader = repo.newObjectReader();
|
||||
try {
|
||||
try (ObjectReader reader = repo.newObjectReader()) {
|
||||
RevCommit headCommit = parseCommit(reader, head.getObjectId());
|
||||
DirCache cache = repo.lockDirCache();
|
||||
ObjectInserter inserter = repo.newObjectInserter();
|
||||
ObjectId commitId;
|
||||
try {
|
||||
TreeWalk treeWalk = new TreeWalk(reader);
|
||||
try (ObjectInserter inserter = repo.newObjectInserter();
|
||||
TreeWalk treeWalk = new TreeWalk(reader)) {
|
||||
|
||||
treeWalk.setRecursive(true);
|
||||
treeWalk.addTree(headCommit.getTree());
|
||||
treeWalk.addTree(new DirCacheIterator(cache));
|
||||
|
@ -380,7 +380,6 @@ public void apply(DirCacheEntry ent) {
|
|||
}
|
||||
|
||||
} finally {
|
||||
inserter.release();
|
||||
cache.unlock();
|
||||
}
|
||||
|
||||
|
@ -391,8 +390,6 @@ public void apply(DirCacheEntry ent) {
|
|||
return parseCommit(reader, commitId);
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(JGitText.get().stashFailed, e);
|
||||
} finally {
|
||||
reader.release();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -143,8 +143,7 @@ public Collection<String> call() throws InvalidConfigurationException,
|
|||
RefNotFoundException, GitAPIException {
|
||||
checkCallable();
|
||||
|
||||
try {
|
||||
SubmoduleWalk generator = SubmoduleWalk.forIndex(repo);
|
||||
try (SubmoduleWalk generator = SubmoduleWalk.forIndex(repo)) {
|
||||
if (!paths.isEmpty())
|
||||
generator.setFilter(PathFilterGroup.createFromStrings(paths));
|
||||
List<String> updated = new ArrayList<String>();
|
||||
|
@ -171,8 +170,7 @@ public Collection<String> call() throws InvalidConfigurationException,
|
|||
submoduleRepo = clone.call().getRepository();
|
||||
}
|
||||
|
||||
try {
|
||||
RevWalk walk = new RevWalk(submoduleRepo);
|
||||
try (RevWalk walk = new RevWalk(submoduleRepo)) {
|
||||
RevCommit commit = walk
|
||||
.parseCommit(generator.getObjectId());
|
||||
|
||||
|
|
|
@ -128,8 +128,7 @@ public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
|
|||
RepositoryState state = repo.getRepositoryState();
|
||||
processOptions(state);
|
||||
|
||||
RevWalk revWalk = new RevWalk(repo);
|
||||
try {
|
||||
try (RevWalk revWalk = new RevWalk(repo)) {
|
||||
// if no id is set, we should attempt to use HEAD
|
||||
if (id == null) {
|
||||
ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
|
||||
|
@ -157,24 +156,19 @@ public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
|
|||
newTag.setObjectId(id);
|
||||
|
||||
// write the tag object
|
||||
ObjectInserter inserter = repo.newObjectInserter();
|
||||
try {
|
||||
try (ObjectInserter inserter = repo.newObjectInserter()) {
|
||||
ObjectId tagId = inserter.insert(newTag);
|
||||
inserter.flush();
|
||||
|
||||
String tag = newTag.getTag();
|
||||
return updateTagRef(tagId, revWalk, tag, newTag.toString());
|
||||
|
||||
} finally {
|
||||
inserter.release();
|
||||
}
|
||||
|
||||
} catch (IOException e) {
|
||||
throw new JGitInternalException(
|
||||
JGitText.get().exceptionCaughtDuringExecutionOfTagCommand,
|
||||
e);
|
||||
} finally {
|
||||
revWalk.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -172,7 +172,7 @@ private void initRevPool(boolean reverse) {
|
|||
throw new IllegalStateException();
|
||||
|
||||
if (revPool != null)
|
||||
revPool.release();
|
||||
revPool.close();
|
||||
|
||||
if (reverse)
|
||||
revPool = new ReverseWalk(getRepository());
|
||||
|
@ -450,7 +450,7 @@ public BlameResult computeBlameResult() throws IOException {
|
|||
r.computeAll();
|
||||
return r;
|
||||
} finally {
|
||||
release();
|
||||
close();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -513,7 +513,7 @@ public boolean next() throws IOException {
|
|||
}
|
||||
|
||||
private boolean done() {
|
||||
release();
|
||||
close();
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
@ -323,7 +323,7 @@ public List<DiffEntry> compute(ProgressMonitor pm) throws IOException {
|
|||
try {
|
||||
return compute(objectReader, pm);
|
||||
} finally {
|
||||
objectReader.release();
|
||||
objectReader.close();
|
||||
}
|
||||
}
|
||||
return Collections.unmodifiableList(entries);
|
||||
|
|
|
@ -403,8 +403,7 @@ private boolean doCheckout() throws CorruptObjectException, IOException,
|
|||
MissingObjectException, IncorrectObjectTypeException,
|
||||
CheckoutConflictException, IndexWriteException {
|
||||
toBeDeleted.clear();
|
||||
ObjectReader objectReader = repo.getObjectDatabase().newReader();
|
||||
try {
|
||||
try (ObjectReader objectReader = repo.getObjectDatabase().newReader()) {
|
||||
if (headCommitTree != null)
|
||||
preScanTwoTrees();
|
||||
else
|
||||
|
@ -454,8 +453,6 @@ private boolean doCheckout() throws CorruptObjectException, IOException,
|
|||
// commit the index builder - a new index is persisted
|
||||
if (!builder.commit())
|
||||
throw new IndexWriteException();
|
||||
} finally {
|
||||
objectReader.release();
|
||||
}
|
||||
return toBeDeleted.size() == 0;
|
||||
}
|
||||
|
@ -1056,8 +1053,7 @@ private void cleanUpConflicts() throws CheckoutConflictException {
|
|||
*/
|
||||
private boolean isModifiedSubtree_IndexWorkingtree(String path)
|
||||
throws CorruptObjectException, IOException {
|
||||
NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
|
||||
try {
|
||||
try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
|
||||
tw.addTree(new DirCacheIterator(dc));
|
||||
tw.addTree(new FileTreeIterator(repo));
|
||||
tw.setRecursive(true);
|
||||
|
@ -1075,8 +1071,6 @@ private boolean isModifiedSubtree_IndexWorkingtree(String path)
|
|||
}
|
||||
}
|
||||
return false;
|
||||
} finally {
|
||||
tw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1105,8 +1099,7 @@ private boolean isModified_IndexTree(String path, ObjectId iId,
|
|||
*/
|
||||
private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
|
||||
throws CorruptObjectException, IOException {
|
||||
NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
|
||||
try {
|
||||
try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
|
||||
tw.addTree(new DirCacheIterator(dc));
|
||||
tw.addTree(tree);
|
||||
tw.setRecursive(true);
|
||||
|
@ -1124,8 +1117,6 @@ private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
|
|||
return true;
|
||||
}
|
||||
return false;
|
||||
} finally {
|
||||
tw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -214,15 +214,10 @@ public byte[] readFile(String uri, String ref, String path)
|
|||
*/
|
||||
protected byte[] readFileFromRepo(Repository repo,
|
||||
String ref, String path) throws GitAPIException, IOException {
|
||||
ObjectReader reader = repo.newObjectReader();
|
||||
byte[] result;
|
||||
try {
|
||||
try (ObjectReader reader = repo.newObjectReader()) {
|
||||
ObjectId oid = repo.resolve(ref + ":" + path); //$NON-NLS-1$
|
||||
result = reader.open(oid).getBytes(Integer.MAX_VALUE);
|
||||
} finally {
|
||||
reader.release();
|
||||
return reader.open(oid).getBytes(Integer.MAX_VALUE);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -748,8 +743,7 @@ public RevCommit call() throws GitAPIException {
|
|||
DirCache index = DirCache.newInCore();
|
||||
DirCacheBuilder builder = index.builder();
|
||||
ObjectInserter inserter = repo.newObjectInserter();
|
||||
RevWalk rw = new RevWalk(repo);
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(repo)) {
|
||||
Config cfg = new Config();
|
||||
for (Project proj : bareProjects) {
|
||||
String name = proj.path;
|
||||
|
@ -831,8 +825,6 @@ public RevCommit call() throws GitAPIException {
|
|||
return rw.parseCommit(commitId);
|
||||
} catch (IOException e) {
|
||||
throw new ManifestErrorException(e);
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
} else {
|
||||
return git
|
||||
|
@ -859,8 +851,10 @@ private void addSubmodule(String url, String name, String revision,
|
|||
try {
|
||||
Repository subRepo = add.call();
|
||||
if (revision != null) {
|
||||
Git sub = new Git(subRepo);
|
||||
sub.checkout().setName(findRef(revision, subRepo)).call();
|
||||
try (Git sub = new Git(subRepo)) {
|
||||
sub.checkout().setName(findRef(revision, subRepo))
|
||||
.call();
|
||||
}
|
||||
subRepo.close();
|
||||
git.add().addFilepattern(name).call();
|
||||
}
|
||||
|
|
|
@ -230,7 +230,7 @@ public boolean pack(ProgressMonitor pm) throws IOException {
|
|||
objdb.rollbackPack(newPackDesc);
|
||||
}
|
||||
} finally {
|
||||
ctx.release();
|
||||
ctx.close();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -601,7 +601,7 @@ public Set<ObjectId> getShallowCommits() throws IOException {
|
|||
|
||||
@Override
|
||||
public void release() {
|
||||
ctx.release();
|
||||
ctx.close();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -631,7 +631,7 @@ public ObjectStream openStream() throws IOException {
|
|||
// The newly created pack is registered in the cache.
|
||||
return ctx.open(id, type).openStream();
|
||||
} finally {
|
||||
ctx.release();
|
||||
ctx.close();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -642,7 +642,7 @@ size, new BufferedInputStream(new InflaterInputStream(
|
|||
new ReadBackStream(pos), inf, bufsz), bufsz)) {
|
||||
@Override
|
||||
public void close() throws IOException {
|
||||
ctx.release();
|
||||
ctx.close();
|
||||
super.close();
|
||||
}
|
||||
};
|
||||
|
|
|
@ -179,11 +179,8 @@ public DfsPackCompactor exclude(PackWriter.ObjectIdSet set) {
|
|||
*/
|
||||
public DfsPackCompactor exclude(DfsPackFile pack) throws IOException {
|
||||
final PackIndex idx;
|
||||
DfsReader ctx = (DfsReader) repo.newObjectReader();
|
||||
try {
|
||||
try (DfsReader ctx = (DfsReader) repo.newObjectReader()) {
|
||||
idx = pack.getPackIndex(ctx);
|
||||
} finally {
|
||||
ctx.release();
|
||||
}
|
||||
return exclude(new PackWriter.ObjectIdSet() {
|
||||
public boolean contains(AnyObjectId id) {
|
||||
|
@ -206,8 +203,7 @@ public void compact(ProgressMonitor pm) throws IOException {
|
|||
pm = NullProgressMonitor.INSTANCE;
|
||||
|
||||
DfsObjDatabase objdb = repo.getObjectDatabase();
|
||||
DfsReader ctx = (DfsReader) objdb.newReader();
|
||||
try {
|
||||
try (DfsReader ctx = (DfsReader) objdb.newReader()) {
|
||||
PackConfig pc = new PackConfig(repo);
|
||||
pc.setIndexVersion(2);
|
||||
pc.setDeltaCompress(false);
|
||||
|
@ -236,7 +232,7 @@ public void compact(ProgressMonitor pm) throws IOException {
|
|||
writeIndex(objdb, pack, pw);
|
||||
|
||||
PackWriter.Statistics stats = pw.getStatistics();
|
||||
pw.release();
|
||||
pw.close();
|
||||
pw = null;
|
||||
|
||||
pack.setPackStats(stats);
|
||||
|
@ -250,11 +246,10 @@ public void compact(ProgressMonitor pm) throws IOException {
|
|||
}
|
||||
} finally {
|
||||
if (pw != null)
|
||||
pw.release();
|
||||
pw.close();
|
||||
}
|
||||
} finally {
|
||||
rw = null;
|
||||
ctx.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -183,8 +183,7 @@ public Ref peel(Ref ref) throws IOException {
|
|||
|
||||
private Ref doPeel(final Ref leaf) throws MissingObjectException,
|
||||
IOException {
|
||||
RevWalk rw = new RevWalk(repository);
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(repository)) {
|
||||
RevObject obj = rw.parseAny(leaf.getObjectId());
|
||||
if (obj instanceof RevTag) {
|
||||
return new ObjectIdRef.PeeledTag(
|
||||
|
@ -198,8 +197,6 @@ private Ref doPeel(final Ref leaf) throws MissingObjectException,
|
|||
leaf.getName(),
|
||||
leaf.getObjectId());
|
||||
}
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -112,8 +112,10 @@ public ObjectStream openStream() throws MissingObjectException, IOException {
|
|||
ObjectId obj = pack.getReverseIdx(ctx).findObject(objectOffset);
|
||||
return ctx.open(obj, type).openStream();
|
||||
} finally {
|
||||
ctx.release();
|
||||
ctx.close();
|
||||
}
|
||||
} finally {
|
||||
ctx.close();
|
||||
}
|
||||
|
||||
// Align buffer to inflater size, at a larger than default block.
|
||||
|
|
|
@ -80,6 +80,6 @@ public int read() throws IOException {
|
|||
|
||||
@Override
|
||||
public void close() {
|
||||
ctx.release();
|
||||
ctx.close();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -477,8 +477,7 @@ public Ref peel(final Ref ref) throws IOException {
|
|||
|
||||
private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
|
||||
IOException {
|
||||
RevWalk rw = new RevWalk(getRepository());
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(getRepository())) {
|
||||
RevObject obj = rw.parseAny(leaf.getObjectId());
|
||||
if (obj instanceof RevTag) {
|
||||
return new ObjectIdRef.PeeledTag(leaf.getStorage(), leaf
|
||||
|
@ -487,8 +486,6 @@ private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
|
|||
return new ObjectIdRef.PeeledNonTag(leaf.getStorage(), leaf
|
||||
.getName(), leaf.getObjectId());
|
||||
}
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -96,8 +96,7 @@ protected Result doRename() throws IOException {
|
|||
objId = source.getOldObjectId();
|
||||
updateHEAD = needToUpdateHEAD();
|
||||
tmp = refdb.newTemporaryUpdate();
|
||||
final RevWalk rw = new RevWalk(refdb.getRepository());
|
||||
try {
|
||||
try (final RevWalk rw = new RevWalk(refdb.getRepository())) {
|
||||
// First backup the source so its never unreachable.
|
||||
tmp.setNewObjectId(objId);
|
||||
tmp.setForceUpdate(true);
|
||||
|
@ -178,7 +177,6 @@ protected Result doRename() throws IOException {
|
|||
} catch (IOException err) {
|
||||
FileUtils.delete(refdb.fileFor(tmp.getName()));
|
||||
}
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -288,7 +288,7 @@ public Object call() throws Exception {
|
|||
runWindow(w);
|
||||
} finally {
|
||||
block.pm.endWorker();
|
||||
or.release();
|
||||
or.close();
|
||||
or = null;
|
||||
}
|
||||
return null;
|
||||
|
|
|
@ -987,7 +987,7 @@ public void writePack(ProgressMonitor compressMonitor,
|
|||
}
|
||||
|
||||
stats.totalBytes = out.length();
|
||||
reader.release();
|
||||
reader.close();
|
||||
endPhase(writeMonitor);
|
||||
}
|
||||
|
||||
|
|
|
@ -400,118 +400,122 @@ public boolean diff(final ProgressMonitor monitor, int estWorkTreeSize,
|
|||
throws IOException {
|
||||
dirCache = repository.readDirCache();
|
||||
|
||||
TreeWalk treeWalk = new TreeWalk(repository);
|
||||
treeWalk.setRecursive(true);
|
||||
// add the trees (tree, dirchache, workdir)
|
||||
if (tree != null)
|
||||
treeWalk.addTree(tree);
|
||||
else
|
||||
treeWalk.addTree(new EmptyTreeIterator());
|
||||
treeWalk.addTree(new DirCacheIterator(dirCache));
|
||||
treeWalk.addTree(initialWorkingTreeIterator);
|
||||
Collection<TreeFilter> filters = new ArrayList<TreeFilter>(4);
|
||||
try (TreeWalk treeWalk = new TreeWalk(repository)) {
|
||||
treeWalk.setRecursive(true);
|
||||
// add the trees (tree, dirchache, workdir)
|
||||
if (tree != null)
|
||||
treeWalk.addTree(tree);
|
||||
else
|
||||
treeWalk.addTree(new EmptyTreeIterator());
|
||||
treeWalk.addTree(new DirCacheIterator(dirCache));
|
||||
treeWalk.addTree(initialWorkingTreeIterator);
|
||||
Collection<TreeFilter> filters = new ArrayList<TreeFilter>(4);
|
||||
|
||||
if (monitor != null) {
|
||||
// Get the maximum size of the work tree and index
|
||||
// and add some (quite arbitrary)
|
||||
if (estIndexSize == 0)
|
||||
estIndexSize = dirCache.getEntryCount();
|
||||
int total = Math.max(estIndexSize * 10 / 9,
|
||||
estWorkTreeSize * 10 / 9);
|
||||
monitor.beginTask(title, total);
|
||||
filters.add(new ProgressReportingFilter(monitor, total));
|
||||
}
|
||||
|
||||
if (filter != null)
|
||||
filters.add(filter);
|
||||
filters.add(new SkipWorkTreeFilter(INDEX));
|
||||
indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
|
||||
filters.add(indexDiffFilter);
|
||||
treeWalk.setFilter(AndTreeFilter.create(filters));
|
||||
fileModes.clear();
|
||||
while (treeWalk.next()) {
|
||||
AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
|
||||
AbstractTreeIterator.class);
|
||||
DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
|
||||
DirCacheIterator.class);
|
||||
WorkingTreeIterator workingTreeIterator = treeWalk.getTree(WORKDIR,
|
||||
WorkingTreeIterator.class);
|
||||
|
||||
if (dirCacheIterator != null) {
|
||||
final DirCacheEntry dirCacheEntry = dirCacheIterator
|
||||
.getDirCacheEntry();
|
||||
if (dirCacheEntry != null) {
|
||||
int stage = dirCacheEntry.getStage();
|
||||
if (stage > 0) {
|
||||
String path = treeWalk.getPathString();
|
||||
addConflict(path, stage);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (monitor != null) {
|
||||
// Get the maximum size of the work tree and index
|
||||
// and add some (quite arbitrary)
|
||||
if (estIndexSize == 0)
|
||||
estIndexSize = dirCache.getEntryCount();
|
||||
int total = Math.max(estIndexSize * 10 / 9,
|
||||
estWorkTreeSize * 10 / 9);
|
||||
monitor.beginTask(title, total);
|
||||
filters.add(new ProgressReportingFilter(monitor, total));
|
||||
}
|
||||
|
||||
if (treeIterator != null) {
|
||||
if (filter != null)
|
||||
filters.add(filter);
|
||||
filters.add(new SkipWorkTreeFilter(INDEX));
|
||||
indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
|
||||
filters.add(indexDiffFilter);
|
||||
treeWalk.setFilter(AndTreeFilter.create(filters));
|
||||
fileModes.clear();
|
||||
while (treeWalk.next()) {
|
||||
AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
|
||||
AbstractTreeIterator.class);
|
||||
DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
|
||||
DirCacheIterator.class);
|
||||
WorkingTreeIterator workingTreeIterator = treeWalk
|
||||
.getTree(WORKDIR, WorkingTreeIterator.class);
|
||||
|
||||
if (dirCacheIterator != null) {
|
||||
if (!treeIterator.idEqual(dirCacheIterator)
|
||||
|| treeIterator.getEntryRawMode()
|
||||
!= dirCacheIterator.getEntryRawMode()) {
|
||||
// in repo, in index, content diff => changed
|
||||
final DirCacheEntry dirCacheEntry = dirCacheIterator
|
||||
.getDirCacheEntry();
|
||||
if (dirCacheEntry != null) {
|
||||
int stage = dirCacheEntry.getStage();
|
||||
if (stage > 0) {
|
||||
String path = treeWalk.getPathString();
|
||||
addConflict(path, stage);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (treeIterator != null) {
|
||||
if (dirCacheIterator != null) {
|
||||
if (!treeIterator.idEqual(dirCacheIterator)
|
||||
|| treeIterator
|
||||
.getEntryRawMode() != dirCacheIterator
|
||||
.getEntryRawMode()) {
|
||||
// in repo, in index, content diff => changed
|
||||
if (!isEntryGitLink(treeIterator)
|
||||
|| !isEntryGitLink(dirCacheIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
changed.add(treeWalk.getPathString());
|
||||
}
|
||||
} else {
|
||||
// in repo, not in index => removed
|
||||
if (!isEntryGitLink(treeIterator)
|
||||
|| !isEntryGitLink(dirCacheIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
changed.add(treeWalk.getPathString());
|
||||
removed.add(treeWalk.getPathString());
|
||||
if (workingTreeIterator != null)
|
||||
untracked.add(treeWalk.getPathString());
|
||||
}
|
||||
} else {
|
||||
// in repo, not in index => removed
|
||||
if (!isEntryGitLink(treeIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
removed.add(treeWalk.getPathString());
|
||||
if (workingTreeIterator != null)
|
||||
untracked.add(treeWalk.getPathString());
|
||||
if (dirCacheIterator != null) {
|
||||
// not in repo, in index => added
|
||||
if (!isEntryGitLink(dirCacheIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
added.add(treeWalk.getPathString());
|
||||
} else {
|
||||
// not in repo, not in index => untracked
|
||||
if (workingTreeIterator != null
|
||||
&& !workingTreeIterator.isEntryIgnored()) {
|
||||
untracked.add(treeWalk.getPathString());
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
if (dirCacheIterator != null) {
|
||||
// not in repo, in index => added
|
||||
if (!isEntryGitLink(dirCacheIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
added.add(treeWalk.getPathString());
|
||||
} else {
|
||||
// not in repo, not in index => untracked
|
||||
if (workingTreeIterator != null
|
||||
&& !workingTreeIterator.isEntryIgnored()) {
|
||||
untracked.add(treeWalk.getPathString());
|
||||
if (workingTreeIterator == null) {
|
||||
// in index, not in workdir => missing
|
||||
if (!isEntryGitLink(dirCacheIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
missing.add(treeWalk.getPathString());
|
||||
} else {
|
||||
if (workingTreeIterator.isModified(
|
||||
dirCacheIterator.getDirCacheEntry(), true,
|
||||
treeWalk.getObjectReader())) {
|
||||
// in index, in workdir, content differs => modified
|
||||
if (!isEntryGitLink(dirCacheIterator)
|
||||
|| !isEntryGitLink(workingTreeIterator)
|
||||
|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL
|
||||
&& ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
|
||||
modified.add(treeWalk.getPathString());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (dirCacheIterator != null) {
|
||||
if (workingTreeIterator == null) {
|
||||
// in index, not in workdir => missing
|
||||
if (!isEntryGitLink(dirCacheIterator)
|
||||
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
|
||||
missing.add(treeWalk.getPathString());
|
||||
} else {
|
||||
if (workingTreeIterator.isModified(
|
||||
dirCacheIterator.getDirCacheEntry(), true,
|
||||
treeWalk.getObjectReader())) {
|
||||
// in index, in workdir, content differs => modified
|
||||
if (!isEntryGitLink(dirCacheIterator) || !isEntryGitLink(workingTreeIterator)
|
||||
|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL && ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
|
||||
modified.add(treeWalk.getPathString());
|
||||
for (int i = 0; i < treeWalk.getTreeCount(); i++) {
|
||||
Set<String> values = fileModes.get(treeWalk.getFileMode(i));
|
||||
String path = treeWalk.getPathString();
|
||||
if (path != null) {
|
||||
if (values == null)
|
||||
values = new HashSet<String>();
|
||||
values.add(path);
|
||||
fileModes.put(treeWalk.getFileMode(i), values);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < treeWalk.getTreeCount(); i++) {
|
||||
Set<String> values = fileModes.get(treeWalk.getFileMode(i));
|
||||
String path = treeWalk.getPathString();
|
||||
if (path != null) {
|
||||
if (values == null)
|
||||
values = new HashSet<String>();
|
||||
values.add(path);
|
||||
fileModes.put(treeWalk.getFileMode(i), values);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL) {
|
||||
|
|
|
@ -460,11 +460,8 @@ public Result forceUpdate() throws IOException {
|
|||
* an unexpected IO error occurred while writing changes.
|
||||
*/
|
||||
public Result update() throws IOException {
|
||||
RevWalk rw = new RevWalk(getRepository());
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(getRepository())) {
|
||||
return update(rw);
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -510,11 +507,8 @@ Result execute(Result status) throws IOException {
|
|||
* @throws IOException
|
||||
*/
|
||||
public Result delete() throws IOException {
|
||||
RevWalk rw = new RevWalk(getRepository());
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(getRepository())) {
|
||||
return delete(rw);
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -379,8 +379,7 @@ public RefRename renameRef(final String fromRef, final String toRef) throws IOEx
|
|||
public ObjectId resolve(final String revstr)
|
||||
throws AmbiguousObjectException, IncorrectObjectTypeException,
|
||||
RevisionSyntaxException, IOException {
|
||||
RevWalk rw = new RevWalk(this);
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(this)) {
|
||||
Object resolved = resolve(rw, revstr);
|
||||
if (resolved instanceof String) {
|
||||
final Ref ref = getRef((String)resolved);
|
||||
|
@ -388,8 +387,6 @@ public ObjectId resolve(final String revstr)
|
|||
} else {
|
||||
return (ObjectId) resolved;
|
||||
}
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -406,8 +403,7 @@ public ObjectId resolve(final String revstr)
|
|||
*/
|
||||
public String simplify(final String revstr)
|
||||
throws AmbiguousObjectException, IOException {
|
||||
RevWalk rw = new RevWalk(this);
|
||||
try {
|
||||
try (RevWalk rw = new RevWalk(this)) {
|
||||
Object resolved = resolve(rw, revstr);
|
||||
if (resolved != null)
|
||||
if (resolved instanceof String)
|
||||
|
@ -415,8 +411,6 @@ public String simplify(final String revstr)
|
|||
else
|
||||
return ((AnyObjectId) resolved).getName();
|
||||
return null;
|
||||
} finally {
|
||||
rw.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -791,8 +785,7 @@ private RevCommit resolveReflog(RevWalk rw, Ref ref, String time)
|
|||
private ObjectId resolveAbbreviation(final String revstr) throws IOException,
|
||||
AmbiguousObjectException {
|
||||
AbbreviatedObjectId id = AbbreviatedObjectId.fromString(revstr);
|
||||
ObjectReader reader = newObjectReader();
|
||||
try {
|
||||
try (ObjectReader reader = newObjectReader()) {
|
||||
Collection<ObjectId> matches = reader.resolve(id);
|
||||
if (matches.size() == 0)
|
||||
return null;
|
||||
|
@ -800,8 +793,6 @@ else if (matches.size() == 1)
|
|||
return matches.iterator().next();
|
||||
else
|
||||
throw new AmbiguousObjectException(id, matches);
|
||||
} finally {
|
||||
reader.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -269,14 +269,15 @@ private static PersonIdent mockAuthor(List<RevCommit> parents) {
|
|||
private DirCache dircacheFromTree(ObjectId treeId) throws IOException {
|
||||
DirCache ret = DirCache.newInCore();
|
||||
DirCacheBuilder aBuilder = ret.builder();
|
||||
TreeWalk atw = new TreeWalk(reader);
|
||||
atw.addTree(treeId);
|
||||
atw.setRecursive(true);
|
||||
while (atw.next()) {
|
||||
DirCacheEntry e = new DirCacheEntry(atw.getRawPath());
|
||||
e.setFileMode(atw.getFileMode(0));
|
||||
e.setObjectId(atw.getObjectId(0));
|
||||
aBuilder.add(e);
|
||||
try (TreeWalk atw = new TreeWalk(reader)) {
|
||||
atw.addTree(treeId);
|
||||
atw.setRecursive(true);
|
||||
while (atw.next()) {
|
||||
DirCacheEntry e = new DirCacheEntry(atw.getRawPath());
|
||||
e.setFileMode(atw.getFileMode(0));
|
||||
e.setObjectId(atw.getObjectId(0));
|
||||
aBuilder.add(e);
|
||||
}
|
||||
}
|
||||
aBuilder.finish();
|
||||
return ret;
|
||||
|
|
|
@ -53,6 +53,7 @@
|
|||
import org.eclipse.jgit.lib.AnyObjectId;
|
||||
import org.eclipse.jgit.lib.ObjectId;
|
||||
import org.eclipse.jgit.lib.ObjectInserter;
|
||||
import org.eclipse.jgit.lib.ObjectInserter.Formatter;
|
||||
import org.eclipse.jgit.lib.ObjectReader;
|
||||
import org.eclipse.jgit.lib.TreeFormatter;
|
||||
|
||||
|
@ -183,7 +184,9 @@ ObjectId writeTree(ObjectInserter inserter) throws IOException {
|
|||
|
||||
@Override
|
||||
ObjectId getTreeId() {
|
||||
return new ObjectInserter.Formatter().idFor(build());
|
||||
try (Formatter f = new ObjectInserter.Formatter()) {
|
||||
return f.idFor(build());
|
||||
}
|
||||
}
|
||||
|
||||
private TreeFormatter build() {
|
||||
|
|
|
@ -122,7 +122,7 @@ public static SubmoduleWalk forIndex(Repository repository)
|
|||
DirCache index = repository.readDirCache();
|
||||
generator.setTree(new DirCacheIterator(index));
|
||||
} catch (IOException e) {
|
||||
generator.release();
|
||||
generator.close();
|
||||
throw e;
|
||||
}
|
||||
return generator;
|
||||
|
@ -152,10 +152,10 @@ public static SubmoduleWalk forPath(Repository repository,
|
|||
if (filter.isDone(generator.walk))
|
||||
return generator;
|
||||
} catch (IOException e) {
|
||||
generator.release();
|
||||
generator.close();
|
||||
throw e;
|
||||
}
|
||||
generator.release();
|
||||
generator.close();
|
||||
return null;
|
||||
}
|
||||
|
||||
|
@ -183,10 +183,10 @@ public static SubmoduleWalk forPath(Repository repository,
|
|||
if (filter.isDone(generator.walk))
|
||||
return generator;
|
||||
} catch (IOException e) {
|
||||
generator.release();
|
||||
generator.close();
|
||||
throw e;
|
||||
}
|
||||
generator.release();
|
||||
generator.close();
|
||||
return null;
|
||||
}
|
||||
|
||||
|
@ -419,8 +419,7 @@ public SubmoduleWalk loadModulesConfig() throws IOException, ConfigInvalidExcept
|
|||
config.load();
|
||||
modulesConfig = config;
|
||||
} else {
|
||||
TreeWalk configWalk = new TreeWalk(repository);
|
||||
try {
|
||||
try (TreeWalk configWalk = new TreeWalk(repository)) {
|
||||
configWalk.addTree(rootTree);
|
||||
|
||||
// The root tree may be part of the submodule walk, so we need to revert
|
||||
|
@ -446,8 +445,6 @@ public SubmoduleWalk loadModulesConfig() throws IOException, ConfigInvalidExcept
|
|||
if (idx > 0)
|
||||
rootTree.next(idx);
|
||||
}
|
||||
} finally {
|
||||
configWalk.release();
|
||||
}
|
||||
}
|
||||
return this;
|
||||
|
|
|
@ -104,7 +104,7 @@ class PushProcess {
|
|||
|
||||
/**
|
||||
* Create process for specified transport and refs updates specification.
|
||||
*
|
||||
*
|
||||
* @param transport
|
||||
* transport between remote and local repository, used to create
|
||||
* connection.
|
||||
|
@ -177,7 +177,7 @@ else if (!preprocessed.isEmpty())
|
|||
}
|
||||
return res;
|
||||
} finally {
|
||||
walker.release();
|
||||
walker.close();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -630,7 +630,7 @@ public void upload(final InputStream input, final OutputStream output,
|
|||
service();
|
||||
} finally {
|
||||
msgOut = NullOutputStream.INSTANCE;
|
||||
walk.release();
|
||||
walk.close();
|
||||
if (timer != null) {
|
||||
try {
|
||||
timer.terminate();
|
||||
|
@ -737,35 +737,35 @@ private void reportErrorDuringNegotiate(String msg) {
|
|||
}
|
||||
|
||||
private void processShallow() throws IOException {
|
||||
DepthWalk.RevWalk depthWalk =
|
||||
new DepthWalk.RevWalk(walk.getObjectReader(), depth);
|
||||
try (DepthWalk.RevWalk depthWalk = new DepthWalk.RevWalk(
|
||||
walk.getObjectReader(), depth)) {
|
||||
|
||||
// Find all the commits which will be shallow
|
||||
for (ObjectId o : wantIds) {
|
||||
try {
|
||||
depthWalk.markRoot(depthWalk.parseCommit(o));
|
||||
} catch (IncorrectObjectTypeException notCommit) {
|
||||
// Ignore non-commits in this loop.
|
||||
// Find all the commits which will be shallow
|
||||
for (ObjectId o : wantIds) {
|
||||
try {
|
||||
depthWalk.markRoot(depthWalk.parseCommit(o));
|
||||
} catch (IncorrectObjectTypeException notCommit) {
|
||||
// Ignore non-commits in this loop.
|
||||
}
|
||||
}
|
||||
|
||||
RevCommit o;
|
||||
while ((o = depthWalk.next()) != null) {
|
||||
DepthWalk.Commit c = (DepthWalk.Commit) o;
|
||||
|
||||
// Commits at the boundary which aren't already shallow in
|
||||
// the client need to be marked as such
|
||||
if (c.getDepth() == depth && !clientShallowCommits.contains(c))
|
||||
pckOut.writeString("shallow " + o.name()); //$NON-NLS-1$
|
||||
|
||||
// Commits not on the boundary which are shallow in the client
|
||||
// need to become unshallowed
|
||||
if (c.getDepth() < depth && clientShallowCommits.remove(c)) {
|
||||
unshallowCommits.add(c.copy());
|
||||
pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RevCommit o;
|
||||
while ((o = depthWalk.next()) != null) {
|
||||
DepthWalk.Commit c = (DepthWalk.Commit) o;
|
||||
|
||||
// Commits at the boundary which aren't already shallow in
|
||||
// the client need to be marked as such
|
||||
if (c.getDepth() == depth && !clientShallowCommits.contains(c))
|
||||
pckOut.writeString("shallow " + o.name()); //$NON-NLS-1$
|
||||
|
||||
// Commits not on the boundary which are shallow in the client
|
||||
// need to become unshallowed
|
||||
if (c.getDepth() < depth && clientShallowCommits.remove(c)) {
|
||||
unshallowCommits.add(c.copy());
|
||||
pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
pckOut.end();
|
||||
}
|
||||
|
||||
|
@ -1460,7 +1460,7 @@ else if (ref.getName().startsWith(Constants.R_HEADS))
|
|||
statistics = pw.getStatistics();
|
||||
if (statistics != null)
|
||||
logger.onPackStatistics(statistics);
|
||||
pw.release();
|
||||
pw.close();
|
||||
}
|
||||
|
||||
if (sideband)
|
||||
|
|
|
@ -252,8 +252,8 @@ public void setPackLockMessage(final String message) {
|
|||
|
||||
@Override
|
||||
public void close() {
|
||||
inserter.release();
|
||||
reader.release();
|
||||
inserter.close();
|
||||
reader.close();
|
||||
for (final RemotePack p : unfetchedPacks) {
|
||||
if (p.tmpIdx != null)
|
||||
p.tmpIdx.delete();
|
||||
|
|
|
@ -220,9 +220,9 @@ private void sendpack(final List<RemoteRefUpdate> updates,
|
|||
String pathPack = null;
|
||||
String pathIdx = null;
|
||||
|
||||
final PackWriter writer = new PackWriter(transport.getPackConfig(),
|
||||
local.newObjectReader());
|
||||
try {
|
||||
try (final PackWriter writer = new PackWriter(transport.getPackConfig(),
|
||||
local.newObjectReader())) {
|
||||
|
||||
final Set<ObjectId> need = new HashSet<ObjectId>();
|
||||
final Set<ObjectId> have = new HashSet<ObjectId>();
|
||||
for (final RemoteRefUpdate r : updates)
|
||||
|
@ -293,8 +293,6 @@ private void sendpack(final List<RemoteRefUpdate> updates,
|
|||
safeDelete(pathPack);
|
||||
|
||||
throw new TransportException(uri, JGitText.get().cannotStoreObjects, err);
|
||||
} finally {
|
||||
writer.release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue