CloneCommand.java

  1. /*
  2.  * Copyright (C) 2011, 2022 Chris Aniszczyk <caniszczyk@gmail.com> and others
  3.  *
  4.  * This program and the accompanying materials are made available under the
  5.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  6.  * https://www.eclipse.org/org/documents/edl-v10.php.
  7.  *
  8.  * SPDX-License-Identifier: BSD-3-Clause
  9.  */
  10. package org.eclipse.jgit.api;

  12. import java.io.File;
  13. import java.io.IOException;
  14. import java.net.URISyntaxException;
  15. import java.text.MessageFormat;
  16. import java.time.Instant;
  17. import java.time.OffsetDateTime;
  18. import java.util.ArrayList;
  19. import java.util.Collection;
  20. import java.util.List;

  22. import org.eclipse.jgit.annotations.NonNull;
  23. import org.eclipse.jgit.annotations.Nullable;
  24. import org.eclipse.jgit.api.errors.GitAPIException;
  25. import org.eclipse.jgit.api.errors.InvalidRemoteException;
  26. import org.eclipse.jgit.api.errors.JGitInternalException;
  27. import org.eclipse.jgit.dircache.DirCache;
  28. import org.eclipse.jgit.dircache.DirCacheCheckout;
  29. import org.eclipse.jgit.errors.IncorrectObjectTypeException;
  30. import org.eclipse.jgit.errors.MissingObjectException;
  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.ConfigConstants;
  35. import org.eclipse.jgit.lib.Constants;
  36. import org.eclipse.jgit.lib.NullProgressMonitor;
  37. import org.eclipse.jgit.lib.ObjectId;
  38. import org.eclipse.jgit.lib.ProgressMonitor;
  39. import org.eclipse.jgit.lib.Ref;
  40. import org.eclipse.jgit.lib.RefUpdate;
  41. import org.eclipse.jgit.lib.Repository;
  42. import org.eclipse.jgit.revwalk.RevCommit;
  43. import org.eclipse.jgit.revwalk.RevWalk;
  44. import org.eclipse.jgit.submodule.SubmoduleWalk;
  45. import org.eclipse.jgit.transport.FetchResult;
  46. import org.eclipse.jgit.transport.RefSpec;
  47. import org.eclipse.jgit.transport.RemoteConfig;
  48. import org.eclipse.jgit.transport.TagOpt;
  49. import org.eclipse.jgit.transport.URIish;
  50. import org.eclipse.jgit.util.FS;
  51. import org.eclipse.jgit.util.FileUtils;

  53. /**
  54.  * Clone a repository into a new working directory
  55.  *
  56.  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-clone.html"
  57.  *      >Git documentation about Clone</a>
  58.  */
  59. public class CloneCommand extends TransportCommand<CloneCommand, Git> {

  61.     private String uri;

  63.     private File directory;

  65.     private File gitDir;

  67.     private boolean bare;

  69.     private FS fs;

  71.     private String remote = Constants.DEFAULT_REMOTE_NAME;

  73.     private String branch = Constants.HEAD;

  75.     private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;

  77.     private boolean cloneAllBranches;

  79.     private boolean mirror;

  81.     private boolean cloneSubmodules;

  83.     private boolean noCheckout;

  85.     private Collection<String> branchesToClone;

  87.     private Callback callback;

  89.     private boolean directoryExistsInitially;

  91.     private boolean gitDirExistsInitially;

  93.     private FETCH_TYPE fetchType;

  95.     private TagOpt tagOption;

  97.     private Integer depth;

  99.     private Instant shallowSince;

  101.     private List<String> shallowExcludes = new ArrayList<>();

  103.     private enum FETCH_TYPE {
  104.         MULTIPLE_BRANCHES, ALL_BRANCHES, MIRROR
  105.     }

  107.     /**
  108.      * Callback for status of clone operation.
  109.      *
  110.      * @since 4.8
  111.      */
  112.     public interface Callback {
  113.         /**
  114.          * Notify initialized submodules.
  115.          *
  116.          * @param submodules
  117.          *            the submodules
  118.          *
  119.          */
  120.         void initializedSubmodules(Collection<String> submodules);

  122.         /**
  123.          * Notify starting to clone a submodule.
  124.          *
  125.          * @param path
  126.          *            the submodule path
  127.          */
  128.         void cloningSubmodule(String path);

  130.         /**
  131.          * Notify checkout of commit
  132.          *
  133.          * @param commit
  134.          *            the id of the commit being checked out
  135.          * @param path
  136.          *            the submodule path
  137.          */
  138.         void checkingOut(AnyObjectId commit, String path);
  139.     }

  141.     /**
  142.      * Create clone command with no repository set
  143.      */
  144.     public CloneCommand() {
  145.         super(null);
  146.     }

  148.     /**
  149.      * Get the git directory. This is primarily used for tests.
  150.      *
  151.      * @return the git directory
  152.      */
  153.     @Nullable
  154.     File getDirectory() {
  155.         return directory;
  156.     }

  158.     /**
  159.      * {@inheritDoc}
  160.      * <p>
  161.      * Executes the {@code Clone} command.
  162.      *
  163.      * The Git instance returned by this command needs to be closed by the
  164.      * caller to free resources held by the underlying {@link Repository}
  165.      * instance. It is recommended to call this method as soon as you don't need
  166.      * a reference to this {@link Git} instance and the underlying
  167.      * {@link Repository} instance anymore.
  168.      */
  169.     @Override
  170.     public Git call() throws GitAPIException, InvalidRemoteException,
  171.             org.eclipse.jgit.api.errors.TransportException {
  172.         URIish u = null;
  173.         try {
  174.             u = new URIish(uri);
  175.             verifyDirectories(u);
  176.         } catch (URISyntaxException e) {
  177.             throw new InvalidRemoteException(
  178.                     MessageFormat.format(JGitText.get().invalidURL, uri), e);
  179.         }
  180.         setFetchType();
  181.         @SuppressWarnings("resource") // Closed by caller
  182.         Repository repository = init();
  183.         FetchResult fetchResult = null;
  184.         Thread cleanupHook = new Thread(() -> cleanup());
  185.         try {
  186.             Runtime.getRuntime().addShutdownHook(cleanupHook);
  187.         } catch (IllegalStateException e) {
  188.             // ignore - the VM is already shutting down
  189.         }
  190.         try {
  191.             fetchResult = fetch(repository, u);
  192.         } catch (IOException ioe) {
  193.             if (repository != null) {
  194.                 repository.close();
  195.             }
  196.             cleanup();
  197.             throw new JGitInternalException(ioe.getMessage(), ioe);
  198.         } catch (URISyntaxException e) {
  199.             if (repository != null) {
  200.                 repository.close();
  201.             }
  202.             cleanup();
  203.             throw new InvalidRemoteException(
  204.                     MessageFormat.format(JGitText.get().invalidRemote, remote),
  205.                     e);
  206.         } catch (GitAPIException | RuntimeException e) {
  207.             if (repository != null) {
  208.                 repository.close();
  209.             }
  210.             cleanup();
  211.             throw e;
  212.         } finally {
  213.             try {
  214.                 Runtime.getRuntime().removeShutdownHook(cleanupHook);
  215.             } catch (IllegalStateException e) {
  216.                 // ignore - the VM is already shutting down
  217.             }
  218.         }
  219.         try {
  220.             checkout(repository, fetchResult);
  221.         } catch (IOException ioe) {
  222.             repository.close();
  223.             throw new JGitInternalException(ioe.getMessage(), ioe);
  224.         } catch (GitAPIException | RuntimeException e) {
  225.             repository.close();
  226.             throw e;
  227.         }
  228.         return new Git(repository, true);
  229.     }

  231.     private void setFetchType() {
  232.         if (mirror) {
  233.             fetchType = FETCH_TYPE.MIRROR;
  234.             setBare(true);
  235.         } else if (cloneAllBranches) {
  236.             fetchType = FETCH_TYPE.ALL_BRANCHES;
  237.         } else if (branchesToClone != null && !branchesToClone.isEmpty()) {
  238.             fetchType = FETCH_TYPE.MULTIPLE_BRANCHES;
  239.         } else {
  240.             // Default: neither mirror nor all nor specific refs given
  241.             fetchType = FETCH_TYPE.ALL_BRANCHES;
  242.         }
  243.     }

  245.     private static boolean isNonEmptyDirectory(File dir) {
  246.         if (dir != null && dir.exists()) {
  247.             File[] files = dir.listFiles();
  248.             return files != null && files.length != 0;
  249.         }
  250.         return false;
  251.     }

  253.     void verifyDirectories(URIish u) {
  254.         if (directory == null && gitDir == null) {
  255.             directory = new File(u.getHumanishName() + (bare ? Constants.DOT_GIT_EXT : "")); //$NON-NLS-1$
  256.         }
  257.         directoryExistsInitially = directory != null && directory.exists();
  258.         gitDirExistsInitially = gitDir != null && gitDir.exists();
  259.         validateDirs(directory, gitDir, bare);
  260.         if (isNonEmptyDirectory(directory)) {
  261.             throw new JGitInternalException(MessageFormat.format(
  262.                     JGitText.get().cloneNonEmptyDirectory, directory.getName()));
  263.         }
  264.         if (isNonEmptyDirectory(gitDir)) {
  265.             throw new JGitInternalException(MessageFormat.format(
  266.                     JGitText.get().cloneNonEmptyDirectory, gitDir.getName()));
  267.         }
  268.     }

  270.     private Repository init() throws GitAPIException {
  271.         InitCommand command = Git.init();
  272.         command.setBare(bare);
  273.         if (fs != null) {
  274.             command.setFs(fs);
  275.         }
  276.         if (directory != null) {
  277.             command.setDirectory(directory);
  278.         }
  279.         if (gitDir != null) {
  280.             command.setGitDir(gitDir);
  281.         }
  282.         return command.call().getRepository();
  283.     }

  285.     private FetchResult fetch(Repository clonedRepo, URIish u)
  286.             throws URISyntaxException,
  287.             org.eclipse.jgit.api.errors.TransportException, IOException,
  288.             GitAPIException {
  289.         // create the remote config and save it
  290.         RemoteConfig config = new RemoteConfig(clonedRepo.getConfig(), remote);
  291.         config.addURI(u);

  293.         boolean fetchAll = fetchType == FETCH_TYPE.ALL_BRANCHES
  294.                 || fetchType == FETCH_TYPE.MIRROR;

  296.         config.setFetchRefSpecs(calculateRefSpecs(fetchType, config.getName()));
  297.         config.setMirror(fetchType == FETCH_TYPE.MIRROR);
  298.         if (tagOption != null) {
  299.             config.setTagOpt(tagOption);
  300.         }
  301.         config.update(clonedRepo.getConfig());

  303.         clonedRepo.getConfig().save();

  305.         // run the fetch command
  306.         FetchCommand command = new FetchCommand(clonedRepo);
  307.         command.setRemote(remote);
  308.         command.setProgressMonitor(monitor);
  309.         if (tagOption != null) {
  310.             command.setTagOpt(tagOption);
  311.         } else {
  312.             command.setTagOpt(
  313.                     fetchAll ? TagOpt.FETCH_TAGS : TagOpt.AUTO_FOLLOW);
  314.         }
  315.         command.setInitialBranch(branch);
  316.         if (depth != null) {
  317.             command.setDepth(depth.intValue());
  318.         }
  319.         if (shallowSince != null) {
  320.             command.setShallowSince(shallowSince);
  321.         }
  322.         command.setShallowExcludes(shallowExcludes);
  323.         configure(command);

  325.         return command.call();
  326.     }

  328.     private List<RefSpec> calculateRefSpecs(FETCH_TYPE type,
  329.             String remoteName) {
  330.         List<RefSpec> specs = new ArrayList<>();
  331.         if (type == FETCH_TYPE.MIRROR) {
  332.             specs.add(new RefSpec().setForceUpdate(true).setSourceDestination(
  333.                     Constants.R_REFS + '*', Constants.R_REFS + '*'));
  334.         } else {
  335.             RefSpec heads = new RefSpec();
  336.             heads = heads.setForceUpdate(true);
  337.             final String dst = (bare ? Constants.R_HEADS
  338.                     : Constants.R_REMOTES + remoteName + '/') + '*';
  339.             heads = heads.setSourceDestination(Constants.R_HEADS + '*', dst);
  340.             if (type == FETCH_TYPE.MULTIPLE_BRANCHES) {
  341.                 RefSpec tags = new RefSpec().setForceUpdate(true)
  342.                         .setSourceDestination(Constants.R_TAGS + '*',
  343.                                 Constants.R_TAGS + '*');
  344.                 for (String selectedRef : branchesToClone) {
  345.                     if (heads.matchSource(selectedRef)) {
  346.                         specs.add(heads.expandFromSource(selectedRef));
  347.                     } else if (tags.matchSource(selectedRef)) {
  348.                         specs.add(tags.expandFromSource(selectedRef));
  349.                     }
  350.                 }
  351.             } else {
  352.                 // We'll fetch the tags anyway.
  353.                 specs.add(heads);
  354.             }
  355.         }
  356.         return specs;
  357.     }

  359.     private void checkout(Repository clonedRepo, FetchResult result)
  360.             throws MissingObjectException, IncorrectObjectTypeException,
  361.             IOException, GitAPIException {

  363.         Ref head = null;
  364.         if (branch.equals(Constants.HEAD)) {
  365.             Ref foundBranch = findBranchToCheckout(result);
  366.             if (foundBranch != null)
  367.                 head = foundBranch;
  368.         }
  369.         if (head == null) {
  370.             head = result.getAdvertisedRef(branch);
  371.             if (head == null)
  372.                 head = result.getAdvertisedRef(Constants.R_HEADS + branch);
  373.             if (head == null)
  374.                 head = result.getAdvertisedRef(Constants.R_TAGS + branch);
  375.         }

  377.         if (head == null || head.getObjectId() == null)
  378.             return; // TODO throw exception?

  380.         if (head.getName().startsWith(Constants.R_HEADS)) {
  381.             final RefUpdate newHead = clonedRepo.updateRef(Constants.HEAD);
  382.             newHead.disableRefLog();
  383.             newHead.link(head.getName());
  384.             addMergeConfig(clonedRepo, head);
  385.         }

  387.         final RevCommit commit = parseCommit(clonedRepo, head);

  389.         boolean detached = !head.getName().startsWith(Constants.R_HEADS);
  390.         RefUpdate u = clonedRepo.updateRef(Constants.HEAD, detached);
  391.         u.setNewObjectId(commit.getId());
  392.         u.forceUpdate();

  394.         if (!bare && !noCheckout) {
  395.             DirCache dc = clonedRepo.lockDirCache();
  396.             DirCacheCheckout co = new DirCacheCheckout(clonedRepo, dc,
  397.                     commit.getTree());
  398.             co.setProgressMonitor(monitor);
  399.             co.checkout();
  400.             if (cloneSubmodules)
  401.                 cloneSubmodules(clonedRepo);
  402.         }
  403.     }

  405.     private void cloneSubmodules(Repository clonedRepo) throws IOException,
  406.             GitAPIException {
  407.         SubmoduleInitCommand init = new SubmoduleInitCommand(clonedRepo);
  408.         Collection<String> submodules = init.call();
  409.         if (submodules.isEmpty()) {
  410.             return;
  411.         }
  412.         if (callback != null) {
  413.             callback.initializedSubmodules(submodules);
  414.         }

  416.         SubmoduleUpdateCommand update = new SubmoduleUpdateCommand(clonedRepo);
  417.         configure(update);
  418.         update.setProgressMonitor(monitor);
  419.         update.setCallback(callback);
  420.         if (!update.call().isEmpty()) {
  421.             SubmoduleWalk walk = SubmoduleWalk.forIndex(clonedRepo);
  422.             while (walk.next()) {
  423.                 try (Repository subRepo = walk.getRepository()) {
  424.                     if (subRepo != null) {
  425.                         cloneSubmodules(subRepo);
  426.                     }
  427.                 }
  428.             }
  429.         }
  430.     }

  432.     private Ref findBranchToCheckout(FetchResult result) {
  433.         final Ref idHEAD = result.getAdvertisedRef(Constants.HEAD);
  434.         ObjectId headId = idHEAD != null ? idHEAD.getObjectId() : null;
  435.         if (headId == null) {
  436.             return null;
  437.         }

  439.         if (idHEAD != null && idHEAD.isSymbolic()) {
  440.             return idHEAD.getTarget();
  441.         }

  443.         Ref master = result.getAdvertisedRef(Constants.R_HEADS
  444.                 + Constants.MASTER);
  445.         ObjectId objectId = master != null ? master.getObjectId() : null;
  446.         if (headId.equals(objectId)) {
  447.             return master;
  448.         }

  450.         Ref foundBranch = null;
  451.         for (Ref r : result.getAdvertisedRefs()) {
  452.             final String n = r.getName();
  453.             if (!n.startsWith(Constants.R_HEADS))
  454.                 continue;
  455.             if (headId.equals(r.getObjectId())) {
  456.                 foundBranch = r;
  457.                 break;
  458.             }
  459.         }
  460.         return foundBranch;
  461.     }

  463.     private void addMergeConfig(Repository clonedRepo, Ref head)
  464.             throws IOException {
  465.         String branchName = Repository.shortenRefName(head.getName());
  466.         clonedRepo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
  467.                 branchName, ConfigConstants.CONFIG_KEY_REMOTE, remote);
  468.         clonedRepo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
  469.                 branchName, ConfigConstants.CONFIG_KEY_MERGE, head.getName());
  470.         String autosetupRebase = clonedRepo.getConfig().getString(
  471.                 ConfigConstants.CONFIG_BRANCH_SECTION, null,
  472.                 ConfigConstants.CONFIG_KEY_AUTOSETUPREBASE);
  473.         if (ConfigConstants.CONFIG_KEY_ALWAYS.equals(autosetupRebase)
  474.                 || ConfigConstants.CONFIG_KEY_REMOTE.equals(autosetupRebase))
  475.             clonedRepo.getConfig().setEnum(
  476.                     ConfigConstants.CONFIG_BRANCH_SECTION, branchName,
  477.                     ConfigConstants.CONFIG_KEY_REBASE, BranchRebaseMode.REBASE);
  478.         clonedRepo.getConfig().save();
  479.     }

  481.     private RevCommit parseCommit(Repository clonedRepo, Ref ref)
  482.             throws MissingObjectException, IncorrectObjectTypeException,
  483.             IOException {
  484.         final RevCommit commit;
  485.         try (RevWalk rw = new RevWalk(clonedRepo)) {
  486.             commit = rw.parseCommit(ref.getObjectId());
  487.         }
  488.         return commit;
  489.     }

  491.     /**
  492.      * Set the URI to clone from
  493.      *
  494.      * @param uri
  495.      *            the URI to clone from, or {@code null} to unset the URI. The
  496.      *            URI must be set before {@link #call} is called.
  497.      * @return this instance
  498.      */
  499.     public CloneCommand setURI(String uri) {
  500.         this.uri = uri;
  501.         return this;
  502.     }

  504.     /**
  505.      * The optional directory associated with the clone operation. If the
  506.      * directory isn't set, a name associated with the source uri will be used.
  507.      *
  508.      * @see URIish#getHumanishName()
  509.      * @param directory
  510.      *            the directory to clone to, or {@code null} if the directory
  511.      *            name should be taken from the source uri
  512.      * @return this instance
  513.      * @throws java.lang.IllegalStateException
  514.      *             if the combination of directory, gitDir and bare is illegal.
  515.      *             E.g. if for a non-bare repository directory and gitDir point
  516.      *             to the same directory of if for a bare repository both
  517.      *             directory and gitDir are specified
  518.      */
  519.     public CloneCommand setDirectory(File directory) {
  520.         validateDirs(directory, gitDir, bare);
  521.         this.directory = directory;
  522.         return this;
  523.     }

  525.     /**
  526.      * Set the repository meta directory (.git)
  527.      *
  528.      * @param gitDir
  529.      *            the repository meta directory, or {@code null} to choose one
  530.      *            automatically at clone time
  531.      * @return this instance
  532.      * @throws java.lang.IllegalStateException
  533.      *             if the combination of directory, gitDir and bare is illegal.
  534.      *             E.g. if for a non-bare repository directory and gitDir point
  535.      *             to the same directory of if for a bare repository both
  536.      *             directory and gitDir are specified
  537.      * @since 3.6
  538.      */
  539.     public CloneCommand setGitDir(File gitDir) {
  540.         validateDirs(directory, gitDir, bare);
  541.         this.gitDir = gitDir;
  542.         return this;
  543.     }

  545.     /**
  546.      * Set whether the cloned repository shall be bare
  547.      *
  548.      * @param bare
  549.      *            whether the cloned repository is bare or not
  550.      * @return this instance
  551.      * @throws java.lang.IllegalStateException
  552.      *             if the combination of directory, gitDir and bare is illegal.
  553.      *             E.g. if for a non-bare repository directory and gitDir point
  554.      *             to the same directory of if for a bare repository both
  555.      *             directory and gitDir are specified
  556.      */
  557.     public CloneCommand setBare(boolean bare) throws IllegalStateException {
  558.         validateDirs(directory, gitDir, bare);
  559.         this.bare = bare;
  560.         return this;
  561.     }

  563.     /**
  564.      * Set the file system abstraction to be used for repositories created by
  565.      * this command.
  566.      *
  567.      * @param fs
  568.      *            the abstraction.
  569.      * @return {@code this} (for chaining calls).
  570.      * @since 4.10
  571.      */
  572.     public CloneCommand setFs(FS fs) {
  573.         this.fs = fs;
  574.         return this;
  575.     }

  577.     /**
  578.      * The remote name used to keep track of the upstream repository for the
  579.      * clone operation. If no remote name is set, the default value of
  580.      * <code>Constants.DEFAULT_REMOTE_NAME</code> will be used.
  581.      *
  582.      * @see Constants#DEFAULT_REMOTE_NAME
  583.      * @param remote
  584.      *            name that keeps track of the upstream repository.
  585.      *            {@code null} means to use DEFAULT_REMOTE_NAME.
  586.      * @return this instance
  587.      */
  588.     public CloneCommand setRemote(String remote) {
  589.         if (remote == null) {
  590.             remote = Constants.DEFAULT_REMOTE_NAME;
  591.         }
  592.         this.remote = remote;
  593.         return this;
  594.     }

  596.     /**
  597.      * Set the initial branch
  598.      *
  599.      * @param branch
  600.      *            the initial branch to check out when cloning the repository.
  601.      *            Can be specified as ref name (<code>refs/heads/master</code>),
  602.      *            branch name (<code>master</code>) or tag name
  603.      *            (<code>v1.2.3</code>). The default is to use the branch
  604.      *            pointed to by the cloned repository's HEAD and can be
  605.      *            requested by passing {@code null} or <code>HEAD</code>.
  606.      * @return this instance
  607.      */
  608.     public CloneCommand setBranch(String branch) {
  609.         if (branch == null) {
  610.             branch = Constants.HEAD;
  611.         }
  612.         this.branch = branch;
  613.         return this;
  614.     }

  616.     /**
  617.      * The progress monitor associated with the clone operation. By default,
  618.      * this is set to <code>NullProgressMonitor</code>
  619.      *
  620.      * @see NullProgressMonitor
  621.      * @param monitor
  622.      *            a {@link org.eclipse.jgit.lib.ProgressMonitor}
  623.      * @return {@code this}
  624.      */
  625.     public CloneCommand setProgressMonitor(ProgressMonitor monitor) {
  626.         if (monitor == null) {
  627.             monitor = NullProgressMonitor.INSTANCE;
  628.         }
  629.         this.monitor = monitor;
  630.         return this;
  631.     }

  633.     /**
  634.      * Set whether all branches have to be fetched.
  635.      * <p>
  636.      * If {@code false}, use {@link #setBranchesToClone(Collection)} to define
  637.      * what will be cloned. If neither are set, all branches will be cloned.
  638.      * </p>
  639.      *
  640.      * @param cloneAllBranches
  641.      *            {@code true} when all branches have to be fetched (indicates
  642.      *            wildcard in created fetch refspec), {@code false} otherwise.
  643.      * @return {@code this}
  644.      */
  645.     public CloneCommand setCloneAllBranches(boolean cloneAllBranches) {
  646.         this.cloneAllBranches = cloneAllBranches;
  647.         return this;
  648.     }

  650.     /**
  651.      * Set up a mirror of the source repository. This implies that a bare
  652.      * repository will be created. Compared to {@link #setBare},
  653.      * {@code #setMirror} not only maps local branches of the source to local
  654.      * branches of the target, it maps all refs (including remote-tracking
  655.      * branches, notes etc.) and sets up a refspec configuration such that all
  656.      * these refs are overwritten by a git remote update in the target
  657.      * repository.
  658.      *
  659.      * @param mirror
  660.      *            whether to mirror all refs from the source repository
  661.      *
  662.      * @return {@code this}
  663.      * @since 5.6
  664.      */
  665.     public CloneCommand setMirror(boolean mirror) {
  666.         this.mirror = mirror;
  667.         return this;
  668.     }

  670.     /**
  671.      * Set whether to clone submodules
  672.      *
  673.      * @param cloneSubmodules
  674.      *            true to initialize and update submodules. Ignored when
  675.      *            {@link #setBare(boolean)} is set to true.
  676.      * @return {@code this}
  677.      */
  678.     public CloneCommand setCloneSubmodules(boolean cloneSubmodules) {
  679.         this.cloneSubmodules = cloneSubmodules;
  680.         return this;
  681.     }

  683.     /**
  684.      * Set the branches or tags to clone.
  685.      * <p>
  686.      * This is ignored if {@link #setCloneAllBranches(boolean)
  687.      * setCloneAllBranches(true)} or {@link #setMirror(boolean) setMirror(true)}
  688.      * is used. If {@code branchesToClone} is {@code null} or empty, it's also
  689.      * ignored.
  690.      * </p>
  691.      *
  692.      * @param branchesToClone
  693.      *            collection of branches to clone. Must be specified as full ref
  694.      *            names (e.g. {@code refs/heads/master} or
  695.      *            {@code refs/tags/v1.0.0}).
  696.      * @return {@code this}
  697.      */
  698.     public CloneCommand setBranchesToClone(Collection<String> branchesToClone) {
  699.         this.branchesToClone = branchesToClone;
  700.         return this;
  701.     }

  703.     /**
  704.      * Set the tag option used for the remote configuration explicitly.
  705.      *
  706.      * @param tagOption
  707.      *            tag option to be used for the remote config
  708.      * @return {@code this}
  709.      * @since 5.8
  710.      */
  711.     public CloneCommand setTagOption(TagOpt tagOption) {
  712.         this.tagOption = tagOption;
  713.         return this;
  714.     }

  716.     /**
  717.      * Set the --no-tags option. Tags are not cloned now and the remote
  718.      * configuration is initialized with the --no-tags option as well.
  719.      *
  720.      * @return {@code this}
  721.      * @since 5.8
  722.      */
  723.     public CloneCommand setNoTags() {
  724.         return setTagOption(TagOpt.NO_TAGS);
  725.     }

  727.     /**
  728.      * Set whether to skip checking out a branch
  729.      *
  730.      * @param noCheckout
  731.      *            if set to <code>true</code> no branch will be checked out
  732.      *            after the clone. This enhances performance of the clone
  733.      *            command when there is no need for a checked out branch.
  734.      * @return {@code this}
  735.      */
  736.     public CloneCommand setNoCheckout(boolean noCheckout) {
  737.         this.noCheckout = noCheckout;
  738.         return this;
  739.     }

  741.     /**
  742.      * Register a progress callback.
  743.      *
  744.      * @param callback
  745.      *            the callback
  746.      * @return {@code this}
  747.      * @since 4.8
  748.      */
  749.     public CloneCommand setCallback(Callback callback) {
  750.         this.callback = callback;
  751.         return this;
  752.     }

  754.     /**
  755.      * Creates a shallow clone with a history truncated to the specified number
  756.      * of commits.
  757.      *
  758.      * @param depth
  759.      *            the depth
  760.      * @return {@code this}
  761.      *
  762.      * @since 6.3
  763.      */
  764.     public CloneCommand setDepth(int depth) {
  765.         if (depth < 1) {
  766.             throw new IllegalArgumentException(JGitText.get().depthMustBeAt1);
  767.         }
  768.         this.depth = Integer.valueOf(depth);
  769.         return this;
  770.     }

  772.     /**
  773.      * Creates a shallow clone with a history after the specified time.
  774.      *
  775.      * @param shallowSince
  776.      *            the timestammp; must not be {@code null}
  777.      * @return {@code this}
  778.      *
  779.      * @since 6.3
  780.      */
  781.     public CloneCommand setShallowSince(@NonNull OffsetDateTime shallowSince) {
  782.         this.shallowSince = shallowSince.toInstant();
  783.         return this;
  784.     }

  786.     /**
  787.      * Creates a shallow clone with a history after the specified time.
  788.      *
  789.      * @param shallowSince
  790.      *            the timestammp; must not be {@code null}
  791.      * @return {@code this}
  792.      *
  793.      * @since 6.3
  794.      */
  795.     public CloneCommand setShallowSince(@NonNull Instant shallowSince) {
  796.         this.shallowSince = shallowSince;
  797.         return this;
  798.     }

  800.     /**
  801.      * Creates a shallow clone with a history, excluding commits reachable from
  802.      * a specified remote branch or tag.
  803.      *
  804.      * @param shallowExclude
  805.      *            the ref or commit; must not be {@code null}
  806.      * @return {@code this}
  807.      *
  808.      * @since 6.3
  809.      */
  810.     public CloneCommand addShallowExclude(@NonNull String shallowExclude) {
  811.         shallowExcludes.add(shallowExclude);
  812.         return this;
  813.     }

  815.     /**
  816.      * Creates a shallow clone with a history, excluding commits reachable from
  817.      * a specified remote branch or tag.
  818.      *
  819.      * @param shallowExclude
  820.      *            the commit; must not be {@code null}
  821.      * @return {@code this}
  822.      *
  823.      * @since 6.3
  824.      */
  825.     public CloneCommand addShallowExclude(@NonNull ObjectId shallowExclude) {
  826.         shallowExcludes.add(shallowExclude.name());
  827.         return this;
  828.     }

  830.     private static void validateDirs(File directory, File gitDir, boolean bare)
  831.             throws IllegalStateException {
  832.         if (directory != null) {
  833.             if (directory.exists() && !directory.isDirectory()) {
  834.                 throw new IllegalStateException(MessageFormat.format(
  835.                         JGitText.get().initFailedDirIsNoDirectory, directory));
  836.             }
  837.             if (gitDir != null && gitDir.exists() && !gitDir.isDirectory()) {
  838.                 throw new IllegalStateException(MessageFormat.format(
  839.                         JGitText.get().initFailedGitDirIsNoDirectory,
  840.                         gitDir));
  841.             }
  842.             if (bare) {
  843.                 if (gitDir != null && !gitDir.equals(directory))
  844.                     throw new IllegalStateException(MessageFormat.format(
  845.                             JGitText.get().initFailedBareRepoDifferentDirs,
  846.                             gitDir, directory));
  847.             } else {
  848.                 if (gitDir != null && gitDir.equals(directory))
  849.                     throw new IllegalStateException(MessageFormat.format(
  850.                             JGitText.get().initFailedNonBareRepoSameDirs,
  851.                             gitDir, directory));
  852.             }
  853.         }
  854.     }

  856.     private void cleanup() {
  857.         try {
  858.             if (directory != null) {
  859.                 if (!directoryExistsInitially) {
  860.                     FileUtils.delete(directory, FileUtils.RECURSIVE
  861.                             | FileUtils.SKIP_MISSING | FileUtils.IGNORE_ERRORS);
  862.                 } else {
  863.                     deleteChildren(directory);
  864.                 }
  865.             }
  866.             if (gitDir != null) {
  867.                 if (!gitDirExistsInitially) {
  868.                     FileUtils.delete(gitDir, FileUtils.RECURSIVE
  869.                             | FileUtils.SKIP_MISSING | FileUtils.IGNORE_ERRORS);
  870.                 } else {
  871.                     deleteChildren(gitDir);
  872.                 }
  873.             }
  874.         } catch (IOException e) {
  875.             // Ignore; this is a best-effort cleanup in error cases, and
  876.             // IOException should not be raised anyway
  877.         }
  878.     }

  880.     private void deleteChildren(File file) throws IOException {
  881.         File[] files = file.listFiles();
  882.         if (files == null) {
  883.             return;
  884.         }
  885.         for (File child : files) {
  886.             FileUtils.delete(child, FileUtils.RECURSIVE | FileUtils.SKIP_MISSING
  887.                     | FileUtils.IGNORE_ERRORS);
  888.         }
  889.     }
  890. }
Created with JaCoCo 0.8.7.202105040129