Example usage for org.eclipse.jgit.api CloneCommand setBranchesToClone

Introduction

In this page you can find the example usage for org.eclipse.jgit.api CloneCommand setBranchesToClone.

Prototype

public CloneCommand setBranchesToClone(Collection<String> branchesToClone) 

Source Link

Document

Set the branches or tags to clone.

Usage

From source file:com.gitblit.manager.GitblitManager.java

License:Apache License

/**
 * Creates a personal fork of the specified repository. The clone is view
 * restricted by default and the owner of the source repository is given
 * access to the clone.//from w  w  w.  j  av  a2 s.  co  m
 *
 * @param repository
 * @param user
 * @return the repository model of the fork, if successful
 * @throws GitBlitException
 */
@Override
public RepositoryModel fork(RepositoryModel repository, UserModel user) throws GitBlitException {
    String cloneName = MessageFormat.format("{0}/{1}.git", user.getPersonalPath(),
            StringUtils.stripDotGit(StringUtils.getLastPathElement(repository.name)));
    String fromUrl = MessageFormat.format("file://{0}/{1}",
            repositoryManager.getRepositoriesFolder().getAbsolutePath(), repository.name);

    // clone the repository
    try {
        Repository canonical = getRepository(repository.name);
        File folder = new File(repositoryManager.getRepositoriesFolder(), cloneName);
        CloneCommand clone = new CloneCommand();
        clone.setBare(true);

        // fetch branches with exclusions
        Collection<Ref> branches = canonical.getRefDatabase().getRefs(Constants.R_HEADS).values();
        List<String> branchesToClone = new ArrayList<String>();
        for (Ref branch : branches) {
            String name = branch.getName();
            if (name.startsWith(Constants.R_TICKET)) {
                // exclude ticket branches
                continue;
            }
            branchesToClone.add(name);
        }
        clone.setBranchesToClone(branchesToClone);
        clone.setURI(fromUrl);
        clone.setDirectory(folder);
        Git git = clone.call();

        // fetch tags
        FetchCommand fetch = git.fetch();
        fetch.setRefSpecs(new RefSpec("+refs/tags/*:refs/tags/*"));
        fetch.call();

        git.getRepository().close();
    } catch (Exception e) {
        throw new GitBlitException(e);
    }

    // create a Gitblit repository model for the clone
    RepositoryModel cloneModel = repository.cloneAs(cloneName);
    // owner has REWIND/RW+ permissions
    cloneModel.addOwner(user.username);

    // ensure initial access restriction of the fork
    // is not lower than the source repository  (issue-495/ticket-167)
    if (repository.accessRestriction.exceeds(cloneModel.accessRestriction)) {
        cloneModel.accessRestriction = repository.accessRestriction;
    }

    repositoryManager.updateRepositoryModel(cloneName, cloneModel, false);

    // add the owner of the source repository to the clone's access list
    if (!ArrayUtils.isEmpty(repository.owners)) {
        for (String owner : repository.owners) {
            UserModel originOwner = userManager.getUserModel(owner);
            if (originOwner != null && !originOwner.canClone(cloneModel)) {
                // origin owner can't yet clone fork, grant explicit clone access
                originOwner.setRepositoryPermission(cloneName, AccessPermission.CLONE);
                reviseUser(originOwner.username, originOwner);
            }
        }
    }

    // grant origin's user list clone permission to fork
    List<String> users = repositoryManager.getRepositoryUsers(repository);
    List<UserModel> cloneUsers = new ArrayList<UserModel>();
    for (String name : users) {
        if (!name.equalsIgnoreCase(user.username)) {
            UserModel cloneUser = userManager.getUserModel(name);
            if (cloneUser.canClone(repository) && !cloneUser.canClone(cloneModel)) {
                // origin user can't yet clone fork, grant explicit clone access
                cloneUser.setRepositoryPermission(cloneName, AccessPermission.CLONE);
            }
            cloneUsers.add(cloneUser);
        }
    }
    userManager.updateUserModels(cloneUsers);

    // grant origin's team list clone permission to fork
    List<String> teams = repositoryManager.getRepositoryTeams(repository);
    List<TeamModel> cloneTeams = new ArrayList<TeamModel>();
    for (String name : teams) {
        TeamModel cloneTeam = userManager.getTeamModel(name);
        if (cloneTeam.canClone(repository) && !cloneTeam.canClone(cloneModel)) {
            // origin team can't yet clone fork, grant explicit clone access
            cloneTeam.setRepositoryPermission(cloneName, AccessPermission.CLONE);
        }
        cloneTeams.add(cloneTeam);
    }
    userManager.updateTeamModels(cloneTeams);

    // add this clone to the cached model
    repositoryManager.addToCachedRepositoryList(cloneModel);

    if (pluginManager != null) {
        for (RepositoryLifeCycleListener listener : pluginManager
                .getExtensions(RepositoryLifeCycleListener.class)) {
            try {
                listener.onFork(repository, cloneModel);
            } catch (Throwable t) {
                logger.error(String.format("failed to call plugin onFork %s", repository.name), t);
            }
        }
    }
    return cloneModel;
}

