patch, 23 partsFix: let FetchProcess use fetch() instead of doFetch()

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
index afaf9e2..e33b35b 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
@@ -139,7 +139,7 @@ class FetchProcess {
 				if (!askFor.isEmpty() && (!includedTags || !askForIsComplete())) {
 					reopenConnection();
 					if (!askFor.isEmpty())
-						conn.doFetch(monitor, askFor.values());
+						conn.fetch(monitor, askFor.values());
 				}
 			}
 		} finally {

org.spearce.jgit/src/org/spearce/jgit/lib/RefUpdate.java, org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/RefUpdate.java b/org.spearce.jgit/src/org/spearce/jgit/lib/RefUpdate.java
index 48044fb..369cb37 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/RefUpdate.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/RefUpdate.java
@@ -105,7 +105,18 @@ public class RefUpdate {
 		 * update to take place, so ref still contains the old value. No
 		 * previous history was lost.
 		 */
-		REJECTED
+		REJECTED,
+
+		/**
+		 * The ref was probably not updated because of I/O error.
+		 * <p>
+		 * Unexpected I/O error occurred when writing new ref. Such error may
+		 * result in uncertain state, but most probably ref was not updated.
+		 * <p>
+		 * This kind of error doesn't include {@link #LOCK_FAILURE}, which is a
+		 * different case.
+		 */
+		IO_FAILURE
 	}
 
 	/** Repository the ref is stored in. */
@@ -256,7 +267,12 @@ public class RefUpdate {
 	 */
 	public Result forceUpdate() throws IOException {
 		requireCanDoUpdate();
-		return result = forceUpdateImpl();
+		try {
+			return result = forceUpdateImpl();
+		} catch (IOException x) {
+			result = Result.IO_FAILURE;
+			throw x;
+		}
 	}
 
 	private Result forceUpdateImpl() throws IOException {
@@ -310,7 +326,12 @@ public class RefUpdate {
 	 */
 	public Result update(final RevWalk walk) throws IOException {
 		requireCanDoUpdate();
-		return result = updateImpl(walk);
+		try {
+			return result = updateImpl(walk);
+		} catch (IOException x) {
+			result = Result.IO_FAILURE;
+			throw x;
+		}
 	}
 
 	private Result updateImpl(final RevWalk walk) throws IOException {
diff --git a/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java b/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java
index 6277970..3a81575 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java
@@ -109,6 +109,9 @@ class Fetch extends TextBuiltin {
 		if (r == RefUpdate.Result.LOCK_FAILURE)
 			return "[lock fail]";
 
+		if (r == RefUpdate.Result.IO_FAILURE)
+			return "[i/o error]";
+
 		if (r == RefUpdate.Result.NEW) {
 			if (u.getRemoteName().startsWith(REFS_HEADS))
 				return "[new branch]";
@@ -143,6 +146,8 @@ class Fetch extends TextBuiltin {
 	private static char shortTypeOf(final RefUpdate.Result r) {
 		if (r == RefUpdate.Result.LOCK_FAILURE)
 			return '!';
+		if (r == RefUpdate.Result.IO_FAILURE)
+			return '!';
 		if (r == RefUpdate.Result.NEW)
 			return '*';
 		if (r == RefUpdate.Result.FORCED)

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java
index 56234a1..771e77a 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java
@@ -49,14 +49,14 @@ import org.spearce.jgit.revwalk.RevWalk;
 
 /** Update of a locally stored tracking branch. */
 public class TrackingRefUpdate {
-	private final RefSpec spec;
+	private final String remoteName;
 
 	private final RefUpdate update;
 
-	TrackingRefUpdate(final Repository db, final RefSpec s,
+	TrackingRefUpdate(final Repository db, final RefSpec spec,
 			final AnyObjectId nv, final String msg) throws IOException {
-		spec = s;
-		update = db.updateRef(s.getDestination());
+		remoteName = spec.getSource();
+		update = db.updateRef(spec.getDestination());
 		update.setForceUpdate(spec.isForceUpdate());
 		update.setNewObjectId(nv);
 		update.setRefLogMessage(msg, true);
@@ -70,7 +70,7 @@ public class TrackingRefUpdate {
 	 * @return the name used within the remote repository.
 	 */
 	public String getRemoteName() {
-		return spec.getSource();
+		return remoteName;
 	}
 
 	/**

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java
index 771e77a..a84b38a 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TrackingRefUpdate.java
@@ -55,9 +55,16 @@ public class TrackingRefUpdate {
 
 	TrackingRefUpdate(final Repository db, final RefSpec spec,
 			final AnyObjectId nv, final String msg) throws IOException {
-		remoteName = spec.getSource();
-		update = db.updateRef(spec.getDestination());
-		update.setForceUpdate(spec.isForceUpdate());
+		this(db, spec.getDestination(), spec.getSource(), spec.isForceUpdate(),
+				nv, msg);
+	}
+
+	TrackingRefUpdate(final Repository db, final String localName,
+			final String remoteName, final boolean forceUpdate,
+			final AnyObjectId nv, final String msg) throws IOException {
+		this.remoteName = remoteName;
+		update = db.updateRef(localName);
+		update.setForceUpdate(forceUpdate);
 		update.setNewObjectId(nv);
 		update.setRefLogMessage(msg, true);
 	}

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/RemoteRefUpdate.java b/org.spearce.jgit/src/org/spearce/jgit/transport/RemoteRefUpdate.java
new file mode 100644
index 0000000..3737c7a
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/RemoteRefUpdate.java
@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the remoteName of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.io.IOException;
+
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.lib.Repository;
+import org.spearce.jgit.revwalk.RevWalk;
+
+/**
+ * Represent request and status of a remote ref update. Specification is
+ * provided by client, while status is handled by {@link PushProcess} class,
+ * being read-only for client.
+ * <p>
+ * Client can create instances of this class directly, basing on user
+ * specification and advertised refs ({@link Connection} or through
+ * {@link Transport} helper methods. Apply this specification on remote
+ * repository using
+ * {@link Transport#push(org.spearce.jgit.lib.ProgressMonitor, java.util.Collection)}
+ * method.
+ * </p>
+ * 
+ */
+public class RemoteRefUpdate {
+	/**
+	 * Represent current status of a remote ref update.
+	 */
+	public static enum Status {
+		/**
+		 * Push process hasn't yet attempted to update this ref. This is the
+		 * default status, prior to push process execution.
+		 */
+		NOT_ATTEMPTED,
+
+		/**
+		 * Remote ref was up to date, there was no need to update anything.
+		 */
+		UP_TO_DATE,
+
+		/**
+		 * Remote ref update was rejected, as it would cause non fast-forward
+		 * update.
+		 */
+		REJECTED_NONFASTFORWARD,
+
+		/**
+		 * Remote ref update was rejected, because remote side doesn't
+		 * support/allow deleting refs.
+		 */
+		REJECTED_NODELETE,
+
+		/**
+		 * Remote ref update was rejected, because old object id on remote
+		 * repository wasn't the same as defined expected old object.
+		 */
+		REJECTED_REMOTE_CHANGED,
+
+		/**
+		 * Remote ref update was rejected for other reason, possibly described
+		 * in {@link RemoteRefUpdate#getMessage()}.
+		 */
+		REJECTED_OTHER_REASON,
+
+		/**
+		 * Remote ref didn't exist. Can occur on delete request of a non
+		 * existing ref.
+		 */
+		NON_EXISTING,
+
+		/**
+		 * Push process is awaiting update report from remote repository. This
+		 * is a temporary state or state after critical error in push process.
+		 */
+		AWAITING_REPORT,
+
+		/**
+		 * Remote ref was successfully updated.
+		 */
+		OK;
+	}
+
+	private final ObjectId expectedOldObjectId;
+
+	private final ObjectId newObjectId;
+
+	private final String remoteName;
+
+	private final TrackingRefUpdate trackingRefUpdate;
+
+	private String srcRef;
+
+	private final boolean forceUpdate;
+
+	private Status status;
+
+	private boolean fastForward;
+
+	private String message;
+
+	/**
+	 * Construct remote ref update request by providing an update specification.
+	 * Object is created with default {@link Status#NOT_ATTEMPTED} status and no
+	 * message.
+	 * 
+	 * @param db
+	 *            repository to push from.
+	 * @param srcRef
+	 *            source revision - any string resolvable by
+	 *            {@link Repository#resolve(String)}. This resolves to the new
+	 *            object that the caller want remote ref to be after update. Use
+	 *            null or {@link ObjectId#zeroId()} string for delete request.
+	 * @param remoteName
+	 *            full name of a remote ref to update, e.g. "refs/heads/master"
+	 *            (no wildcard, no short name).
+	 * @param 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 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 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 {@link ObjectId#zeroId()} when expecting no
+	 *            remote ref with this name.
+	 * @throws IOException
+	 *             when I/O error occurred during creating
+	 *             {@link TrackingRefUpdate} for local tracking branch.
+	 * @throws IllegalArgumentException
+	 *             if some required parameter was null or srcRef can't be
+	 *             resolved to any object.
+	 */
+	public RemoteRefUpdate(final Repository db, final String srcRef,
+			final String remoteName, final boolean forceUpdate,
+			final String localName, final ObjectId expectedOldObjectId)
+			throws IOException {
+		if (remoteName == null)
+			throw new IllegalArgumentException("remote name can't be null");
+		this.srcRef = srcRef;
+		this.newObjectId = (srcRef == null ? ObjectId.zeroId() : db
+				.resolve(srcRef));
+		if (newObjectId == null)
+			throw new IllegalArgumentException(
+					"source ref doesn't resolve to any object");
+		this.remoteName = remoteName;
+		this.forceUpdate = forceUpdate;
+		if (localName != null && db != null)
+			trackingRefUpdate = new TrackingRefUpdate(db, localName,
+					remoteName, forceUpdate, newObjectId, "push");
+		else
+			trackingRefUpdate = null;
+		this.expectedOldObjectId = expectedOldObjectId;
+		this.status = Status.NOT_ATTEMPTED;
+	}
+
+	/**
+	 * @return expectedOldObjectId required to be advertised by remote side, as
+	 *         set in constructor; may be null.
+	 */
+	public ObjectId getExpectedOldObjectId() {
+		return expectedOldObjectId;
+	}
+
+	/**
+	 * @return true if some object is required to be advertised by remote side,
+	 *         as set in constructor; false otherwise.
+	 */
+	public boolean isExpectingOldObjectId() {
+		return expectedOldObjectId != null;
+	}
+
+	/**
+	 * @return newObjectId for remote ref, as set in constructor.
+	 */
+	public ObjectId getNewObjectId() {
+		return newObjectId;
+	}
+
+	/**
+	 * @return true if this update is deleting update; false otherwise.
+	 */
+	public boolean isDelete() {
+		return ObjectId.zeroId().equals(newObjectId);
+	}
+
+	/**
+	 * @return name of remote ref to update, as set in constructor.
+	 */
+	public String getRemoteName() {
+		return remoteName;
+	}
+
+	/**
+	 * @return local tracking branch update if localName was set in constructor.
+	 */
+	public TrackingRefUpdate getTrackingRefUpdate() {
+		return trackingRefUpdate;
+	}
+
+	/**
+	 * @return source revision as specified by user (in constructor), could be
+	 *         any string parseable by {@link Repository#resolve(String)}; can
+	 *         be null if specified that way in constructor - this stands for
+	 *         delete request.
+	 */
+	public String getSrcRef() {
+		return srcRef;
+	}
+
+	/**
+	 * @return true if user specified a local tracking branch for remote update;
+	 *         false otherwise.
+	 */
+	public boolean hasTrackingRefUpdate() {
+		return trackingRefUpdate != null;
+	}
+
+	/**
+	 * @return true if this update is forced regardless of old remote ref
+	 *         object; false otherwise.
+	 */
+	public boolean isForceUpdate() {
+		return forceUpdate;
+	}
+
+	/**
+	 * @return status of remote ref update operation.
+	 */
+	public Status getStatus() {
+		return status;
+	}
+
+	/**
+	 * Check whether update was fast-forward. Note that this result is
+	 * meaningful only after successful update (when status is {@link Status#OK}).
+	 * 
+	 * @return true if update was fast-forward; false otherwise.
+	 */
+	public boolean isFastForward() {
+		return fastForward;
+	}
+
+	/**
+	 * @return message describing reasons of status when needed/possible; may be
+	 *         null.
+	 */
+	public String getMessage() {
+		return message;
+	}
+
+	protected void setStatus(final Status status) {
+		this.status = status;
+	}
+
+	protected void setFastForward(boolean fastForward) {
+		this.fastForward = fastForward;
+	}
+
+	protected void setMessage(final String message) {
+		this.message = message;
+	}
+
+	/**
+	 * Update locally stored tracking branch with the new object.
+	 * 
+	 * @param walk
+	 *            walker used for checking update properties.
+	 * @throws IOException
+	 *             when I/O error occurred during update
+	 */
+	protected void updateTrackingRef(final RevWalk walk) throws IOException {
+		trackingRefUpdate.update(walk);
+	}
+}

org.spearce.jgit/src/org/spearce/jgit/transport/FetchResult.java, org.spearce.jgit/src/org/spearce/jgit/transport/OperationResult.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchResult.java b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchResult.java
index bd94b5f..cc8557f 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchResult.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchResult.java
@@ -40,94 +40,22 @@ package org.spearce.jgit.transport;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
-import java.util.Map;
-import java.util.SortedMap;
-import java.util.TreeMap;
-
-import org.spearce.jgit.lib.Ref;
 
 /**
  * Final status after a successful fetch from a remote repository.
  * 
  * @see Transport#fetch(org.spearce.jgit.lib.ProgressMonitor, Collection)
  */
-public class FetchResult {
-	private final SortedMap<String, TrackingRefUpdate> updates;
-
+public class FetchResult extends OperationResult {
 	private final List<FetchHeadRecord> forMerge;
 
-	private Map<String, Ref> advertisedRefs;
-
 	FetchResult() {
-		updates = new TreeMap<String, TrackingRefUpdate>();
 		forMerge = new ArrayList<FetchHeadRecord>();
-		advertisedRefs = Collections.<String, Ref> emptyMap();
-	}
-
-	void add(final TrackingRefUpdate u) {
-		updates.put(u.getLocalName(), u);
 	}
 
 	void add(final FetchHeadRecord r) {
 		if (!r.notForMerge)
 			forMerge.add(r);
 	}
-
-	void setAdvertisedRefs(final Map<String, Ref> ar) {
-		advertisedRefs = ar;
-	}
-
-	/**
-	 * Get the complete list of refs advertised by the remote.
-	 * <p>
-	 * The returned refs may appear in any order. If the caller needs these to
-	 * be sorted, they should be copied into a new array or List and then sorted
-	 * by the caller as necessary.
-	 * 
-	 * @return available/advertised refs. Never null. Not modifiable. The
-	 *         collection can be empty if the remote side has no refs (it is an
-	 *         empty/newly created repository).
-	 */
-	public Collection<Ref> getAdvertisedRefs() {
-		return advertisedRefs.values();
-	}
-
-	/**
-	 * Get a single advertised ref by name.
-	 * <p>
-	 * The name supplied should be valid ref name. To get a peeled value for a
-	 * ref (aka <code>refs/tags/v1.0^{}</code>) use the base name (without
-	 * the <code>^{}</code> suffix) and look at the peeled object id.
-	 * 
-	 * @param name
-	 *            name of the ref to obtain.
-	 * @return the requested ref; null if the remote did not advertise this ref.
-	 */
-	public final Ref getAdvertisedRef(final String name) {
-		return advertisedRefs.get(name);
-	}
-
-	/**
-	 * Get the status of all local tracking refs that were updated.
-	 * 
-	 * @return unmodifiable collection of local updates. Never null. Empty if
-	 *         there were no local tracking refs updated.
-	 */
-	public Collection<TrackingRefUpdate> getTrackingRefUpdates() {
-		return Collections.unmodifiableCollection(updates.values());
-	}
-
-	/**
-	 * Get the status for a specific local tracking ref update.
-	 * 
-	 * @param localName
-	 *            name of the local ref (e.g. "refs/remotes/origin/master").
-	 * @return status of the local ref; null if this local ref was not touched
-	 *         during this fetch.
-	 */
-	public TrackingRefUpdate getTrackingRefUpdate(final String localName) {
-		return updates.get(localName);
-	}
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/OperationResult.java b/org.spearce.jgit/src/org/spearce/jgit/transport/OperationResult.java
new file mode 100644
index 0000000..9b411e1
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/OperationResult.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
+ * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import org.spearce.jgit.lib.Ref;
+
+/**
+ * Class holding result of operation on remote repository. This includes refs
+ * advertised by remote repo and local tracking refs updates.
+ */
+public abstract class OperationResult {
+
+	protected Map<String, Ref> advertisedRefs = Collections.emptyMap();
+
+	protected final SortedMap<String, TrackingRefUpdate> updates = new TreeMap<String, TrackingRefUpdate>();
+
+	/**
+	 * Get the complete list of refs advertised by the remote.
+	 * <p>
+	 * The returned refs may appear in any order. If the caller needs these to
+	 * be sorted, they should be copied into a new array or List and then sorted
+	 * by the caller as necessary.
+	 * 
+	 * @return available/advertised refs. Never null. Not modifiable. The
+	 *         collection can be empty if the remote side has no refs (it is an
+	 *         empty/newly created repository).
+	 */
+	public Collection<Ref> getAdvertisedRefs() {
+		return Collections.unmodifiableCollection(advertisedRefs.values());
+	}
+
+	/**
+	 * Get a single advertised ref by name.
+	 * <p>
+	 * The name supplied should be valid ref name. To get a peeled value for a
+	 * ref (aka <code>refs/tags/v1.0^{}</code>) use the base name (without
+	 * the <code>^{}</code> suffix) and look at the peeled object id.
+	 * 
+	 * @param name
+	 *            name of the ref to obtain.
+	 * @return the requested ref; null if the remote did not advertise this ref.
+	 */
+	public final Ref getAdvertisedRef(final String name) {
+		return advertisedRefs.get(name);
+	}
+
+	/**
+	 * Get the status of all local tracking refs that were updated.
+	 * 
+	 * @return unmodifiable collection of local updates. Never null. Empty if
+	 *         there were no local tracking refs updated.
+	 */
+	public Collection<TrackingRefUpdate> getTrackingRefUpdates() {
+		return Collections.unmodifiableCollection(updates.values());
+	}
+
+	/**
+	 * Get the status for a specific local tracking ref update.
+	 * 
+	 * @param localName
+	 *            name of the local ref (e.g. "refs/remotes/origin/master").
+	 * @return status of the local ref; null if this local ref was not touched
+	 *         during this operation.
+	 */
+	public TrackingRefUpdate getTrackingRefUpdate(final String localName) {
+		return updates.get(localName);
+	}
+
+	protected void setAdvertisedRefs(final Map<String, Ref> ar) {
+		advertisedRefs = ar;
+	}
+
+	protected void add(final TrackingRefUpdate u) {
+		updates.put(u.getLocalName(), u);
+	}
+}
\ No newline at end of file

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PushResult.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PushResult.java
new file mode 100644
index 0000000..11e5928
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PushResult.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ * 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Result of push operation to the remote repository. Holding information of
+ * {@link OperationResult} and remote refs updates status.
+ * 
+ * @see Transport#push(org.spearce.jgit.lib.ProgressMonitor, Collection)
+ */
+public class PushResult extends OperationResult {
+	private Map<String, RemoteRefUpdate> remoteUpdates = Collections.emptyMap();
+
+	/**
+	 * Get status of remote refs updates. Together with
+	 * {@link #getAdvertisedRefs()} it provides full description/status of each
+	 * ref update.
+	 * <p>
+	 * Returned collection is not sorted in any order.
+	 * </p>
+	 * 
+	 * @return collection of remote refs updates
+	 */
+	public Collection<RemoteRefUpdate> getRemoteUpdates() {
+		return Collections.unmodifiableCollection(remoteUpdates.values());
+	}
+
+	/**
+	 * Get status of specific remote ref update by remote ref name. Together
+	 * with {@link #getAdvertisedRef(String)} it provide full description/status
+	 * of this ref update.
+	 * 
+	 * @param refName
+	 *            remote ref name
+	 * @return status of remote ref update
+	 */
+	public RemoteRefUpdate getRemoteUpdate(final String refName) {
+		return remoteUpdates.get(refName);
+	}
+
+	protected void setRemoteUpdates(
+			final Map<String, RemoteRefUpdate> remoteUpdates) {
+		this.remoteUpdates = remoteUpdates;
+	}
+}

org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java
index 5f15a8d..6209030 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java
@@ -150,6 +150,7 @@ abstract class PackFetchConnection extends FetchConnection {
 		local = packTransport.local;
 		uri = packTransport.uri;
 		includeTags = packTransport.getTagOpt() != TagOpt.NO_TAGS;
+		thinPack = packTransport.isFetchThin();
 
 		walk = new RevWalk(local);
 		reachableCommits = new RevCommitList<RevCommit>();
@@ -363,7 +364,8 @@ abstract class PackFetchConnection extends FetchConnection {
 			includeTags = wantCapability(line, OPTION_INCLUDE_TAG);
 		wantCapability(line, OPTION_OFS_DELTA);
 		multiAck = wantCapability(line, OPTION_MULTI_ACK);
-		thinPack = wantCapability(line, OPTION_THIN_PACK);
+		if (thinPack)
+			thinPack = wantCapability(line, OPTION_THIN_PACK);
 		if (wantCapability(line, OPTION_SIDE_BAND_64K))
 			sideband = true;
 		else if (wantCapability(line, OPTION_SIDE_BAND))
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java b/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
index 6cc38ec..c4b71eb 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
@@ -142,6 +142,16 @@ public abstract class Transport {
 		throw new NotSupportedException("URI not supported: " + remote);
 	}
 
+	/**
+	 * Default setting for {@link #fetchThin} option.
+	 */
+	public static final boolean DEFAULT_FETCH_THIN = true;
+
+	/**
+	 * Default setting for {@link #pushThin} option.
+	 */
+	public static final boolean DEFAULT_PUSH_THIN = false;
+
 	/** The repository this transport fetches into, or pushes out of. */
 	protected final Repository local;
 
@@ -165,6 +175,12 @@ public abstract class Transport {
 	 */
 	private TagOpt tagopt = TagOpt.NO_TAGS;
 
+	/** Should fetch request thin-pack if remote repository can produce it. */
+	private boolean fetchThin = DEFAULT_FETCH_THIN;
+
+	/** Should push produce thin-pack when sending objects to remote repository. */
+	private boolean pushThin = DEFAULT_PUSH_THIN;
+
 	/**
 	 * Create a new transport instance.
 	 * 
@@ -234,6 +250,53 @@ public abstract class Transport {
 	}
 
 	/**
+	 * Default setting is: {@link #DEFAULT_FETCH_THIN}
+	 * 
+	 * @return true if fetch should request thin-pack when possible; false
+	 *         otherwise
+	 * @see PackTransport
+	 */
+	public boolean isFetchThin() {
+		return fetchThin;
+	}
+
+	/**
+	 * Set the thin-pack preference for fetch operation. Default setting is:
+	 * {@link #DEFAULT_FETCH_THIN}
+	 * 
+	 * @param fetchThin
+	 *            true when fetch should request thin-pack when possible; false
+	 *            when it shouldn't
+	 * @see PackTransport
+	 */
+	public void setFetchThin(final boolean fetchThin) {
+		this.fetchThin = fetchThin;
+	}
+
+	/**
+	 * Default setting is: {@value #DEFAULT_PUSH_THIN}
+	 * 
+	 * @return true if push should produce thin-pack in pack transports
+	 * @see PackTransport
+	 */
+	public boolean isPushThin() {
+		return pushThin;
+	}
+
+	/**
+	 * Set thin-pack preference for push operation. Default setting is:
+	 * {@value #DEFAULT_PUSH_THIN}
+	 * 
+	 * @param pushThin
+	 *            true when push should produce thin-pack in pack transports;
+	 *            false when it shouldn't
+	 * @see PackTransport
+	 */
+	public void setPushThin(final boolean pushThin) {
+		this.pushThin = pushThin;
+	}
+
+	/**
 	 * Fetch objects and refs from the remote repository to the local one.
 	 * <p>
 	 * This is a utility function providing standard fetch behavior. Local

org.spearce.jgit/src/org/spearce/jgit/transport/BaseConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/BaseFetchConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/BasePackFetchConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/Connection.java, org.spearce.jgit/src/org/spearce/jgit/transport/FetchConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java, org.spearce.jgit/src/org/spearce/jgit/transport/PackTransport.java, org.spearce.jgit/src/org/spearce/jgit/transport/PushConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java, org.spearce.jgit/src/org/spearce/jgit/transport/WalkFetchConnection.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/BaseConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BaseConnection.java
new file mode 100644
index 0000000..9a6b7df
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BaseConnection.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
+ * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.Ref;
+
+/**
+ * Base helper class for implementing operations connections.
+ * 
+ * @see BasePackConnection
+ * @see BaseFetchConnection
+ */
+abstract class BaseConnection implements Connection {
+
+	private Map<String, Ref> advertisedRefs = Collections.emptyMap();
+
+	private boolean startedOperation;
+
+	public Map<String, Ref> getRefsMap() {
+		return advertisedRefs;
+	}
+
+	public final Collection<Ref> getRefs() {
+		return advertisedRefs.values();
+	}
+
+	public final Ref getRef(final String name) {
+		return advertisedRefs.get(name);
+	}
+
+	public abstract void close();
+
+	/**
+	 * Denote the list of refs available on the remote repository.
+	 * <p>
+	 * Implementors should invoke this method once they have obtained the refs
+	 * that are available from the remote repository.
+	 * 
+	 * @param all
+	 *            the complete list of refs the remote has to offer. This map
+	 *            will be wrapped in an unmodifiable way to protect it, but it
+	 *            does not get copied.
+	 */
+	protected void available(final Map<String, Ref> all) {
+		advertisedRefs = Collections.unmodifiableMap(all);
+	}
+
+	/**
+	 * Helper method for ensuring one-operation per connection. Check whether
+	 * operation was already marked as started, and mark it as started.
+	 * 
+	 * @throws TransportException
+	 *             if operation was already marked as started.
+	 */
+	protected void markStartedOperation() throws TransportException {
+		if (startedOperation)
+			throw new TransportException(
+					"Only one operation call per connection is supported.");
+		startedOperation = true;
+	}
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/BaseFetchConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BaseFetchConnection.java
new file mode 100644
index 0000000..7fb13bc
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BaseFetchConnection.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.util.Collection;
+
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.ProgressMonitor;
+import org.spearce.jgit.lib.Ref;
+
+/**
+ * Base helper class for fetch connection implementations. Provides some common
+ * typical structures and methods used during fetch connection.
+ * <p>
+ * Implementors of fetch over pack-based protocols should consider using
+ * {@link BasePackFetchConnection} instead.
+ * </p>
+ */
+abstract class BaseFetchConnection extends BaseConnection implements
+		FetchConnection {
+	public final void fetch(final ProgressMonitor monitor,
+			final Collection<Ref> want) throws TransportException {
+		markStartedOperation();
+		doFetch(monitor, want);
+	}
+
+	/**
+	 * Default implementation of {@link FetchConnection#didFetchIncludeTags()} -
+	 * returning false.
+	 */
+	public boolean didFetchIncludeTags() {
+		return false;
+	}
+
+	/**
+	 * Implementation of {@link #fetch(ProgressMonitor, Collection)} without
+	 * checking for multiple fetch.
+	 * 
+	 * @param monitor
+	 *            as in {@link #fetch(ProgressMonitor, Collection)}
+	 * @param want
+	 *            as in {@link #fetch(ProgressMonitor, Collection)}
+	 * @throws TransportException
+	 *             as in {@link #fetch(ProgressMonitor, Collection)}, but
+	 *             implementation doesn't have to care about multiple
+	 *             {@link #fetch(ProgressMonitor, Collection)} calls, as it is
+	 *             checked in this class.
+	 */
+	protected abstract void doFetch(final ProgressMonitor monitor,
+			final Collection<Ref> want) throws TransportException;
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java
new file mode 100644
index 0000000..d119672
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
+ * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Set;
+
+import org.spearce.jgit.errors.PackProtocolException;
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.lib.Ref;
+import org.spearce.jgit.lib.Repository;
+
+/**
+ * Base helper class for pack-based operations implementations. Provides partial
+ * implementation of pack-protocol - refs advertising and capabilities support,
+ * and some other helper methods.
+ * 
+ * @see BasePackFetchConnection
+ * @see BasePackPushConnection
+ */
+abstract class BasePackConnection extends BaseConnection {
+
+	/** The repository this transport fetches into, or pushes out of. */
+	protected final Repository local;
+
+	/** Remote repository location. */
+	protected final URIish uri;
+
+	/** Buffered input stream reading from the remote. */
+	protected InputStream in;
+
+	/** Buffered output stream sending to the remote. */
+	protected OutputStream out;
+
+	/** Packet line decoder around {@link #in}. */
+	protected PacketLineIn pckIn;
+
+	/** Packet line encoder around {@link #out}. */
+	protected PacketLineOut pckOut;
+
+	/** Capability tokens advertised by the remote side. */
+	private final Set<String> remoteCapablities = new HashSet<String>();
+
+	BasePackConnection(final PackTransport packTransport) {
+		local = packTransport.local;
+		uri = packTransport.uri;
+	}
+
+	protected void init(final InputStream myIn, final OutputStream myOut) {
+		in = myIn instanceof BufferedInputStream ? myIn
+				: new BufferedInputStream(myIn);
+		out = myOut instanceof BufferedOutputStream ? myOut
+				: new BufferedOutputStream(myOut);
+
+		pckIn = new PacketLineIn(in);
+		pckOut = new PacketLineOut(out);
+	}
+
+	protected void readAdvertisedRefs() throws TransportException {
+		try {
+			readAdvertisedRefsImpl();
+		} catch (TransportException err) {
+			close();
+			throw err;
+		} catch (IOException err) {
+			close();
+			throw new TransportException(err.getMessage(), err);
+		} catch (RuntimeException err) {
+			close();
+			throw new TransportException(err.getMessage(), err);
+		}
+	}
+
+	private void readAdvertisedRefsImpl() throws IOException {
+		final LinkedHashMap<String, Ref> avail = new LinkedHashMap<String, Ref>();
+		for (;;) {
+			String line;
+
+			try {
+				line = pckIn.readString();
+			} catch (EOFException eof) {
+				if (avail.isEmpty())
+					throw new TransportException(uri + " not found.");
+				throw eof;
+			}
+
+			if (avail.isEmpty()) {
+				final int nul = line.indexOf('\0');
+				if (nul >= 0) {
+					// The first line (if any) may contain "hidden"
+					// capability values after a NUL byte.
+					for (String c : line.substring(nul + 1).split(" "))
+						remoteCapablities.add(c);
+					line = line.substring(0, nul);
+				}
+
+				if (line.equals("capabilties^{}")) {
+					// special line from git-receive-pack to show
+					// capabilities when there are no refs to advertise
+					continue;
+				}
+			}
+
+			if (line.length() == 0)
+				break;
+
+			String name = line.substring(41, line.length());
+			final ObjectId id = ObjectId.fromString(line.substring(0, 40));
+			if (name.endsWith("^{}")) {
+				name = name.substring(0, name.length() - 3);
+				final Ref prior = avail.get(name);
+				if (prior == null)
+					throw new PackProtocolException(uri + ": advertisement of "
+							+ name + "^{} came before " + name);
+
+				if (prior.getPeeledObjectId() != null)
+					throw duplicateAdvertisement(name + "^{}");
+
+				avail.put(name, new Ref(name, prior.getObjectId(), id));
+			} else {
+				final Ref prior = avail.put(name, new Ref(name, id));
+				if (prior != null)
+					throw duplicateAdvertisement(name);
+			}
+		}
+		available(avail);
+	}
+
+	protected boolean isCapableOf(final String option) {
+		return remoteCapablities.contains(option);
+	}
+
+	protected boolean wantCapability(final StringBuilder b, final String option) {
+		if (!isCapableOf(option))
+			return false;
+		if (b.length() > 0)
+			b.append(' ');
+		b.append(option);
+		return true;
+	}
+
+	private PackProtocolException duplicateAdvertisement(final String name) {
+		return new PackProtocolException(uri + ": duplicate advertisements of "
+				+ name);
+	}
+
+	@Override
+	public void close() {
+		if (out != null) {
+			try {
+				pckOut.end();
+				out.close();
+			} catch (IOException err) {
+				// Ignore any close errors.
+			} finally {
+				out = null;
+				pckOut = null;
+			}
+		}
+
+		if (in != null) {
+			try {
+				in.close();
+			} catch (IOException err) {
+				// Ignore any close errors.
+			} finally {
+				in = null;
+				pckIn = null;
+			}
+		}
+	}
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackFetchConnection.java
similarity index 76%
rename from org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java
rename to org.spearce.jgit/src/org/spearce/jgit/transport/BasePackFetchConnection.java
index 6209030..04a91bf 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/PackFetchConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackFetchConnection.java
@@ -38,26 +38,15 @@
 
 package org.spearce.jgit.transport;
 
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.EOFException;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
 import java.util.Collection;
 import java.util.Date;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.Set;
 
-import org.spearce.jgit.errors.PackProtocolException;
 import org.spearce.jgit.errors.TransportException;
 import org.spearce.jgit.lib.AnyObjectId;
 import org.spearce.jgit.lib.MutableObjectId;
-import org.spearce.jgit.lib.ObjectId;
 import org.spearce.jgit.lib.ProgressMonitor;
 import org.spearce.jgit.lib.Ref;
-import org.spearce.jgit.lib.Repository;
 import org.spearce.jgit.revwalk.RevCommit;
 import org.spearce.jgit.revwalk.RevCommitList;
 import org.spearce.jgit.revwalk.RevFlag;
@@ -78,8 +67,14 @@ import org.spearce.jgit.revwalk.filter.RevFilter;
  * This connection requires only a bi-directional pipe or socket, and thus is
  * easily wrapped up into a local process pipe, anonymous TCP socket, or a
  * command executed through an SSH tunnel.
+ * <p>
+ * Concrete implementations should just call
+ * {@link #init(java.io.InputStream, java.io.OutputStream)} and
+ * {@link #readAdvertisedRefs()} methods in constructor or before any use. They
+ * should also handle resources releasing in {@link #close()} method if needed.
  */
-abstract class PackFetchConnection extends FetchConnection {
+abstract class BasePackFetchConnection extends BasePackConnection implements
+		FetchConnection {
 	/**
 	 * Maximum number of 'have' lines to send before giving up.
 	 * <p>
@@ -103,27 +98,6 @@ abstract class PackFetchConnection extends FetchConnection {
 
 	static final String OPTION_SHALLOW = "shallow";
 
-	/** The repository this transport fetches into, or pushes out of. */
-	protected final Repository local;
-
-	/** Remote repository location. */
-	protected final URIish uri;
-
-	/** Capability tokens advertised by the remote side. */
-	protected final Set<String> remoteCapablities = new HashSet<String>();
-
-	/** Buffered input stream reading from the remote. */
-	protected InputStream in;
-
-	/** Buffered output stream sending to the remote. */
-	protected OutputStream out;
-
-	/** Packet line decoder around {@link #in}. */
-	protected PacketLineIn pckIn;
-
-	/** Packet line encoder around {@link #out}. */
-	protected PacketLineOut pckOut;
-
 	private final RevWalk walk;
 
 	/** All commits that are immediately reachable by a local ref. */
@@ -146,9 +120,8 @@ abstract class PackFetchConnection extends FetchConnection {
 
 	private boolean includeTags;
 
-	PackFetchConnection(final PackTransport packTransport) {
-		local = packTransport.local;
-		uri = packTransport.uri;
+	BasePackFetchConnection(final PackTransport packTransport) {
+		super(packTransport);
 		includeTags = packTransport.getTagOpt() != TagOpt.NO_TAGS;
 		thinPack = packTransport.isFetchThin();
 
@@ -163,91 +136,16 @@ abstract class PackFetchConnection extends FetchConnection {
 		walk.carry(ADVERTISED);
 	}
 
-	protected void init(final InputStream myIn, final OutputStream myOut) {
-		in = myIn instanceof BufferedInputStream ? myIn
-				: new BufferedInputStream(myIn);
-		out = myOut instanceof BufferedOutputStream ? myOut
-				: new BufferedOutputStream(myOut);
-
-		pckIn = new PacketLineIn(in);
-		pckOut = new PacketLineOut(out);
+	public final void fetch(final ProgressMonitor monitor,
+			final Collection<Ref> want) throws TransportException {
+		markStartedOperation();
+		doFetch(monitor, want);
 	}
 
-	@Override
 	public boolean didFetchIncludeTags() {
-		return includeTags;
-	}
-
-	protected void readAdvertisedRefs() throws TransportException {
-		try {
-			readAdvertisedRefsImpl();
-		} catch (TransportException err) {
-			close();
-			throw err;
-		} catch (IOException err) {
-			close();
-			throw new TransportException(err.getMessage(), err);
-		} catch (RuntimeException err) {
-			close();
-			throw new TransportException(err.getMessage(), err);
-		}
-	}
-
-	private void readAdvertisedRefsImpl() throws IOException {
-		final LinkedHashMap<String, Ref> avail = new LinkedHashMap<String, Ref>();
-		for (;;) {
-			String line;
-
-			try {
-				line = pckIn.readString();
-			} catch (EOFException eof) {
-				if (avail.isEmpty())
-					throw new TransportException(uri + " not found.");
-				throw eof;
-			}
-
-			if (avail.isEmpty()) {
-				// The first line (if any) may contain "hidden"
-				// capability values after a NUL byte.
-				//
-				final int nul = line.indexOf('\0');
-				if (nul >= 0) {
-					for (String c : line.substring(nul + 1).split(" "))
-						remoteCapablities.add(c);
-					line = line.substring(0, nul);
-				}
-			}
-
-			if (line.length() == 0)
-				break;
-
-			String name = line.substring(41, line.length());
-			final ObjectId id = ObjectId.fromString(line.substring(0, 40));
-			if (name.endsWith("^{}")) {
-				name = name.substring(0, name.length() - 3);
-				final Ref prior = avail.get(name);
-				if (prior == null)
-					throw new PackProtocolException("advertisement of " + name
-							+ "^{} came before " + name);
-
-				if (prior.getPeeledObjectId() != null)
-					throw duplicateAdvertisement(name + "^{}");
-
-				avail.put(name, new Ref(name, prior.getObjectId(), id));
-			} else {
-				final Ref prior = avail.put(name, new Ref(name, id));
-				if (prior != null)
-					throw duplicateAdvertisement(name);
-			}
-		}
-		available(avail);
+		return false;
 	}
 
-	private PackProtocolException duplicateAdvertisement(final String name) {
-		return new PackProtocolException("duplicate advertisements of " + name);
-	}
-
-	@Override
 	protected void doFetch(final ProgressMonitor monitor,
 			final Collection<Ref> want) throws TransportException {
 		try {
@@ -373,15 +271,6 @@ abstract class PackFetchConnection extends FetchConnection {
 		return line.toString();
 	}
 
-	private boolean wantCapability(final StringBuilder b, final String option) {
-		if (!remoteCapablities.contains(option))
-			return false;
-		if (b.length() > 0)
-			b.append(' ');
-		b.append(option);
-		return true;
-	}
-
 	private void negotiate(final ProgressMonitor monitor) throws IOException,
 			CancelledException {
 		final MutableObjectId ackId = new MutableObjectId();
@@ -568,32 +457,6 @@ abstract class PackFetchConnection extends FetchConnection {
 		ip.renameAndOpenPack();
 	}
 
-	@Override
-	public void close() {
-		if (out != null) {
-			try {
-				pckOut.end();
-				out.close();
-			} catch (IOException err) {
-				// Ignore any close errors.
-			} finally {
-				out = null;
-				pckOut = null;
-			}
-		}
-
-		if (in != null) {
-			try {
-				in.close();
-			} catch (IOException err) {
-				// Ignore any close errors.
-			} finally {
-				in = null;
-				pckIn = null;
-			}
-		}
-	}
-
 	private static class CancelledException extends Exception {
 		private static final long serialVersionUID = 1L;
 	}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/Connection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/Connection.java
new file mode 100644
index 0000000..5a91e9b
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/Connection.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.spearce.jgit.lib.Ref;
+
+/**
+ * Represent connection for operation on a remote repository.
+ * <p>
+ * Currently all operations on remote repository (fetch and push) provide
+ * information about remote refs. Every connection is able to be closed and
+ * should be closed - this is a connection client responsibility.
+ * 
+ * @see Transport
+ */
+public interface Connection {
+
+	/**
+	 * Get the complete map of refs advertised as available for fetching or
+	 * pushing.
+	 * 
+	 * @return available/advertised refs: map of refname to ref. Never null. Not
+	 *         modifiable. The collection can be empty if the remote side has no
+	 *         refs (it is an empty/newly created repository).
+	 */
+	public Map<String, Ref> getRefsMap();
+
+	/**
+	 * Get the complete list of refs advertised as available for fetching or
+	 * pushing.
+	 * <p>
+	 * The returned refs may appear in any order. If the caller needs these to
+	 * be sorted, they should be copied into a new array or List and then sorted
+	 * by the caller as necessary.
+	 * 
+	 * @return available/advertised refs. Never null. Not modifiable. The
+	 *         collection can be empty if the remote side has no refs (it is an
+	 *         empty/newly created repository).
+	 */
+	public Collection<Ref> getRefs();
+
+	/**
+	 * Get a single advertised ref by name.
+	 * <p>
+	 * The name supplied should be valid ref name. To get a peeled value for a
+	 * ref (aka <code>refs/tags/v1.0^{}</code>) use the base name (without
+	 * the <code>^{}</code> suffix) and look at the peeled object id.
+	 * 
+	 * @param name
+	 *            name of the ref to obtain.
+	 * @return the requested ref; null if the remote did not advertise this ref.
+	 */
+	public Ref getRef(final String name);
+
+	/**
+	 * Close any resources used by this connection.
+	 * <p>
+	 * If the remote repository is contacted by a network socket this method
+	 * must close that network socket, disconnecting the two peers. If the
+	 * remote repository is actually local (same system) this method must close
+	 * any open file handles used to read the "remote" repository.
+	 */
+	public void close();
+
+}
\ No newline at end of file
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchConnection.java
index 8e7641c..9d25b0d 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchConnection.java
@@ -38,8 +38,6 @@
 package org.spearce.jgit.transport;
 
 import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
 
 import org.spearce.jgit.errors.TransportException;
 import org.spearce.jgit.lib.ProgressMonitor;
@@ -62,84 +60,13 @@ import org.spearce.jgit.lib.Ref;
  * 
  * @see Transport
  */
-public abstract class FetchConnection {
-	private Map<String, Ref> cachedRefs = Collections.<String, Ref> emptyMap();
-
-	/** Have we started {@link #fetch(ProgressMonitor, Collection)} yet? */
-	private boolean startedFetch;
-
-	Map<String, Ref> getCachedRefs() {
-		return cachedRefs;
-	}
-
-	/**
-	 * Denote the list of refs available on the remote repository.
-	 * <p>
-	 * Implementors should invoke this method once they have obtained the refs
-	 * that are available from the remote repository.s
-	 * 
-	 * @param all
-	 *            the complete list of refs the remote has to offer. This map
-	 *            will be wrapped in an unmodifiable way to protect it, but it
-	 *            does not get copied.
-	 */
-	protected void available(final Map<String, Ref> all) {
-		cachedRefs = Collections.unmodifiableMap(all);
-	}
-
-	/**
-	 * Get the complete list of refs advertised as available for fetching.
-	 * <p>
-	 * The returned refs may appear in any order. If the caller needs these to
-	 * be sorted, they should be copied into a new array or List and then sorted
-	 * by the caller as necessary.
-	 * 
-	 * @return available/advertised refs. Never null. Not modifiable. The
-	 *         collection can be empty if the remote side has no refs (it is an
-	 *         empty/newly created repository).
-	 */
-	public final Collection<Ref> getRefs() {
-		return cachedRefs.values();
-	}
-
-	/**
-	 * Get a single advertised ref by name.
-	 * <p>
-	 * The name supplied should be valid ref name. To get a peeled value for a
-	 * ref (aka <code>refs/tags/v1.0^{}</code>) use the base name (without
-	 * the <code>^{}</code> suffix) and look at the peeled object id.
-	 * 
-	 * @param name
-	 *            name of the ref to obtain.
-	 * @return the requested ref; null if the remote did not advertise this ref.
-	 */
-	public final Ref getRef(final String name) {
-		return cachedRefs.get(name);
-	}
-
+public interface FetchConnection extends Connection {
 	/**
 	 * Fetch objects we don't have but that are reachable from advertised refs.
-	 * 
-	 * @param monitor
-	 *            progress monitor to update the end-user about the amount of
-	 *            work completed, or to indicate cancellation.
-	 * @param want
-	 *            one or more refs advertised by this connection that the caller
-	 *            wants to store locally.
-	 * @throws TransportException
-	 *             objects could not be copied due to a network failure,
-	 *             protocol error, or error on remote side.
-	 */
-	public final void fetch(final ProgressMonitor monitor,
-			final Collection<Ref> want) throws TransportException {
-		if (startedFetch)
-			throw new TransportException("Only one fetch call supported.");
-		startedFetch = true;
-		doFetch(monitor, want);
-	}
-
-	/**
-	 * Fetch objects this repository does not yet contain.
+	 * <p>
+	 * Only one call per connection is allowed. Subsequent calls will result in
+	 * {@link TransportException}.
+	 * </p>
 	 * <p>
 	 * Implementations are free to use network connections as necessary to
 	 * efficiently (for both client and server) transfer objects from the remote
@@ -147,22 +74,24 @@ public abstract class FetchConnection {
 	 * avoid replacing/overwriting/duplicating an object already available in
 	 * the local destination repository. Locally available objects and packs
 	 * should always be preferred over remotely available objects and packs.
+	 * {@link Transport#isFetchThin()} should be honored if applicable.
+	 * </p>
 	 * 
 	 * @param monitor
-	 *            progress feedback to inform the end-user about the status of
-	 *            the object transfer. Implementors should poll the monitor at
-	 *            regular intervals to look for cancellation requests from the
-	 *            user.
+	 *            progress monitor to inform the end-user about the amount of
+	 *            work completed, or to indicate cancellation. Implementations
+	 *            should poll the monitor at regular intervals to look for
+	 *            cancellation requests from the user.
 	 * @param want
-	 *            one or more refs that were previously passed to
-	 *            {@link #available(Map)} by the implementation. These refs
-	 *            indicate the objects the caller wants copied.
+	 *            one or more refs advertised by this connection that the caller
+	 *            wants to store locally.
 	 * @throws TransportException
 	 *             objects could not be copied due to a network failure,
-	 *             protocol error, or error on remote side.
+	 *             protocol error, or error on remote side, or connection was
+	 *             already used for fetch.
 	 */
-	protected abstract void doFetch(ProgressMonitor monitor,
-			Collection<Ref> want) throws TransportException;
+	public void fetch(final ProgressMonitor monitor, final Collection<Ref> want)
+			throws TransportException;
 
 	/**
 	 * Did the last {@link #fetch(ProgressMonitor, Collection)} get tags?
@@ -170,9 +99,9 @@ public abstract class FetchConnection {
 	 * Some Git aware transports are able to implicitly grab an annotated tag if
 	 * {@link TagOpt#AUTO_FOLLOW} or {@link TagOpt#FETCH_TAGS} was selected and
 	 * the object the tag peels to (references) was transferred as part of the
-	 * last {@link #doFetch(ProgressMonitor, Collection)} call. If it is
-	 * possible for such tags to have been included in the transfer this method
-	 * returns true, allowing the caller to attempt tag discovery.
+	 * last {@link #fetch(ProgressMonitor, Collection)} call. If it is possible
+	 * for such tags to have been included in the transfer this method returns
+	 * true, allowing the caller to attempt tag discovery.
 	 * <p>
 	 * By returning only true/false (and not the actual list of tags obtained)
 	 * the transport itself does not need to be aware of whether or not tags
@@ -181,17 +110,5 @@ public abstract class FetchConnection {
 	 * @return true if the last fetch call implicitly included tag objects;
 	 *         false if tags were not implicitly obtained.
 	 */
-	public boolean didFetchIncludeTags() {
-		return false;
-	}
-
-	/**
-	 * Close any resources used by this connection.
-	 * <p>
-	 * If the remote repository is contacted by a network socket this method
-	 * must close that network socket, disconnecting the two peers. If the
-	 * remote repository is actually local (same system) this method must close
-	 * any open file handles used to read the "remote" repository.
-	 */
-	public abstract void close();
-}
+	public boolean didFetchIncludeTags();
+}
\ No newline at end of file
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
index e33b35b..c765c12 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
@@ -97,7 +97,7 @@ class FetchProcess {
 
 		conn = transport.openFetch();
 		try {
-			result.setAdvertisedRefs(conn.getCachedRefs());
+			result.setAdvertisedRefs(conn.getRefsMap());
 			final Set<Ref> matched = new HashSet<Ref>();
 			for (final RefSpec spec : toFetch) {
 				if (spec.isWildcard())
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PackTransport.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PackTransport.java
index 177e065..50708d3 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/PackTransport.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PackTransport.java
@@ -46,7 +46,8 @@ import org.spearce.jgit.lib.Repository;
  * forth by creating pack files on the source side and indexing them on the
  * receiving side.
  * 
- * @see PackFetchConnection
+ * @see BasePackFetchConnection
+ * @see BasePackPushConnection
  */
 abstract class PackTransport extends Transport {
 	PackTransport(final Repository local, final URIish u) {
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PushConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PushConnection.java
index 316bb95..835b15c 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/PushConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PushConnection.java
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
- *
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ * 
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or
@@ -37,6 +38,12 @@
 
 package org.spearce.jgit.transport;
 
+import java.util.Map;
+
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.ProgressMonitor;
+import org.spearce.jgit.transport.RemoteRefUpdate.Status;
+
 /**
  * Lists known refs from the remote and sends objects to the remote.
  * <p>
@@ -55,14 +62,47 @@ package org.spearce.jgit.transport;
  * 
  * @see Transport
  */
-public abstract class PushConnection {
+public interface PushConnection extends Connection {
+
 	/**
-	 * Close any resources used by this connection.
+	 * Pushes to the remote repository basing on provided specification. This
+	 * possibly result in update/creation/deletion of refs on remote repository
+	 * and sending objects that remote repository need to have a consistent
+	 * objects graph from new refs.
+	 * <p>
+	 * <p>
+	 * Only one call per connection is allowed. Subsequent calls will result in
+	 * {@link TransportException}.
+	 * </p>
 	 * <p>
-	 * If the remote repository is contacted by a network socket this method
-	 * must close that network socket, disconnecting the two peers. If the
-	 * remote repository is actually local (same system) this method must close
-	 * any open file handles used to read the "remote" repository.
+	 * Implementation may use local repository to send a minimum set of objects
+	 * needed by remote repository in efficient way.
+	 * {@link Transport#isPushThin()} should be honored if applicable.
+	 * refUpdates should be filled with information about status of each update.
+	 * </p>
+	 * 
+	 * @param monitor
+	 *            progress monitor to update the end-user about the amount of
+	 *            work completed, or to indicate cancellation. Implementors
+	 *            should poll the monitor at regular intervals to look for
+	 *            cancellation requests from the user.
+	 * @param refUpdates
+	 *            map of remote refnames to remote refs update
+	 *            specifications/statuses. Can't be empty. This indicate what
+	 *            refs caller want to update on remote side. Only refs updates
+	 *            with {@link Status#NOT_ATTEMPTED} should passed.
+	 *            Implementation must ensure that and appropriate status with
+	 *            optional message should be set during call. No refUpdate with
+	 *            {@link Status#AWAITING_REPORT} or {@link Status#NOT_ATTEMPTED}
+	 *            can be leaved by implementation after return from this call.
+	 * @throws TransportException
+	 *             objects could not be copied due to a network failure,
+	 *             critical protocol error, or error on remote side, or
+	 *             connection was already used for push - new connection must be
+	 *             created. Non-critical errors concerning only isolated refs
+	 *             should be placed in refUpdates.
 	 */
-	public abstract void close();
+	public void push(final ProgressMonitor monitor,
+			final Map<String, RemoteRefUpdate> refUpdates)
+			throws TransportException;
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
index 2c173fd..48120a8 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
@@ -95,7 +95,7 @@ class TransportBundle extends PackTransport {
 		return new BundleFetchConnection();
 	}
 
-	class BundleFetchConnection extends FetchConnection {
+	class BundleFetchConnection extends BaseFetchConnection {
 		FileInputStream in;
 
 		RewindBufferedInputStream bin;
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
index e37757a..a7a419e 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
@@ -99,7 +99,7 @@ class TransportGitAnon extends PackTransport {
 		pckOut.flush();
 	}
 
-	class TcpFetchConnection extends PackFetchConnection {
+	class TcpFetchConnection extends BasePackFetchConnection {
 		private Socket sock;
 
 		TcpFetchConnection() throws TransportException {
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
index 8944df7..f6e456a 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
@@ -188,7 +188,7 @@ class TransportGitSsh extends PackTransport {
 		}
 	}
 
-	class SshFetchConnection extends PackFetchConnection {
+	class SshFetchConnection extends BasePackFetchConnection {
 		private Session session;
 
 		private ChannelExec channel;
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
index cde648d..e109cf4 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
@@ -83,7 +83,7 @@ class TransportLocal extends PackTransport {
 		return new LocalFetchConnection();
 	}
 
-	class LocalFetchConnection extends PackFetchConnection {
+	class LocalFetchConnection extends BasePackFetchConnection {
 		private Process uploadPack;
 
 		LocalFetchConnection() throws TransportException {
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkFetchConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkFetchConnection.java
index 45c2ded..78116b2 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkFetchConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkFetchConnection.java
@@ -95,7 +95,7 @@ import org.spearce.jgit.treewalk.TreeWalk;
  * 
  * @see WalkRemoteObjectDatabase
  */
-class WalkFetchConnection extends FetchConnection {
+class WalkFetchConnection extends BaseFetchConnection {
 	/** The repository this transport fetches into, or pushes out of. */
 	private final Repository local;
 

org.spearce.jgit.test/tst/org/spearce/jgit/lib/PackWriterTest.java, org.spearce.jgit/src/org/spearce/jgit/lib/PackWriter.java

diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/lib/PackWriterTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/lib/PackWriterTest.java
index 9572342..f94eb72 100644
--- a/org.spearce.jgit.test/tst/org/spearce/jgit/lib/PackWriterTest.java
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/lib/PackWriterTest.java
@@ -120,7 +120,7 @@ public class PackWriterTest extends RepositoryTestCase {
 	 * @throws IOException
 	 */
 	public void testWriteEmptyPack1() throws IOException {
-		createVerifyOpenPack(EMPTY_LIST_OBJECT, EMPTY_LIST_OBJECT, false);
+		createVerifyOpenPack(EMPTY_LIST_OBJECT, EMPTY_LIST_OBJECT, false, false);
 
 		assertEquals(0, writer.getObjectsNumber());
 		assertEquals(0, pack.getObjectCount());
@@ -142,6 +142,37 @@ public class PackWriterTest extends RepositoryTestCase {
 	}
 
 	/**
+	 * Try to pass non-existing object as uninteresting, with non-ignoring
+	 * setting.
+	 * 
+	 * @throws IOException
+	 */
+	public void testNotIgnoreNonExistingObjects() throws IOException {
+		final ObjectId nonExisting = ObjectId
+				.fromString("0000000000000000000000000000000000000001");
+		try {
+			createVerifyOpenPack(EMPTY_LIST_OBJECT, Collections.nCopies(1,
+					nonExisting), false, false);
+			fail("Should have thrown MissingObjectException");
+		} catch (MissingObjectException x) {
+			// expected
+		}
+	}
+
+	/**
+	 * Try to pass non-existing object as uninteresting, with ignoring setting.
+	 * 
+	 * @throws IOException
+	 */
+	public void testIgnoreNonExistingObjects() throws IOException {
+		final ObjectId nonExisting = ObjectId
+				.fromString("0000000000000000000000000000000000000001");
+		createVerifyOpenPack(EMPTY_LIST_OBJECT, Collections.nCopies(1,
+				nonExisting), false, true);
+		// shouldn't throw anything
+	}
+
+	/**
 	 * Create pack basing on only interesting objects, then precisely verify
 	 * content. No delta reuse here.
 	 * 
@@ -326,7 +357,7 @@ public class PackWriterTest extends RepositoryTestCase {
 		final LinkedList<ObjectId> interestings = new LinkedList<ObjectId>();
 		interestings.add(ObjectId
 				.fromString("82c6b885ff600be425b4ea96dee75dca255b69e7"));
-		createVerifyOpenPack(interestings, EMPTY_LIST_OBJECT, false);
+		createVerifyOpenPack(interestings, EMPTY_LIST_OBJECT, false, false);
 
 		final ObjectId expectedOrder[] = new ObjectId[] {
 				ObjectId.fromString("82c6b885ff600be425b4ea96dee75dca255b69e7"),
@@ -352,7 +383,7 @@ public class PackWriterTest extends RepositoryTestCase {
 		final LinkedList<ObjectId> uninterestings = new LinkedList<ObjectId>();
 		uninterestings.add(ObjectId
 				.fromString("540a36d136cf413e4b064c2b0e0a4db60f77feab"));
-		createVerifyOpenPack(interestings, uninterestings, false);
+		createVerifyOpenPack(interestings, uninterestings, false, false);
 
 		final ObjectId expectedOrder[] = new ObjectId[] {
 				ObjectId.fromString("82c6b885ff600be425b4ea96dee75dca255b69e7"),
@@ -380,7 +411,7 @@ public class PackWriterTest extends RepositoryTestCase {
 		final LinkedList<ObjectId> uninterestings = new LinkedList<ObjectId>();
 		uninterestings.add(ObjectId
 				.fromString("c59759f143fb1fe21c197981df75a7ee00290799"));
-		createVerifyOpenPack(interestings, uninterestings, thin);
+		createVerifyOpenPack(interestings, uninterestings, thin, false);
 
 		final ObjectId writtenObjects[] = new ObjectId[] {
 				ObjectId.fromString("82c6b885ff600be425b4ea96dee75dca255b69e7"),
@@ -404,9 +435,11 @@ public class PackWriterTest extends RepositoryTestCase {
 	}
 
 	private void createVerifyOpenPack(final Collection<ObjectId> interestings,
-			final Collection<ObjectId> uninterestings, final boolean thin)
+			final Collection<ObjectId> uninterestings, final boolean thin,
+			final boolean ignoreMissingUninteresting)
 			throws MissingObjectException, IOException {
-		writer.writePack(interestings, uninterestings, thin);
+		writer.writePack(interestings, uninterestings, thin,
+				ignoreMissingUninteresting);
 		verifyOpenPack(thin);
 	}
 
diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/PackWriter.java b/org.spearce.jgit/src/org/spearce/jgit/lib/PackWriter.java
index ba43da5..a331237 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/PackWriter.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/PackWriter.java
@@ -77,7 +77,7 @@ import org.spearce.jgit.util.NB;
  * Typical usage consists of creating instance intended for some pack,
  * configuring options through accessors methods and finally call
  * {@link #writePack(Iterator)} or
- * {@link #writePack(Collection, Collection, boolean)} with objects
+ * {@link #writePack(Collection, Collection, boolean, boolean)} with objects
  * specification, to generate a pack stream.
  * </p>
  * <p>
@@ -98,7 +98,7 @@ public class PackWriter {
 	 * Title of {@link ProgressMonitor} task used during counting objects to
 	 * pack.
 	 * 
-	 * @see #writePack(Collection, Collection, boolean)
+	 * @see #writePack(Collection, Collection, boolean, boolean)
 	 */
 	public static final String COUNTING_OBJECTS_PROGRESS = "Counting objects to pack";
 
@@ -107,7 +107,7 @@ public class PackWriter {
 	 * reuse or delta reuse.
 	 * 
 	 * @see #writePack(Iterator)
-	 * @see #writePack(Collection, Collection, boolean)
+	 * @see #writePack(Collection, Collection, boolean, boolean)
 	 */
 	public static final String SEARCHING_REUSE_PROGRESS = "Searching for delta and object reuse";
 
@@ -116,7 +116,7 @@ public class PackWriter {
 	 * (objects)
 	 * 
 	 * @see #writePack(Iterator)
-	 * @see #writePack(Collection, Collection, boolean)
+	 * @see #writePack(Collection, Collection, boolean, boolean)
 	 */
 	public static final String WRITING_OBJECTS_PROGRESS = "Writing objects";
 
@@ -193,7 +193,7 @@ public class PackWriter {
 	 * Create writer for specified repository, that will write a pack to
 	 * provided output stream. Objects for packing are specified in
 	 * {@link #writePack(Iterator)} or
-	 * {@link #writePack(Collection, Collection, boolean)}.
+	 * {@link #writePack(Collection, Collection, boolean, boolean)}.
 	 * 
 	 * @param repo
 	 *            repository where objects are stored.
@@ -203,7 +203,7 @@ public class PackWriter {
 	 * @param monitor
 	 *            operations progress monitor, used within
 	 *            {@link #writePack(Iterator)} or
-	 *            {@link #writePack(Collection, Collection, boolean)}.
+	 *            {@link #writePack(Collection, Collection, boolean, boolean)}.
 	 */
 	public PackWriter(final Repository repo, final OutputStream out,
 			final ProgressMonitor monitor) {
@@ -233,7 +233,8 @@ public class PackWriter {
 	 * writer will search for delta representation of object in repository and
 	 * use it if possible. Normally, only deltas with base to another object
 	 * existing in set of objects to pack will be used. Exception is however
-	 * thin-pack (see {@link #writePack(Collection, Collection, boolean)} and
+	 * thin-pack (see
+	 * {@link #writePack(Collection, Collection, boolean, boolean)} and
 	 * {@link #writePack(Iterator)}) where base object must exist on other side
 	 * machine.
 	 * <p>
@@ -442,15 +443,21 @@ public class PackWriter {
 	 *            belonging to party repository (uninteresting/boundary) as
 	 *            determined by set; this kind of pack is used only for
 	 *            transport; true - to produce thin pack, false - otherwise.
+	 * @param ignoreMissingUninteresting
+	 *            true if writer should ignore non existing uninteresting
+	 *            objects during construction set of objects to pack; false
+	 *            otherwise - non existing uninteresting objects may cause
+	 *            {@link MissingObjectException}
 	 * @throws IOException
 	 *             when some I/O problem occur during reading objects for pack
 	 *             or writing pack stream.
 	 */
 	public void writePack(final Collection<ObjectId> interestingObjects,
-			final Collection<ObjectId> uninterestingObjects, boolean thin)
+			final Collection<ObjectId> uninterestingObjects,
+			final boolean thin, final boolean ignoreMissingUninteresting)
 			throws IOException {
 		ObjectWalk walker = setUpWalker(interestingObjects,
-				uninterestingObjects, thin);
+				uninterestingObjects, thin, ignoreMissingUninteresting);
 		findObjectsToPack(walker);
 		writePackInternal();
 	}
@@ -682,7 +689,8 @@ public class PackWriter {
 
 	private ObjectWalk setUpWalker(
 			final Collection<ObjectId> interestingObjects,
-			final Collection<ObjectId> uninterestingObjects, boolean thin)
+			final Collection<ObjectId> uninterestingObjects,
+			final boolean thin, final boolean ignoreMissingUninteresting)
 			throws MissingObjectException, IOException,
 			IncorrectObjectTypeException {
 		final ObjectWalk walker = new ObjectWalk(db);
@@ -696,7 +704,14 @@ public class PackWriter {
 			walker.markStart(o);
 		}
 		for (ObjectId id : uninterestingObjects) {
-			RevObject o = walker.parseAny(id);
+			final RevObject o;
+			try {
+				o = walker.parseAny(id);
+			} catch (MissingObjectException x) {
+				if (ignoreMissingUninteresting)
+					continue;
+				throw x;
+			}
 			walker.markUninteresting(o);
 		}
 		return walker;

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java
new file mode 100644
index 0000000..159e331
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
+import org.spearce.jgit.errors.PackProtocolException;
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.lib.PackWriter;
+import org.spearce.jgit.lib.ProgressMonitor;
+import org.spearce.jgit.lib.Ref;
+import org.spearce.jgit.transport.RemoteRefUpdate.Status;
+
+/**
+ * Push implementation using the native Git pack transfer service.
+ * <p>
+ * This is the canonical implementation for transferring objects to the remote
+ * repository from the local repository by talking to the 'git-receive-pack'
+ * service. Objects are packed on the local side into a pack file and then sent
+ * to the remote repository.
+ * <p>
+ * This connection requires only a bi-directional pipe or socket, and thus is
+ * easily wrapped up into a local process pipe, anonymous TCP socket, or a
+ * command executed through an SSH tunnel.
+ * <p>
+ * This implementation honors {@link Transport#isPushThin()} option.
+ * <p>
+ * Concrete implementations should just call
+ * {@link #init(java.io.InputStream, java.io.OutputStream)} and
+ * {@link #readAdvertisedRefs()} methods in constructor or before any use. They
+ * should also handle resources releasing in {@link #close()} method if needed.
+ */
+class BasePackPushConnection extends BasePackConnection implements
+		PushConnection {
+	static final String CAPABILITY_REPORT_STATUS = "report-status";
+
+	static final String CAPABILITY_DELETE_REFS = "delete-refs";
+
+	private final boolean thinPack;
+
+	private boolean capableDeleteRefs;
+
+	private boolean capableReport;
+
+	private boolean sentCommand;
+
+	private boolean writePack;
+
+	BasePackPushConnection(final PackTransport transport) {
+		super(transport);
+		thinPack = transport.isPushThin();
+	}
+
+	public void push(final ProgressMonitor monitor,
+			final Map<String, RemoteRefUpdate> refUpdates)
+			throws TransportException {
+		markStartedOperation();
+		doPush(monitor, refUpdates);
+	}
+
+	protected void doPush(final ProgressMonitor monitor,
+			final Map<String, RemoteRefUpdate> refUpdates)
+			throws TransportException {
+		try {
+			writeCommands(refUpdates.values(), monitor);
+			if (writePack)
+				writePack(refUpdates, monitor);
+			if (sentCommand && capableReport)
+				readStatusReport(refUpdates);
+		} catch (TransportException e) {
+			throw e;
+		} catch (Exception e) {
+			throw new TransportException(uri + ": " + e.getMessage(), e);
+		} finally {
+			close();
+		}
+	}
+
+	private void writeCommands(final Collection<RemoteRefUpdate> refUpdates,
+			final ProgressMonitor monitor) throws IOException {
+		final String capabilties = enableCapabilties();
+		for (final RemoteRefUpdate rru : refUpdates) {
+			if (!capableDeleteRefs && rru.isDelete()) {
+				rru.setStatus(Status.REJECTED_NODELETE);
+				continue;
+			}
+
+			final StringBuilder sb = new StringBuilder();
+			final Ref advertisedRef = getRef(rru.getRemoteName());
+			final ObjectId oldId = (advertisedRef == null ? ObjectId.zeroId()
+					: advertisedRef.getObjectId());
+			sb.append(oldId);
+			sb.append(' ');
+			sb.append(rru.getNewObjectId());
+			sb.append(' ');
+			sb.append(rru.getRemoteName());
+			if (!sentCommand) {
+				sentCommand = true;
+				sb.append(capabilties);
+			}
+
+			pckOut.writeString(sb.toString());
+			rru.setStatus(sentCommand ? Status.AWAITING_REPORT : Status.OK);
+			if (!rru.isDelete())
+				writePack = true;
+		}
+
+		if (monitor.isCancelled())
+			throw new TransportException(uri + ": push cancelled");
+		pckOut.end();
+	}
+
+	private String enableCapabilties() {
+		final StringBuilder line = new StringBuilder();
+		capableReport = wantCapability(line, CAPABILITY_REPORT_STATUS);
+		capableDeleteRefs = wantCapability(line, CAPABILITY_DELETE_REFS);
+		if (line.length() > 0)
+			line.insert(0, '\0');
+		return line.toString();
+	}
+
+	private void writePack(final Map<String, RemoteRefUpdate> refUpdates,
+			final ProgressMonitor monitor) throws IOException {
+		final PackWriter writer = new PackWriter(local, out, monitor);
+		final ArrayList<ObjectId> remoteObjects = new ArrayList<ObjectId>(
+				getRefs().size());
+		final ArrayList<ObjectId> newObjects = new ArrayList<ObjectId>(
+				refUpdates.size());
+
+		for (final Ref r : getRefs())
+			remoteObjects.add(r.getObjectId());
+		for (final RemoteRefUpdate r : refUpdates.values())
+			newObjects.add(r.getNewObjectId());
+
+		writer.writePack(newObjects, remoteObjects, thinPack, true);
+	}
+
+	private void readStatusReport(final Map<String, RemoteRefUpdate> refUpdates)
+			throws IOException {
+		final String unpackLine = pckIn.readString();
+		if (!unpackLine.startsWith("unpack "))
+			throw new PackProtocolException(uri + ": unexpected report line: "
+					+ unpackLine);
+		final String unpackStatus = unpackLine.substring("unpack ".length());
+		if (!unpackStatus.equals("ok"))
+			throw new TransportException(uri
+					+ ": error occurred during unpacking on the remote end: "
+					+ unpackStatus);
+
+		String refLine;
+		while ((refLine = pckIn.readString()).length() > 0) {
+			boolean ok = false;
+			int refNameEnd = -1;
+			if (refLine.startsWith("ok ")) {
+				ok = true;
+				refNameEnd = refLine.length();
+			} else if (refLine.startsWith("ng ")) {
+				ok = false;
+				refNameEnd = refLine.indexOf(" ", 3);
+			}
+			if (refNameEnd == -1)
+				throw new PackProtocolException(uri
+						+ ": unexpected report line: " + refLine);
+			final String refName = refLine.substring(3, refNameEnd);
+			final String message = (ok ? null : refLine
+					.substring(refNameEnd + 1));
+
+			final RemoteRefUpdate rru = refUpdates.get(refName);
+			if (rru == null)
+				throw new PackProtocolException(uri
+						+ ": unexpected ref report: " + refName);
+			if (ok) {
+				rru.setStatus(Status.OK);
+			} else {
+				rru.setStatus(Status.REJECTED_OTHER_REASON);
+				rru.setMessage(message);
+			}
+		}
+		for (final RemoteRefUpdate rru : refUpdates.values()) {
+			if (rru.getStatus() == Status.AWAITING_REPORT)
+				throw new PackProtocolException(uri
+						+ ": expected report for ref " + rru.getRemoteName()
+						+ " not received");
+		}
+	}
+}

diff --git a/org.spearce.jgit/src/org/spearce/jgit/revwalk/RevWalk.java b/org.spearce.jgit/src/org/spearce/jgit/revwalk/RevWalk.java
index fc757a5..7976d75 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/revwalk/RevWalk.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/revwalk/RevWalk.java
@@ -347,7 +347,7 @@ public class RevWalk implements Iterable<RevCommit> {
 		final TreeFilter oldTF = treeFilter;
 		try {
 			finishDelayedFreeFlags();
-			reset(~freeFlags & ~RESERVED_FLAGS);
+			reset(~freeFlags & APP_FLAGS);
 			filter = RevFilter.MERGE_BASE;
 			treeFilter = TreeFilter.ALL;
 			markStart(tip);

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java
new file mode 100644
index 0000000..f742949
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ * 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.spearce.jgit.errors.MissingObjectException;
+import org.spearce.jgit.errors.NotSupportedException;
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.lib.ProgressMonitor;
+import org.spearce.jgit.lib.Ref;
+import org.spearce.jgit.revwalk.RevCommit;
+import org.spearce.jgit.revwalk.RevObject;
+import org.spearce.jgit.revwalk.RevWalk;
+import org.spearce.jgit.transport.RemoteRefUpdate.Status;
+
+/**
+ * Class performing push operation on remote repository.
+ * 
+ * @see Transport#push(ProgressMonitor, Collection)
+ */
+class PushProcess {
+	/** Task name for {@link ProgressMonitor} used during opening connection. */
+	static final String PROGRESS_OPENING_CONNECTION = "Opening connection";
+
+	/** Transport used to perform this operation. */
+	private final Transport transport;
+
+	/** Push operation connection created to perform this operation */
+	private PushConnection connection;
+
+	/** Refs to update on remote side. */
+	private final Map<String, RemoteRefUpdate> toPush;
+
+	/** Revision walker for checking some updates properties. */
+	private final RevWalk walker;
+
+	/**
+	 * Create process for specified transport and refs updates specification.
+	 * 
+	 * @param transport
+	 *            transport between remote and local repository, used to create
+	 *            connection.
+	 * @param toPush
+	 *            specification of refs updates (and local tracking branches).
+	 * @throws TransportException
+	 */
+	PushProcess(final Transport transport,
+			final Collection<RemoteRefUpdate> toPush) throws TransportException {
+		this.walker = new RevWalk(transport.local);
+		this.transport = transport;
+		this.toPush = new HashMap<String, RemoteRefUpdate>();
+		for (final RemoteRefUpdate rru : toPush) {
+			if (this.toPush.put(rru.getRemoteName(), rru) != null)
+				throw new TransportException(
+						"Duplicate remote ref update is illegal. Affected remote name: "
+								+ rru.getRemoteName());
+		}
+	}
+
+	/**
+	 * Perform push operation between local and remote repository - set remote
+	 * refs appropriately, send needed objects and update local tracking refs.
+	 * 
+	 * @param monitor
+	 *            progress monitor used for feedback about operation.
+	 * @return result of push operation with complete status description.
+	 * @throws NotSupportedException
+	 *             when push operation is not supported by provided transport.
+	 * @throws TransportException
+	 *             when some error occurred during operation, like I/O, protocol
+	 *             error, or local database consistency error.
+	 */
+	PushResult execute(final ProgressMonitor monitor)
+			throws NotSupportedException, TransportException {
+		monitor.beginTask(PROGRESS_OPENING_CONNECTION, ProgressMonitor.UNKNOWN);
+		connection = transport.openPush();
+		try {
+			monitor.endTask();
+
+			final Map<String, RemoteRefUpdate> preprocessed = prepareRemoteUpdates();
+			if (!preprocessed.isEmpty())
+				connection.push(monitor, preprocessed);
+		} finally {
+			connection.close();
+		}
+		updateTrackingRefs();
+		return prepareOperationResult();
+	}
+
+	private Map<String, RemoteRefUpdate> prepareRemoteUpdates()
+			throws TransportException {
+		final Map<String, RemoteRefUpdate> result = new HashMap<String, RemoteRefUpdate>();
+		for (final RemoteRefUpdate rru : toPush.values()) {
+			final Ref advertisedRef = connection.getRef(rru.getRemoteName());
+			final ObjectId advertisedOld = (advertisedRef == null ? ObjectId
+					.zeroId() : advertisedRef.getObjectId());
+
+			if (rru.getNewObjectId().equals(advertisedOld)) {
+				if (rru.isDelete()) {
+					// ref does exist neither locally nor remotely
+					rru.setStatus(Status.NON_EXISTING);
+				} else {
+					// same object - nothing to do
+					rru.setStatus(Status.UP_TO_DATE);
+				}
+				continue;
+			}
+
+			// caller has explicitly specified expected old object id, while it
+			// has been changed in the mean time - reject
+			if (rru.isExpectingOldObjectId()
+					&& !rru.getExpectedOldObjectId().equals(advertisedOld)) {
+				rru.setStatus(Status.REJECTED_REMOTE_CHANGED);
+				continue;
+			}
+
+			// create ref (hasn't existed on remote side) and delete ref
+			// are always fast-forward commands, feasible at this level
+			if (advertisedOld.equals(ObjectId.zeroId()) || rru.isDelete()) {
+				rru.setFastForward(true);
+				result.put(rru.getRemoteName(), rru);
+				continue;
+			}
+
+			// check for fast-forward:
+			// - both old and new ref must point to commits, AND
+			// - both of them must be known for us, exist in repository, AND
+			// - old commit must be ancestor of new commit
+			boolean fastForward = true;
+			try {
+				RevObject oldRev = walker.parseAny(advertisedOld);
+				final RevObject newRev = walker.parseAny(rru.getNewObjectId());
+				if (!(oldRev instanceof RevCommit)
+						|| !(newRev instanceof RevCommit)
+						|| !walker.isMergedInto((RevCommit) oldRev,
+								(RevCommit) newRev))
+					fastForward = false;
+			} catch (MissingObjectException x) {
+				fastForward = false;
+			} catch (Exception x) {
+				throw new TransportException(transport.getURI()
+						+ ": reading objects from local repository failed: "
+						+ x.getMessage(), x);
+			}
+			rru.setFastForward(fastForward);
+			if (!fastForward && !rru.isForceUpdate())
+				rru.setStatus(Status.REJECTED_NONFASTFORWARD);
+			else
+				result.put(rru.getRemoteName(), rru);
+		}
+		return result;
+	}
+
+	private void updateTrackingRefs() {
+		for (final RemoteRefUpdate rru : toPush.values()) {
+			final Status status = rru.getStatus();
+			if (rru.hasTrackingRefUpdate()
+					&& (status == Status.UP_TO_DATE || status == Status.OK)) {
+				// update local tracking branch only when there is a chance that
+				// it has changed; this is possible for:
+				// -updated (OK) status,
+				// -up to date (UP_TO_DATE) status
+				try {
+					rru.updateTrackingRef(walker);
+				} catch (IOException e) {
+					// ignore as RefUpdate has stored I/O error status
+				}
+			}
+		}
+	}
+
+	private PushResult prepareOperationResult() {
+		final PushResult result = new PushResult();
+		result.setAdvertisedRefs(connection.getRefsMap());
+		result.setRemoteUpdates(toPush);
+
+		for (final RemoteRefUpdate rru : toPush.values()) {
+			final TrackingRefUpdate tru = rru.getTrackingRefUpdate();
+			if (tru != null)
+				result.add(tru);
+		}
+		return result;
+	}
+}

diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/Repository.java b/org.spearce.jgit/src/org/spearce/jgit/lib/Repository.java
index 64f93ff..2b43b2c 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/Repository.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/Repository.java
@@ -524,7 +524,7 @@ public class Repository {
 	 * </ul>
 	 *
 	 * @param revstr A git object references expression
-	 * @return an ObjectId
+	 * @return an ObjectId or null if revstr can't be resolved to any ObjectId
 	 * @throws IOException on serious errors
 	 */
 	public ObjectId resolve(final String revstr) throws IOException {

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/RefSpec.java b/org.spearce.jgit/src/org/spearce/jgit/transport/RefSpec.java
index 38489be..1589e19 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/RefSpec.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/RefSpec.java
@@ -281,6 +281,17 @@ public class RefSpec {
 	}
 
 	/**
+	 * Does this specification's source description match the ref name?
+	 * 
+	 * @param r
+	 *            ref name that should be tested.
+	 * @return true if the names match; false otherwise.
+	 */
+	public boolean matchSource(final String r) {
+		return match(r, getSource());
+	}
+
+	/**
 	 * Does this specification's source description match the ref?
 	 * 
 	 * @param r
@@ -288,7 +299,18 @@ public class RefSpec {
 	 * @return true if the names match; false otherwise.
 	 */
 	public boolean matchSource(final Ref r) {
-		return match(r, getSource());
+		return match(r.getName(), getSource());
+	}
+
+	/**
+	 * Does this specification's destination description match the ref name?
+	 * 
+	 * @param r
+	 *            ref name that should be tested.
+	 * @return true if the names match; false otherwise.
+	 */
+	public boolean matchDestination(final String r) {
+		return match(r, getDestination());
 	}
 
 	/**
@@ -299,7 +321,21 @@ public class RefSpec {
 	 * @return true if the names match; false otherwise.
 	 */
 	public boolean matchDestination(final Ref r) {
-		return match(r, getDestination());
+		return match(r.getName(), getDestination());
+	}
+
+	/**
+	 * Expand this specification to exactly match a ref name.
+	 * <p>
+	 * Callers must first verify the passed ref name matches this specification,
+	 * otherwise expansion results may be unpredictable.
+	 * 
+	 * @param r
+	 *            a ref name that matched our source specification.
+	 * @return a new specification that is not a wildcard.
+	 */
+	public RefSpec expandFromSource(final String r) {
+		return isWildcard() ? new RefSpec(this, r) : this;
 	}
 
 	/**
@@ -316,12 +352,12 @@ public class RefSpec {
 		return isWildcard() ? new RefSpec(this, r.getName()) : this;
 	}
 
-	private boolean match(final Ref r, final String s) {
+	private boolean match(final String refName, final String s) {
 		if (s == null)
 			return false;
 		if (isWildcard())
-			return r.getName().startsWith(s.substring(0, s.length() - 1));
-		return r.getName().equals(s);
+			return refName.startsWith(s.substring(0, s.length() - 1));
+		return refName.equals(s);
 	}
 
 	public int hashCode() {

org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java, org.spearce.jgit/src/org/spearce/jgit/transport/WalkTransport.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java b/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
index c4b71eb..da5b41e 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
  *
  * All rights reserved.
  *
@@ -42,12 +43,16 @@ import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 import org.spearce.jgit.errors.NotSupportedException;
 import org.spearce.jgit.errors.TransportException;
 import org.spearce.jgit.lib.NullProgressMonitor;
 import org.spearce.jgit.lib.ProgressMonitor;
+import org.spearce.jgit.lib.Ref;
 import org.spearce.jgit.lib.Repository;
 
 /**
@@ -105,6 +110,8 @@ public abstract class Transport {
 		tn.setOptionUploadPack(cfg.getUploadPack());
 		tn.fetch = cfg.getFetchRefSpecs();
 		tn.tagopt = cfg.getTagOpt();
+		tn.setOptionReceivePack(cfg.getReceivePack());
+		tn.push = cfg.getPushRefSpecs();
 		return tn;
 	}
 
@@ -152,6 +159,20 @@ public abstract class Transport {
 	 */
 	public static final boolean DEFAULT_PUSH_THIN = false;
 
+	/**
+	 * Specification for fetch or push operations, to fetch or push all tags.
+	 * Acts as --tags.
+	 */
+	public static final RefSpec REFSPEC_TAGS = new RefSpec(
+			"refs/tags/*:refs/tags/*");
+
+	/**
+	 * Specification for push operation, to push all refs under refs/heads. Acts
+	 * as --all.
+	 */
+	public static final RefSpec REFSPEC_PUSH_ALL = new RefSpec(
+			"refs/heads/*:refs/heads/*");
+
 	/** The repository this transport fetches into, or pushes out of. */
 	protected final Repository local;
 
@@ -162,7 +183,7 @@ public abstract class Transport {
 	private String optionUploadPack = RemoteConfig.DEFAULT_UPLOAD_PACK;
 
 	/** Specifications to apply during fetch. */
-	private List<RefSpec> fetch = Collections.<RefSpec> emptyList();
+	private List<RefSpec> fetch = Collections.emptyList();
 
 	/**
 	 * How {@link #fetch(ProgressMonitor, Collection)} should handle tags.
@@ -178,6 +199,12 @@ public abstract class Transport {
 	/** Should fetch request thin-pack if remote repository can produce it. */
 	private boolean fetchThin = DEFAULT_FETCH_THIN;
 
+	/** Name of the receive pack program, if it must be executed. */
+	private String optionReceivePack = RemoteConfig.DEFAULT_RECEIVE_PACK;
+
+	/** Specifications to apply during push. */
+	private List<RefSpec> push = Collections.emptyList();
+
 	/** Should push produce thin-pack when sending objects to remote repository. */
 	private boolean pushThin = DEFAULT_PUSH_THIN;
 
@@ -274,6 +301,31 @@ public abstract class Transport {
 	}
 
 	/**
+	 * Default setting is: {@value RemoteConfig#DEFAULT_RECEIVE_PACK}
+	 * 
+	 * @return remote executable providing receive-pack service for pack
+	 *         transports.
+	 * @see PackTransport
+	 */
+	public String getOptionReceivePack() {
+		return optionReceivePack;
+	}
+
+	/**
+	 * Set remote executable providing receive-pack service for pack transports.
+	 * Default setting is: {@value RemoteConfig#DEFAULT_RECEIVE_PACK}
+	 * 
+	 * @param optionReceivePack
+	 *            remote executable, if null or empty default one is set;
+	 */
+	public void setOptionReceivePack(String optionReceivePack) {
+		if (optionReceivePack != null && optionReceivePack.length() > 0)
+			this.optionReceivePack = optionReceivePack;
+		else
+			this.optionReceivePack = RemoteConfig.DEFAULT_RECEIVE_PACK;
+	}
+
+	/**
 	 * Default setting is: {@value #DEFAULT_PUSH_THIN}
 	 * 
 	 * @return true if push should produce thin-pack in pack transports
@@ -356,6 +408,98 @@ public abstract class Transport {
 	}
 
 	/**
+	 * Push objects and refs from the local repository to the remote one.
+	 * <p>
+	 * This is a utility function providing standard push behavior. It updates
+	 * remote refs and send there necessary objects according to remote ref
+	 * update specification. After successful remote ref update, associated
+	 * locally stored tracking branch is updated if set up accordingly. Detailed
+	 * operation result is provided after execution.
+	 * <p>
+	 * For setting up remote ref update specification from ref spec, see helper
+	 * method {@link #findRemoteRefUpdatesFor(Collection)}, predefined refspecs ({@link #REFSPEC_TAGS},
+	 * {@link #REFSPEC_PUSH_ALL}) or consider using directly
+	 * {@link RemoteRefUpdate} for more possibilities.
+	 * 
+	 * @see RemoteRefUpdate
+	 * 
+	 * @param monitor
+	 *            progress monitor to inform the user about our processing
+	 *            activity. Must not be null. Use {@link NullProgressMonitor} if
+	 *            progress updates are not interesting or necessary.
+	 * @param toPush
+	 *            specification of refs to push. May be null or the empty
+	 *            collection to use the specifications from the RemoteConfig
+	 *            converted by {@link #findRemoteRefUpdatesFor(Collection)}. No
+	 *            more than 1 RemoteRefUpdate with the same remoteName is
+	 *            allowed.
+	 * @return information about results of remote refs updates, tracking refs
+	 *         updates and refs advertised by remote repository.
+	 * @throws NotSupportedException
+	 *             this transport implementation does not support pusing
+	 *             objects.
+	 * @throws TransportException
+	 *             the remote connection could not be established or object
+	 *             copying (if necessary) failed at I/O or protocol level or
+	 *             update specification was incorrect.
+	 */
+	public PushResult push(final ProgressMonitor monitor,
+			Collection<RemoteRefUpdate> toPush) throws NotSupportedException,
+			TransportException {
+		if (toPush == null || toPush.isEmpty()) {
+			// If the caller did not ask for anything use the defaults.
+			toPush = findRemoteRefUpdatesFor(push);
+			if (toPush.isEmpty())
+				throw new TransportException("Nothing to push.");
+		}
+		final PushProcess pushProcess = new PushProcess(this, toPush);
+		return pushProcess.execute(monitor);
+	}
+
+	/**
+	 * Convert push remote refs update specification from {@link RefSpec} form
+	 * to {@link RemoteRefUpdate}. Conversion expands wildcards by matching
+	 * source part to local refs. expectedOldObjectId in RemoteRefUpdate is
+	 * always set as null. Tracking branch is configured if RefSpec destination
+	 * matches source of any fetch ref spec for this transport remote
+	 * configuration.
+	 * 
+	 * @param specs
+	 *            collection of RefSpec to convert.
+	 * @return collection of set up {@link RemoteRefUpdate}.
+	 * @throws TransportException
+	 *             when problem occurred during conversion or specification set
+	 *             up: most probably, missing objects or refs.
+	 */
+	public Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(
+			final Collection<RefSpec> specs) throws TransportException {
+		final List<RemoteRefUpdate> result = new LinkedList<RemoteRefUpdate>();
+		final Collection<RefSpec> procRefs = expandPushWildcardsFor(specs);
+
+		for (final RefSpec spec : procRefs) {
+			try {
+				final String srcRef = spec.getSource();
+				// null destination (no-colon in ref-spec) is a special case
+				final String remoteName = (spec.getDestination() == null ? spec
+						.getSource() : spec.getDestination());
+				final boolean forceUpdate = spec.isForceUpdate();
+				final String localName = findTrackingRefName(remoteName);
+
+				final RemoteRefUpdate rru = new RemoteRefUpdate(local, srcRef,
+						remoteName, forceUpdate, localName, null);
+				result.add(rru);
+			} catch (TransportException x) {
+				throw x;
+			} catch (Exception x) {
+				throw new TransportException(
+						"Problem with resolving push ref spec \"" + spec
+								+ "\" locally: " + x.getMessage(), x);
+			}
+		}
+		return result;
+	}
+
+	/**
 	 * Begins a new connection for fetching from the remote repository.
 	 * 
 	 * @return a fresh connection to fetch from the remote repository.
@@ -373,9 +517,41 @@ public abstract class Transport {
 	 * @return a fresh connection to push into the remote repository.
 	 * @throws NotSupportedException
 	 *             the implementation does not support pushing.
+	 * @throws TransportException
+	 *             the remote connection could not be established
 	 */
-	public final PushConnection openPush() throws NotSupportedException
-	/* TransportException */{
-		throw new NotSupportedException("No push support.");
+	public abstract PushConnection openPush() throws NotSupportedException,
+			TransportException;
+
+	private Collection<RefSpec> expandPushWildcardsFor(
+			final Collection<RefSpec> specs) {
+		final Map<String, Ref> localRefs = local.getAllRefs();
+		final Collection<RefSpec> procRefs = new HashSet<RefSpec>();
+
+		for (final RefSpec spec : specs) {
+			if (spec.isWildcard()) {
+				for (final Ref localRef : localRefs.values()) {
+					if (spec.matchSource(localRef))
+						procRefs.add(spec.expandFromSource(localRef));
+				}
+			} else {
+				procRefs.add(spec);
+			}
+		}
+		return procRefs;
+	}
+
+	private String findTrackingRefName(final String remoteName) {
+		// try to find matching tracking refs
+		for (final RefSpec fetchSpec : fetch) {
+			if (fetchSpec.matchSource(remoteName)) {
+				if (fetchSpec.isWildcard())
+					return fetchSpec.expandFromSource(remoteName)
+							.getDestination();
+				else
+					return fetchSpec.getDestination();
+			}
+		}
+		return null;
 	}
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
index 48120a8..1bf081a 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportBundle.java
@@ -95,6 +95,12 @@ class TransportBundle extends PackTransport {
 		return new BundleFetchConnection();
 	}
 
+	@Override
+	public PushConnection openPush() throws NotSupportedException {
+		throw new NotSupportedException(
+				"Push is not supported for bundle transport");
+	}
+
 	class BundleFetchConnection extends BaseFetchConnection {
 		FileInputStream in;
 
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
index a7a419e..6e49083 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
  *
  * All rights reserved.
  *
@@ -71,6 +72,11 @@ class TransportGitAnon extends PackTransport {
 		return new TcpFetchConnection();
 	}
 
+	@Override
+	public PushConnection openPush() throws TransportException {
+		return new TcpPushConnection();
+	}
+
 	Socket openConnection() throws TransportException {
 		final int port = uri.getPort() > 0 ? uri.getPort() : GIT_PORT;
 		try {
@@ -131,4 +137,37 @@ class TransportGitAnon extends PackTransport {
 			}
 		}
 	}
+
+	class TcpPushConnection extends BasePackPushConnection {
+		private Socket sock;
+
+		TcpPushConnection() throws TransportException {
+			super(TransportGitAnon.this);
+			sock = openConnection();
+			try {
+				init(sock.getInputStream(), sock.getOutputStream());
+				service("git-receive-pack", pckOut);
+			} catch (IOException err) {
+				close();
+				throw new TransportException(uri.toString()
+						+ ": remote hung up unexpectedly", err);
+			}
+			readAdvertisedRefs();
+		}
+
+		@Override
+		public void close() {
+			super.close();
+
+			if (sock != null) {
+				try {
+					sock.close();
+				} catch (IOException err) {
+					// Ignore errors during close.
+				} finally {
+					sock = null;
+				}
+			}
+		}
+	}
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
index f6e456a..55be4f6 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
  *
  * All rights reserved.
  *
@@ -88,6 +89,11 @@ class TransportGitSsh extends PackTransport {
 		return new SshFetchConnection();
 	}
 
+	@Override
+	public PushConnection openPush() throws TransportException {
+		return new SshPushConnection();
+	}
+
 	private static void sqMinimal(final StringBuilder cmd, final String val) {
 		if (val.matches("^[a-zA-Z0-9._/-]*$")) {
 			// If the string matches only generally safe characters
@@ -232,4 +238,49 @@ class TransportGitSsh extends PackTransport {
 			}
 		}
 	}
+
+	class SshPushConnection extends BasePackPushConnection {
+		private Session session;
+
+		private ChannelExec channel;
+
+		SshPushConnection() throws TransportException {
+			super(TransportGitSsh.this);
+			try {
+				session = openSession();
+				channel = exec(session, getOptionReceivePack());
+				init(channel.getInputStream(), channel.getOutputStream());
+			} catch (TransportException err) {
+				close();
+				throw err;
+			} catch (IOException err) {
+				close();
+				throw new TransportException(uri.toString()
+						+ ": remote hung up unexpectedly", err);
+			}
+			readAdvertisedRefs();
+		}
+
+		@Override
+		public void close() {
+			super.close();
+
+			if (channel != null) {
+				try {
+					if (channel.isConnected())
+						channel.disconnect();
+				} finally {
+					channel = null;
+				}
+			}
+
+			if (session != null) {
+				try {
+					sch.releaseSession(session);
+				} finally {
+					session = null;
+				}
+			}
+		}
+	}
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
index e109cf4..f48dc6d 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
@@ -2,6 +2,7 @@
  * Copyright (C) 2007, Dave Watson <dwatson@mimvista.com>
  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
  *
  * All rights reserved.
  *
@@ -43,6 +44,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 
+import org.spearce.jgit.errors.NotSupportedException;
 import org.spearce.jgit.errors.TransportException;
 import org.spearce.jgit.lib.Repository;
 import org.spearce.jgit.util.FS;
@@ -83,50 +85,35 @@ class TransportLocal extends PackTransport {
 		return new LocalFetchConnection();
 	}
 
+	@Override
+	public PushConnection openPush() throws NotSupportedException,
+			TransportException {
+		return new LocalPushConnection();
+	}
+
+	protected Process startProcessWithErrStream(final String cmd)
+			throws TransportException {
+		try {
+			final Process proc = Runtime.getRuntime().exec(
+					new String[] { cmd, "." }, null, remoteGitDir);
+			new StreamRewritingThread(proc.getErrorStream()).start();
+			return proc;
+		} catch (IOException err) {
+			throw new TransportException(uri.toString() + ": "
+					+ err.getMessage(), err);
+		}
+	}
+
 	class LocalFetchConnection extends BasePackFetchConnection {
 		private Process uploadPack;
 
 		LocalFetchConnection() throws TransportException {
 			super(TransportLocal.this);
-			try {
-				uploadPack = Runtime.getRuntime().exec(
-						new String[] { getOptionUploadPack(), "." }, null,
-						remoteGitDir);
-			} catch (IOException err) {
-				throw new TransportException(uri.toString() + ": "
-						+ err.getMessage(), err);
-			}
-			startErrorThread();
+			uploadPack = startProcessWithErrStream(getOptionReceivePack());
 			init(uploadPack.getInputStream(), uploadPack.getOutputStream());
 			readAdvertisedRefs();
 		}
 
-		private void startErrorThread() {
-			final InputStream errorStream = uploadPack.getErrorStream();
-			new Thread("JGit " + getOptionUploadPack() + " Errors") {
-				public void run() {
-					final byte[] tmp = new byte[512];
-					try {
-						for (;;) {
-							final int n = errorStream.read(tmp);
-							if (n < 0)
-								break;
-							System.err.write(tmp, 0, n);
-							System.err.flush();
-						}
-					} catch (IOException err) {
-						// Ignore errors reading errors.
-					} finally {
-						try {
-							errorStream.close();
-						} catch (IOException err2) {
-							// Ignore errors closing the pipe.
-						}
-					}
-				}
-			}.start();
-		}
-
 		@Override
 		public void close() {
 			super.close();
@@ -142,4 +129,60 @@ class TransportLocal extends PackTransport {
 			}
 		}
 	}
+
+	class LocalPushConnection extends BasePackPushConnection {
+		private Process receivePack;
+
+		LocalPushConnection() throws TransportException {
+			super(TransportLocal.this);
+			receivePack = startProcessWithErrStream(getOptionReceivePack());
+			init(receivePack.getInputStream(), receivePack.getOutputStream());
+			readAdvertisedRefs();
+		}
+
+		@Override
+		public void close() {
+			super.close();
+
+			if (receivePack != null) {
+				try {
+					receivePack.waitFor();
+				} catch (InterruptedException ie) {
+					// Stop waiting and return anyway.
+				} finally {
+					receivePack = null;
+				}
+			}
+		}
+	}
+
+	class StreamRewritingThread extends Thread {
+		private final InputStream in;
+
+		StreamRewritingThread(final InputStream in) {
+			super("JGit " + getOptionUploadPack() + " Errors");
+			this.in = in;
+		}
+
+		public void run() {
+			final byte[] tmp = new byte[512];
+			try {
+				for (;;) {
+					final int n = in.read(tmp);
+					if (n < 0)
+						break;
+					System.err.write(tmp, 0, n);
+					System.err.flush();
+				}
+			} catch (IOException err) {
+				// Ignore errors reading errors.
+			} finally {
+				try {
+					in.close();
+				} catch (IOException err2) {
+					// Ignore errors closing the pipe.
+				}
+			}
+		}
+	}
 }
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkTransport.java b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkTransport.java
index ae51d6d..29dd661 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/WalkTransport.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/WalkTransport.java
@@ -37,6 +37,7 @@
 
 package org.spearce.jgit.transport;
 
+import org.spearce.jgit.errors.NotSupportedException;
 import org.spearce.jgit.lib.Repository;
 
 /**
@@ -55,4 +56,10 @@ abstract class WalkTransport extends Transport {
 	WalkTransport(final Repository local, final URIish u) {
 		super(local, u);
 	}
+
+	@Override
+	public PushConnection openPush() throws NotSupportedException {
+		throw new NotSupportedException(
+				"Push is not supported by object walking transports");
+	}
 }

diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/transport/PushProcessTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/transport/PushProcessTest.java
new file mode 100644
index 0000000..f0cfe98
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/transport/PushProcessTest.java
@@ -0,0 +1,407 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+import org.spearce.jgit.errors.NotSupportedException;
+import org.spearce.jgit.errors.TransportException;
+import org.spearce.jgit.lib.ObjectId;
+import org.spearce.jgit.lib.ProgressMonitor;
+import org.spearce.jgit.lib.Ref;
+import org.spearce.jgit.lib.Repository;
+import org.spearce.jgit.lib.RepositoryTestCase;
+import org.spearce.jgit.lib.TextProgressMonitor;
+import org.spearce.jgit.lib.RefUpdate.Result;
+import org.spearce.jgit.transport.RemoteRefUpdate.Status;
+
+public class PushProcessTest extends RepositoryTestCase {
+	private PushProcess process;
+
+	private MockTransport transport;
+
+	private HashSet<RemoteRefUpdate> refUpdates;
+
+	private HashSet<Ref> advertisedRefs;
+
+	private Status connectionUpdateStatus;
+
+	@Override
+	public void setUp() throws Exception {
+		super.setUp();
+		transport = new MockTransport(db, new URIish());
+		refUpdates = new HashSet<RemoteRefUpdate>();
+		advertisedRefs = new HashSet<Ref>();
+		connectionUpdateStatus = Status.OK;
+	}
+
+	/**
+	 * Test for fast-forward remote update.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateFastForward() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		testOneUpdateStatus(rru, ref, Status.OK, true);
+	}
+
+	/**
+	 * Test for non fast-forward remote update, when remote object is not known
+	 * to local repository.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateNonFastForwardUnknownObject() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("0000000000000000000000000000000000000001"));
+		testOneUpdateStatus(rru, ref, Status.REJECTED_NONFASTFORWARD, null);
+	}
+
+	/**
+	 * Test for non fast-forward remote update, when remote object is known to
+	 * local repository, but it is not an ancestor of new object.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateNonFastForward() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
+		testOneUpdateStatus(rru, ref, Status.REJECTED_NONFASTFORWARD, null);
+	}
+
+	/**
+	 * Test for non fast-forward remote update, when force update flag is set.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateNonFastForwardForced() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+				"refs/heads/master", true, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
+		testOneUpdateStatus(rru, ref, Status.OK, false);
+	}
+
+	/**
+	 * Test for remote ref creation.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateCreateRef() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+				"refs/heads/master", false, null, null);
+		testOneUpdateStatus(rru, null, Status.OK, true);
+	}
+
+	/**
+	 * Test for remote ref deletion.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateDelete() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db, null,
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
+		testOneUpdateStatus(rru, ref, Status.OK, true);
+	}
+
+	/**
+	 * Test for remote ref deletion (try), when that ref doesn't exist on remote
+	 * repo.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateDeleteNonExisting() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db, null,
+				"refs/heads/master", false, null, null);
+		testOneUpdateStatus(rru, null, Status.NON_EXISTING, null);
+	}
+
+	/**
+	 * Test for remote ref update, when it is already up to date.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateUpToDate() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
+		testOneUpdateStatus(rru, ref, Status.UP_TO_DATE, null);
+	}
+
+	/**
+	 * Test for remote ref update with expected remote object.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateExpectedRemote() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, ObjectId
+						.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		testOneUpdateStatus(rru, ref, Status.OK, true);
+	}
+
+	/**
+	 * Test for remote ref update with expected old object set, when old object
+	 * is not that expected one.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateUnexpectedRemote() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, ObjectId
+						.fromString("0000000000000000000000000000000000000001"));
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		testOneUpdateStatus(rru, ref, Status.REJECTED_REMOTE_CHANGED, null);
+	}
+
+	/**
+	 * Test for remote ref update with expected old object set, when old object
+	 * is not that expected one and force update flag is set (which should have
+	 * lower priority) - shouldn't change behavior.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateUnexpectedRemoteVsForce() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", true, null, ObjectId
+						.fromString("0000000000000000000000000000000000000001"));
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		testOneUpdateStatus(rru, ref, Status.REJECTED_REMOTE_CHANGED, null);
+	}
+
+	/**
+	 * Test for remote ref udpate, when connection rejects update.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateRejectedByConnection() throws IOException {
+		connectionUpdateStatus = Status.REJECTED_OTHER_REASON;
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		testOneUpdateStatus(rru, ref, Status.REJECTED_OTHER_REASON, null);
+	}
+
+	/**
+	 * Test for remote refs updates with mixed cases that shouldn't depend on
+	 * each other.
+	 * 
+	 * @throws IOException
+	 */
+	public void testUpdateMixedCases() throws IOException {
+		final RemoteRefUpdate rruOk = new RemoteRefUpdate(db, null,
+				"refs/heads/master", false, null, null);
+		final Ref refToChange = new Ref("refs/heads/master", ObjectId
+				.fromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
+		final RemoteRefUpdate rruReject = new RemoteRefUpdate(db, null,
+				"refs/heads/nonexisting", false, null, null);
+		refUpdates.add(rruOk);
+		refUpdates.add(rruReject);
+		advertisedRefs.add(refToChange);
+		executePush();
+		assertEquals(Status.OK, rruOk.getStatus());
+		assertEquals(true, rruOk.isFastForward());
+		assertEquals(Status.NON_EXISTING, rruReject.getStatus());
+	}
+
+	/**
+	 * Test for local tracking ref update.
+	 * 
+	 * @throws IOException
+	 */
+	public void testTrackingRefUpdateEnabled() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, "refs/remotes/test/master", null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		refUpdates.add(rru);
+		advertisedRefs.add(ref);
+		final PushResult result = executePush();
+		final TrackingRefUpdate tru = result
+				.getTrackingRefUpdate("refs/remotes/test/master");
+		assertNotNull(tru);
+		assertEquals("refs/remotes/test/master", tru.getLocalName());
+		assertEquals(Result.NEW, tru.getResult());
+	}
+
+	/**
+	 * Test for local tracking ref update disabled.
+	 * 
+	 * @throws IOException
+	 */
+	public void testTrackingRefUpdateDisabled() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		refUpdates.add(rru);
+		advertisedRefs.add(ref);
+		final PushResult result = executePush();
+		assertTrue(result.getTrackingRefUpdates().isEmpty());
+	}
+
+	/**
+	 * Test for local tracking ref update when remote update has failed.
+	 * 
+	 * @throws IOException
+	 */
+	public void testTrackingRefUpdateOnReject() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+				"refs/heads/master", false, null, null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("2c349335b7f797072cf729c4f3bb0914ecb6dec9"));
+		final PushResult result = testOneUpdateStatus(rru, ref,
+				Status.REJECTED_NONFASTFORWARD, null);
+		assertTrue(result.getTrackingRefUpdates().isEmpty());
+	}
+
+	/**
+	 * Test for push operation result - that contains expected elements.
+	 * 
+	 * @throws IOException
+	 */
+	public void testPushResult() throws IOException {
+		final RemoteRefUpdate rru = new RemoteRefUpdate(db,
+				"2c349335b7f797072cf729c4f3bb0914ecb6dec9",
+				"refs/heads/master", false, "refs/remotes/test/master", null);
+		final Ref ref = new Ref("refs/heads/master", ObjectId
+				.fromString("ac7e7e44c1885efb472ad54a78327d66bfc4ecef"));
+		refUpdates.add(rru);
+		advertisedRefs.add(ref);
+		final PushResult result = executePush();
+		assertEquals(1, result.getTrackingRefUpdates().size());
+		assertEquals(1, result.getAdvertisedRefs().size());
+		assertEquals(1, result.getRemoteUpdates().size());
+		assertNotNull(result.getTrackingRefUpdate("refs/remotes/test/master"));
+		assertNotNull(result.getAdvertisedRef("refs/heads/master"));
+		assertNotNull(result.getRemoteUpdate("refs/heads/master"));
+	}
+
+	private PushResult testOneUpdateStatus(final RemoteRefUpdate rru,
+			final Ref advertisedRef, final Status expectedStatus,
+			Boolean fastForward) throws NotSupportedException,
+			TransportException {
+		refUpdates.add(rru);
+		if (advertisedRef != null)
+			advertisedRefs.add(advertisedRef);
+		final PushResult result = executePush();
+		assertEquals(expectedStatus, rru.getStatus());
+		if (fastForward != null)
+			assertEquals(fastForward.booleanValue(), rru.isFastForward());
+		return result;
+	}
+
+	private PushResult executePush() throws NotSupportedException,
+			TransportException {
+		process = new PushProcess(transport, refUpdates);
+		return process.execute(new TextProgressMonitor());
+	}
+
+	private class MockTransport extends Transport {
+		MockTransport(Repository local, URIish uri) {
+			super(local, uri);
+		}
+
+		@Override
+		public FetchConnection openFetch() throws NotSupportedException,
+				TransportException {
+			throw new NotSupportedException("mock");
+		}
+
+		@Override
+		public PushConnection openPush() throws NotSupportedException,
+				TransportException {
+			return new MockPushConnection();
+		}
+	}
+
+	private class MockPushConnection extends BaseConnection implements
+			PushConnection {
+		MockPushConnection() {
+			final Map<String, Ref> refsMap = new HashMap<String, Ref>();
+			for (final Ref r : advertisedRefs)
+				refsMap.put(r.getName(), r);
+			available(refsMap);
+		}
+
+		@Override
+		public void close() {
+			// nothing here
+		}
+
+		public void push(ProgressMonitor monitor,
+				Map<String, RemoteRefUpdate> refUpdates)
+				throws TransportException {
+			for (final RemoteRefUpdate rru : refUpdates.values()) {
+				assertEquals(Status.NOT_ATTEMPTED, rru.getStatus());
+				rru.setStatus(connectionUpdateStatus);
+			}
+		}
+	}
+}

diff --git a/org.spearce.jgit.test/tst/org/spearce/jgit/transport/TransportTest.java b/org.spearce.jgit.test/tst/org/spearce/jgit/transport/TransportTest.java
new file mode 100644
index 0000000..47d738b
--- /dev/null
+++ b/org.spearce.jgit.test/tst/org/spearce/jgit/transport/TransportTest.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.transport;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import org.spearce.jgit.lib.RepositoryConfig;
+import org.spearce.jgit.lib.RepositoryTestCase;
+
+public class TransportTest extends RepositoryTestCase {
+	private Transport transport;
+
+	private RemoteConfig remoteConfig;
+
+	@Override
+	public void setUp() throws Exception {
+		super.setUp();
+		final RepositoryConfig config = db.getConfig();
+		remoteConfig = new RemoteConfig(config, "test");
+		remoteConfig.addURI(new URIish("http://everyones.loves.git/u/2"));
+	}
+
+	/**
+	 * Test RefSpec to RemoteRefUpdate conversion with simple RefSpec - no
+	 * wildcard, no tracking ref in repo configuration.
+	 * 
+	 * @throws IOException
+	 */
+	public void testFindRemoteRefUpdatesNoWildcardNoTracking()
+			throws IOException {
+		transport = Transport.open(db, remoteConfig);
+		final Collection<RemoteRefUpdate> result = transport
+				.findRemoteRefUpdatesFor(Collections.nCopies(1, new RefSpec(
+						"refs/heads/master:refs/heads/x")));
+
+		assertEquals(1, result.size());
+		final RemoteRefUpdate rru = result.iterator().next();
+		assertNull(rru.getExpectedOldObjectId());
+		assertFalse(rru.isForceUpdate());
+		assertEquals("refs/heads/master", rru.getSrcRef());
+		assertEquals(db.resolve("refs/heads/master"), rru.getNewObjectId());
+		assertEquals("refs/heads/x", rru.getRemoteName());
+	}
+
+	/**
+	 * Test RefSpec to RemoteRefUpdate conversion with no-destination RefSpec
+	 * (destination should be set up for the same name as source).
+	 * 
+	 * @throws IOException
+	 */
+	public void testFindRemoteRefUpdatesNoWildcardNoDestination()
+			throws IOException {
+		transport = Transport.open(db, remoteConfig);
+		final Collection<RemoteRefUpdate> result = transport
+				.findRemoteRefUpdatesFor(Collections.nCopies(1, new RefSpec(
+						"+refs/heads/master")));
+
+		assertEquals(1, result.size());
+		final RemoteRefUpdate rru = result.iterator().next();
+		assertNull(rru.getExpectedOldObjectId());
+		assertTrue(rru.isForceUpdate());
+		assertEquals("refs/heads/master", rru.getSrcRef());
+		assertEquals(db.resolve("refs/heads/master"), rru.getNewObjectId());
+		assertEquals("refs/heads/master", rru.getRemoteName());
+	}
+
+	/**
+	 * Test RefSpec to RemoteRefUpdate conversion with wildcard RefSpec.
+	 * 
+	 * @throws IOException
+	 */
+	public void testFindRemoteRefUpdatesWildcardNoTracking() throws IOException {
+		transport = Transport.open(db, remoteConfig);
+		final Collection<RemoteRefUpdate> result = transport
+				.findRemoteRefUpdatesFor(Collections.nCopies(1, new RefSpec(
+						"+refs/heads/*:refs/heads/test/*")));
+
+		assertEquals(7, result.size());
+		boolean foundA = false;
+		boolean foundB = false;
+		for (final RemoteRefUpdate rru : result) {
+			if ("refs/heads/a".equals(rru.getSrcRef())
+					&& "refs/heads/test/a".equals(rru.getRemoteName()))
+				foundA = true;
+			if ("refs/heads/b".equals(rru.getSrcRef())
+					&& "refs/heads/test/b".equals(rru.getRemoteName()))
+				foundB = true;
+		}
+		assertTrue(foundA);
+		assertTrue(foundB);
+	}
+
+	/**
+	 * Test RefSpec to RemoteRefUpdate conversion for more than one RefSpecs
+	 * handling.
+	 * 
+	 * @throws IOException
+	 */
+	public void testFindRemoteRefUpdatesTwoRefSpecs() throws IOException {
+		transport = Transport.open(db, remoteConfig);
+		final RefSpec specA = new RefSpec("+refs/heads/a:refs/heads/b");
+		final RefSpec specC = new RefSpec("+refs/heads/c:refs/heads/d");
+		final Collection<RefSpec> specs = Arrays.asList(specA, specC);
+		final Collection<RemoteRefUpdate> result = transport
+				.findRemoteRefUpdatesFor(specs);
+
+		assertEquals(2, result.size());
+		boolean foundA = false;
+		boolean foundC = false;
+		for (final RemoteRefUpdate rru : result) {
+			if ("refs/heads/a".equals(rru.getSrcRef())
+					&& "refs/heads/b".equals(rru.getRemoteName()))
+				foundA = true;
+			if ("refs/heads/c".equals(rru.getSrcRef())
+					&& "refs/heads/d".equals(rru.getRemoteName()))
+				foundC = true;
+		}
+		assertTrue(foundA);
+		assertTrue(foundC);
+	}
+
+	/**
+	 * Test RefSpec to RemoteRefUpdate conversion for tracking ref search.
+	 * 
+	 * @throws IOException
+	 */
+	public void testFindRemoteRefUpdatesTrackingRef() throws IOException {
+		remoteConfig.addFetchRefSpec(new RefSpec(
+				"refs/heads/*:refs/remotes/test/*"));
+		transport = Transport.open(db, remoteConfig);
+		final Collection<RemoteRefUpdate> result = transport
+				.findRemoteRefUpdatesFor(Collections.nCopies(1, new RefSpec(
+						"+refs/heads/a:refs/heads/a")));
+
+		assertEquals(1, result.size());
+		final TrackingRefUpdate tru = result.iterator().next()
+				.getTrackingRefUpdate();
+		assertEquals("refs/remotes/test/a", tru.getLocalName());
+		assertEquals("refs/heads/a", tru.getRemoteName());
+		assertEquals(db.resolve("refs/heads/a"), tru.getNewObjectId());
+		assertNull(tru.getOldObjectId());
+	}
+}

diff --git a/org.spearce.jgit/src/org/spearce/jgit/pgm/Main.java b/org.spearce.jgit/src/org/spearce/jgit/pgm/Main.java
index 44f8a42..8afd0d7 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/pgm/Main.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/pgm/Main.java
@@ -85,12 +85,12 @@ public class Main {
 
 	private static void execute(final String[] argv) throws Exception {
 		int argi = 0;
-		String gitdir = ".git";
 
+		File gitdir = null;
 		for (; argi < argv.length; argi++) {
 			final String arg = argv[argi];
 			if (arg.startsWith("--git-dir="))
-				gitdir = arg.substring("--git-dir=".length());
+				gitdir = new File(arg.substring("--git-dir=".length()));
 			else if (arg.equals("--show-stack-trace"))
 				showStackTrace = true;
 			else if (arg.startsWith("--"))
@@ -101,8 +101,15 @@ public class Main {
 
 		if (argi == argv.length)
 			usage();
+		if (gitdir == null)
+			gitdir = findGitDir();
+		if (gitdir == null || !gitdir.isDirectory()) {
+			System.err.println("error: can't find git directory");
+			System.exit(1);
+		}
+
 		final TextBuiltin cmd = createCommand(argv[argi++]);
-		cmd.db = new Repository(new File(gitdir));
+		cmd.db = new Repository(gitdir);
 		try {
 			cmd.execute(subarray(argv, argi));
 		} finally {
@@ -111,6 +118,17 @@ public class Main {
 		}
 	}
 
+	private static File findGitDir() {
+		File current = new File(".").getAbsoluteFile();
+		while (current != null) {
+			final File gitDir = new File(current, ".git");
+			if (gitDir.isDirectory())
+				return gitDir;
+			current = current.getParentFile();
+		}
+		return null;
+	}
+
 	private static String[] subarray(final String[] argv, final int i) {
 		return Arrays.asList(argv).subList(i, argv.length).toArray(
 				new String[0]);

org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java, org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java, org.spearce.jgit/src/org/spearce/jgit/pgm/TextBuiltin.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java b/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java
index 3a81575..c9c997e 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/pgm/Fetch.java
@@ -40,8 +40,6 @@ package org.spearce.jgit.pgm;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.spearce.jgit.lib.Constants;
-import org.spearce.jgit.lib.ObjectId;
 import org.spearce.jgit.lib.RefUpdate;
 import org.spearce.jgit.lib.TextProgressMonitor;
 import org.spearce.jgit.transport.FetchResult;
@@ -50,12 +48,6 @@ import org.spearce.jgit.transport.TrackingRefUpdate;
 import org.spearce.jgit.transport.Transport;
 
 class Fetch extends TextBuiltin {
-	private static final String REFS_HEADS = Constants.HEADS_PREFIX + "/";
-
-	private static final String REFS_REMOTES = Constants.REMOTES_PREFIX + "/";
-
-	private static final String REFS_TAGS = Constants.TAGS_PREFIX + "/";
-
 	@Override
 	void execute(String[] args) throws Exception {
 		int argi = 0;
@@ -84,20 +76,8 @@ class Fetch extends TextBuiltin {
 		for (final TrackingRefUpdate u : r.getTrackingRefUpdates()) {
 			final char type = shortTypeOf(u.getResult());
 			final String longType = longTypeOf(u);
-
-			String src = u.getRemoteName();
-			if (src.startsWith(REFS_HEADS))
-				src = src.substring(REFS_HEADS.length());
-			else if (src.startsWith(REFS_TAGS))
-				src = src.substring(REFS_TAGS.length());
-
-			String dst = u.getLocalName();
-			if (dst.startsWith(REFS_HEADS))
-				dst = dst.substring(REFS_HEADS.length());
-			else if (dst.startsWith(REFS_TAGS))
-				dst = dst.substring(REFS_TAGS.length());
-			else if (dst.startsWith(REFS_REMOTES))
-				dst = dst.substring(REFS_REMOTES.length());
+			final String src = abbreviateRef(u.getRemoteName(), false);
+			final String dst = abbreviateRef(u.getLocalName(), true);
 
 			out.format(" %c %-17s %-10s -> %s", type, longType, src, dst);
 			out.println();
@@ -121,14 +101,14 @@ class Fetch extends TextBuiltin {
 		}
 
 		if (r == RefUpdate.Result.FORCED) {
-			final String aOld = abbreviate(u.getOldObjectId());
-			final String aNew = abbreviate(u.getNewObjectId());
+			final String aOld = abbreviateObject(u.getOldObjectId());
+			final String aNew = abbreviateObject(u.getNewObjectId());
 			return aOld + "..." + aNew;
 		}
 
 		if (r == RefUpdate.Result.FAST_FORWARD) {
-			final String aOld = abbreviate(u.getOldObjectId());
-			final String aNew = abbreviate(u.getNewObjectId());
+			final String aOld = abbreviateObject(u.getOldObjectId());
+			final String aNew = abbreviateObject(u.getNewObjectId());
 			return aOld + ".." + aNew;
 		}
 
@@ -139,10 +119,6 @@ class Fetch extends TextBuiltin {
 		return "[" + r.name() + "]";
 	}
 
-	private static String abbreviate(final ObjectId id) {
-		return id.toString().substring(0, 7);
-	}
-
 	private static char shortTypeOf(final RefUpdate.Result r) {
 		if (r == RefUpdate.Result.LOCK_FAILURE)
 			return '!';
diff --git a/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java b/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java
new file mode 100644
index 0000000..4130bc9
--- /dev/null
+++ b/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Git Development Community nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spearce.jgit.pgm;
+
+import java.util.Collection;
+import java.util.LinkedList;
+
+import org.spearce.jgit.lib.Ref;
+import org.spearce.jgit.lib.TextProgressMonitor;
+import org.spearce.jgit.transport.PushResult;
+import org.spearce.jgit.transport.RefSpec;
+import org.spearce.jgit.transport.RemoteRefUpdate;
+import org.spearce.jgit.transport.Transport;
+import org.spearce.jgit.transport.RemoteRefUpdate.Status;
+
+class Push extends TextBuiltin {
+
+	private boolean verbose = false;
+
+	private Transport transport;
+
+	private boolean first = true;
+
+	@Override
+	void execute(String[] args) throws Exception {
+		final LinkedList<RefSpec> refSpecs = new LinkedList<RefSpec>();
+		Boolean thin = null;
+		String exec = null;
+		boolean forceAll = false;
+
+		int argi = 0;
+		for (; argi < args.length; argi++) {
+			final String a = args[argi];
+			if ("--thin".equals(a))
+				thin = true;
+			else if ("--no-thin".equals(a))
+				thin = false;
+			else if ("-f".equals(a) || "--force".equals(a))
+				forceAll = true;
+			else if (a.startsWith("--exec="))
+				exec = a.substring("--exec=".length());
+			else if (a.startsWith("--receive-pack="))
+				exec = a.substring("--receive-pack=".length());
+			else if ("--tags".equals(a))
+				refSpecs.add(Transport.REFSPEC_TAGS);
+			else if ("--all".equals(a))
+				refSpecs.add(Transport.REFSPEC_PUSH_ALL);
+			else if ("-v".equals(a))
+				verbose = true;
+			else if ("--".equals(a)) {
+				argi++;
+				break;
+			} else if (a.startsWith("-"))
+				die("usage: push [--all] [--tags] [--force] [--thin]\n"
+						+ "[--receive-pack=<git-receive-pack>] [<repository> [<refspec>]...]");
+			else
+				break;
+		}
+
+		final String repository;
+		if (argi == args.length)
+			repository = "origin";
+		else
+			repository = args[argi++];
+		transport = Transport.open(db, repository);
+		if (thin != null)
+			transport.setPushThin(thin);
+		if (exec != null)
+			transport.setOptionReceivePack(exec);
+
+		for (; argi < args.length; argi++) {
+			final RefSpec spec = new RefSpec(args[argi]);
+			if (forceAll)
+				spec.setForceUpdate(true);
+			refSpecs.add(spec);
+		}
+		final Collection<RemoteRefUpdate> toPush = transport
+				.findRemoteRefUpdatesFor(refSpecs);
+
+		final PushResult result = transport.push(new TextProgressMonitor(),
+				toPush);
+		printPushResult(result);
+	}
+
+	private void printPushResult(final PushResult result) {
+		boolean everythingUpToDate = true;
+		// at first, print up-to-date ones...
+		for (final RemoteRefUpdate rru : result.getRemoteUpdates()) {
+			if (rru.getStatus() == Status.UP_TO_DATE) {
+				if (verbose)
+					printRefUpdateResult(result, rru);
+			} else
+				everythingUpToDate = false;
+		}
+
+		for (final RemoteRefUpdate rru : result.getRemoteUpdates()) {
+			// ...then successful updates...
+			if (rru.getStatus() == Status.OK)
+				printRefUpdateResult(result, rru);
+		}
+
+		for (final RemoteRefUpdate rru : result.getRemoteUpdates()) {
+			// ...finally, others (problematic)
+			if (rru.getStatus() != Status.OK
+					&& rru.getStatus() != Status.UP_TO_DATE)
+				printRefUpdateResult(result, rru);
+		}
+
+		if (everythingUpToDate)
+			out.println("Everything up-to-date");
+	}
+
+	private void printRefUpdateResult(final PushResult result,
+			final RemoteRefUpdate rru) {
+		if (first) {
+			first = false;
+			out.format("To %s\n", transport.getURI());
+		}
+
+		final String remoteName = rru.getRemoteName();
+		final String srcRef = rru.isDelete() ? null : rru.getSrcRef();
+
+		switch (rru.getStatus()) {
+		case OK:
+			if (rru.isDelete())
+				printUpdateLine('-', "[deleted]", null, remoteName, null);
+			else {
+				final Ref oldRef = result.getAdvertisedRef(remoteName);
+				if (oldRef == null) {
+					final String summary;
+					if (remoteName.startsWith(REFS_TAGS))
+						summary = "[new tag]";
+					else
+						summary = "[new branch]";
+					printUpdateLine('*', summary, srcRef, remoteName, null);
+				} else {
+					boolean fastForward = rru.isFastForward();
+					final char flag = fastForward ? ' ' : '+';
+					final String summary = abbreviateObject(oldRef
+							.getObjectId())
+							+ (fastForward ? ".." : "...")
+							+ abbreviateObject(rru.getNewObjectId());
+					final String message = fastForward ? null : "forced update";
+					printUpdateLine(flag, summary, srcRef, remoteName, message);
+				}
+			}
+			break;
+
+		case NON_EXISTING:
+			printUpdateLine('X', "[no match]", null, remoteName, null);
+			break;
+
+		case REJECTED_NODELETE:
+			printUpdateLine('!', "[rejected]", null, remoteName,
+					"remote side does not support deleting refs");
+			break;
+
+		case REJECTED_NONFASTFORWARD:
+			printUpdateLine('!', "[rejected]", srcRef, remoteName,
+					"non-fast forward");
+			break;
+
+		case REJECTED_REMOTE_CHANGED:
+			final String message = "remote ref object changed - is not expected one "
+					+ abbreviateObject(rru.getExpectedOldObjectId());
+			printUpdateLine('!', "[rejected]", srcRef, remoteName, message);
+			break;
+
+		case REJECTED_OTHER_REASON:
+			printUpdateLine('!', "[remote rejected]", srcRef, remoteName, rru
+					.getMessage());
+			break;
+
+		case UP_TO_DATE:
+			if (verbose)
+				printUpdateLine('=', "[up to date]", srcRef, remoteName, null);
+			break;
+
+		case NOT_ATTEMPTED:
+		case AWAITING_REPORT:
+			printUpdateLine('?', "[unexpected push-process behavior]", srcRef,
+					remoteName, rru.getMessage());
+			break;
+		}
+	}
+
+	private void printUpdateLine(final char flag, final String summary,
+			final String srcRef, final String destRef, final String message) {
+		out.format(" %c %-17s", flag, summary);
+
+		if (srcRef != null)
+			out.format(" %s ->", abbreviateRef(srcRef, true));
+		out.format(" %s", abbreviateRef(destRef, true));
+
+		if (message != null)
+			out.format(" (%s)", message);
+
+		out.println();
+	}
+}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/pgm/TextBuiltin.java b/org.spearce.jgit/src/org/spearce/jgit/pgm/TextBuiltin.java
index 163f795..b3d8f39 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/pgm/TextBuiltin.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/pgm/TextBuiltin.java
@@ -43,10 +43,17 @@ import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
+import org.spearce.jgit.lib.Constants;
 import org.spearce.jgit.lib.ObjectId;
 import org.spearce.jgit.lib.Repository;
 
 abstract class TextBuiltin {
+	protected static final String REFS_HEADS = Constants.HEADS_PREFIX + "/";
+
+	protected static final String REFS_REMOTES = Constants.REMOTES_PREFIX + "/";
+
+	protected static final String REFS_TAGS = Constants.TAGS_PREFIX + "/";
+
 	protected PrintWriter out;
 
 	protected Repository db;
@@ -72,4 +79,18 @@ abstract class TextBuiltin {
 	protected static Die die(final String why) {
 		return new Die(why);
 	}
+
+	protected static String abbreviateObject(final ObjectId id) {
+		return id.toString().substring(0, 7);
+	}
+
+	protected String abbreviateRef(String dst, boolean abbreviateRemote) {
+		if (dst.startsWith(REFS_HEADS))
+			dst = dst.substring(REFS_HEADS.length());
+		else if (dst.startsWith(REFS_TAGS))
+			dst = dst.substring(REFS_TAGS.length());
+		else if (abbreviateRemote && dst.startsWith(REFS_REMOTES))
+			dst = dst.substring(REFS_REMOTES.length());
+		return dst;
+	}
 }

org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java, org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
index c765c12..f9c2266 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/FetchProcess.java
@@ -100,6 +100,10 @@ class FetchProcess {
 			result.setAdvertisedRefs(conn.getRefsMap());
 			final Set<Ref> matched = new HashSet<Ref>();
 			for (final RefSpec spec : toFetch) {
+				if (spec.getSource() == null)
+					throw new TransportException(
+							"Source ref not specified for refspec: " + spec);
+
 				if (spec.isWildcard())
 					expandWildcard(spec, matched);
 				else
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java b/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
index da5b41e..8260da6 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/Transport.java
@@ -363,14 +363,15 @@ public abstract class Transport {
 	 * @param toFetch
 	 *            specification of refs to fetch locally. May be null or the
 	 *            empty collection to use the specifications from the
-	 *            RemoteConfig.
+	 *            RemoteConfig. Source for each RefSpec can't be null.
 	 * @return information describing the tracking refs updated.
 	 * @throws NotSupportedException
 	 *             this transport implementation does not support fetching
 	 *             objects.
 	 * @throws TransportException
 	 *             the remote connection could not be established or object
-	 *             copying (if necessary) failed.
+	 *             copying (if necessary) failed or update specification was
+	 *             incorrect.
 	 */
 	public FetchResult fetch(final ProgressMonitor monitor,
 			Collection<RefSpec> toFetch) throws NotSupportedException,

org.spearce.jgit/src/org/spearce/jgit/errors/PackProtocolException.java, org.spearce.jgit/src/org/spearce/jgit/errors/TransportException.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/errors/PackProtocolException.java b/org.spearce.jgit/src/org/spearce/jgit/errors/PackProtocolException.java
index 525496a..7b5b4f6 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/errors/PackProtocolException.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/errors/PackProtocolException.java
@@ -38,6 +38,7 @@
 
 package org.spearce.jgit.errors;
 
+import org.spearce.jgit.transport.URIish;
 
 /**
  * Indicates a protocol error has occurred while fetching/pushing objects.
@@ -46,6 +47,35 @@ public class PackProtocolException extends TransportException {
 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * Constructs an PackProtocolException with the specified detail message
+	 * prefixed with provided URI.
+	 * 
+	 * @param uri
+	 *            URI used for transport
+	 * @param s
+	 *            message
+	 */
+	public PackProtocolException(final URIish uri, final String s) {
+		super(uri + ": " + s);
+	}
+
+	/**
+	 * Constructs an PackProtocolException with the specified detail message
+	 * prefixed with provided URI.
+	 * 
+	 * @param uri
+	 *            URI used for transport
+	 * @param s
+	 *            message
+	 * @param cause
+	 *            root cause exception
+	 */
+	public PackProtocolException(final URIish uri, final String s,
+			final Throwable cause) {
+		this(uri + ": " + s, cause);
+	}
+
+	/**
 	 * Constructs an PackProtocolException with the specified detail message.
 	 * 
 	 * @param s
diff --git a/org.spearce.jgit/src/org/spearce/jgit/errors/TransportException.java b/org.spearce.jgit/src/org/spearce/jgit/errors/TransportException.java
index 7b378db..13c7a28 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/errors/TransportException.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/errors/TransportException.java
@@ -40,6 +40,8 @@ package org.spearce.jgit.errors;
 
 import java.io.IOException;
 
+import org.spearce.jgit.transport.URIish;
+
 /**
  * Indicates a protocol error has occurred while fetching/pushing objects.
  */
@@ -47,6 +49,35 @@ public class TransportException extends IOException {
 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * Constructs an TransportException with the specified detail message
+	 * prefixed with provided URI.
+	 * 
+	 * @param uri
+	 *            URI used for transport
+	 * @param s
+	 *            message
+	 */
+	public TransportException(final URIish uri, final String s) {
+		super(uri + ": " + s);
+	}
+
+	/**
+	 * Constructs an TransportException with the specified detail message
+	 * prefixed with provided URI.
+	 * 
+	 * @param uri
+	 *            URI used for transport
+	 * @param s
+	 *            message
+	 * @param cause
+	 *            root cause exception
+	 */
+	public TransportException(final URIish uri, final String s,
+			final Throwable cause) {
+		this(uri + ": " + s, cause);
+	}
+
+	/**
 	 * Constructs an TransportException with the specified detail message.
 	 * 
 	 * @param s

org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java, org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java, org.spearce.jgit/src/org/spearce/jgit/transport/TransportSftp.java

diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java
index d119672..9b39ebc 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackConnection.java
@@ -125,7 +125,7 @@ abstract class BasePackConnection extends BaseConnection {
 				line = pckIn.readString();
 			} catch (EOFException eof) {
 				if (avail.isEmpty())
-					throw new TransportException(uri + " not found.");
+					throw new TransportException(uri, "not found.");
 				throw eof;
 			}
 
@@ -155,7 +155,7 @@ abstract class BasePackConnection extends BaseConnection {
 				name = name.substring(0, name.length() - 3);
 				final Ref prior = avail.get(name);
 				if (prior == null)
-					throw new PackProtocolException(uri + ": advertisement of "
+					throw new PackProtocolException(uri, "advertisement of "
 							+ name + "^{} came before " + name);
 
 				if (prior.getPeeledObjectId() != null)
@@ -185,7 +185,7 @@ abstract class BasePackConnection extends BaseConnection {
 	}
 
 	private PackProtocolException duplicateAdvertisement(final String name) {
-		return new PackProtocolException(uri + ": duplicate advertisements of "
+		return new PackProtocolException(uri, "duplicate advertisements of "
 				+ name);
 	}
 
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java
index 159e331..c56605a 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/BasePackPushConnection.java
@@ -110,7 +110,7 @@ class BasePackPushConnection extends BasePackConnection implements
 		} catch (TransportException e) {
 			throw e;
 		} catch (Exception e) {
-			throw new TransportException(uri + ": " + e.getMessage(), e);
+			throw new TransportException(uri, e.getMessage(), e);
 		} finally {
 			close();
 		}
@@ -146,7 +146,7 @@ class BasePackPushConnection extends BasePackConnection implements
 		}
 
 		if (monitor.isCancelled())
-			throw new TransportException(uri + ": push cancelled");
+			throw new TransportException(uri, "push cancelled");
 		pckOut.end();
 	}
 
@@ -179,13 +179,13 @@ class BasePackPushConnection extends BasePackConnection implements
 			throws IOException {
 		final String unpackLine = pckIn.readString();
 		if (!unpackLine.startsWith("unpack "))
-			throw new PackProtocolException(uri + ": unexpected report line: "
+			throw new PackProtocolException(uri, "unexpected report line: "
 					+ unpackLine);
 		final String unpackStatus = unpackLine.substring("unpack ".length());
 		if (!unpackStatus.equals("ok"))
-			throw new TransportException(uri
-					+ ": error occurred during unpacking on the remote end: "
-					+ unpackStatus);
+			throw new TransportException(uri,
+					"error occurred during unpacking on the remote end: "
+							+ unpackStatus);
 
 		String refLine;
 		while ((refLine = pckIn.readString()).length() > 0) {
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java b/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java
index f742949..1b5f9c6 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/PushProcess.java
@@ -178,9 +178,9 @@ class PushProcess {
 			} catch (MissingObjectException x) {
 				fastForward = false;
 			} catch (Exception x) {
-				throw new TransportException(transport.getURI()
-						+ ": reading objects from local repository failed: "
-						+ x.getMessage(), x);
+				throw new TransportException(transport.getURI(),
+						"reading objects from local repository failed: "
+								+ x.getMessage(), x);
 			}
 			rru.setFastForward(fastForward);
 			if (!fastForward && !rru.isForceUpdate())
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
index 6e49083..8a78099 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitAnon.java
@@ -82,12 +82,11 @@ class TransportGitAnon extends PackTransport {
 		try {
 			return new Socket(InetAddress.getByName(uri.getHost()), port);
 		} catch (IOException c) {
-			final String us = uri.toString();
 			if (c instanceof UnknownHostException)
-				throw new TransportException(us + ": Unknown host");
+				throw new TransportException(uri, "unknown host");
 			if (c instanceof ConnectException)
-				throw new TransportException(us + ": " + c.getMessage());
-			throw new TransportException(us + ": " + c.getMessage(), c);
+				throw new TransportException(uri, c.getMessage());
+			throw new TransportException(uri, c.getMessage(), c);
 		}
 	}
 
@@ -116,8 +115,8 @@ class TransportGitAnon extends PackTransport {
 				service("git-upload-pack", pckOut);
 			} catch (IOException err) {
 				close();
-				throw new TransportException(uri.toString()
-						+ ": remote hung up unexpectedly", err);
+				throw new TransportException(uri,
+						"remote hung up unexpectedly", err);
 			}
 			readAdvertisedRefs();
 		}
@@ -149,8 +148,8 @@ class TransportGitAnon extends PackTransport {
 				service("git-receive-pack", pckOut);
 			} catch (IOException err) {
 				close();
-				throw new TransportException(uri.toString()
-						+ ": remote hung up unexpectedly", err);
+				throw new TransportException(uri,
+						"remote hung up unexpectedly", err);
 			}
 			readAdvertisedRefs();
 		}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
index 55be4f6..46c60c3 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportGitSsh.java
@@ -162,13 +162,12 @@ class TransportGitSsh extends PackTransport {
 				session.connect();
 			return session;
 		} catch (JSchException je) {
-			final String us = uri.toString();
 			final Throwable c = je.getCause();
 			if (c instanceof UnknownHostException)
-				throw new TransportException(us + ": Unknown host");
+				throw new TransportException(uri, "unknown host");
 			if (c instanceof ConnectException)
-				throw new TransportException(us + ": " + c.getMessage());
-			throw new TransportException(us + ": " + je.getMessage(), je);
+				throw new TransportException(uri, c.getMessage());
+			throw new TransportException(uri, je.getMessage(), je);
 		}
 	}
 
@@ -189,8 +188,7 @@ class TransportGitSsh extends PackTransport {
 			channel.connect();
 			return channel;
 		} catch (JSchException je) {
-			throw new TransportException(uri.toString() + ": "
-					+ je.getMessage(), je);
+			throw new TransportException(uri, je.getMessage(), je);
 		}
 	}
 
@@ -210,8 +208,8 @@ class TransportGitSsh extends PackTransport {
 				throw err;
 			} catch (IOException err) {
 				close();
-				throw new TransportException(uri.toString()
-						+ ": remote hung up unexpectedly", err);
+				throw new TransportException(uri,
+						"remote hung up unexpectedly", err);
 			}
 			readAdvertisedRefs();
 		}
@@ -255,8 +253,8 @@ class TransportGitSsh extends PackTransport {
 				throw err;
 			} catch (IOException err) {
 				close();
-				throw new TransportException(uri.toString()
-						+ ": remote hung up unexpectedly", err);
+				throw new TransportException(uri,
+						"remote hung up unexpectedly", err);
 			}
 			readAdvertisedRefs();
 		}
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
index f48dc6d..761d1b8 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java
@@ -99,8 +99,7 @@ class TransportLocal extends PackTransport {
 			new StreamRewritingThread(proc.getErrorStream()).start();
 			return proc;
 		} catch (IOException err) {
-			throw new TransportException(uri.toString() + ": "
-					+ err.getMessage(), err);
+			throw new TransportException(uri, err.getMessage(), err);
 		}
 	}
 
diff --git a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportSftp.java b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportSftp.java
index cfe22c1..21657ef 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/transport/TransportSftp.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/transport/TransportSftp.java
@@ -111,13 +111,12 @@ class TransportSftp extends WalkTransport {
 				session.connect();
 			return session;
 		} catch (JSchException je) {
-			final String us = uri.toString();
 			final Throwable c = je.getCause();
 			if (c instanceof UnknownHostException)
-				throw new TransportException(us + ": Unknown host");
+				throw new TransportException(uri, "unknown host");
 			if (c instanceof ConnectException)
-				throw new TransportException(us + ": " + c.getMessage());
-			throw new TransportException(us + ": " + je.getMessage(), je);
+				throw new TransportException(uri, c.getMessage());
+			throw new TransportException(uri, je.getMessage(), je);
 		}
 	}
 
@@ -127,8 +126,7 @@ class TransportSftp extends WalkTransport {
 			channel.connect();
 			return (ChannelSftp) channel;
 		} catch (JSchException je) {
-			throw new TransportException(uri.toString() + ": "
-					+ je.getMessage(), je);
+			throw new TransportException(uri, je.getMessage(), je);
 		}
 	}
 
@@ -259,7 +257,7 @@ class TransportSftp extends WalkTransport {
 			} catch (FileNotFoundException notPacked) {
 				// Perhaps it wasn't worthwhile, or is just an older repository.
 			} catch (IOException e) {
-				throw new TransportException(uri + ": error in packed-refs", e);
+				throw new TransportException(uri, "error in packed-refs", e);
 			}
 			readRef(avail, "../HEAD", "HEAD");
 			readLooseRefs(avail, "../refs", "refs/");

diff --git a/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java b/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java
index 4130bc9..cbdf465 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/pgm/Push.java
@@ -104,9 +104,9 @@ class Push extends TextBuiltin {
                        transport.setOptionReceivePack(exec);

                for (; argi < args.length; argi++) {
-                       final RefSpec spec = new RefSpec(args[argi]);
+                       RefSpec spec = new RefSpec(args[argi]);
                        if (forceAll)
-                               spec.setForceUpdate(true);
+                               spec = spec.setForceUpdate(true);
                        refSpecs.add(spec);
                }
                final Collection<RemoteRefUpdate> toPush = transport