Support a configured credentials provider in LsRemoteCommand

Refactored the three common transport configuration options:
credentials provider, timeout, and transport config callback
into a new TransportCommand base class which is now extended
by all commands that use a Transport object during execution.

Bug: 349188
Change-Id: I90c2c14fb4e3cc4712905158f9047153a0c235c2
Signed-off-by: Kevin Sawicki <kevin@github.com>
Signed-off-by: Chris Aniszczyk <zx@twitter.com>

org.eclipse.jgit/src/org/eclipse/jgit/api/CloneCommand.java

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.Callable;
 
 import org.eclipse.jgit.JGitText;
 import org.eclipse.jgit.api.errors.InvalidRemoteException;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
-import org.eclipse.jgit.transport.CredentialsProvider;
 import org.eclipse.jgit.transport.FetchResult;
 import org.eclipse.jgit.transport.RefSpec;
 import org.eclipse.jgit.transport.RemoteConfig;
  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-clone.html"
  *      >Git documentation about Clone</a>
  */
-public class CloneCommand implements Callable<Git> {
+public class CloneCommand extends TransportCommand<CloneCommand, Git> {
 
 	private String uri;
 
 
 	private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;
 
-	private CredentialsProvider credentialsProvider;
-
-	private int timeout;
-
 	private boolean cloneAllBranches;
 
 	private boolean noCheckout;
 
 	private Collection<String> branchesToClone;
 
-	private TransportConfigCallback transportConfigCallback;
+	/**
+	 * Create clone command with no repository set
+	 */
+	public CloneCommand() {
+		super(null);
+	}
 
 	/**
 	 * Executes the {@code Clone} command.
 		return command.call().getRepository();
 	}
 
-	private FetchResult fetch(Repository repo, URIish u)
+	private FetchResult fetch(Repository clonedRepo, URIish u)
 			throws URISyntaxException,
 			JGitInternalException,
 			InvalidRemoteException, IOException {
 		// create the remote config and save it
-		RemoteConfig config = new RemoteConfig(repo.getConfig(), remote);
+		RemoteConfig config = new RemoteConfig(clonedRepo.getConfig(), remote);
 		config.addURI(u);
 
 		final String dst = bare ? Constants.R_HEADS : Constants.R_REMOTES
 		refSpec = refSpec.setSourceDestination(Constants.R_HEADS + "*", dst + "/*"); //$NON-NLS-1$ //$NON-NLS-2$
 
 		config.addFetchRefSpec(refSpec);
-		config.update(repo.getConfig());
+		config.update(clonedRepo.getConfig());
 
-		repo.getConfig().save();
+		clonedRepo.getConfig().save();
 
 		// run the fetch command
-		FetchCommand command = new FetchCommand(repo);
+		FetchCommand command = new FetchCommand(clonedRepo);
 		command.setRemote(remote);
 		command.setProgressMonitor(monitor);
 		command.setTagOpt(TagOpt.FETCH_TAGS);
-		command.setTimeout(timeout);
-		if (credentialsProvider != null)
-			command.setCredentialsProvider(credentialsProvider);
-		command.setTransportConfigCallback(transportConfigCallback);
+		configure(command);
 
 		List<RefSpec> specs = calculateRefSpecs(dst);
 		command.setRefSpecs(specs);
 		return specs;
 	}
 
-	private void checkout(Repository repo, FetchResult result)
+	private void checkout(Repository clonedRepo, FetchResult result)
 			throws JGitInternalException,
 			MissingObjectException, IncorrectObjectTypeException, IOException {
 
 			return; // throw exception?
 
 		if (head.getName().startsWith(Constants.R_HEADS)) {
-			final RefUpdate newHead = repo.updateRef(Constants.HEAD);
+			final RefUpdate newHead = clonedRepo.updateRef(Constants.HEAD);
 			newHead.disableRefLog();
 			newHead.link(head.getName());
-			addMergeConfig(repo, head);
+			addMergeConfig(clonedRepo, head);
 		}
 
-		final RevCommit commit = parseCommit(repo, head);
+		final RevCommit commit = parseCommit(clonedRepo, head);
 
 		boolean detached = !head.getName().startsWith(Constants.R_HEADS);
-		RefUpdate u = repo.updateRef(Constants.HEAD, detached);
+		RefUpdate u = clonedRepo.updateRef(Constants.HEAD, detached);
 		u.setNewObjectId(commit.getId());
 		u.forceUpdate();
 
 		if (!bare) {
-			DirCache dc = repo.lockDirCache();
-			DirCacheCheckout co = new DirCacheCheckout(repo, dc,
+			DirCache dc = clonedRepo.lockDirCache();
+			DirCacheCheckout co = new DirCacheCheckout(clonedRepo, dc,
 					commit.getTree());
 			co.checkout();
 		}
 		return foundBranch;
 	}
 
-	private void addMergeConfig(Repository repo, Ref head) throws IOException {
+	private void addMergeConfig(Repository clonedRepo, Ref head)
+			throws IOException {
 		String branchName = Repository.shortenRefName(head.getName());
-		repo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
+		clonedRepo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
 				branchName, ConfigConstants.CONFIG_KEY_REMOTE, remote);
-		repo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
+		clonedRepo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
 				branchName, ConfigConstants.CONFIG_KEY_MERGE, head.getName());
-		repo.getConfig().save();
+		clonedRepo.getConfig().save();
 	}
 
-	private RevCommit parseCommit(final Repository repo, final Ref ref)
+	private RevCommit parseCommit(final Repository clonedRepo, final Ref ref)
 			throws MissingObjectException, IncorrectObjectTypeException,
 			IOException {
-		final RevWalk rw = new RevWalk(repo);
+		final RevWalk rw = new RevWalk(clonedRepo);
 		final RevCommit commit;
 		try {
 			commit = rw.parseCommit(ref.getObjectId());
 		return this;
 	}
 
-	/**
-	 * @param credentialsProvider
-	 *            the {@link CredentialsProvider} to use
-	 * @return {@code this}
-	 */
-	public CloneCommand setCredentialsProvider(
-			CredentialsProvider credentialsProvider) {
-		this.credentialsProvider = credentialsProvider;
-		return this;
-	}
-
-	/**
-	 * @param timeout
-	 *            the timeout used for the fetch step
-	 * @return {@code this}
-	 */
-	public CloneCommand setTimeout(int timeout) {
-		this.timeout = timeout;
-		return this;
-	}
-
 	/**
 	 * @param cloneAllBranches
 	 *            true when all branches have to be fetched (indicates wildcard
 		this.noCheckout = noCheckout;
 		return this;
 	}
-
-	/**
-	 * @param transportConfigCallback
-	 *            if set, the callback will be invoked after the Transport has
-	 *            created, but before the Transport is used. The callback can
-	 *            use this opportunity to set additional type-specific
-	 *            configuration on the Transport instance.
-	 * @return {@code this}
-	 */
-	public CloneCommand setTransportConfigCallback(
-			TransportConfigCallback transportConfigCallback) {
-		this.transportConfigCallback = transportConfigCallback;
-		return this;
-	}
 }

org.eclipse.jgit/src/org/eclipse/jgit/api/FetchCommand.java

 import org.eclipse.jgit.lib.NullProgressMonitor;
 import org.eclipse.jgit.lib.ProgressMonitor;
 import org.eclipse.jgit.lib.Repository;
-import org.eclipse.jgit.transport.CredentialsProvider;
 import org.eclipse.jgit.transport.FetchResult;
 import org.eclipse.jgit.transport.RefSpec;
 import org.eclipse.jgit.transport.TagOpt;
  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-fetch.html"
  *      >Git documentation about Fetch</a>
  */
-public class FetchCommand extends GitCommand<FetchResult> {
+public class FetchCommand extends TransportCommand<FetchCommand, FetchResult> {
 
 	private String remote = Constants.DEFAULT_REMOTE_NAME;
 
 
 	private boolean thin = Transport.DEFAULT_FETCH_THIN;
 
-	private int timeout;
-
-	private CredentialsProvider credentialsProvider;
-
 	private TagOpt tagOption;
 
-	private TransportConfigCallback transportConfigCallback;
-
 	/**
 	 * @param repo
 	 */
 			try {
 				transport.setCheckFetchedObjects(checkFetchedObjects);
 				transport.setRemoveDeletedRefs(removeDeletedRefs);
-				transport.setTimeout(timeout);
 				transport.setDryRun(dryRun);
 				if (tagOption != null)
 					transport.setTagOpt(tagOption);
 				transport.setFetchThin(thin);
-				if (credentialsProvider != null)
-					transport.setCredentialsProvider(credentialsProvider);
-				if (transportConfigCallback != null)
-					transportConfigCallback.configure(transport);
+				configure(transport);
 
 				FetchResult result = transport.fetch(monitor, refSpecs);
 				return result;
 		return remote;
 	}
 
-	/**
-	 * @param timeout
-	 *            the timeout used for the fetch operation
-	 * @return {@code this}
-	 */
-	public FetchCommand setTimeout(int timeout) {
-		checkCallable();
-		this.timeout = timeout;
-		return this;
-	}
-
 	/**
 	 * @return the timeout used for the fetch operation
 	 */
 		return this;
 	}
 
-	/**
-	 * @param credentialsProvider
-	 *            the {@link CredentialsProvider} to use
-	 * @return {@code this}
-	 */
-	public FetchCommand setCredentialsProvider(
-			CredentialsProvider credentialsProvider) {
-		checkCallable();
-		this.credentialsProvider = credentialsProvider;
-		return this;
-	}
-
 	/**
 	 * Sets the specification of annotated tag behavior during fetch
 	 *
 		this.tagOption = tagOpt;
 		return this;
 	}
-
-	/**
-	 * @param transportConfigCallback
-	 *            if set, the callback will be invoked after the Transport has
-	 *            created, but before the Transport is used. The callback can
-	 *            use this opportunity to set additional type-specific
-	 *            configuration on the Transport instance.
-	 * @return {@code this}
-	 */
-	public FetchCommand setTransportConfigCallback(
-			TransportConfigCallback transportConfigCallback) {
-		checkCallable();
-		this.transportConfigCallback = transportConfigCallback;
-		return this;
-	}
 }

org.eclipse.jgit/src/org/eclipse/jgit/api/LsRemoteCommand.java

  *      href="http://www.kernel.org/pub/software/scm/git/docs/git-ls-remote.html"
  *      >Git documentation about ls-remote</a>
  */
-public class LsRemoteCommand extends GitCommand<Collection<Ref>> {
+public class LsRemoteCommand extends
+		TransportCommand<LsRemoteCommand, Collection<Ref>> {
 
 	private String remote = Constants.DEFAULT_REMOTE_NAME;
 
 		try {
 			Transport transport = Transport.open(repo, remote);
 			transport.setOptionUploadPack(uploadPack);
+			configure(transport);
 
 			try {
 				Collection<RefSpec> refSpecs = new ArrayList<RefSpec>(1);

org.eclipse.jgit/src/org/eclipse/jgit/api/PullCommand.java

 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.RepositoryState;
-import org.eclipse.jgit.transport.CredentialsProvider;
 import org.eclipse.jgit.transport.FetchResult;
 
 /**
  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-pull.html"
  *      >Git documentation about Pull</a>
  */
-public class PullCommand extends GitCommand<PullResult> {
-	private int timeout = 0;
+public class PullCommand extends TransportCommand<PullCommand, PullResult> {
 
 	private final static String DOT = ".";
 
 	private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;
 
-	private CredentialsProvider credentialsProvider;
-
-	private TransportConfigCallback transportConfigCallback;
-
 	/**
 	 * @param repo
 	 */
 		super(repo);
 	}
 
-	/**
-	 * @param timeout
-	 *            in seconds
-	 * @return this instance
-	 */
-	public PullCommand setTimeout(int timeout) {
-		this.timeout = timeout;
-		return this;
-	}
-
 	/**
 	 * @param monitor
 	 *            a progress monitor
 		return this;
 	}
 
-	/**
-	 * @param credentialsProvider
-	 *            the {@link CredentialsProvider} to use
-	 * @return this instance
-	 */
-	public PullCommand setCredentialsProvider(
-			CredentialsProvider credentialsProvider) {
-		checkCallable();
-		this.credentialsProvider = credentialsProvider;
-		return this;
-	}
-
-	/**
-	 * @param transportConfigCallback
-	 *            if set, the callback will be invoked after the Transport has
-	 *            created, but before the Transport is used. The callback can
-	 *            use this opportunity to set additional type-specific
-	 *            configuration on the Transport instance.
-	 * @return {@code this}
-	 */
-	public PullCommand setTransportConfigCallback(
-			TransportConfigCallback transportConfigCallback) {
-		checkCallable();
-		this.transportConfigCallback = transportConfigCallback;
-		return this;
-	}
-
 	/**
 	 * Executes the {@code Pull} command with all the options and parameters
 	 * collected by the setter methods (e.g.
 			FetchCommand fetch = new FetchCommand(repo);
 			fetch.setRemote(remote);
 			fetch.setProgressMonitor(monitor);
-			fetch.setTimeout(this.timeout);
-			fetch.setCredentialsProvider(credentialsProvider);
-			fetch.setTransportConfigCallback(transportConfigCallback);
+			configure(fetch);
 
 			fetchRes = fetch.call();
 		} else {

org.eclipse.jgit/src/org/eclipse/jgit/api/PushCommand.java

 import org.eclipse.jgit.lib.ProgressMonitor;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
-import org.eclipse.jgit.transport.CredentialsProvider;
 import org.eclipse.jgit.transport.PushResult;
 import org.eclipse.jgit.transport.RefSpec;
 import org.eclipse.jgit.transport.RemoteConfig;
  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-push.html"
  *      >Git documentation about Push</a>
  */
-public class PushCommand extends GitCommand<Iterable<PushResult>> {
+public class PushCommand extends
+		TransportCommand<PushCommand, Iterable<PushResult>> {
 
 	private String remote = Constants.DEFAULT_REMOTE_NAME;
 
 
 	private boolean thin = Transport.DEFAULT_PUSH_THIN;
 
-	private int timeout;
-
-	private CredentialsProvider credentialsProvider;
-
-	private TransportConfigCallback transportConfigCallback;
-
 	/**
 	 * @param repo
 	 */
 			final List<Transport> transports;
 			transports = Transport.openAll(repo, remote, Transport.Operation.PUSH);
 			for (final Transport transport : transports) {
-				if (0 <= timeout)
-					transport.setTimeout(timeout);
 				transport.setPushThin(thin);
 				if (receivePack != null)
 					transport.setOptionReceivePack(receivePack);
 				transport.setDryRun(dryRun);
-				if (credentialsProvider != null)
-					transport.setCredentialsProvider(credentialsProvider);
-				if (transportConfigCallback != null)
-					transportConfigCallback.configure(transport);
+				configure(transport);
 
 				final Collection<RemoteRefUpdate> toPush = transport
 						.findRemoteRefUpdatesFor(refSpecs);
 		return receivePack;
 	}
 
-	/**
-	 * @param timeout
-	 *            the timeout used for the push operation
-	 * @return {@code this}
-	 */
-	public PushCommand setTimeout(int timeout) {
-		checkCallable();
-		this.timeout = timeout;
-		return this;
-	}
-
 	/**
 	 * @return the timeout used for the push operation
 	 */
 		this.force = force;
 		return this;
 	}
-
-	/**
-	 * @param credentialsProvider
-	 *            the {@link CredentialsProvider} to use
-	 * @return {@code this}
-	 */
-	public PushCommand setCredentialsProvider(
-			CredentialsProvider credentialsProvider) {
-		checkCallable();
-		this.credentialsProvider = credentialsProvider;
-		return this;
-	}
-
-	/**
-	 * @param transportConfigCallback
-	 *            if set, the callback will be invoked after the Transport has
-	 *            created, but before the Transport is used. The callback can
-	 *            use this opportunity to set additional type-specific
-	 *            configuration on the Transport instance.
-	 * @return {@code this}
-	 */
-	public PushCommand setTransportConfigCallback(
-			TransportConfigCallback transportConfigCallback) {
-		checkCallable();
-		this.transportConfigCallback = transportConfigCallback;
-		return this;
-	}
 }

org.eclipse.jgit/src/org/eclipse/jgit/api/TransportCommand.java

+/*
+ * Copyright (C) 2011, GitHub Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * 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 Eclipse Foundation, Inc. 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.eclipse.jgit.api;
+
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.transport.CredentialsProvider;
+import org.eclipse.jgit.transport.Transport;
+
+/**
+ * Base class for commands that use a {@link Transport} during execution.
+ * <p>
+ * This class provides standard configuration of a transport for options such as
+ * a {@link CredentialsProvider}, a timeout, and a
+ * {@link TransportConfigCallback}.
+ *
+ * @param <C>
+ * @param <T>
+ */
+public abstract class TransportCommand<C extends GitCommand, T> extends
+		GitCommand<T> {
+
+	/**
+	 * Configured credentials provider
+	 */
+	protected CredentialsProvider credentialsProvider;
+
+	/**
+	 * Configured transport timeout
+	 */
+	protected int timeout;
+
+	/**
+	 * Configured callback for transport configuration
+	 */
+	protected TransportConfigCallback transportConfigCallback;
+
+	/**
+	 * @param repo
+	 */
+	protected TransportCommand(final Repository repo) {
+		super(repo);
+	}
+
+	/**
+	 * @param credentialsProvider
+	 *            the {@link CredentialsProvider} to use
+	 * @return {@code this}
+	 */
+	public C setCredentialsProvider(
+			final CredentialsProvider credentialsProvider) {
+		this.credentialsProvider = credentialsProvider;
+		return self();
+	}
+
+	/**
+	 * @param timeout
+	 *            the timeout used for the transport step
+	 * @return {@code this}
+	 */
+	public C setTimeout(int timeout) {
+		this.timeout = timeout;
+		return self();
+	}
+
+	/**
+	 * @param transportConfigCallback
+	 *            if set, the callback will be invoked after the
+	 *            {@link Transport} has created, but before the
+	 *            {@link Transport} is used. The callback can use this
+	 *            opportunity to set additional type-specific configuration on
+	 *            the {@link Transport} instance.
+	 * @return {@code this}
+	 */
+	public C setTransportConfigCallback(
+			final TransportConfigCallback transportConfigCallback) {
+		this.transportConfigCallback = transportConfigCallback;
+		return self();
+	}
+
+	/** @return {@code this} */
+	@SuppressWarnings("unchecked")
+	protected final C self() {
+		return (C) this;
+	}
+
+	/**
+	 * Configure transport with credentials provider, timeout, and config
+	 * callback
+	 *
+	 * @param transport
+	 * @return {@code this}
+	 */
+	protected C configure(final Transport transport) {
+		if (credentialsProvider != null)
+			transport.setCredentialsProvider(credentialsProvider);
+		transport.setTimeout(timeout);
+		if (transportConfigCallback != null)
+			transportConfigCallback.configure(transport);
+		return self();
+	}
+
+	/**
+	 * Configure a child command with the current configuration set in
+	 * {@code this} command
+	 *
+	 * @param childCommand
+	 * @return {@code this}
+	 */
+	protected C configure(final TransportCommand childCommand) {
+		childCommand.setCredentialsProvider(credentialsProvider);
+		childCommand.setTimeout(timeout);
+		childCommand.setTransportConfigCallback(transportConfigCallback);
+		return self();
+	}
+}