---

From source file:com.microsoft.tfs.client.eclipse.ui.egit.importwizard.CloneGitRepositoryCommand.java

License:Open Source License

private boolean cloneRepository(final IProgressMonitor progressMonitor) {
    final CloneCommand cloneRepository = Git.cloneRepository();

    cloneRepository.setCredentialsProvider(credentialsProvider);
    cloneRepository.setProgressMonitor(new CloneProgress(progressMonitor));

    final File workFolder = new File(workingDirectory);
    if (!workFolder.exists()) {
        if (!workFolder.mkdirs()) {
            if (!workFolder.isDirectory()) {
                final String errorMessageFormat = "Cannot create {0} directory"; //$NON-NLS-1$
                throw new RuntimeException(MessageFormat.format(errorMessageFormat, workingDirectory));
            }//from  ww  w .  ja v a  2s.  c o m
        }
    }
    cloneRepository.setDirectory(new File(workingDirectory));

    cloneRepository.setRemote(remoteName);
    cloneRepository.setURI(URIUtils.encodeQueryIgnoringPercentCharacters(repositoryUrl.toString()));

    cloneRepository.setCloneAllBranches(true);
    cloneRepository.setBranchesToClone(Arrays.asList(refs));
    cloneRepository.setBranch(defaultRef);

    cloneRepository.setNoCheckout(false);
    cloneRepository.setTimeout(timeout);
    cloneRepository.setCloneSubmodules(cloneSubmodules);

    try {
        cloneRepository.call();
        if (progressMonitor.isCanceled()) {
            throw new CanceledException();
        }

        registerClonedRepository(workingDirectory);
    } catch (final CanceledException e) {
        throw e;
    } catch (final Exception e) {
        logger.error("Error cloning repository:", e); //$NON-NLS-1$
        errorMessage = e.getLocalizedMessage();
        return false;
    }

    return true;
}

---

From source file:com.rimerosolutions.ant.git.tasks.CloneTask.java

License:Apache License

@Override
public void execute() {
    try {/*  w  ww.  ja  va 2 s  .  c o m*/
        CloneCommand cloneCommand = new CloneCommand();

        if (branchToTrack != null) {
            cloneCommand.setBranch(branchToTrack);
        }

        if (!branchNames.isEmpty()) {
            cloneCommand.setBranchesToClone(branchNames);
        }

        cloneCommand.setURI(getUri()).setBare(bare).setCloneAllBranches(cloneAllBranches)
                .setCloneSubmodules(cloneSubModules).setNoCheckout(noCheckout).setDirectory(getDirectory());

        setupCredentials(cloneCommand);

        if (getProgressMonitor() != null) {
            cloneCommand.setProgressMonitor(getProgressMonitor());
        }

        cloneCommand.call();
    } catch (Exception e) {
        throw new GitBuildException(String.format(MESSAGE_CLONE_FAILED, getUri()), e);
    }
}

