CheckoutOperation.java

package com.proalpha.pds.gitutils.common;
 
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URISyntaxException;
import java.text.MessageFormat;
import java.util.Collection;
import java.util.List;
 
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.egit.core.op.FetchOperation;
import org.eclipse.egit.core.securestorage.UserPasswordCredentials;
import org.eclipse.egit.ui.internal.SecureStoreUtils;
import org.eclipse.egit.ui.internal.credentials.EGitCredentialsProvider;
import org.eclipse.jgit.api.CheckoutCommand;
import org.eclipse.jgit.api.CheckoutResult;
import org.eclipse.jgit.api.CreateBranchCommand.SetupUpstreamMode;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.MergeCommand;
import org.eclipse.jgit.api.MergeCommand.FastForwardMode;
import org.eclipse.jgit.api.MergeResult;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.errors.InvalidObjectIdException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.RefSpec;
import org.eclipse.jgit.transport.RemoteConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.proalpha.git.PaGit;
import com.proalpha.git.util.PaBranchName;
import com.proalpha.git.util.PaRepository;
 
public class CheckoutOperation {
 
    private final Logger logger = LoggerFactory.getLogger(CheckoutOperation.class);
 
    protected static final String DEFAULT_SOURCE = "HEAD";
 
    protected String targetRef;
    protected String sourceRef;
    protected boolean updateTargetRef;
    protected boolean updateSourceRef;
 
    protected String remote;
 
    protected Repository repository;
 
    protected IProgressMonitor monitor;
 
    private CheckoutCommand cmd;
 
    protected MergeCommand mergeCmd;
 
    protected MergeResult mergeResult;
 
    public CheckoutOperation(Repository repository, String remote, String sourceRef, String targetRef,
            boolean updateSourceRef, boolean updateTargetRef) {
        this.repository = repository;
 
        this.sourceRef = sourceRef;
        this.targetRef = targetRef;
 
        this.updateSourceRef = updateSourceRef;
        this.updateTargetRef = updateTargetRef;
 
        this.remote = remote;
        PaGit.init(new Git(repository));
    }
 
    public CheckoutOperation(Repository repository, String targetRef) {
        this(repository, Constants.DEFAULT_REMOTE_NAME, DEFAULT_SOURCE, targetRef, false, false);
    }
 
    public void run() throws InvocationTargetException {
 
        if (logger.isInfoEnabled())
            logger.info(MessageFormat.format("Checkout/creation of branch {0}", this.targetRef));
 
        try {
            if (isLocalBranch(this.targetRef)) {
                // Checkout existing local branch (with possible fetch to update)
                checkoutLocalBranch();
            } else {
                if (isServerBranch(this.targetRef)) {
                    // Checkout existing server branch
                    checkoutServerBranch();
                } else {
                    // Create a new branch (with possible fetch of source branch to start
                    // with newest version
                    createNewBranch();
                }
            }
        } finally {
            PaGit.getInstance().close();
        }
 
    }
 
    @SuppressWarnings("restriction")
    protected boolean tryFetch(String ref) {
 
        if (!this.isServerBranch(ref))
            return false;
 
        try {
            RemoteConfig config = this.getRemoteConfig();
 
            if (config == null)
                return false;
 
            RefSpec spec = new RefSpec("+refs/heads/" + ref + ":refs/remotes/" + remote + "/" + ref);
            config.addFetchRefSpec(spec);
 
            FetchOperation op = new FetchOperation(this.repository, config, config.getTimeout(), false /* no dryRun */);
            op.setCredentialsProvider(getCredentialProvider());
 
            op.run(monitor);
 
            return true;
        } catch (URISyntaxException ex) {
            logger.warn("The remote config seems to be strange", ex);
        } catch (InvocationTargetException ex) {
            logger.warn("Error while running the fetch operation ()", ex);
        }
 
        return false;
    }
 
    protected RemoteConfig getRemoteConfig() throws URISyntaxException {
        List<RemoteConfig> configs = RemoteConfig.getAllRemoteConfigs(repository.getConfig());
 
        for (RemoteConfig c : configs) {
            if (c.getName().equals(this.remote)) {
                return c;
            }
        }
        return null;
    }
 
    public void setProgressMonitor(IProgressMonitor monitor) {
        this.monitor = monitor;
    }
 
    public CheckoutResult getResult() {
 
        if (cmd != null)
            if (mergeResult == null /* no merge was performed */ || (mergeResult
                    .getMergeStatus() == MergeResult.MergeStatus.FAST_FORWARD
                    || mergeResult.getMergeStatus() == MergeResult.MergeStatus.MERGED
                    || mergeResult.getMergeStatus() == MergeResult.MergeStatus.ALREADY_UP_TO_DATE))
                return cmd.getResult();
            else
                // Something went wrong during the merge operation: We just indicate
                // a general error, so the user is informed and must check the
                // reason by himself
                return CheckoutResult.ERROR_RESULT;
 
        return null;
    }
 
    protected boolean isLocalBranch(String ref) {
        try {
            String shortRef = PaBranchName.getShortBranchName(ref);
            List<Ref> refs = PaGit.getInstance().getGit().branchList().call();
 
            for (Ref r : refs) {
                if (PaBranchName.getShortBranchName(r.getName()).equals(shortRef)) {
                    return true;
                }
            }
 
        } catch (GitAPIException ex) {
            logger.error(ex.getMessage(), ex);
        }
        return false;
    }
 
