From 168114fd39a0829a5ce9a63bab248cf73c0c7e1e Mon Sep 17 00:00:00 2001 From: "Shawn O. Pearce" Date: Mon, 31 Jan 2011 07:07:05 -0800 Subject: [PATCH] Show resolving deltas progress to push clients CGit push clients 1.6.6 and later support progress messages on the side-band-64k channel during push, as this was introduced to handle server side hook errors reported over smart HTTP. Since JGit's delta resolution isn't always as fast as CGit's is, a user may think the server has crashed and failed to report status if the user pushed a lot of content and sees no feedback. Exposing the progress monitor during the resolving deltas phase will let the user know the server is still making forward progress. This also helps BasePackPushConnection, which has a bounded timeout on how long it will wait before assuming the remote server is dead. Progress messages pushed down the side-band channel will reset the read timer, helping the connection to stay alive and avoid timing out before the remote side's work is complete. Change-Id: I429c825e5a724d2f21c66f95526d9c49edcc6ca9 Signed-off-by: Shawn O. Pearce --- .../file/ObjectDirectoryPackParser.java | 5 +- .../eclipse/jgit/transport/PackParser.java | 59 +++++++++++++------ .../eclipse/jgit/transport/ReceivePack.java | 14 ++++- 3 files changed, 56 insertions(+), 22 deletions(-) diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/ObjectDirectoryPackParser.java b/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/ObjectDirectoryPackParser.java index b13df8108c..d8df339d5e 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/ObjectDirectoryPackParser.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/storage/file/ObjectDirectoryPackParser.java @@ -168,13 +168,14 @@ public class ObjectDirectoryPackParser extends PackParser { } @Override - public PackLock parse(ProgressMonitor progress) throws IOException { + public PackLock parse(ProgressMonitor receiving, ProgressMonitor resolving) + throws IOException { tmpPack = File.createTempFile("incoming_", ".pack", db.getDirectory()); tmpIdx = new File(db.getDirectory(), baseName(tmpPack) + ".idx"); try { out = new RandomAccessFile(tmpPack, "rw"); - super.parse(progress); + super.parse(receiving, resolving); out.seek(packEnd); out.write(packHash); diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/PackParser.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/PackParser.java index 9d75328af4..bae01f17d2 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/PackParser.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/PackParser.java @@ -406,10 +406,33 @@ public abstract class PackParser { * @throws IOException * the stream is malformed, or contains corrupt objects. */ - public PackLock parse(ProgressMonitor progress) throws IOException { - if (progress == null) - progress = NullProgressMonitor.INSTANCE; - progress.start(2 /* tasks */); + public final PackLock parse(ProgressMonitor progress) throws IOException { + return parse(progress, progress); + } + + /** + * Parse the pack stream. + * + * @param receiving + * receives progress feedback during the initial receiving + * objects phase. If null, {@link NullProgressMonitor} will be + * used. + * @param resolving + * receives progress feedback during the resolving objects phase. + * @return the pack lock, if one was requested by setting + * {@link #setLockMessage(String)}. + * @throws IOException + * the stream is malformed, or contains corrupt objects. + */ + public PackLock parse(ProgressMonitor receiving, ProgressMonitor resolving) + throws IOException { + if (receiving == null) + receiving = NullProgressMonitor.INSTANCE; + if (resolving == null) + resolving = NullProgressMonitor.INSTANCE; + + if (receiving == resolving) + receiving.start(2 /* tasks */); try { readPackHeader(); @@ -418,21 +441,25 @@ public abstract class PackParser { baseByPos = new LongMap(); deferredCheckBlobs = new ArrayList(); - progress.beginTask(JGitText.get().receivingObjects, + receiving.beginTask(JGitText.get().receivingObjects, (int) objectCount); - for (int done = 0; done < objectCount; done++) { - indexOneObject(); - progress.update(1); - if (progress.isCancelled()) - throw new IOException(JGitText.get().downloadCancelled); + try { + for (int done = 0; done < objectCount; done++) { + indexOneObject(); + receiving.update(1); + if (receiving.isCancelled()) + throw new IOException(JGitText.get().downloadCancelled); + } + readPackFooter(); + endInput(); + } finally { + receiving.endTask(); } - readPackFooter(); - endInput(); + if (!deferredCheckBlobs.isEmpty()) doDeferredCheckBlobs(); - progress.endTask(); if (deltaCount > 0) { - resolveDeltas(progress); + resolveDeltas(resolving); if (entryCount < objectCount) { if (!isAllowThin()) { throw new IOException(MessageFormat.format(JGitText @@ -440,7 +467,7 @@ public abstract class PackParser { (objectCount - entryCount))); } - resolveDeltasWithExternalBases(progress); + resolveDeltasWithExternalBases(resolving); if (entryCount < objectCount) { throw new IOException(MessageFormat.format(JGitText @@ -467,8 +494,6 @@ public abstract class PackParser { inflater = null; objectDatabase.close(); } - - progress.endTask(); } return null; // By default there is no locking. } diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java index 8c50604f13..59037c3bd7 100644 --- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java +++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java @@ -77,6 +77,7 @@ import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectIdSubclassMap; import org.eclipse.jgit.lib.ObjectInserter; import org.eclipse.jgit.lib.PersonIdent; +import org.eclipse.jgit.lib.ProgressMonitor; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.RefUpdate; import org.eclipse.jgit.lib.Repository; @@ -162,6 +163,8 @@ public class ReceivePack { private Writer msgs; + private SideBandOutputStream msgOut; + private PackParser parser; /** The refs we advertised as existing at the start of the connection. */ @@ -758,9 +761,9 @@ public class ReceivePack { OutputStream out = rawOut; rawOut = new SideBandOutputStream(CH_DATA, MAX_BUF, out); + msgOut = new SideBandOutputStream(CH_PROGRESS, MAX_BUF, out); pckOut = new PacketLineOut(rawOut); - msgs = new OutputStreamWriter(new SideBandOutputStream(CH_PROGRESS, - MAX_BUF, out), Constants.CHARSET); + msgs = new OutputStreamWriter(msgOut, Constants.CHARSET); } } @@ -780,6 +783,11 @@ public class ReceivePack { if (timeoutIn != null) timeoutIn.setTimeout(10 * timeout * 1000); + ProgressMonitor receiving = NullProgressMonitor.INSTANCE; + ProgressMonitor resolving = NullProgressMonitor.INSTANCE; + if (sideBand) + resolving = new SideBandProgressMonitor(msgOut); + ObjectInserter ins = db.newObjectInserter(); try { String lockMsg = "jgit receive-pack"; @@ -792,7 +800,7 @@ public class ReceivePack { parser.setNeedBaseObjectIds(checkReferencedIsReachable); parser.setObjectChecking(isCheckReceivedObjects()); parser.setLockMessage(lockMsg); - packLock = parser.parse(NullProgressMonitor.INSTANCE); + packLock = parser.parse(receiving, resolving); ins.flush(); } finally { ins.release(); -- 2.39.5