---

From source file:org.ajoberstar.gradle.git.tasks.GitClone.java

License:Apache License

/**
 * Clones a Git repository as configured.
 */// ww  w .  jav  a2  s  . c  o m
@TaskAction
public void cloneRepo() {
    CloneCommand cmd = Git.cloneRepository();
    TransportAuthUtil.configure(cmd, this);
    cmd.setURI(getUri().toString());
    cmd.setRemote(getRemote());
    cmd.setBare(getBare());
    cmd.setNoCheckout(!getCheckout());
    cmd.setBranch(getRef());
    cmd.setBranchesToClone(getBranchesToClone());
    cmd.setCloneAllBranches(getCloneAllBranches());
    cmd.setDirectory(getDestinationDir());
    try {
        cmd.call();
    } catch (InvalidRemoteException e) {
        throw new GradleException("Invalid remote specified: " + getRemote(), e);
    } catch (TransportException e) {
        throw new GradleException("Problem with transport.", e);
    } catch (GitAPIException e) {
        throw new GradleException("Problem with clone.", e);
    }
    //TODO add progress monitor to log progress to Gradle status bar
}

---

From source file:org.apache.oozie.action.hadoop.GitOperations.java

License:Apache License

/**
 * Clones a Git repository/*from w w w  .j a v a  2 s . com*/
 * @param outputDir location in which to clone the Git repository
 * @throws GitOperationsException if the Git clone fails
 */
private void cloneRepo(final File outputDir) throws GitOperationsException {
    final SshSessionFactory sshSessionFactory = new JschConfigSessionFactory() {
        @Override
        protected void configure(final OpenSshConfig.Host host, final Session session) {
            // nop
        }

        @Override
        protected JSch createDefaultJSch(final FS fs) throws JSchException {
            JSch.setConfig("StrictHostKeyChecking", "no");
            final JSch defaultJSch = super.createDefaultJSch(fs);

            if (credentialFile != null) {
                defaultJSch.addIdentity(credentialFile.toString());
            }

            return defaultJSch;
        }
    };

    final CloneCommand cloneCommand = Git.cloneRepository();
    cloneCommand.setURI(srcURL.toString());

    if (srcURL.getScheme().toLowerCase().equals("ssh")) {
        cloneCommand.setTransportConfigCallback(new TransportConfigCallback() {
            @Override
            public void configure(final Transport transport) {
                final SshTransport sshTransport = (SshTransport) transport;
                sshTransport.setSshSessionFactory(sshSessionFactory);
            }
        });
    }

    cloneCommand.setDirectory(outputDir);
    // set our branch identifier
    if (branch != null) {
        cloneCommand.setBranchesToClone(Arrays.asList("refs/heads/" + branch));
    }

    try {
        cloneCommand.call();
    } catch (final GitAPIException e) {
        throw new GitOperationsException("Unable to clone Git repo: ", e);
    }
}

---

From source file:org.eclipse.che.git.impl.jgit.JGitConnection.java

License:Open Source License

public void clone(CloneRequest request) throws GitException, UnauthorizedException {
    String remoteUri;//from  www  .jav a  2 s. c  om
    boolean removeIfFailed = false;
    try {
        if (request.getRemoteName() == null) {
            request.setRemoteName(Constants.DEFAULT_REMOTE_NAME);
        }
        if (request.getWorkingDir() == null) {
            request.setWorkingDir(repository.getWorkTree().getCanonicalPath());
        }

        // If clone fails and the .git folder didn't exist we want to remove it.
        // We have to do this here because the clone command doesn't revert its own changes in case of failure.
        removeIfFailed = !repository.getDirectory().exists();

        remoteUri = request.getRemoteUri();
        CloneCommand cloneCommand = Git.cloneRepository().setDirectory(new File(request.getWorkingDir()))
                .setRemote(request.getRemoteName()).setURI(remoteUri);
        if (request.getBranchesToFetch().isEmpty()) {
            cloneCommand.setCloneAllBranches(true);
        } else {
            cloneCommand.setBranchesToClone(request.getBranchesToFetch());
        }

        executeRemoteCommand(remoteUri, cloneCommand);

        StoredConfig repositoryConfig = getRepository().getConfig();
        GitUser gitUser = getUser();
        if (gitUser != null) {
            repositoryConfig.setString(ConfigConstants.CONFIG_USER_SECTION, null,
                    ConfigConstants.CONFIG_KEY_NAME, gitUser.getName());
            repositoryConfig.setString(ConfigConstants.CONFIG_USER_SECTION, null,
                    ConfigConstants.CONFIG_KEY_EMAIL, gitUser.getEmail());
        }
        repositoryConfig.save();
    } catch (IOException | GitAPIException exception) {
        // Delete .git directory in case it was created
        if (removeIfFailed) {
            deleteRepositoryFolder();
        }
        throw new GitException(exception.getMessage(), exception);
    }
}