    protected boolean isServerBranch(String ref) {
        try {
            String shortRef = PaBranchName.getShortBranchName(ref);
            Collection<Ref> refs = PaGit.getInstance().getGit().lsRemote().setHeads(true).setTags(false)
                    .setCredentialsProvider(getCredentialProvider()).setRemote(this.remote).call();
 
            for (Ref r : refs) {
                if (PaBranchName.getShortBranchName(r.getName()).equals(shortRef)) {
                    return true;
                }
            }
 
        } catch (GitAPIException ex) {
            logger.error("Error while retrieving server branches.", ex);
        }
        return false;
    }
 
    protected EGitCredentialsProvider getCredentialProvider() {
 
        UserPasswordCredentials credentials = null;
 
        try {
            RemoteConfig config = this.getRemoteConfig();
            try {
                // NOTE: We assume that exactly one URI is specified in the remote
                // If this is not the case, we may get the wrong credentials
                if (config != null)
                    credentials = SecureStoreUtils.getCredentials(config.getURIs().get(0));
 
            } catch (IllegalArgumentException ex) {
                logger.warn("Could not get credentials for the URI of following git repository: {}",
                        (config.getURIs().isEmpty()) ? config.getName() + " - NO URI!" : config.getURIs().get(0));
            }
        } catch (URISyntaxException ex) {
            logger.warn("Could not get credentials for the URI due to URI syntax exception", ex);
        }
 
        if (credentials != null)
            return new EGitCredentialsProvider(credentials.getUser(), credentials.getPassword());
        else
            return new EGitCredentialsProvider();
 
    }
 
    private void checkoutLocalBranch() throws InvocationTargetException {
        // Branch is already known in the local repository
        // --> Checkout and possibly update
        try {
            cmd = PaGit.getInstance().getGit().checkout().setName(this.targetRef);
            cmd.call();
 
            if (logger.isInfoEnabled())
                logger.info(MessageFormat.format("Checkout of existing local branch {0} successful", this.targetRef));
 
            if (this.updateTargetRef && tryFetch(this.targetRef)) {
                // On branches like master, FF merge will result in the same as rebase because there
                // are no manual commits on client.
                mergeCmd = PaGit.getInstance().getGit().merge().setFastForward(MergeCommand.FastForwardMode.FF)
                        .include(this.repository.resolve(this.remote + "/" + this.targetRef));
                mergeResult = mergeCmd.call();
                
                if (mergeResult.getMergeStatus().isSuccessful())
                    if (logger.isInfoEnabled())
                        logger.info(MessageFormat.format("Merge of remote branch {0} successful",
                                this.remote + "/" + this.targetRef));
                else {
                    if (logger.isInfoEnabled())
                        logger.error(MessageFormat.format("Error while updating local ref {0}  while merging",
                                this.targetRef));
                    throw new InvocationTargetException(new Throwable("Merge into {0} failed"));
                }
            }
 
        } catch (GitAPIException | IOException e1) {
            logger.error(MessageFormat.format("Error while checkout of local branch {0}", this.targetRef), e1);
            throw new InvocationTargetException(e1.getCause() != null ? e1.getCause() : e1);
        }
    }
 
    private void checkoutServerBranch() throws InvocationTargetException {
        try {
            tryFetch(this.targetRef);
 
            cmd = PaGit.getInstance().getGit().checkout().setCreateBranch(true).setName(this.targetRef)
                    .setUpstreamMode(SetupUpstreamMode.TRACK).setStartPoint(this.remote + "/" + this.targetRef);
            cmd.call();
 
            logger.info(MessageFormat.format("Branch {0} created by checkout of remote branch {1}", this.targetRef,
                    this.remote + "/" + this.targetRef));
        } catch (GitAPIException e1) {
            logger.error(MessageFormat.format("Error while checkout of server branch {0}", targetRef), e1);
            throw new InvocationTargetException(e1.getCause() != null ? e1.getCause() : e1);
        }
    }
 
    private void createNewBranch() throws InvocationTargetException {
        try {
            if (this.updateSourceRef && tryFetch(this.sourceRef) && !PaRepository.isRemoteTrackingBranch(this.sourceRef)) {
                try {
                    PaGit.getInstance().getGit().checkout().setCreateBranch(false).setName(this.sourceRef).call();
                    mergeCmd = PaGit.getInstance().getGit().merge().setFastForward(FastForwardMode.FF_ONLY)
                            .include(this.repository.resolve(this.remote + "/" + this.sourceRef));
                    mergeResult = mergeCmd.call();
 
                    if (mergeResult.getMergeStatus().isSuccessful()) {
                        if (logger.isInfoEnabled())
                            logger.info(MessageFormat.format("Merge of remote branch {0} successful",
                                    this.remote + "/" + this.targetRef));
                    }
                    else {
                        if (logger.isInfoEnabled())
                            logger.error(MessageFormat.format("Error while updating local ref {0}  while merging",
                                    this.targetRef));
                        throw new InvocationTargetException(new Throwable("Merge into {0} failed"));
                    }
                } catch (InvalidObjectIdException | IOException ioie) {
                    if (logger.isWarnEnabled())
                        logger.warn(MessageFormat.format("Source ref {0} could not be updated and/or merged into {1}.", 
                                this.sourceRef, this.targetRef), ioie);
                }
            }
 
            cmd = PaGit.getInstance().getGit().checkout().setCreateBranch(true).setName(this.targetRef)
                    .setUpstreamMode(SetupUpstreamMode.NOTRACK).setStartPoint(this.sourceRef);
            cmd.call();
 
            if (logger.isInfoEnabled())
                logger.info(MessageFormat.format("Creation of branch {0} by branching-off local branch {1}", this.targetRef, this.sourceRef));
        } catch (GitAPIException e1) {
            if (logger.isErrorEnabled())
                logger.error(MessageFormat.format("Error while creating new local branch {0}", targetRef), e1);
            throw new InvocationTargetException(e1.getCause() != null ? e1.getCause() : e1);
        }
    }
}