CloneCommand.java

  1. /*
  2.  * Copyright (C) 2011, 2017 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.util.ArrayList;
  17. import java.util.Collection;
  18. import java.util.List;

  20. import org.eclipse.jgit.annotations.Nullable;
  21. import org.eclipse.jgit.api.errors.GitAPIException;
  22. import org.eclipse.jgit.api.errors.InvalidRemoteException;
  23. import org.eclipse.jgit.api.errors.JGitInternalException;
  24. import org.eclipse.jgit.dircache.DirCache;
  25. import org.eclipse.jgit.dircache.DirCacheCheckout;
  26. import org.eclipse.jgit.errors.IncorrectObjectTypeException;
  27. import org.eclipse.jgit.errors.MissingObjectException;
  28. import org.eclipse.jgit.internal.JGitText;
  29. import org.eclipse.jgit.lib.AnyObjectId;
  30. import org.eclipse.jgit.lib.BranchConfig.BranchRebaseMode;
  31. import org.eclipse.jgit.lib.ConfigConstants;
  32. import org.eclipse.jgit.lib.Constants;
  33. import org.eclipse.jgit.lib.NullProgressMonitor;
  34. import org.eclipse.jgit.lib.ObjectId;
  35. import org.eclipse.jgit.lib.ProgressMonitor;
  36. import org.eclipse.jgit.lib.Ref;
  37. import org.eclipse.jgit.lib.RefUpdate;
  38. import org.eclipse.jgit.lib.Repository;
  39. import org.eclipse.jgit.revwalk.RevCommit;
  40. import org.eclipse.jgit.revwalk.RevWalk;
  41. import org.eclipse.jgit.submodule.SubmoduleWalk;
  42. import org.eclipse.jgit.transport.FetchResult;
  43. import org.eclipse.jgit.transport.RefSpec;
  44. import org.eclipse.jgit.transport.RemoteConfig;
  45. import org.eclipse.jgit.transport.TagOpt;
  46. import org.eclipse.jgit.transport.URIish;
  47. import org.eclipse.jgit.util.FS;
  48. import org.eclipse.jgit.util.FileUtils;

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

  58.     private String uri;

  60.     private File directory;

  62.     private File gitDir;

  64.     private boolean bare;

  66.     private FS fs;

  68.     private String remote = Constants.DEFAULT_REMOTE_NAME;

  70.     private String branch = Constants.HEAD;

  72.     private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;

  74.     private boolean cloneAllBranches;

  76.     private boolean mirror;

  78.     private boolean cloneSubmodules;

  80.     private boolean noCheckout;

  82.     private Collection<String> branchesToClone;

  84.     private Callback callback;

  86.     private boolean directoryExistsInitially;

  88.     private boolean gitDirExistsInitially;

  90.     private FETCH_TYPE fetchType;

  92.     private TagOpt tagOption;

  94.     private enum FETCH_TYPE {
  95.         MULTIPLE_BRANCHES, ALL_BRANCHES, MIRROR
  96.     }

  98.     /**
  99.      * Callback for status of clone operation.
  100.      *
  101.      * @since 4.8
  102.      */
  103.     public interface Callback {
  104.         /**
  105.          * Notify initialized submodules.
  106.          *
  107.          * @param submodules
  108.          *            the submodules
  109.          *
  110.          */
  111.         void initializedSubmodules(Collection<String> submodules);

  113.         /**
  114.          * Notify starting to clone a submodule.
  115.          *
  116.          * @param path
  117.          *            the submodule path
  118.          */
  119.         void cloningSubmodule(String path);

  121.         /**
  122.          * Notify checkout of commit
  123.          *
  124.          * @param commit
  125.          *            the id of the commit being checked out
  126.          * @param path
  127.          *            the submodule path
  128.          */
  129.         void checkingOut(AnyObjectId commit, String path);
  130.     }

  132.     /**
  133.      * Create clone command with no repository set
  134.      */
  135.     public CloneCommand() {
  136.         super(null);
  137.     }

  139.     /**
  140.      * Get the git directory. This is primarily used for tests.
  141.      *
  142.      * @return the git directory
  143.      */
  144.     @Nullable
  145.     File getDirectory() {
  146.         return directory;
  147.     }

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

  216.     private void setFetchType() {
  217.         if (mirror) {
  218.             fetchType = FETCH_TYPE.MIRROR;
  219.             setBare(true);
  220.         } else if (cloneAllBranches) {
  221.             fetchType = FETCH_TYPE.ALL_BRANCHES;
  222.         } else if (branchesToClone != null && !branchesToClone.isEmpty()) {
  223.             fetchType = FETCH_TYPE.MULTIPLE_BRANCHES;
  224.         } else {
  225.             // Default: neither mirror nor all nor specific refs given
  226.             fetchType = FETCH_TYPE.ALL_BRANCHES;
  227.         }
  228.     }

  230.     private static boolean isNonEmptyDirectory(File dir) {
  231.         if (dir != null && dir.exists()) {
  232.             File[] files = dir.listFiles();
  233.             return files != null && files.length != 0;
  234.         }
  235.         return false;
  236.     }

  238.     void verifyDirectories(URIish u) {
  239.         if (directory == null && gitDir == null) {
  240.             directory = new File(u.getHumanishName() + (bare ? Constants.DOT_GIT_EXT : "")); //$NON-NLS-1$
  241.         }
  242.         directoryExistsInitially = directory != null && directory.exists();
  243.         gitDirExistsInitially = gitDir != null && gitDir.exists();
  244.         validateDirs(directory, gitDir, bare);
  245.         if (isNonEmptyDirectory(directory)) {
  246.             throw new JGitInternalException(MessageFormat.format(
  247.                     JGitText.get().cloneNonEmptyDirectory, directory.getName()));
  248.         }
  249.         if (isNonEmptyDirectory(gitDir)) {
  250.             throw new JGitInternalException(MessageFormat.format(
  251.                     JGitText.get().cloneNonEmptyDirectory, gitDir.getName()));
  252.         }
  253.     }

  255.     private Repository init() throws GitAPIException {
  256.         InitCommand command = Git.init();
  257.         command.setBare(bare);
  258.         if (fs != null) {
  259.             command.setFs(fs);
  260.         }
  261.         if (directory != null) {
  262.             command.setDirectory(directory);
  263.         }
  264.         if (gitDir != null) {
  265.             command.setGitDir(gitDir);
  266.         }
  267.         return command.call().getRepository();
  268.     }

  270.     private FetchResult fetch(Repository clonedRepo, URIish u)
  271.             throws URISyntaxException,
  272.             org.eclipse.jgit.api.errors.TransportException, IOException,
  273.             GitAPIException {
  274.         // create the remote config and save it
  275.         RemoteConfig config = new RemoteConfig(clonedRepo.getConfig(), remote);
  276.         config.addURI(u);

  278.         boolean fetchAll = fetchType == FETCH_TYPE.ALL_BRANCHES
  279.                 || fetchType == FETCH_TYPE.MIRROR;

  281.         config.setFetchRefSpecs(calculateRefSpecs(fetchType, config.getName()));
  282.         config.setMirror(fetchType == FETCH_TYPE.MIRROR);
  283.         if (tagOption != null) {
  284.             config.setTagOpt(tagOption);
  285.         }
  286.         config.update(clonedRepo.getConfig());

  288.         clonedRepo.getConfig().save();

  290.         // run the fetch command
  291.         FetchCommand command = new FetchCommand(clonedRepo);
  292.         command.setRemote(remote);
  293.         command.setProgressMonitor(monitor);
  294.         if (tagOption != null) {
  295.             command.setTagOpt(tagOption);
  296.         } else {
  297.             command.setTagOpt(
  298.                     fetchAll ? TagOpt.FETCH_TAGS : TagOpt.AUTO_FOLLOW);
  299.         }
  300.         command.setInitialBranch(branch);
  301.         configure(command);

  303.         return command.call();
  304.     }

  306.     private List<RefSpec> calculateRefSpecs(FETCH_TYPE type,
  307.             String remoteName) {
  308.         List<RefSpec> specs = new ArrayList<>();
  309.         if (type == FETCH_TYPE.MIRROR) {
  310.             specs.add(new RefSpec().setForceUpdate(true).setSourceDestination(
  311.                     Constants.R_REFS + '*', Constants.R_REFS + '*'));
  312.         } else {
  313.             RefSpec heads = new RefSpec();
  314.             heads = heads.setForceUpdate(true);
  315.             final String dst = (bare ? Constants.R_HEADS
  316.                     : Constants.R_REMOTES + remoteName + '/') + '*';
  317.             heads = heads.setSourceDestination(Constants.R_HEADS + '*', dst);
  318.             if (type == FETCH_TYPE.MULTIPLE_BRANCHES) {
  319.                 RefSpec tags = new RefSpec().setForceUpdate(true)
  320.                         .setSourceDestination(Constants.R_TAGS + '*',
  321.                                 Constants.R_TAGS + '*');
  322.                 for (String selectedRef : branchesToClone) {
  323.                     if (heads.matchSource(selectedRef)) {
  324.                         specs.add(heads.expandFromSource(selectedRef));
  325.                     } else if (tags.matchSource(selectedRef)) {
  326.                         specs.add(tags.expandFromSource(selectedRef));
  327.                     }
  328.                 }
  329.             } else {
  330.                 // We'll fetch the tags anyway.
  331.                 specs.add(heads);
  332.             }
  333.         }
  334.         return specs;
  335.     }

  337.     private void checkout(Repository clonedRepo, FetchResult result)
  338.             throws MissingObjectException, IncorrectObjectTypeException,
  339.             IOException, GitAPIException {

  341.         Ref head = null;
  342.         if (branch.equals(Constants.HEAD)) {
  343.             Ref foundBranch = findBranchToCheckout(result);
  344.             if (foundBranch != null)
  345.                 head = foundBranch;
  346.         }
  347.         if (head == null) {
  348.             head = result.getAdvertisedRef(branch);
  349.             if (head == null)
  350.                 head = result.getAdvertisedRef(Constants.R_HEADS + branch);
  351.             if (head == null)
  352.                 head = result.getAdvertisedRef(Constants.R_TAGS + branch);
  353.         }

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

  358.         if (head.getName().startsWith(Constants.R_HEADS)) {
  359.             final RefUpdate newHead = clonedRepo.updateRef(Constants.HEAD);
  360.             newHead.disableRefLog();
  361.             newHead.link(head.getName());
  362.             addMergeConfig(clonedRepo, head);
  363.         }

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

  367.         boolean detached = !head.getName().startsWith(Constants.R_HEADS);
  368.         RefUpdate u = clonedRepo.updateRef(Constants.HEAD, detached);
  369.         u.setNewObjectId(commit.getId());
  370.         u.forceUpdate();

  372.         if (!bare) {
  373.             DirCache dc = clonedRepo.lockDirCache();
  374.             DirCacheCheckout co = new DirCacheCheckout(clonedRepo, dc,
  375.                     commit.getTree());
  376.             co.setProgressMonitor(monitor);
  377.             co.checkout();
  378.             if (cloneSubmodules)
  379.                 cloneSubmodules(clonedRepo);
  380.         }
  381.     }

  383.     private void cloneSubmodules(Repository clonedRepo) throws IOException,
  384.             GitAPIException {
  385.         SubmoduleInitCommand init = new SubmoduleInitCommand(clonedRepo);
  386.         Collection<String> submodules = init.call();
  387.         if (submodules.isEmpty()) {
  388.             return;
  389.         }
  390.         if (callback != null) {
  391.             callback.initializedSubmodules(submodules);
  392.         }

  394.         SubmoduleUpdateCommand update = new SubmoduleUpdateCommand(clonedRepo);
  395.         configure(update);
  396.         update.setProgressMonitor(monitor);
  397.         update.setCallback(callback);
  398.         if (!update.call().isEmpty()) {
  399.             SubmoduleWalk walk = SubmoduleWalk.forIndex(clonedRepo);
  400.             while (walk.next()) {
  401.                 try (Repository subRepo = walk.getRepository()) {
  402.                     if (subRepo != null) {
  403.                         cloneSubmodules(subRepo);
  404.                     }
  405.                 }
  406.             }
  407.         }
  408.     }

  410.     private Ref findBranchToCheckout(FetchResult result) {
  411.         final Ref idHEAD = result.getAdvertisedRef(Constants.HEAD);
  412.         ObjectId headId = idHEAD != null ? idHEAD.getObjectId() : null;
  413.         if (headId == null) {
  414.             return null;
  415.         }

  417.         if (idHEAD != null && idHEAD.isSymbolic()) {
  418.             return idHEAD.getTarget();
  419.         }

  421.         Ref master = result.getAdvertisedRef(Constants.R_HEADS
  422.                 + Constants.MASTER);
  423.         ObjectId objectId = master != null ? master.getObjectId() : null;
  424.         if (headId.equals(objectId)) {
  425.             return master;
  426.         }

  428.         Ref foundBranch = null;
  429.         for (Ref r : result.getAdvertisedRefs()) {
  430.             final String n = r.getName();
  431.             if (!n.startsWith(Constants.R_HEADS))
  432.                 continue;
  433.             if (headId.equals(r.getObjectId())) {
  434.                 foundBranch = r;
  435.                 break;
  436.             }
  437.         }
  438.         return foundBranch;
  439.     }

  441.     private void addMergeConfig(Repository clonedRepo, Ref head)
  442.             throws IOException {
  443.         String branchName = Repository.shortenRefName(head.getName());
  444.         clonedRepo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
  445.                 branchName, ConfigConstants.CONFIG_KEY_REMOTE, remote);
  446.         clonedRepo.getConfig().setString(ConfigConstants.CONFIG_BRANCH_SECTION,
  447.                 branchName, ConfigConstants.CONFIG_KEY_MERGE, head.getName());
  448.         String autosetupRebase = clonedRepo.getConfig().getString(
  449.                 ConfigConstants.CONFIG_BRANCH_SECTION, null,
  450.                 ConfigConstants.CONFIG_KEY_AUTOSETUPREBASE);
  451.         if (ConfigConstants.CONFIG_KEY_ALWAYS.equals(autosetupRebase)
  452.                 || ConfigConstants.CONFIG_KEY_REMOTE.equals(autosetupRebase))
  453.             clonedRepo.getConfig().setEnum(
  454.                     ConfigConstants.CONFIG_BRANCH_SECTION, branchName,
  455.                     ConfigConstants.CONFIG_KEY_REBASE, BranchRebaseMode.REBASE);
  456.         clonedRepo.getConfig().save();
  457.     }

  459.     private RevCommit parseCommit(Repository clonedRepo, Ref ref)
  460.             throws MissingObjectException, IncorrectObjectTypeException,
  461.             IOException {
  462.         final RevCommit commit;
  463.         try (RevWalk rw = new RevWalk(clonedRepo)) {
  464.             commit = rw.parseCommit(ref.getObjectId());
  465.         }
  466.         return commit;
  467.     }

  469.     /**
  470.      * Set the URI to clone from
  471.      *
  472.      * @param uri
  473.      *            the URI to clone from, or {@code null} to unset the URI. The
  474.      *            URI must be set before {@link #call} is called.
  475.      * @return this instance
  476.      */
  477.     public CloneCommand setURI(String uri) {
  478.         this.uri = uri;
  479.         return this;
  480.     }

  482.     /**
  483.      * The optional directory associated with the clone operation. If the
  484.      * directory isn't set, a name associated with the source uri will be used.
  485.      *
  486.      * @see URIish#getHumanishName()
  487.      * @param directory
  488.      *            the directory to clone to, or {@code null} if the directory
  489.      *            name should be taken from the source uri
  490.      * @return this instance
  491.      * @throws java.lang.IllegalStateException
  492.      *             if the combination of directory, gitDir and bare is illegal.
  493.      *             E.g. if for a non-bare repository directory and gitDir point
  494.      *             to the same directory of if for a bare repository both
  495.      *             directory and gitDir are specified
  496.      */
  497.     public CloneCommand setDirectory(File directory) {
  498.         validateDirs(directory, gitDir, bare);
  499.         this.directory = directory;
  500.         return this;
  501.     }

  503.     /**
  504.      * Set the repository meta directory (.git)
  505.      *
  506.      * @param gitDir
  507.      *            the repository meta directory, or {@code null} to choose one
  508.      *            automatically at clone time
  509.      * @return this instance
  510.      * @throws java.lang.IllegalStateException
  511.      *             if the combination of directory, gitDir and bare is illegal.
  512.      *             E.g. if for a non-bare repository directory and gitDir point
  513.      *             to the same directory of if for a bare repository both
  514.      *             directory and gitDir are specified
  515.      * @since 3.6
  516.      */
  517.     public CloneCommand setGitDir(File gitDir) {
  518.         validateDirs(directory, gitDir, bare);
  519.         this.gitDir = gitDir;
  520.         return this;
  521.     }

  523.     /**
  524.      * Set whether the cloned repository shall be bare
  525.      *
  526.      * @param bare
  527.      *            whether the cloned repository is bare or not
  528.      * @return this instance
  529.      * @throws java.lang.IllegalStateException
  530.      *             if the combination of directory, gitDir and bare is illegal.
  531.      *             E.g. if for a non-bare repository directory and gitDir point
  532.      *             to the same directory of if for a bare repository both
  533.      *             directory and gitDir are specified
  534.      */
  535.     public CloneCommand setBare(boolean bare) throws IllegalStateException {
  536.         validateDirs(directory, gitDir, bare);
  537.         this.bare = bare;
  538.         return this;
  539.     }

  541.     /**
  542.      * Set the file system abstraction to be used for repositories created by
  543.      * this command.
  544.      *
  545.      * @param fs
  546.      *            the abstraction.
  547.      * @return {@code this} (for chaining calls).
  548.      * @since 4.10
  549.      */
  550.     public CloneCommand setFs(FS fs) {
  551.         this.fs = fs;
  552.         return this;
  553.     }

  555.     /**
  556.      * The remote name used to keep track of the upstream repository for the
  557.      * clone operation. If no remote name is set, the default value of
  558.      * <code>Constants.DEFAULT_REMOTE_NAME</code> will be used.
  559.      *
  560.      * @see Constants#DEFAULT_REMOTE_NAME
  561.      * @param remote
  562.      *            name that keeps track of the upstream repository.
  563.      *            {@code null} means to use DEFAULT_REMOTE_NAME.
  564.      * @return this instance
  565.      */
  566.     public CloneCommand setRemote(String remote) {
  567.         if (remote == null) {
  568.             remote = Constants.DEFAULT_REMOTE_NAME;
  569.         }
  570.         this.remote = remote;
  571.         return this;
  572.     }

  574.     /**
  575.      * Set the initial branch
  576.      *
  577.      * @param branch
  578.      *            the initial branch to check out when cloning the repository.
  579.      *            Can be specified as ref name (<code>refs/heads/master</code>),
  580.      *            branch name (<code>master</code>) or tag name
  581.      *            (<code>v1.2.3</code>). The default is to use the branch
  582.      *            pointed to by the cloned repository's HEAD and can be
  583.      *            requested by passing {@code null} or <code>HEAD</code>.
  584.      * @return this instance
  585.      */
  586.     public CloneCommand setBranch(String branch) {
  587.         if (branch == null) {
  588.             branch = Constants.HEAD;
  589.         }
  590.         this.branch = branch;
  591.         return this;
  592.     }

  594.     /**
  595.      * The progress monitor associated with the clone operation. By default,
  596.      * this is set to <code>NullProgressMonitor</code>
  597.      *
  598.      * @see NullProgressMonitor
  599.      * @param monitor
  600.      *            a {@link org.eclipse.jgit.lib.ProgressMonitor}
  601.      * @return {@code this}
  602.      */
  603.     public CloneCommand setProgressMonitor(ProgressMonitor monitor) {
  604.         if (monitor == null) {
  605.             monitor = NullProgressMonitor.INSTANCE;
  606.         }
  607.         this.monitor = monitor;
  608.         return this;
  609.     }

  611.     /**
  612.      * Set whether all branches have to be fetched.
  613.      * <p>
  614.      * If {@code false}, use {@link #setBranchesToClone(Collection)} to define
  615.      * what will be cloned. If neither are set, all branches will be cloned.
  616.      * </p>
  617.      *
  618.      * @param cloneAllBranches
  619.      *            {@code true} when all branches have to be fetched (indicates
  620.      *            wildcard in created fetch refspec), {@code false} otherwise.
  621.      * @return {@code this}
  622.      */
  623.     public CloneCommand setCloneAllBranches(boolean cloneAllBranches) {
  624.         this.cloneAllBranches = cloneAllBranches;
  625.         return this;
  626.     }

  628.     /**
  629.      * Set up a mirror of the source repository. This implies that a bare
  630.      * repository will be created. Compared to {@link #setBare},
  631.      * {@code #setMirror} not only maps local branches of the source to local
  632.      * branches of the target, it maps all refs (including remote-tracking
  633.      * branches, notes etc.) and sets up a refspec configuration such that all
  634.      * these refs are overwritten by a git remote update in the target
  635.      * repository.
  636.      *
  637.      * @param mirror
  638.      *            whether to mirror all refs from the source repository
  639.      *
  640.      * @return {@code this}
  641.      * @since 5.6
  642.      */
  643.     public CloneCommand setMirror(boolean mirror) {
  644.         this.mirror = mirror;
  645.         return this;
  646.     }

  648.     /**
  649.      * Set whether to clone submodules
  650.      *
  651.      * @param cloneSubmodules
  652.      *            true to initialize and update submodules. Ignored when
  653.      *            {@link #setBare(boolean)} is set to true.
  654.      * @return {@code this}
  655.      */
  656.     public CloneCommand setCloneSubmodules(boolean cloneSubmodules) {
  657.         this.cloneSubmodules = cloneSubmodules;
  658.         return this;
  659.     }

  661.     /**
  662.      * Set the branches or tags to clone.
  663.      * <p>
  664.      * This is ignored if {@link #setCloneAllBranches(boolean)
  665.      * setCloneAllBranches(true)} or {@link #setMirror(boolean) setMirror(true)}
  666.      * is used. If {@code branchesToClone} is {@code null} or empty, it's also
  667.      * ignored.
  668.      * </p>
  669.      *
  670.      * @param branchesToClone
  671.      *            collection of branches to clone. Must be specified as full ref
  672.      *            names (e.g. {@code refs/heads/master} or
  673.      *            {@code refs/tags/v1.0.0}).
  674.      * @return {@code this}
  675.      */
  676.     public CloneCommand setBranchesToClone(Collection<String> branchesToClone) {
  677.         this.branchesToClone = branchesToClone;
  678.         return this;
  679.     }

  681.     /**
  682.      * Set the tag option used for the remote configuration explicitly.
  683.      *
  684.      * @param tagOption
  685.      *            tag option to be used for the remote config
  686.      * @return {@code this}
  687.      * @since 5.8
  688.      */
  689.     public CloneCommand setTagOption(TagOpt tagOption) {
  690.         this.tagOption = tagOption;
  691.         return this;
  692.     }

  694.     /**
  695.      * Set the --no-tags option. Tags are not cloned now and the remote
  696.      * configuration is initialized with the --no-tags option as well.
  697.      *
  698.      * @return {@code this}
  699.      * @since 5.8
  700.      */
  701.     public CloneCommand setNoTags() {
  702.         return setTagOption(TagOpt.NO_TAGS);
  703.     }

  705.     /**
  706.      * Set whether to skip checking out a branch
  707.      *
  708.      * @param noCheckout
  709.      *            if set to <code>true</code> no branch will be checked out
  710.      *            after the clone. This enhances performance of the clone
  711.      *            command when there is no need for a checked out branch.
  712.      * @return {@code this}
  713.      */
  714.     public CloneCommand setNoCheckout(boolean noCheckout) {
  715.         this.noCheckout = noCheckout;
  716.         return this;
  717.     }

  719.     /**
  720.      * Register a progress callback.
  721.      *
  722.      * @param callback
  723.      *            the callback
  724.      * @return {@code this}
  725.      * @since 4.8
  726.      */
  727.     public CloneCommand setCallback(Callback callback) {
  728.         this.callback = callback;
  729.         return this;
  730.     }

  732.     private static void validateDirs(File directory, File gitDir, boolean bare)
  733.             throws IllegalStateException {
  734.         if (directory != null) {
  735.             if (directory.exists() && !directory.isDirectory()) {
  736.                 throw new IllegalStateException(MessageFormat.format(
  737.                         JGitText.get().initFailedDirIsNoDirectory, directory));
  738.             }
  739.             if (gitDir != null && gitDir.exists() && !gitDir.isDirectory()) {
  740.                 throw new IllegalStateException(MessageFormat.format(
  741.                         JGitText.get().initFailedGitDirIsNoDirectory,
  742.                         gitDir));
  743.             }
  744.             if (bare) {
  745.                 if (gitDir != null && !gitDir.equals(directory))
  746.                     throw new IllegalStateException(MessageFormat.format(
  747.                             JGitText.get().initFailedBareRepoDifferentDirs,
  748.                             gitDir, directory));
  749.             } else {
  750.                 if (gitDir != null && gitDir.equals(directory))
  751.                     throw new IllegalStateException(MessageFormat.format(
  752.                             JGitText.get().initFailedNonBareRepoSameDirs,
  753.                             gitDir, directory));
  754.             }
  755.         }
  756.     }

  758.     private void cleanup() {
  759.         try {
  760.             if (directory != null) {
  761.                 if (!directoryExistsInitially) {
  762.                     FileUtils.delete(directory, FileUtils.RECURSIVE
  763.                             | FileUtils.SKIP_MISSING | FileUtils.IGNORE_ERRORS);
  764.                 } else {
  765.                     deleteChildren(directory);
  766.                 }
  767.             }
  768.             if (gitDir != null) {
  769.                 if (!gitDirExistsInitially) {
  770.                     FileUtils.delete(gitDir, FileUtils.RECURSIVE
  771.                             | FileUtils.SKIP_MISSING | FileUtils.IGNORE_ERRORS);
  772.                 } else {
  773.                     deleteChildren(gitDir);
  774.                 }
  775.             }
  776.         } catch (IOException e) {
  777.             // Ignore; this is a best-effort cleanup in error cases, and
  778.             // IOException should not be raised anyway
  779.         }
  780.     }

  782.     private void deleteChildren(File file) throws IOException {
  783.         File[] files = file.listFiles();
  784.         if (files == null) {
  785.             return;
  786.         }
  787.         for (File child : files) {
  788.             FileUtils.delete(child, FileUtils.RECURSIVE | FileUtils.SKIP_MISSING
  789.                     | FileUtils.IGNORE_ERRORS);
  790.         }
  791.     }
  792. }
Created with JaCoCo 0.8.6.202009150832