---

From source file:org.eclipse.oomph.setup.git.impl.GitCloneTaskImpl.java

License:Open Source License

private static Git cloneRepository(SetupTaskContext context, File workDir, String checkoutBranch,
        String remoteName, String remoteURI, boolean recursive, IProgressMonitor monitor) throws Exception {
    context.log("Cloning Git repo " + remoteURI + " to " + workDir);

    CloneCommand command = Git.cloneRepository();
    command.setNoCheckout(true);//w w  w. ja v a  2s. co m
    command.setURI(remoteURI);
    command.setRemote(remoteName);
    command.setBranchesToClone(Collections.singleton(checkoutBranch));
    command.setDirectory(workDir);
    command.setTimeout(60);
    command.setProgressMonitor(new EclipseGitProgressTransformer(monitor));
    return command.call();
}

---

From source file:org.flowerplatform.web.git.GitService.java

License:Open Source License

@RemoteInvocation
public boolean cloneRepository(final ServiceInvocationContext context, List<PathFragment> selectedPath,
        String repositoryUrl, final List<String> selectedBranches, final String remoteName,
        final boolean cloneAllBranches) {
    tlCommand.set((InvokeServiceMethodServerCommand) context.getCommand());

    final URIish uri;
    try {/*from w  w  w .  ja  va 2  s  .  c o m*/
        uri = new URIish(repositoryUrl.trim());
    } catch (URISyntaxException e) {
        context.getCommunicationChannel().appendOrSendCommand(
                new DisplaySimpleMessageClientCommand(CommonPlugin.getInstance().getMessage("error"),
                        e.getReason(), DisplaySimpleMessageClientCommand.ICON_ERROR));
        return false;
    }

    @SuppressWarnings("unchecked")
    final Pair<File, Object> node = (Pair<File, Object>) GenericTreeStatefulService
            .getNodeByPathFor(selectedPath, null);

    File gitReposFile = GitPlugin.getInstance().getUtils().getGitRepositoriesFile(node.a);
    final File mainRepo = GitPlugin.getInstance().getUtils()
            .getMainRepositoryFile(new File(gitReposFile, uri.getHumanishName()), true);

    final ProgressMonitor monitor = ProgressMonitor.create(
            GitPlugin.getInstance().getMessage("git.clone.monitor.title", uri),
            context.getCommunicationChannel());
    monitor.beginTask(GitPlugin.getInstance().getMessage("git.clone.monitor.title", uri), 2);

    Job job = new Job(
            MessageFormat.format(GitPlugin.getInstance().getMessage("git.clone.monitor.title", uri), uri)) {
        @Override
        protected IStatus run(IProgressMonitor m) {
            Repository repository = null;
            try {
                CloneCommand cloneRepository = Git.cloneRepository();

                cloneRepository.setNoCheckout(true);
                cloneRepository.setDirectory(mainRepo);
                cloneRepository.setProgressMonitor(new GitProgressMonitor(new SubProgressMonitor(monitor, 1)));
                cloneRepository.setRemote(remoteName);
                cloneRepository.setURI(uri.toString());
                cloneRepository.setTimeout(30);
                cloneRepository.setCloneAllBranches(cloneAllBranches);
                cloneRepository.setCloneSubmodules(false);
                if (selectedBranches.size() > 0) {
                    cloneRepository.setBranchesToClone(selectedBranches);
                }

                Git git = cloneRepository.call();
                repository = git.getRepository();

                // notify clients about changes
                dispatchContentUpdate(node);

                monitor.worked(1);
            } catch (Exception e) {
                if (repository != null)
                    repository.close();
                GitPlugin.getInstance().getUtils().delete(mainRepo.getParentFile());

                if (monitor.isCanceled()) {
                    return Status.OK_STATUS;
                }
                if (GitPlugin.getInstance().getUtils().isAuthentificationException(e)) {
                    openLoginWindow();
                    return Status.OK_STATUS;
                }
                logger.debug(GitPlugin.getInstance().getMessage("git.cloneWizard.error",
                        new Object[] { mainRepo.getName() }), e);
                context.getCommunicationChannel()
                        .appendOrSendCommand(new DisplaySimpleMessageClientCommand(
                                CommonPlugin.getInstance().getMessage("error"),
                                GitPlugin.getInstance().getMessage("git.cloneWizard.error",
                                        new Object[] { mainRepo.getName() }),
                                DisplaySimpleMessageClientCommand.ICON_ERROR));

                return Status.CANCEL_STATUS;
            } finally {
                monitor.done();
                if (repository != null) {
                    repository.close();
                }
            }
            return Status.OK_STATUS;
        }
    };
    job.schedule();
    return true;
}

