PullCommand.java

  1. /*
  2.  * Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>
  3.  * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
  4.  * Copyright (C) 2016, 2021 Laurent Delaigue <laurent.delaigue@obeo.fr> and others
  5.  *
  6.  * This program and the accompanying materials are made available under the
  7.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  8.  * https://www.eclipse.org/org/documents/edl-v10.php.
  9.  *
  10.  * SPDX-License-Identifier: BSD-3-Clause
  11.  */
  12. package org.eclipse.jgit.api;

  14. import java.io.IOException;
  15. import java.text.MessageFormat;

  17. import org.eclipse.jgit.annotations.Nullable;
  18. import org.eclipse.jgit.api.MergeCommand.FastForwardMode;
  19. import org.eclipse.jgit.api.MergeCommand.FastForwardMode.Merge;
  20. import org.eclipse.jgit.api.RebaseCommand.Operation;
  21. import org.eclipse.jgit.api.errors.CanceledException;
  22. import org.eclipse.jgit.api.errors.GitAPIException;
  23. import org.eclipse.jgit.api.errors.InvalidConfigurationException;
  24. import org.eclipse.jgit.api.errors.InvalidRemoteException;
  25. import org.eclipse.jgit.api.errors.JGitInternalException;
  26. import org.eclipse.jgit.api.errors.NoHeadException;
  27. import org.eclipse.jgit.api.errors.RefNotAdvertisedException;
  28. import org.eclipse.jgit.api.errors.RefNotFoundException;
  29. import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
  30. import org.eclipse.jgit.dircache.DirCacheCheckout;
  31. import org.eclipse.jgit.internal.JGitText;
  32. import org.eclipse.jgit.lib.AnyObjectId;
  33. import org.eclipse.jgit.lib.BranchConfig.BranchRebaseMode;
  34. import org.eclipse.jgit.lib.Config;
  35. import org.eclipse.jgit.lib.ConfigConstants;
  36. import org.eclipse.jgit.lib.Constants;
  37. import org.eclipse.jgit.lib.NullProgressMonitor;
  38. import org.eclipse.jgit.lib.ObjectId;
  39. import org.eclipse.jgit.lib.ProgressMonitor;
  40. import org.eclipse.jgit.lib.Ref;
  41. import org.eclipse.jgit.lib.RefUpdate;
  42. import org.eclipse.jgit.lib.RefUpdate.Result;
  43. import org.eclipse.jgit.lib.Repository;
  44. import org.eclipse.jgit.lib.RepositoryState;
  45. import org.eclipse.jgit.lib.SubmoduleConfig.FetchRecurseSubmodulesMode;
  46. import org.eclipse.jgit.merge.ContentMergeStrategy;
  47. import org.eclipse.jgit.merge.MergeStrategy;
  48. import org.eclipse.jgit.revwalk.RevCommit;
  49. import org.eclipse.jgit.revwalk.RevWalk;
  50. import org.eclipse.jgit.transport.FetchResult;
  51. import org.eclipse.jgit.transport.TagOpt;

  53. /**
  54.  * The Pull command
  55.  *
  56.  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-pull.html"
  57.  *      >Git documentation about Pull</a>
  58.  */
  59. public class PullCommand extends TransportCommand<PullCommand, PullResult> {

  61.     private static final String DOT = "."; //$NON-NLS-1$

  63.     private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;

  65.     private BranchRebaseMode pullRebaseMode = null;

  67.     private String remote;

  69.     private String remoteBranchName;

  71.     private MergeStrategy strategy = MergeStrategy.RECURSIVE;

  73.     private ContentMergeStrategy contentStrategy;

  75.     private TagOpt tagOption;

  77.     private FastForwardMode fastForwardMode;

  79.     private FetchRecurseSubmodulesMode submoduleRecurseMode = null;

  81.     /**
  82.      * Constructor for PullCommand.
  83.      *
  84.      * @param repo
  85.      *            the {@link org.eclipse.jgit.lib.Repository}
  86.      */
  87.     protected PullCommand(Repository repo) {
  88.         super(repo);
  89.     }

  91.     /**
  92.      * Set progress monitor
  93.      *
  94.      * @param monitor
  95.      *            a progress monitor
  96.      * @return this instance
  97.      */
  98.     public PullCommand setProgressMonitor(ProgressMonitor monitor) {
  99.         if (monitor == null) {
  100.             monitor = NullProgressMonitor.INSTANCE;
  101.         }
  102.         this.monitor = monitor;
  103.         return this;
  104.     }

  106.     /**
  107.      * Set if rebase should be used after fetching. If set to true, rebase is
  108.      * used instead of merge. This is equivalent to --rebase on the command
  109.      * line.
  110.      * <p>
  111.      * If set to false, merge is used after fetching, overriding the
  112.      * configuration file. This is equivalent to --no-rebase on the command
  113.      * line.
  114.      * <p>
  115.      * This setting overrides the settings in the configuration file. By
  116.      * default, the setting in the repository configuration file is used.
  117.      * <p>
  118.      * A branch can be configured to use rebase by default. See
  119.      * branch.[name].rebase and branch.autosetuprebase.
  120.      *
  121.      * @param useRebase
  122.      *            whether to use rebase after fetching
  123.      * @return {@code this}
  124.      */
  125.     public PullCommand setRebase(boolean useRebase) {
  126.         checkCallable();
  127.         pullRebaseMode = useRebase ? BranchRebaseMode.REBASE
  128.                 : BranchRebaseMode.NONE;
  129.         return this;
  130.     }

  132.     /**
  133.      * Sets the {@link org.eclipse.jgit.lib.BranchConfig.BranchRebaseMode} to
  134.      * use after fetching.
  135.      *
  136.      * <dl>
  137.      * <dt>BranchRebaseMode.REBASE</dt>
  138.      * <dd>Equivalent to {@code --rebase} on the command line: use rebase
  139.      * instead of merge after fetching.</dd>
  140.      * <dt>BranchRebaseMode.PRESERVE</dt>
  141.      * <dd>Equivalent to {@code --preserve-merges} on the command line: rebase
  142.      * preserving local merge commits.</dd>
  143.      * <dt>BranchRebaseMode.INTERACTIVE</dt>
  144.      * <dd>Equivalent to {@code --interactive} on the command line: use
  145.      * interactive rebase.</dd>
  146.      * <dt>BranchRebaseMode.NONE</dt>
  147.      * <dd>Equivalent to {@code --no-rebase}: merge instead of rebasing.
  148.      * <dt>{@code null}</dt>
  149.      * <dd>Use the setting defined in the git configuration, either {@code
  150.      * branch.[name].rebase} or, if not set, {@code pull.rebase}</dd>
  151.      * </dl>
  152.      *
  153.      * This setting overrides the settings in the configuration file. By
  154.      * default, the setting in the repository configuration file is used.
  155.      * <p>
  156.      * A branch can be configured to use rebase by default. See
  157.      * {@code branch.[name].rebase}, {@code branch.autosetuprebase}, and
  158.      * {@code pull.rebase}.
  159.      *
  160.      * @param rebaseMode
  161.      *            the {@link org.eclipse.jgit.lib.BranchConfig.BranchRebaseMode}
  162.      *            to use
  163.      * @return {@code this}
  164.      * @since 4.5
  165.      */
  166.     public PullCommand setRebase(BranchRebaseMode rebaseMode) {
  167.         checkCallable();
  168.         pullRebaseMode = rebaseMode;
  169.         return this;
  170.     }

  172.     /**
  173.      * {@inheritDoc}
  174.      * <p>
  175.      * Execute the {@code Pull} command with all the options and parameters
  176.      * collected by the setter methods (e.g.
  177.      * {@link #setProgressMonitor(ProgressMonitor)}) of this class. Each
  178.      * instance of this class should only be used for one invocation of the
  179.      * command. Don't call this method twice on an instance.
  180.      */
  181.     @Override
  182.     public PullResult call() throws GitAPIException,
  183.             WrongRepositoryStateException, InvalidConfigurationException,
  184.             InvalidRemoteException, CanceledException,
  185.             RefNotFoundException, RefNotAdvertisedException, NoHeadException,
  186.             org.eclipse.jgit.api.errors.TransportException {
  187.         checkCallable();

  189.         monitor.beginTask(JGitText.get().pullTaskName, 2);
  190.         Config repoConfig = repo.getConfig();

  192.         String branchName = null;
  193.         try {
  194.             String fullBranch = repo.getFullBranch();
  195.             if (fullBranch != null
  196.                     && fullBranch.startsWith(Constants.R_HEADS)) {
  197.                 branchName = fullBranch.substring(Constants.R_HEADS.length());
  198.             }
  199.         } catch (IOException e) {
  200.             throw new JGitInternalException(
  201.                     JGitText.get().exceptionCaughtDuringExecutionOfPullCommand,
  202.                     e);
  203.         }
  204.         if (remoteBranchName == null && branchName != null) {
  205.             // get the name of the branch in the remote repository
  206.             // stored in configuration key branch.<branch name>.merge
  207.             remoteBranchName = repoConfig.getString(
  208.                     ConfigConstants.CONFIG_BRANCH_SECTION, branchName,
  209.                     ConfigConstants.CONFIG_KEY_MERGE);
  210.         }
  211.         if (remoteBranchName == null) {
  212.             remoteBranchName = branchName;
  213.         }
  214.         if (remoteBranchName == null) {
  215.             throw new NoHeadException(
  216.                     JGitText.get().cannotCheckoutFromUnbornBranch);
  217.         }

  219.         if (!repo.getRepositoryState().equals(RepositoryState.SAFE))
  220.             throw new WrongRepositoryStateException(MessageFormat.format(
  221.                     JGitText.get().cannotPullOnARepoWithState, repo
  222.                             .getRepositoryState().name()));

  224.         if (remote == null && branchName != null) {
  225.             // get the configured remote for the currently checked out branch
  226.             // stored in configuration key branch.<branch name>.remote
  227.             remote = repoConfig.getString(
  228.                     ConfigConstants.CONFIG_BRANCH_SECTION, branchName,
  229.                     ConfigConstants.CONFIG_KEY_REMOTE);
  230.         }
  231.         if (remote == null) {
  232.             // fall back to default remote
  233.             remote = Constants.DEFAULT_REMOTE_NAME;
  234.         }

  236.         // determines whether rebase should be used after fetching
  237.         if (pullRebaseMode == null && branchName != null) {
  238.             pullRebaseMode = getRebaseMode(branchName, repoConfig);
  239.         }


  242.         final boolean isRemote = !remote.equals("."); //$NON-NLS-1$
  243.         String remoteUri;
  244.         FetchResult fetchRes;
  245.         if (isRemote) {
  246.             remoteUri = repoConfig.getString(
  247.                     ConfigConstants.CONFIG_REMOTE_SECTION, remote,
  248.                     ConfigConstants.CONFIG_KEY_URL);
  249.             if (remoteUri == null) {
  250.                 String missingKey = ConfigConstants.CONFIG_REMOTE_SECTION + DOT
  251.                         + remote + DOT + ConfigConstants.CONFIG_KEY_URL;
  252.                 throw new InvalidConfigurationException(MessageFormat.format(
  253.                         JGitText.get().missingConfigurationForKey, missingKey));
  254.             }

  256.             if (monitor.isCancelled())
  257.                 throw new CanceledException(MessageFormat.format(
  258.                         JGitText.get().operationCanceled,
  259.                         JGitText.get().pullTaskName));

  261.             FetchCommand fetch = new FetchCommand(repo).setRemote(remote)
  262.                     .setProgressMonitor(monitor).setTagOpt(tagOption)
  263.                     .setRecurseSubmodules(submoduleRecurseMode);
  264.             configure(fetch);

  266.             fetchRes = fetch.call();
  267.         } else {
  268.             // we can skip the fetch altogether
  269.             remoteUri = JGitText.get().localRepository;
  270.             fetchRes = null;
  271.         }

  273.         monitor.update(1);

  275.         if (monitor.isCancelled())
  276.             throw new CanceledException(MessageFormat.format(
  277.                     JGitText.get().operationCanceled,
  278.                     JGitText.get().pullTaskName));

  280.         // we check the updates to see which of the updated branches
  281.         // corresponds to the remote branch name
  282.         AnyObjectId commitToMerge;
  283.         if (isRemote) {
  284.             Ref r = null;
  285.             if (fetchRes != null) {
  286.                 r = fetchRes.getAdvertisedRef(remoteBranchName);
  287.                 if (r == null) {
  288.                     r = fetchRes.getAdvertisedRef(Constants.R_HEADS
  289.                             + remoteBranchName);
  290.                 }
  291.             }
  292.             if (r == null) {
  293.                 throw new RefNotAdvertisedException(MessageFormat.format(
  294.                         JGitText.get().couldNotGetAdvertisedRef, remote,
  295.                         remoteBranchName));
  296.             }
  297.             commitToMerge = r.getObjectId();
  298.         } else {
  299.             try {
  300.                 commitToMerge = repo.resolve(remoteBranchName);
  301.                 if (commitToMerge == null) {
  302.                     throw new RefNotFoundException(MessageFormat.format(
  303.                             JGitText.get().refNotResolved, remoteBranchName));
  304.                 }
  305.             } catch (IOException e) {
  306.                 throw new JGitInternalException(
  307.                         JGitText.get().exceptionCaughtDuringExecutionOfPullCommand,
  308.                         e);
  309.             }
  310.         }

  312.         String upstreamName = MessageFormat.format(
  313.                 JGitText.get().upstreamBranchName,
  314.                 Repository.shortenRefName(remoteBranchName), remoteUri);

  316.         PullResult result;
  317.         if (pullRebaseMode != BranchRebaseMode.NONE) {
  318.             try {
  319.                 Ref head = repo.exactRef(Constants.HEAD);
  320.                 if (head == null) {
  321.                     throw new NoHeadException(JGitText
  322.                             .get().commitOnRepoWithoutHEADCurrentlyNotSupported);
  323.                 }
  324.                 ObjectId headId = head.getObjectId();
  325.                 if (headId == null) {
  326.                     // Pull on an unborn branch: checkout
  327.                     try (RevWalk revWalk = new RevWalk(repo)) {
  328.                         RevCommit srcCommit = revWalk
  329.                                 .parseCommit(commitToMerge);
  330.                         DirCacheCheckout dco = new DirCacheCheckout(repo,
  331.                                 repo.lockDirCache(), srcCommit.getTree());
  332.                         dco.setFailOnConflict(true);
  333.                         dco.setProgressMonitor(monitor);
  334.                         dco.checkout();
  335.                         RefUpdate refUpdate = repo
  336.                                 .updateRef(head.getTarget().getName());
  337.                         refUpdate.setNewObjectId(commitToMerge);
  338.                         refUpdate.setExpectedOldObjectId(null);
  339.                         refUpdate.setRefLogMessage("initial pull", false); //$NON-NLS-1$
  340.                         if (refUpdate.update() != Result.NEW) {
  341.                             throw new NoHeadException(JGitText
  342.                                     .get().commitOnRepoWithoutHEADCurrentlyNotSupported);
  343.                         }
  344.                         monitor.endTask();
  345.                         return new PullResult(fetchRes, remote,
  346.                                 RebaseResult.result(
  347.                                         RebaseResult.Status.FAST_FORWARD,
  348.                                         srcCommit));
  349.                     }
  350.                 }
  351.             } catch (NoHeadException e) {
  352.                 throw e;
  353.             } catch (IOException e) {
  354.                 throw new JGitInternalException(JGitText
  355.                         .get().exceptionCaughtDuringExecutionOfPullCommand, e);
  356.             }
  357.             RebaseCommand rebase = new RebaseCommand(repo);
  358.             RebaseResult rebaseRes = rebase.setUpstream(commitToMerge)
  359.                     .setProgressMonitor(monitor)
  360.                     .setUpstreamName(upstreamName)
  361.                     .setOperation(Operation.BEGIN)
  362.                     .setStrategy(strategy)
  363.                     .setContentMergeStrategy(contentStrategy)
  364.                     .setPreserveMerges(
  365.                             pullRebaseMode == BranchRebaseMode.PRESERVE)
  366.                     .call();
  367.             result = new PullResult(fetchRes, remote, rebaseRes);
  368.         } else {
  369.             MergeCommand merge = new MergeCommand(repo);
  370.             MergeResult mergeRes = merge.include(upstreamName, commitToMerge)
  371.                     .setProgressMonitor(monitor)
  372.                     .setStrategy(strategy)
  373.                     .setContentMergeStrategy(contentStrategy)
  374.                     .setFastForward(getFastForwardMode()).call();
  375.             monitor.update(1);
  376.             result = new PullResult(fetchRes, remote, mergeRes);
  377.         }
  378.         monitor.endTask();
  379.         return result;
  380.     }

  382.     /**
  383.      * The remote (uri or name) to be used for the pull operation. If no remote
  384.      * is set, the branch's configuration will be used. If the branch
  385.      * configuration is missing the default value of
  386.      * <code>Constants.DEFAULT_REMOTE_NAME</code> will be used.
  387.      *
  388.      * @see Constants#DEFAULT_REMOTE_NAME
  389.      * @param remote
  390.      *            name of the remote to pull from
  391.      * @return {@code this}
  392.      * @since 3.3
  393.      */
  394.     public PullCommand setRemote(String remote) {
  395.         checkCallable();
  396.         this.remote = remote;
  397.         return this;
  398.     }

  400.     /**
  401.      * The remote branch name to be used for the pull operation. If no
  402.      * remoteBranchName is set, the branch's configuration will be used. If the
  403.      * branch configuration is missing the remote branch with the same name as
  404.      * the current branch is used.
  405.      *
  406.      * @param remoteBranchName
  407.      *            remote branch name to be used for pull operation
  408.      * @return {@code this}
  409.      * @since 3.3
  410.      */
  411.     public PullCommand setRemoteBranchName(String remoteBranchName) {
  412.         checkCallable();
  413.         this.remoteBranchName = remoteBranchName;
  414.         return this;
  415.     }

  417.     /**
  418.      * Get the remote name used for pull operation
  419.      *
  420.      * @return the remote used for the pull operation if it was set explicitly
  421.      * @since 3.3
  422.      */
  423.     public String getRemote() {
  424.         return remote;
  425.     }

  427.     /**
  428.      * Get the remote branch name for the pull operation
  429.      *
  430.      * @return the remote branch name used for the pull operation if it was set
  431.      *         explicitly
  432.      * @since 3.3
  433.      */
  434.     public String getRemoteBranchName() {
  435.         return remoteBranchName;
  436.     }

  438.     /**
  439.      * Set the @{code MergeStrategy}
  440.      *
  441.      * @param strategy
  442.      *            The merge strategy to use during this pull operation.
  443.      * @return {@code this}
  444.      * @since 3.4
  445.      */
  446.     public PullCommand setStrategy(MergeStrategy strategy) {
  447.         this.strategy = strategy;
  448.         return this;
  449.     }

  451.     /**
  452.      * Sets the content merge strategy to use if the
  453.      * {@link #setStrategy(MergeStrategy) merge strategy} is "resolve" or
  454.      * "recursive".
  455.      *
  456.      * @param strategy
  457.      *            the {@link ContentMergeStrategy} to be used
  458.      * @return {@code this}
  459.      * @since 5.12
  460.      */
  461.     public PullCommand setContentMergeStrategy(ContentMergeStrategy strategy) {
  462.         this.contentStrategy = strategy;
  463.         return this;
  464.     }

  466.     /**
  467.      * Set the specification of annotated tag behavior during fetch
  468.      *
  469.      * @param tagOpt
  470.      *            the {@link org.eclipse.jgit.transport.TagOpt}
  471.      * @return {@code this}
  472.      * @since 4.7
  473.      */
  474.     public PullCommand setTagOpt(TagOpt tagOpt) {
  475.         checkCallable();
  476.         this.tagOption = tagOpt;
  477.         return this;
  478.     }

  480.     /**
  481.      * Set the fast forward mode. It is used if pull is configured to do a merge
  482.      * as opposed to rebase. If non-{@code null} takes precedence over the
  483.      * fast-forward mode configured in git config.
  484.      *
  485.      * @param fastForwardMode
  486.      *            corresponds to the --ff/--no-ff/--ff-only options. If
  487.      *            {@code null} use the value of {@code pull.ff} configured in
  488.      *            git config. If {@code pull.ff} is not configured fall back to
  489.      *            the value of {@code merge.ff}. If {@code merge.ff} is not
  490.      *            configured --ff is the built-in default.
  491.      * @return {@code this}
  492.      * @since 4.9
  493.      */
  494.     public PullCommand setFastForward(
  495.             @Nullable FastForwardMode fastForwardMode) {
  496.         checkCallable();
  497.         this.fastForwardMode = fastForwardMode;
  498.         return this;
  499.     }

  501.     /**
  502.      * Set the mode to be used for recursing into submodules.
  503.      *
  504.      * @param recurse
  505.      *            the
  506.      *            {@link org.eclipse.jgit.lib.SubmoduleConfig.FetchRecurseSubmodulesMode}
  507.      *            to be used for recursing into submodules
  508.      * @return {@code this}
  509.      * @since 4.7
  510.      * @see FetchCommand#setRecurseSubmodules(FetchRecurseSubmodulesMode)
  511.      */
  512.     public PullCommand setRecurseSubmodules(
  513.             @Nullable FetchRecurseSubmodulesMode recurse) {
  514.         this.submoduleRecurseMode = recurse;
  515.         return this;
  516.     }

  518.     /**
  519.      * Reads the rebase mode to use for a pull command from the repository
  520.      * configuration. This is the value defined for the configurations
  521.      * {@code branch.[branchName].rebase}, or,if not set, {@code pull.rebase}.
  522.      * If neither is set, yields
  523.      * {@link org.eclipse.jgit.lib.BranchConfig.BranchRebaseMode#NONE}.
  524.      *
  525.      * @param branchName
  526.      *            name of the local branch
  527.      * @param config
  528.      *            the {@link org.eclipse.jgit.lib.Config} to read the value from
  529.      * @return the {@link org.eclipse.jgit.lib.BranchConfig.BranchRebaseMode}
  530.      * @since 4.5
  531.      */
  532.     public static BranchRebaseMode getRebaseMode(String branchName,
  533.             Config config) {
  534.         BranchRebaseMode mode = config.getEnum(BranchRebaseMode.values(),
  535.                 ConfigConstants.CONFIG_BRANCH_SECTION,
  536.                 branchName, ConfigConstants.CONFIG_KEY_REBASE, null);
  537.         if (mode == null) {
  538.             mode = config.getEnum(BranchRebaseMode.values(),
  539.                     ConfigConstants.CONFIG_PULL_SECTION, null,
  540.                     ConfigConstants.CONFIG_KEY_REBASE, BranchRebaseMode.NONE);
  541.         }
  542.         return mode;
  543.     }

  545.     private FastForwardMode getFastForwardMode() {
  546.         if (fastForwardMode != null) {
  547.             return fastForwardMode;
  548.         }
  549.         Config config = repo.getConfig();
  550.         Merge ffMode = config.getEnum(Merge.values(),
  551.                 ConfigConstants.CONFIG_PULL_SECTION, null,
  552.                 ConfigConstants.CONFIG_KEY_FF, null);
  553.         return ffMode != null ? FastForwardMode.valueOf(ffMode) : null;
  554.     }
  555. }
Created with JaCoCo 0.8.7.202105040129