motiejus
/
jgit
1
Fork 0
Code Releases Activity

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 <spearce@spearce.org>
This commit is contained in:
Shawn O. Pearce 2011-01-31 07:07:05 -08:00
parent c2ab3421a2
commit 168114fd39
3 changed files with 56 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
org.eclipse.jgit/src/org/eclipse/jgit/storage/file/ObjectDirectoryPackParser.java
View File

@ -168,13 +168,14 @@ public PackFile getPackFile() {
}
@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);

59
org.eclipse.jgit/src/org/eclipse/jgit/transport/PackParser.java
View File

@ -406,10 +406,33 @@ public List<PackedObjectInfo> getSortedObjectList(
* @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 PackLock parse(ProgressMonitor progress) throws IOException {
baseByPos = new LongMap<UnresolvedDelta>();
deferredCheckBlobs = new ArrayList<PackedObjectInfo>();
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 PackLock parse(ProgressMonitor progress) throws IOException {
(objectCount - entryCount)));
}
resolveDeltasWithExternalBases(progress);
resolveDeltasWithExternalBases(resolving);
if (entryCount < objectCount) {
throw new IOException(MessageFormat.format(JGitText
@ -467,8 +494,6 @@ public PackLock parse(ProgressMonitor progress) throws IOException {
inflater = null;
objectDatabase.close();
}
progress.endTask();
}
return null; // By default there is no locking.
}

14
org.eclipse.jgit/src/org/eclipse/jgit/transport/ReceivePack.java
View File

@ -77,6 +77,7 @@
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 @@ private void enableCapabilities() {
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 @@ private void receivePack() throws IOException {
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 @@ private void receivePack() throws IOException {
parser.setNeedBaseObjectIds(checkReferencedIsReachable);
parser.setObjectChecking(isCheckReceivedObjects());
parser.setLockMessage(lockMsg);
packLock = parser.parse(NullProgressMonitor.INSTANCE);
packLock = parser.parse(receiving, resolving);
ins.flush();
} finally {
ins.release();