---

From source file:org.jabylon.team.git.GitTeamProvider.java

License:Open Source License

@Override
public void checkout(ProjectVersion project, IProgressMonitor monitor) throws TeamProviderException {
    try {//from   ww  w  .j a  v  a  2s.  co m
        SubMonitor subMon = SubMonitor.convert(monitor, 100);
        subMon.setTaskName("Checking out");
        subMon.worked(20);
        File repoDir = new File(project.absoluteFilePath().path());
        CloneCommand clone = Git.cloneRepository();
        clone.setBare(false);
        clone.setNoCheckout(false);
        // if(!"master".equals(project.getName()))
        clone.setBranch("refs/heads/" + project.getName());
        // clone.setCloneAllBranches(true);
        clone.setBranchesToClone(Collections.singletonList("refs/heads/" + project.getName()));

        clone.setDirectory(repoDir);

        URI uri = project.getParent().getRepositoryURI();
        if (!"https".equals(uri.scheme()) && !"http".equals(uri.scheme()))
            clone.setTransportConfigCallback(createTransportConfigCallback(project.getParent()));
        clone.setCredentialsProvider(createCredentialsProvider(project.getParent()));
        clone.setURI(stripUserInfo(uri).toString());
        clone.setProgressMonitor(new ProgressMonitorWrapper(subMon.newChild(70)));

        clone.call();
        subMon.done();
        if (monitor != null)
            monitor.done();
    } catch (TransportException e) {
        throw new TeamProviderException(e);
    } catch (InvalidRemoteException e) {
        throw new TeamProviderException(e);
    } catch (GitAPIException e) {
        throw new TeamProviderException(e);
    }
}

---

From source file:org.jenkinsci.git.CloneOperation.java

License:Open Source License

public Repository invoke(File file, VirtualChannel channel) throws IOException {
    String directory = repo.getDirectory();
    File gitDir;/*from   w  w  w  . java2s.c  om*/
    if (directory == null || directory.length() == 0 || ".".equals(directory))
        gitDir = file;
    else
        gitDir = new File(file, directory);

    CloneCommand clone = Git.cloneRepository();
    clone.setURI(repo.getUri());
    clone.setCloneAllBranches(false);
    clone.setBranchesToClone(Collections.singletonList(repo.getBranch()));
    clone.setDirectory(gitDir);
    clone.setNoCheckout(true);
    return clone.call().getRepository();
}

---

• «
• 1
• 2
• »