rdt/org.eclipse.ptp.rdt.sync.git.core/src/org/eclipse/ptp/rdt/sync/git/core/GitRemoteSyncConnection.java - ptp/org.eclipse.ptp - Git at Google

 /*******************************************************************************
  * Copyright (c) 2011 Oak Ridge National Laboratory and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    John Eblen - initial implementation
  *******************************************************************************/
 package org.eclipse.ptp.rdt.sync.git.core;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
 import java.io.StringReader;
 import java.net.URISyntaxException;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jgit.api.AddCommand;
 import org.eclipse.jgit.api.CommitCommand;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.MergeCommand;
 import org.eclipse.jgit.api.errors.CheckoutConflictException;
 import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.api.errors.InvalidMergeHeadsException;
 import org.eclipse.jgit.api.errors.NoFilepatternException;
 import org.eclipse.jgit.api.errors.NoHeadException;
 import org.eclipse.jgit.api.errors.NoMessageException;
 import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
 import org.eclipse.jgit.errors.NotSupportedException;
 import org.eclipse.jgit.errors.TransportException;
 import org.eclipse.jgit.errors.UnmergedPathException;
 import org.eclipse.jgit.lib.NullProgressMonitor;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.StoredConfig;
 import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
 import org.eclipse.jgit.transport.CredentialsProvider;
 import org.eclipse.jgit.transport.RefSpec;
 import org.eclipse.jgit.transport.RemoteConfig;
 import org.eclipse.jgit.transport.RemoteSession;
 import org.eclipse.jgit.transport.SshSessionFactory;
 import org.eclipse.jgit.transport.Transport;
 import org.eclipse.jgit.transport.TransportGitSsh;
 import org.eclipse.jgit.transport.URIish;
 import org.eclipse.jgit.util.FS;
 import org.eclipse.ptp.rdt.sync.git.core.CommandRunner.CommandResults;
 import org.eclipse.ptp.remote.core.AbstractRemoteProcess;
 import org.eclipse.ptp.remote.core.IRemoteConnection;
 import org.eclipse.ptp.remote.core.exception.RemoteConnectionException;

 /**
  *
  * This class implements a remote sync tool using git, as accessed through the jgit library.
  *
  */
 public class GitRemoteSyncConnection {
 	private final static String remoteProjectName = "eclipse_auto"; //$NON-NLS-1$
 	private final static String commitMessage = "Eclipse Automatic Commit"; //$NON-NLS-1$
 	private final static String remotePushBranch = "ptp-push"; //$NON-NLS-1$
 	private final IRemoteConnection connection;
 	private final String localDirectory;
 	private final String remoteDirectory;
 	private Git git;
 	private TransportGitSsh transport;

 	/**
 	 * Create a remote sync connection using git. Assumes that the local directory exists but not necessarily the remote directory.
 	 * It is created if not.
 	 *
 	 * @param conn
 	 * @param localDir
 	 * @param remoteDir
 	 * @throws RemoteSyncException
 	 *             on problems building the remote repository. Specific exception nested. Upon such an exception, the instance is
 	 *             invalid and should not be used.
 	 */
 	public GitRemoteSyncConnection(IRemoteConnection conn, String localDir, String remoteDir) throws RemoteSyncException {
 		connection = conn;
 		localDirectory = localDir;
 		remoteDirectory = remoteDir;

 		// Build repo, creating it if it is not already present.
 		try {
 			buildRepo();
 		} catch (final CoreException e) {
 			throw new RemoteSyncException(e);
 		} catch (final IOException e) {
 			throw new RemoteSyncException(e);
 		} catch (final RemoteExecutionException e) {
 			throw new RemoteSyncException(e);
 		}

 		// Build transport
 		final RemoteConfig remoteConfig = buildRemoteConfig(git.getRepository().getConfig());
 		buildTransport(remoteConfig);
 	}

 	/**
 	 * Builds the remote configuration for the connection, setting up fetch and push operations between local and remote master
 	 * branches.
 	 *
 	 * @param config
 	 *            configuration for the local repository
 	 * @return the remote configuration
 	 * @throws RuntimeException
 	 *             if the URI in the passed configuration is not properly formatted.
 	 */
 	private RemoteConfig buildRemoteConfig(StoredConfig config) {
 		RemoteConfig rconfig = null;

 		try {
 			rconfig = new RemoteConfig(config, remoteProjectName);
 		} catch (final URISyntaxException e) {
 			throw new RuntimeException(e);
 		}

 		final RefSpec refSpecFetch = new RefSpec("+refs/heads/master:refs/remotes/" +  //$NON-NLS-1$
 												                      remoteProjectName + "/master"); //$NON-NLS-1$
 		final RefSpec refSpecPush = new RefSpec("+master:" + remotePushBranch); //$NON-NLS-1$
 		rconfig.addFetchRefSpec(refSpecFetch);
 		rconfig.addPushRefSpec(refSpecPush);

 		return rconfig;
 	}

 	/**
 	 *
 	 * @param localDirectory
 	 * @param remoteHost
 	 * @return the repository
 	 * @throws CoreException
 	 *             on problems creating the remote directory.
 	 * @throws IOException
 	 *             on problems writing to the file system.
 	 * @throws RemoteExecutionException
 	 *             on failure to run remote commands.
 	 * @throws RemoteSyncException
 	 *             on problems with initial local commit.
 	 * TODO: Consider the consequences of exceptions that occur at various points, which can leave the repo in a partial state.
 	 * 		   For example, if the repo is created but the initial commit fails.
 	 * TODO: Consider evaluating the output of "git init".
 	 */
 	private Git buildRepo() throws CoreException, IOException, RemoteExecutionException, RemoteSyncException {
 		final File localDir = new File(localDirectory);
 		final FileRepositoryBuilder repoBuilder = new FileRepositoryBuilder();
 		Repository repository = null;

 		try {
 			repository = repoBuilder.setWorkTree(localDir).build();
 		} catch (final IOException e) {
 			throw e;
 		}
 		git = new Git(repository);

 		// Create and configure local repository if it is not already present. Set the git instance.
 		if (repoReady() == false) {
 			try {
 				repository.create(false);
 			} catch (final IOException e) {
 				throw e;
 			}

 			// An initial commit to create the master branch.
 			try {
 				doCommit();
 			} catch (final RemoteSyncException e) {
 				throw e;
 			}
 		}

 		// Create remote directory if necessary.
 		try {
 			CommandRunner.createRemoteDirectory(connection, remoteDirectory);
 		} catch (final CoreException e) {
 			throw e;
 		}

 		// Initialize remote directory if necessary
 		try {
 			doRemoteInit();
 		} catch (final IOException e) {
 			throw e;
 		} catch (final RemoteExecutionException e) {
 			throw e;
 		}

 		// Commit remote files if necessary
 		try {
 			doRemoteCommit();
 		} catch (final IOException e) {
 			throw e;
 		} catch (final RemoteExecutionException e) {
 			throw e;
 		}

 		return new Git(repository);
 	}

 	/**
 	* Create and configure remote repository if it is not already present. Note that "git init" is "safe" on a repo already
 	* created, so we can simply rerun it each time.
 	* @throws IOException
 	* @throws RemoteExecutionException
 	*/
 	private void doRemoteInit() throws IOException, RemoteExecutionException {
 		String command = null;
 		CommandResults commandResults = null;

 		command = "git init"; //$NON-NLS-1$
 		try {
 			commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
 		} catch (final IOException e) {
 			throw e;
 		} catch (final InterruptedException e) {
 			throw new RemoteExecutionException(e);
 		} catch (RemoteConnectionException e) {
 			throw new RemoteExecutionException(e);
 		}

 		if (commandResults.getExitCode() != 0) {
 			throw new RemoteExecutionException("remote git init failed with message: " + //$NON-NLS-1$
 																						commandResults.getStderr());
 		}
 	}

 	/*
 	 * Do a commit on the remote repository. First we add and delete files from the git index as needed, and then we call "git commit"
 	 * TODO: Modified files already added by "git add" will not be found by "getRemoteFileStatus". Thus, a commit may not happen even
 	 * though there are outstanding changes. Note that this can only occur by accessing the repo outside of Eclipse.
 	 */
 	private void doRemoteCommit() throws IOException, RemoteExecutionException {
 		Set<String> filesToAdd = new HashSet<String>();
 		Set<String> filesToDelete = new HashSet<String>();
 		boolean needToCommit = false;

 		try {
 			getRemoteFileStatus(filesToAdd, filesToDelete);
 			for (String fileName : filesToDelete) {
 				if (filesToAdd.contains(fileName)) {
 					filesToAdd.remove(fileName);
 				}
 			}
 			if (filesToAdd.size() > 0) {
 				addRemoteFiles(filesToAdd);
 				needToCommit = true;
 			}
 			if (filesToDelete.size() > 0) {
 				deleteRemoteFiles(filesToDelete);
 				needToCommit = true;
 			}

 			if (needToCommit) {
 				commitRemoteFiles();
 			}
 		} catch (IOException e) {
 			throw e;
 		} catch (RemoteExecutionException e) {
 			throw e;
 		}
 	}

 	/*
 	 * Do a "git commit" on the remote host
 	 */
 	private void commitRemoteFiles() throws IOException, RemoteExecutionException {
 		final String command = "git commit -m \"" + commitMessage + "\""; //$NON-NLS-1$ //$NON-NLS-2$
 		CommandResults commandResults = null;

 		try {
 			commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
 		} catch (final IOException e) {
 			throw e;
 		} catch (final InterruptedException e) {
 			throw new RemoteExecutionException(e);
 		} catch (RemoteConnectionException e) {
 			throw new RemoteExecutionException(e);
 		}
 		if (commandResults.getExitCode() != 0) {
 			throw new RemoteExecutionException("remote git commit failed with message: " + //$NON-NLS-1$
 																						 commandResults.getStderr());
 		}
 	}

 	/*
 	 * Do a "git rm <Files>" on the remote host
 	 */
 	private void deleteRemoteFiles(Set<String> filesToDelete) throws IOException, RemoteExecutionException {
 		String command = "git rm"; //$NON-NLS-1$
 		for (String fileName : filesToDelete) {
 			command = command.concat(" "); //$NON-NLS-1$
 			command = command.concat(fileName);
 		}

 		CommandResults commandResults = null;
 		try {
 			commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
 		} catch (final IOException e) {
 			throw e;
 		} catch (final InterruptedException e) {
 			throw new RemoteExecutionException(e);
 		} catch (RemoteConnectionException e) {
 			throw new RemoteExecutionException(e);
 		}
 		if (commandResults.getExitCode() != 0) {
 			throw new RemoteExecutionException("remote git rm failed with message: " + //$NON-NLS-1$
 																						 commandResults.getStderr());
 		}
 	}

 	/*
 	 * Do a "git add <Files>" on the remote host
 	 */
 	private void addRemoteFiles(Set<String> filesToAdd) throws IOException, RemoteExecutionException {
 		String command = "git add"; //$NON-NLS-1$
 		for (String fileName : filesToAdd) {
 			command = command.concat(" "); //$NON-NLS-1$
 			command = command.concat(fileName);
 		}

 		CommandResults commandResults = null;
 		try {
 			commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
 		} catch (final IOException e) {
 			throw e;
 		} catch (final InterruptedException e) {
 			throw new RemoteExecutionException(e);
 		} catch (RemoteConnectionException e) {
 			throw new RemoteExecutionException(e);
 		}
 		if (commandResults.getExitCode() != 0) {
 			throw new RemoteExecutionException("remote git add failed with message: " + //$NON-NLS-1$
 																						 commandResults.getStderr());
 		}
 	}

 	/*
 	 * Use "git ls-files" to obtain a list of files that need to be added or deleted from the git index.
 	 */
 	private void getRemoteFileStatus(Set<String> filesToAdd, Set<String> filesToDelete)
 																					throws IOException, RemoteExecutionException {
 		final String command = "git ls-files -t --modified --others --deleted"; //$NON-NLS-1$
 		CommandResults commandResults = null;

 		try {
 			commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
 		} catch (final IOException e) {
 			throw e;
 		} catch (final InterruptedException e) {
 			throw new RemoteExecutionException(e);
 		} catch (RemoteConnectionException e) {
 			throw new RemoteExecutionException(e);
 		}
 		if (commandResults.getExitCode() != 0) {
 			throw new RemoteExecutionException("remote git ls-files failed with message: " + //$NON-NLS-1$
 																						 commandResults.getStderr());
 		}

 		BufferedReader statusReader = new BufferedReader(new StringReader(commandResults.getStdout()));
 		String line = null;
 		while ((line = statusReader.readLine()) != null) {
 			String[] lineParts = line.split("\\s+"); //$NON-NLS-1$
 			if (lineParts.length < 2) {
 				continue;
 			}
 			if (lineParts[0].startsWith("R")) { //$NON-NLS-1$
 				filesToDelete.add(lineParts[1]);
 			} else {
 				filesToAdd.add(lineParts[1]);
 			}
 		}
 		statusReader.close();
 	}

 	// Subclass JGit's generic RemoteSession to set up running of remote commands using the available process builder.
 	public class PTPSession implements RemoteSession {
 		private URIish uri;

 		public PTPSession(URIish uri) {
 			this.uri = uri;
 		}

 		public Process exec(String command, int timeout) throws TransportException {
 			// TODO: Use a library for command splitting.
 			List<String> commandList = new LinkedList<String>();
 			commandList.add("sh"); //$NON-NLS-1$
 			commandList.add("-c"); //$NON-NLS-1$
 			commandList.add(command);

 			try {
 				if (!connection.isOpen()) {
 					connection.open(null);
 				}
 				return (AbstractRemoteProcess) connection.getRemoteServices().getProcessBuilder(connection, commandList).start();
 			} catch (IOException e) {
 				throw new TransportException(uri, e.getMessage(), e);
 			} catch (RemoteConnectionException e) {
 				throw new TransportException(uri, e.getMessage(), e);
 			}

 		}

 		public void disconnect() {
 			// Nothing to do
 		}
 	}

 	/**
 	 * Creates the transport object that JGit uses for executing commands remotely.
 	 *
 	 * @param remoteConfig
 	 * 				the remote configuration for our local Git repo
 	 * @return the transport
 	 * @throws RuntimeException
 	 *             if the requested transport is not supported by JGit.
 	 */
 	private void buildTransport(RemoteConfig remoteConfig) {
 		final URIish uri = buildURI();
 		try {
 			transport = (TransportGitSsh) Transport.open(git.getRepository(), uri);
 		} catch (NotSupportedException e) {
 			throw new RuntimeException(e);
 		} catch (TransportException e) {
 			throw new RuntimeException(e);
 		}

 		// Set the transport to use our own means of executing remote commands.
 		transport.setSshSessionFactory(new SshSessionFactory() {
 			@Override
 			public RemoteSession getSession(URIish uri, CredentialsProvider credentialsProvider, FS fs, int tms) throws TransportException {
 				return new PTPSession(uri);
 			}
 		});

 		transport.applyConfig(remoteConfig);
 	}

 	/**
 	 * Build the URI for the remote host as needed by the transport. Since the transport will use an external SSH session, we do
 	 * not need to provide user, host, or password. However, the function for opening a transport throws an exception if the host
 	 * is null or empty length. So we set it to a dummy string.
 	 *
 	 * @return URIish
 	 */
 	private URIish buildURI() {
 		return new URIish()
 				// .setUser(connection.getUsername())
 				.setHost("/not/a/real/host") //$NON-NLS-1$
 				// .setPass("")
 				.setScheme("ssh") //$NON-NLS-1$
 				.setPath(remoteDirectory);
 	}

 	public void close() {
 		transport.close();
 	}

 	/**
 	 * Commits files in working directory. For now, we just commit all files. So adding ".", handles all files, including newly
 	 * created files, and setting the all flag (-a) ensures that deleted files are updated.
 	 * TODO: Figure out how to do this more efficiently, as was done remotely (using git ls-files)
 	 *
 	 * @throws RemoteSyncException
 	 *             on problems committing.
 	 */
 	private void doCommit() throws RemoteSyncException {
 		final AddCommand addCommand = git.add();
 		addCommand.addFilepattern("."); //$NON-NLS-1$
 		try {
 			addCommand.call();
 		} catch (final NoFilepatternException e) {
 			throw new RemoteSyncException(e);
 		}

 		final CommitCommand commitCommand = git.commit();
 		commitCommand.setAll(true);
 		commitCommand.setMessage(commitMessage);

 		try {
 			commitCommand.call();
 		} catch (final GitAPIException e) {
 			throw new RemoteSyncException(e);
 		} catch (final UnmergedPathException e) {
 			throw new RemoteSyncException(e);
 		}
 	}

 	/**
 	 * @return the connection (IRemoteConnection)
 	 */
 	public IRemoteConnection getConnection() {
 		return connection;
 	}

 	/**
 	 * @return the localDirectory
 	 */
 	public String getLocalDirectory() {
 		return localDirectory;
 	}

 	/**
 	 * @return the remoteDirectory
 	 */
 	public String getRemoteDirectory() {
 		return remoteDirectory;
 	}

 	/**
 	 *
 	 * @param localDirectory
 	 * @return If the repo has actually been initialized
 	 * TODO: Consider the ways this could go wrong. What if the directory name already ends in a slash? What if ".git" is a file or
 	 * does not contain the appropriate files?
 	 */
 	private boolean repoReady() {
 		final String repoDirectory = localDirectory + "/.git"; //$NON-NLS-1$
 		final File repoDir = new File(repoDirectory);
 		return repoDir.exists();
 	}

 	/**
 	 * Many of the listed exceptions appear to be unrecoverable, caused by errors in the initial setup. It is vital, though, that
 	 * failed syncs are reported and handled. So all exceptions are checked exceptions, embedded in a RemoteSyncException.
 	 *
 	 * @throws RemoteSyncException
 	 *             for various problems sync'ing. The specific exception is nested within the RemoteSyncException.
 	 * TODO: Consider possible platform dependency.
 	 */
 	public void syncLocalToRemote() throws RemoteSyncException {
 		// First commit changes to the local repository.
 		try {
 			doCommit();
 		} catch (final RemoteSyncException e) {
 			throw e;
 		}

 		// Then push them to the remote site.
 		try {
 			transport.push(NullProgressMonitor.INSTANCE, null);
 		} catch (final NotSupportedException e) {
 			throw new RemoteSyncException(e);
 		} catch (final TransportException e) {
 			throw new RemoteSyncException(e);
 		}

 		// Now remotely merge changes with master branch
 		CommandResults mergeResults;
 		final String command = "git merge " + remotePushBranch; //$NON-NLS-1$
 		try {
 			mergeResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
 		} catch (final IOException e) {
 			throw new RemoteSyncException(e);
 		} catch (final InterruptedException e) {
 			throw new RemoteSyncException(e);
 		} catch (RemoteConnectionException e) {
 			throw new RemoteSyncException(e);
 		}

 		if (mergeResults.getExitCode() != 0) {
 			throw new RemoteSyncException(new RemoteExecutionException("Remote merge failed with message: " +  //$NON-NLS-1$
 																									mergeResults.getStderr()));
 		}
 	}

 	/**
 	 * @throws RemoteSyncException
 	 *             for various problems sync'ing. The specific exception is nested within the RemoteSyncException. Many of the
 	 *             listed exceptions appear to be unrecoverable, caused by errors in the initial setup. It is vital, though, that
 	 *             failed syncs are reported and handled. So all exceptions are checked exceptions, embedded in a
 	 *             RemoteSyncException.
 	 */
 	public void syncRemoteToLocal() throws RemoteSyncException {

 		// TODO: Figure out why pull doesn't work and why we have to fetch and merge instead.
 		// PullCommand pullCommand = gitConnection.getGit().pull().
 		// try {
 		// pullCommand.call();
 		// } catch (WrongRepositoryStateException e) {
 		// throw new RemoteSyncException(e);
 		// } catch (InvalidConfigurationException e) {
 		// throw new RemoteSyncException(e);
 		// } catch (DetachedHeadException e) {
 		// throw new RemoteSyncException(e);
 		// } catch (InvalidRemoteException e) {
 		// throw new RemoteSyncException(e);
 		// } catch (CanceledException e) {
 		// throw new RemoteSyncException(e);
 		// }

 		// First, commit in case any changes have occurred remotely.
 		try {
 			doRemoteCommit();
 		} catch (IOException e) {
 			throw new RemoteSyncException(e);
 		} catch (RemoteExecutionException e) {
 			throw new RemoteSyncException(e);
 		}

 		// Next, fetch the remote repository
 		try {
 			transport.fetch(NullProgressMonitor.INSTANCE, null);
 		} catch (final NotSupportedException e) {
 			throw new RemoteSyncException(e);
 		} catch (final TransportException e) {
 			throw new RemoteSyncException(e);
 		}

 		// Now merge. Before merging we set the head for merging to master.
 		Ref masterRef = null;
 		try {
 			masterRef = git.getRepository().getRef("refs/remotes/" + remoteProjectName + "/master"); //$NON-NLS-1$ //$NON-NLS-2$
 		} catch (final IOException e) {
 			throw new RemoteSyncException(e);
 		}

 		final MergeCommand mergeCommand = git.merge().include(masterRef);
 		try {
 			mergeCommand.call();
 		} catch (final NoHeadException e) {
 			throw new RemoteSyncException(e);
 		} catch (final ConcurrentRefUpdateException e) {
 			throw new RemoteSyncException(e);
 		} catch (final CheckoutConflictException e) {
 			throw new RemoteSyncException(e);
 		} catch (final InvalidMergeHeadsException e) {
 			throw new RemoteSyncException(e);
 		} catch (final WrongRepositoryStateException e) {
 			throw new RemoteSyncException(e);
 		} catch (final NoMessageException e) {
 			throw new RemoteSyncException(e);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2011 Oak Ridge National Laboratory and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* John Eblen - initial implementation
	*******************************************************************************/
	package org.eclipse.ptp.rdt.sync.git.core;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.IOException;
	import java.io.StringReader;
	import java.net.URISyntaxException;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.jgit.api.AddCommand;
	import org.eclipse.jgit.api.CommitCommand;
	import org.eclipse.jgit.api.Git;
	import org.eclipse.jgit.api.MergeCommand;
	import org.eclipse.jgit.api.errors.CheckoutConflictException;
	import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
	import org.eclipse.jgit.api.errors.GitAPIException;
	import org.eclipse.jgit.api.errors.InvalidMergeHeadsException;
	import org.eclipse.jgit.api.errors.NoFilepatternException;
	import org.eclipse.jgit.api.errors.NoHeadException;
	import org.eclipse.jgit.api.errors.NoMessageException;
	import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
	import org.eclipse.jgit.errors.NotSupportedException;
	import org.eclipse.jgit.errors.TransportException;
	import org.eclipse.jgit.errors.UnmergedPathException;
	import org.eclipse.jgit.lib.NullProgressMonitor;
	import org.eclipse.jgit.lib.Ref;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.lib.StoredConfig;
	import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
	import org.eclipse.jgit.transport.CredentialsProvider;
	import org.eclipse.jgit.transport.RefSpec;
	import org.eclipse.jgit.transport.RemoteConfig;
	import org.eclipse.jgit.transport.RemoteSession;
	import org.eclipse.jgit.transport.SshSessionFactory;
	import org.eclipse.jgit.transport.Transport;
	import org.eclipse.jgit.transport.TransportGitSsh;
	import org.eclipse.jgit.transport.URIish;
	import org.eclipse.jgit.util.FS;
	import org.eclipse.ptp.rdt.sync.git.core.CommandRunner.CommandResults;
	import org.eclipse.ptp.remote.core.AbstractRemoteProcess;
	import org.eclipse.ptp.remote.core.IRemoteConnection;
	import org.eclipse.ptp.remote.core.exception.RemoteConnectionException;

	/**
	*
	* This class implements a remote sync tool using git, as accessed through the jgit library.
	*
	*/
	public class GitRemoteSyncConnection {
	private final static String remoteProjectName = "eclipse_auto"; //$NON-NLS-1$
	private final static String commitMessage = "Eclipse Automatic Commit"; //$NON-NLS-1$
	private final static String remotePushBranch = "ptp-push"; //$NON-NLS-1$
	private final IRemoteConnection connection;
	private final String localDirectory;
	private final String remoteDirectory;
	private Git git;
	private TransportGitSsh transport;

	/**
	* Create a remote sync connection using git. Assumes that the local directory exists but not necessarily the remote directory.
	* It is created if not.
	*
	* @param conn
	* @param localDir
	* @param remoteDir
	* @throws RemoteSyncException
	* on problems building the remote repository. Specific exception nested. Upon such an exception, the instance is
	* invalid and should not be used.
	*/
	public GitRemoteSyncConnection(IRemoteConnection conn, String localDir, String remoteDir) throws RemoteSyncException {
	connection = conn;
	localDirectory = localDir;
	remoteDirectory = remoteDir;

	// Build repo, creating it if it is not already present.
	try {
	buildRepo();
	} catch (final CoreException e) {
	throw new RemoteSyncException(e);
	} catch (final IOException e) {
	throw new RemoteSyncException(e);
	} catch (final RemoteExecutionException e) {
	throw new RemoteSyncException(e);
	}

	// Build transport
	final RemoteConfig remoteConfig = buildRemoteConfig(git.getRepository().getConfig());
	buildTransport(remoteConfig);
	}

	/**
	* Builds the remote configuration for the connection, setting up fetch and push operations between local and remote master
	* branches.
	*
	* @param config
	* configuration for the local repository
	* @return the remote configuration
	* @throws RuntimeException
	* if the URI in the passed configuration is not properly formatted.
	*/
	private RemoteConfig buildRemoteConfig(StoredConfig config) {
	RemoteConfig rconfig = null;

	try {
	rconfig = new RemoteConfig(config, remoteProjectName);
	} catch (final URISyntaxException e) {
	throw new RuntimeException(e);
	}

	final RefSpec refSpecFetch = new RefSpec("+refs/heads/master:refs/remotes/" + //$NON-NLS-1$
	remoteProjectName + "/master"); //$NON-NLS-1$
	final RefSpec refSpecPush = new RefSpec("+master:" + remotePushBranch); //$NON-NLS-1$
	rconfig.addFetchRefSpec(refSpecFetch);
	rconfig.addPushRefSpec(refSpecPush);

	return rconfig;
	}

	/**
	*
	* @param localDirectory
	* @param remoteHost
	* @return the repository
	* @throws CoreException
	* on problems creating the remote directory.
	* @throws IOException
	* on problems writing to the file system.
	* @throws RemoteExecutionException
	* on failure to run remote commands.
	* @throws RemoteSyncException
	* on problems with initial local commit.
	* TODO: Consider the consequences of exceptions that occur at various points, which can leave the repo in a partial state.
	* For example, if the repo is created but the initial commit fails.
	* TODO: Consider evaluating the output of "git init".
	*/
	private Git buildRepo() throws CoreException, IOException, RemoteExecutionException, RemoteSyncException {
	final File localDir = new File(localDirectory);
	final FileRepositoryBuilder repoBuilder = new FileRepositoryBuilder();
	Repository repository = null;

	try {
	repository = repoBuilder.setWorkTree(localDir).build();
	} catch (final IOException e) {
	throw e;
	}
	git = new Git(repository);

	// Create and configure local repository if it is not already present. Set the git instance.
	if (repoReady() == false) {
	try {
	repository.create(false);
	} catch (final IOException e) {
	throw e;
	}

	// An initial commit to create the master branch.
	try {
	doCommit();
	} catch (final RemoteSyncException e) {
	throw e;
	}
	}

	// Create remote directory if necessary.
	try {
	CommandRunner.createRemoteDirectory(connection, remoteDirectory);
	} catch (final CoreException e) {
	throw e;
	}

	// Initialize remote directory if necessary
	try {
	doRemoteInit();
	} catch (final IOException e) {
	throw e;
	} catch (final RemoteExecutionException e) {
	throw e;
	}

	// Commit remote files if necessary
	try {
	doRemoteCommit();
	} catch (final IOException e) {
	throw e;
	} catch (final RemoteExecutionException e) {
	throw e;
	}

	return new Git(repository);
	}

	/**
	* Create and configure remote repository if it is not already present. Note that "git init" is "safe" on a repo already
	* created, so we can simply rerun it each time.
	* @throws IOException
	* @throws RemoteExecutionException
	*/
	private void doRemoteInit() throws IOException, RemoteExecutionException {
	String command = null;
	CommandResults commandResults = null;

	command = "git init"; //$NON-NLS-1$
	try {
	commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
	} catch (final IOException e) {
	throw e;
	} catch (final InterruptedException e) {
	throw new RemoteExecutionException(e);
	} catch (RemoteConnectionException e) {
	throw new RemoteExecutionException(e);
	}

	if (commandResults.getExitCode() != 0) {
	throw new RemoteExecutionException("remote git init failed with message: " + //$NON-NLS-1$
	commandResults.getStderr());
	}
	}

	/*
	* Do a commit on the remote repository. First we add and delete files from the git index as needed, and then we call "git commit"
	* TODO: Modified files already added by "git add" will not be found by "getRemoteFileStatus". Thus, a commit may not happen even
	* though there are outstanding changes. Note that this can only occur by accessing the repo outside of Eclipse.
	*/
	private void doRemoteCommit() throws IOException, RemoteExecutionException {
	Set<String> filesToAdd = new HashSet<String>();
	Set<String> filesToDelete = new HashSet<String>();
	boolean needToCommit = false;

	try {
	getRemoteFileStatus(filesToAdd, filesToDelete);
	for (String fileName : filesToDelete) {
	if (filesToAdd.contains(fileName)) {
	filesToAdd.remove(fileName);
	}
	}
	if (filesToAdd.size() > 0) {
	addRemoteFiles(filesToAdd);
	needToCommit = true;
	}
	if (filesToDelete.size() > 0) {
	deleteRemoteFiles(filesToDelete);
	needToCommit = true;
	}

	if (needToCommit) {
	commitRemoteFiles();
	}
	} catch (IOException e) {
	throw e;
	} catch (RemoteExecutionException e) {
	throw e;
	}
	}

	/*
	* Do a "git commit" on the remote host
	*/
	private void commitRemoteFiles() throws IOException, RemoteExecutionException {
	final String command = "git commit -m \"" + commitMessage + "\""; //$NON-NLS-1$ //$NON-NLS-2$
	CommandResults commandResults = null;

	try {
	commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
	} catch (final IOException e) {
	throw e;
	} catch (final InterruptedException e) {
	throw new RemoteExecutionException(e);
	} catch (RemoteConnectionException e) {
	throw new RemoteExecutionException(e);
	}
	if (commandResults.getExitCode() != 0) {
	throw new RemoteExecutionException("remote git commit failed with message: " + //$NON-NLS-1$
	commandResults.getStderr());
	}
	}

	/*
	* Do a "git rm <Files>" on the remote host
	*/
	private void deleteRemoteFiles(Set<String> filesToDelete) throws IOException, RemoteExecutionException {
	String command = "git rm"; //$NON-NLS-1$
	for (String fileName : filesToDelete) {
	command = command.concat(" "); //$NON-NLS-1$
	command = command.concat(fileName);
	}

	CommandResults commandResults = null;
	try {
	commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
	} catch (final IOException e) {
	throw e;
	} catch (final InterruptedException e) {
	throw new RemoteExecutionException(e);
	} catch (RemoteConnectionException e) {
	throw new RemoteExecutionException(e);
	}
	if (commandResults.getExitCode() != 0) {
	throw new RemoteExecutionException("remote git rm failed with message: " + //$NON-NLS-1$
	commandResults.getStderr());
	}
	}

	/*
	* Do a "git add <Files>" on the remote host
	*/
	private void addRemoteFiles(Set<String> filesToAdd) throws IOException, RemoteExecutionException {
	String command = "git add"; //$NON-NLS-1$
	for (String fileName : filesToAdd) {
	command = command.concat(" "); //$NON-NLS-1$
	command = command.concat(fileName);
	}

	CommandResults commandResults = null;
	try {
	commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
	} catch (final IOException e) {
	throw e;
	} catch (final InterruptedException e) {
	throw new RemoteExecutionException(e);
	} catch (RemoteConnectionException e) {
	throw new RemoteExecutionException(e);
	}
	if (commandResults.getExitCode() != 0) {
	throw new RemoteExecutionException("remote git add failed with message: " + //$NON-NLS-1$
	commandResults.getStderr());
	}
	}

	/*
	* Use "git ls-files" to obtain a list of files that need to be added or deleted from the git index.
	*/
	private void getRemoteFileStatus(Set<String> filesToAdd, Set<String> filesToDelete)
	throws IOException, RemoteExecutionException {
	final String command = "git ls-files -t --modified --others --deleted"; //$NON-NLS-1$
	CommandResults commandResults = null;

	try {
	commandResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
	} catch (final IOException e) {
	throw e;
	} catch (final InterruptedException e) {
	throw new RemoteExecutionException(e);
	} catch (RemoteConnectionException e) {
	throw new RemoteExecutionException(e);
	}
	if (commandResults.getExitCode() != 0) {
	throw new RemoteExecutionException("remote git ls-files failed with message: " + //$NON-NLS-1$
	commandResults.getStderr());
	}

	BufferedReader statusReader = new BufferedReader(new StringReader(commandResults.getStdout()));
	String line = null;
	while ((line = statusReader.readLine()) != null) {
	String[] lineParts = line.split("\\s+"); //$NON-NLS-1$
	if (lineParts.length < 2) {
	continue;
	}
	if (lineParts[0].startsWith("R")) { //$NON-NLS-1$
	filesToDelete.add(lineParts[1]);
	} else {
	filesToAdd.add(lineParts[1]);
	}
	}
	statusReader.close();
	}

	// Subclass JGit's generic RemoteSession to set up running of remote commands using the available process builder.
	public class PTPSession implements RemoteSession {
	private URIish uri;

	public PTPSession(URIish uri) {
	this.uri = uri;
	}

	public Process exec(String command, int timeout) throws TransportException {
	// TODO: Use a library for command splitting.
	List<String> commandList = new LinkedList<String>();
	commandList.add("sh"); //$NON-NLS-1$
	commandList.add("-c"); //$NON-NLS-1$
	commandList.add(command);

	try {
	if (!connection.isOpen()) {
	connection.open(null);
	}
	return (AbstractRemoteProcess) connection.getRemoteServices().getProcessBuilder(connection, commandList).start();
	} catch (IOException e) {
	throw new TransportException(uri, e.getMessage(), e);
	} catch (RemoteConnectionException e) {
	throw new TransportException(uri, e.getMessage(), e);
	}

	}

	public void disconnect() {
	// Nothing to do
	}
	}

	/**
	* Creates the transport object that JGit uses for executing commands remotely.
	*
	* @param remoteConfig
	* the remote configuration for our local Git repo
	* @return the transport
	* @throws RuntimeException
	* if the requested transport is not supported by JGit.
	*/
	private void buildTransport(RemoteConfig remoteConfig) {
	final URIish uri = buildURI();
	try {
	transport = (TransportGitSsh) Transport.open(git.getRepository(), uri);
	} catch (NotSupportedException e) {
	throw new RuntimeException(e);
	} catch (TransportException e) {
	throw new RuntimeException(e);
	}

	// Set the transport to use our own means of executing remote commands.
	transport.setSshSessionFactory(new SshSessionFactory() {
	@Override
	public RemoteSession getSession(URIish uri, CredentialsProvider credentialsProvider, FS fs, int tms) throws TransportException {
	return new PTPSession(uri);
	}
	});

	transport.applyConfig(remoteConfig);
	}

	/**
	* Build the URI for the remote host as needed by the transport. Since the transport will use an external SSH session, we do
	* not need to provide user, host, or password. However, the function for opening a transport throws an exception if the host
	* is null or empty length. So we set it to a dummy string.
	*
	* @return URIish
	*/
	private URIish buildURI() {
	return new URIish()
	// .setUser(connection.getUsername())
	.setHost("/not/a/real/host") //$NON-NLS-1$
	// .setPass("")
	.setScheme("ssh") //$NON-NLS-1$
	.setPath(remoteDirectory);
	}

	public void close() {
	transport.close();
	}

	/**
	* Commits files in working directory. For now, we just commit all files. So adding ".", handles all files, including newly
	* created files, and setting the all flag (-a) ensures that deleted files are updated.
	* TODO: Figure out how to do this more efficiently, as was done remotely (using git ls-files)
	*
	* @throws RemoteSyncException
	* on problems committing.
	*/
	private void doCommit() throws RemoteSyncException {
	final AddCommand addCommand = git.add();
	addCommand.addFilepattern("."); //$NON-NLS-1$
	try {
	addCommand.call();
	} catch (final NoFilepatternException e) {
	throw new RemoteSyncException(e);
	}

	final CommitCommand commitCommand = git.commit();
	commitCommand.setAll(true);
	commitCommand.setMessage(commitMessage);

	try {
	commitCommand.call();
	} catch (final GitAPIException e) {
	throw new RemoteSyncException(e);
	} catch (final UnmergedPathException e) {
	throw new RemoteSyncException(e);
	}
	}

	/**
	* @return the connection (IRemoteConnection)
	*/
	public IRemoteConnection getConnection() {
	return connection;
	}

	/**
	* @return the localDirectory
	*/
	public String getLocalDirectory() {
	return localDirectory;
	}

	/**
	* @return the remoteDirectory
	*/
	public String getRemoteDirectory() {
	return remoteDirectory;
	}

	/**
	*
	* @param localDirectory
	* @return If the repo has actually been initialized
	* TODO: Consider the ways this could go wrong. What if the directory name already ends in a slash? What if ".git" is a file or
	* does not contain the appropriate files?
	*/
	private boolean repoReady() {
	final String repoDirectory = localDirectory + "/.git"; //$NON-NLS-1$
	final File repoDir = new File(repoDirectory);
	return repoDir.exists();
	}

	/**
	* Many of the listed exceptions appear to be unrecoverable, caused by errors in the initial setup. It is vital, though, that
	* failed syncs are reported and handled. So all exceptions are checked exceptions, embedded in a RemoteSyncException.
	*
	* @throws RemoteSyncException
	* for various problems sync'ing. The specific exception is nested within the RemoteSyncException.
	* TODO: Consider possible platform dependency.
	*/
	public void syncLocalToRemote() throws RemoteSyncException {
	// First commit changes to the local repository.
	try {
	doCommit();
	} catch (final RemoteSyncException e) {
	throw e;
	}

	// Then push them to the remote site.
	try {
	transport.push(NullProgressMonitor.INSTANCE, null);
	} catch (final NotSupportedException e) {
	throw new RemoteSyncException(e);
	} catch (final TransportException e) {
	throw new RemoteSyncException(e);
	}

	// Now remotely merge changes with master branch
	CommandResults mergeResults;
	final String command = "git merge " + remotePushBranch; //$NON-NLS-1$
	try {
	mergeResults = CommandRunner.executeRemoteCommand(connection, command, remoteDirectory, null);
	} catch (final IOException e) {
	throw new RemoteSyncException(e);
	} catch (final InterruptedException e) {
	throw new RemoteSyncException(e);
	} catch (RemoteConnectionException e) {
	throw new RemoteSyncException(e);
	}

	if (mergeResults.getExitCode() != 0) {
	throw new RemoteSyncException(new RemoteExecutionException("Remote merge failed with message: " + //$NON-NLS-1$
	mergeResults.getStderr()));
	}
	}

	/**
	* @throws RemoteSyncException
	* for various problems sync'ing. The specific exception is nested within the RemoteSyncException. Many of the
	* listed exceptions appear to be unrecoverable, caused by errors in the initial setup. It is vital, though, that
	* failed syncs are reported and handled. So all exceptions are checked exceptions, embedded in a
	* RemoteSyncException.
	*/
	public void syncRemoteToLocal() throws RemoteSyncException {

	// TODO: Figure out why pull doesn't work and why we have to fetch and merge instead.
	// PullCommand pullCommand = gitConnection.getGit().pull().
	// try {
	// pullCommand.call();
	// } catch (WrongRepositoryStateException e) {
	// throw new RemoteSyncException(e);
	// } catch (InvalidConfigurationException e) {
	// throw new RemoteSyncException(e);
	// } catch (DetachedHeadException e) {
	// throw new RemoteSyncException(e);
	// } catch (InvalidRemoteException e) {
	// throw new RemoteSyncException(e);
	// } catch (CanceledException e) {
	// throw new RemoteSyncException(e);
	// }

	// First, commit in case any changes have occurred remotely.
	try {
	doRemoteCommit();
	} catch (IOException e) {
	throw new RemoteSyncException(e);
	} catch (RemoteExecutionException e) {
	throw new RemoteSyncException(e);
	}

	// Next, fetch the remote repository
	try {
	transport.fetch(NullProgressMonitor.INSTANCE, null);
	} catch (final NotSupportedException e) {
	throw new RemoteSyncException(e);
	} catch (final TransportException e) {
	throw new RemoteSyncException(e);
	}

	// Now merge. Before merging we set the head for merging to master.
	Ref masterRef = null;
	try {
	masterRef = git.getRepository().getRef("refs/remotes/" + remoteProjectName + "/master"); //$NON-NLS-1$ //$NON-NLS-2$
	} catch (final IOException e) {
	throw new RemoteSyncException(e);
	}

	final MergeCommand mergeCommand = git.merge().include(masterRef);
	try {
	mergeCommand.call();
	} catch (final NoHeadException e) {
	throw new RemoteSyncException(e);
	} catch (final ConcurrentRefUpdateException e) {
	throw new RemoteSyncException(e);
	} catch (final CheckoutConflictException e) {
	throw new RemoteSyncException(e);
	} catch (final InvalidMergeHeadsException e) {
	throw new RemoteSyncException(e);
	} catch (final WrongRepositoryStateException e) {
	throw new RemoteSyncException(e);
	} catch (final NoMessageException e) {
	throw new RemoteSyncException(e);
	}
	}
	}