Example usage for org.eclipse.jgit.lib Constants R_HEADS

List of usage examples for org.eclipse.jgit.lib Constants R_HEADS

Introduction

In this page you can find the example usage for org.eclipse.jgit.lib Constants R_HEADS.

Prototype

String R_HEADS

To view the source code for org.eclipse.jgit.lib Constants R_HEADS.

Click Source Link

Document

Prefix for branch refs

Usage

From source file:com.barchart.jenkins.cascade.PluginScmGit.java

License:BSD License

/**
 * Head branch reference./* w  ww  .  j av a  2 s  . c  o m*/
 * <p>
 * Example: refs/heads/master
 */
public static String refHeads(final String branchName) {
    return Constants.R_HEADS + branchName;
}

From source file:com.cloudbees.eclipse.dev.scm.egit.ForgeEGitSync.java

License:Open Source License

public static File cloneRepo(String url, URI locationURI, IProgressMonitor monitor)
        throws InterruptedException, InvocationTargetException, URISyntaxException {
    //GitScmUrlImportWizardPage
    //GitImportWizard

    // See ProjectReferenceImporter for hints on cloning and importing!
    /*/*from w w  w  . j av  a  2s .co m*/
        CloneOperation clone = Utils.createInstance(CloneOperation.class, new Class[] { URIish.class, Boolean.TYPE,
            Collection.class, File.class, String.class, String.class, Integer.TYPE }, new Object[] { new URIish(url),
            true, Collections.EMPTY_LIST, new File(""), null, "origin", 5000 });
        if (clone == null) {
          // old constructor didn't have timeout at the end
        clone = Utils.createInstance(CloneOperation.class, new Class[] { URIish.class, Boolean.TYPE, Collection.class,
              File.class, String.class, String.class }, new Object[] { new URIish(url), true, Collections.EMPTY_LIST,
              new File(""), null, "origin" });
                
      }*/
    if (monitor.isCanceled()) {
        return null;
    }

    try {
        int timeout = 60;

        // force plugin activation
        Activator.getDefault().getLog();

        Platform.getPreferencesService().getInt("org.eclipse.egit.core",
                UIPreferences.REMOTE_CONNECTION_TIMEOUT, 60, null);

        String branch = "master";

        url = reformatGitUrlToCurrent(url);

        URIish gitUrl = new URIish(url);
        File workDir = new File(locationURI);
        //final File repositoryPath = workDir.append(Constants.DOT_GIT_EXT).toFile();

        String refName = Constants.R_HEADS + branch;

        GitConnectionType type = CloudBeesUIPlugin.getDefault().getGitConnectionType();

        final CloneOperation cloneOperation = new CloneOperation(gitUrl, true, null, workDir, refName,
                Constants.DEFAULT_REMOTE_NAME, timeout);

        // https password
        if (type.equals(GitConnectionType.HTTPS)) {

            try {

                String username = CloudBeesUIPlugin.getDefault().getPreferenceStore()
                        .getString(PreferenceConstants.P_EMAIL);
                String password = CloudBeesUIPlugin.getDefault().readP();

                CredentialsProvider credentialsProvider = new UsernamePasswordCredentialsProvider(username,
                        password);

                // Store to secure storage to ensure the connection remains available without reentering the password

                UserPasswordCredentials credentials = new UserPasswordCredentials(username, password);

                URIish uri = new URIish(url);
                SecureStoreUtils.storeCredentials(credentials, uri);

                cloneOperation.setCredentialsProvider(credentialsProvider);

            } catch (StorageException e) {
                throw new InvocationTargetException(new Exception("Failed to read credentials!", e));
            }
        }

        cloneOperation.run(monitor);

        return workDir;
    } catch (final InvocationTargetException e1) {
        throw e1;
    } catch (InterruptedException e2) {
        throw e2;
    }

}

From source file:com.cloudbees.jenkins.plugins.bitbucket.BitbucketSCMSource.java

License:Open Source License

@NonNull
@Override// w w  w.  j av a  2  s.  c om
protected List<Action> retrieveActions(@NonNull SCMHead head, @CheckForNull SCMHeadEvent event,
        @NonNull TaskListener listener) throws IOException, InterruptedException {
    // TODO when we have support for trusted events, use the details from event if event was from trusted source
    List<Action> result = new ArrayList<>();
    String serverUrl = StringUtils.removeEnd(bitbucketUrl(), "/");
    if (StringUtils.isNotEmpty(bitbucketServerUrl)) {
        String branchUrl;
        String title;
        if (head instanceof PullRequestSCMHead) {
            PullRequestSCMHead pr = (PullRequestSCMHead) head;
            branchUrl = "projects/" + repoOwner + "/repos/" + repository + "/pull-requests/" + pr.getId()
                    + "/overview";
            title = getPullRequestTitleCache().get(pr.getId());
            ContributorMetadataAction contributor = getPullRequestContributorCache().get(pr.getId());
            if (contributor != null) {
                result.add(contributor);
            }
        } else {
            branchUrl = "projects/" + repoOwner + "/repos/" + repository + "/compare/commits?sourceBranch="
                    + URLEncoder.encode(Constants.R_HEADS + head.getName(), "UTF-8");
            title = null;
        }
        result.add(new BitbucketLink("icon-bitbucket-branch", serverUrl + "/" + branchUrl));
        result.add(new ObjectMetadataAction(title, null, serverUrl + "/" + branchUrl));
    } else {
        String branchUrl;
        String title;
        if (head instanceof PullRequestSCMHead) {
            PullRequestSCMHead pr = (PullRequestSCMHead) head;
            branchUrl = repoOwner + "/" + repository + "/pull-requests/" + pr.getId();
            title = getPullRequestTitleCache().get(pr.getId());
            ContributorMetadataAction contributor = getPullRequestContributorCache().get(pr.getId());
            if (contributor != null) {
                result.add(contributor);
            }
        } else {
            branchUrl = repoOwner + "/" + repository + "/branch/" + head.getName();
            title = null;
        }
        result.add(new BitbucketLink("icon-bitbucket-branch", serverUrl + "/" + branchUrl));
        result.add(new ObjectMetadataAction(title, null, serverUrl + "/" + branchUrl));
    }
    SCMSourceOwner owner = getOwner();
    if (owner instanceof Actionable) {
        for (BitbucketDefaultBranch p : ((Actionable) owner).getActions(BitbucketDefaultBranch.class)) {
            if (StringUtils.equals(getRepoOwner(), p.getRepoOwner())
                    && StringUtils.equals(repository, p.getRepository())
                    && StringUtils.equals(p.getDefaultBranch(), head.getName())) {
                result.add(new PrimaryInstanceMetadataAction());
                break;
            }
        }
    }
    return result;
}

From source file:com.denimgroup.threadfix.service.repository.GitServiceImpl.java

License:Mozilla Public License

@Override
public boolean testConfiguration(Application application, String repo, String branch) throws GitAPIException {
    InitCommand initCommand = new InitCommand();
    File applicationDirectory = DiskUtils.getScratchFile(baseDirectory + application.getId() + "-test");
    initCommand.setDirectory(applicationDirectory);

    Git otherGit = initCommand.call();// ww w  .j a  va 2  s . com

    otherGit.getRepository().getConfig().setString("remote", "origin", "url", repo);

    String targetRefSpec = branch == null || branch.isEmpty() ? Constants.R_HEADS + "*:refs/remotes/origin/*"
            : Constants.R_HEADS + branch;

    FetchCommand fetchCommand = otherGit.fetch()
            .setCredentialsProvider(getUnencryptedApplicationCredentials(application)).setDryRun(true)
            .setRefSpecs(new RefSpec(targetRefSpec)).setRemote("origin");

    fetchCommand.call();

    return true;
}

From source file:com.gitblit.client.MessageRenderer.java

License:Apache License

private void showRef(String ref, JLabel label) {
    String name = ref;/*w w w  .  j  a va 2 s  .c om*/
    Color bg = getBackground();
    Border border = null;
    if (name.startsWith(Constants.R_HEADS)) {
        // local branch
        bg = Color.decode("#CCFFCC");
        name = name.substring(Constants.R_HEADS.length());
        border = new LineBorder(Color.decode("#00CC33"), 1);
    } else if (name.startsWith(Constants.R_REMOTES)) {
        // remote branch
        bg = Color.decode("#CAC2F5");
        name = name.substring(Constants.R_REMOTES.length());
        border = new LineBorder(Color.decode("#6C6CBF"), 1);
    } else if (name.startsWith(Constants.R_TAGS)) {
        // tag
        bg = Color.decode("#FFFFAA");
        name = name.substring(Constants.R_TAGS.length());
        border = new LineBorder(Color.decode("#FFCC00"), 1);
    } else if (name.equals(Constants.HEAD)) {
        // HEAD
        bg = Color.decode("#FFAAFF");
        border = new LineBorder(Color.decode("#FF00EE"), 1);
    } else {
    }
    label.setText(name);
    label.setBackground(bg);
    label.setBorder(border);
    label.setVisible(true);
}

From source file:com.gitblit.client.MessageRenderer.java

License:Apache License

@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
        int row, int column) {
    if (isSelected)
        setBackground(table.getSelectionBackground());
    else/*from w  ww. ja v  a  2s. c o m*/
        setBackground(table.getBackground());
    messageLabel.setForeground(isSelected ? table.getSelectionForeground() : table.getForeground());
    if (value == null) {
        return this;
    }
    FeedEntryModel entry = (FeedEntryModel) value;

    if (gitblit == null) {
        // no gitblit client, just display message
        messageLabel.setText(entry.title);
    } else {
        // show message in BOLD if its a new entry
        if (entry.published.after(gitblit.getLastFeedRefresh(entry.repository, entry.branch))) {
            messageLabel.setText("<html><body><b>" + entry.title);
        } else {
            messageLabel.setText(entry.title);
        }
    }

    // reset ref label
    resetRef(headLabel);
    resetRef(branchLabel);
    resetRef(remoteLabel);
    resetRef(tagLabel);

    int parentCount = 0;
    if (entry.tags != null) {
        for (String tag : entry.tags) {
            if (tag.startsWith("ref:")) {
                // strip ref:
                tag = tag.substring("ref:".length());
            } else {
                // count parents
                if (tag.startsWith("parent:")) {
                    parentCount++;
                }
            }
            if (tag.equals(entry.branch)) {
                // skip current branch label
                continue;
            }
            if (tag.startsWith(Constants.R_HEADS)) {
                // local branch
                showRef(tag, branchLabel);
            } else if (tag.startsWith(Constants.R_REMOTES)) {
                // remote branch
                showRef(tag, remoteLabel);
            } else if (tag.startsWith(Constants.R_TAGS)) {
                // tag
                showRef(tag, tagLabel);
            } else if (tag.equals(Constants.HEAD)) {
                // HEAD
                showRef(tag, headLabel);
            }
        }
    }

    if (parentCount > 1) {
        // multiple parents, show merge icon
        messageLabel.setIcon(mergeIcon);
    } else {
        messageLabel.setIcon(blankIcon);
    }
    return this;
}

From source file:com.gitblit.FederationPullExecutor.java

License:Apache License

/**
 * Mirrors a repository and, optionally, the server's users, and/or
 * configuration settings from a origin Gitblit instance.
 * /*from   w  w w  .ja va 2s  . co m*/
 * @param registration
 * @throws Exception
 */
private void pull(FederationModel registration) throws Exception {
    Map<String, RepositoryModel> repositories = FederationUtils.getRepositories(registration, true);
    String registrationFolder = registration.folder.toLowerCase().trim();
    // confirm valid characters in server alias
    Character c = StringUtils.findInvalidCharacter(registrationFolder);
    if (c != null) {
        logger.error(MessageFormat.format(
                "Illegal character ''{0}'' in folder name ''{1}'' of federation registration {2}!", c,
                registrationFolder, registration.name));
        return;
    }
    File repositoriesFolder = new File(GitBlit.getString(Keys.git.repositoriesFolder, "git"));
    File registrationFolderFile = new File(repositoriesFolder, registrationFolder);
    registrationFolderFile.mkdirs();

    // Clone/Pull the repository
    for (Map.Entry<String, RepositoryModel> entry : repositories.entrySet()) {
        String cloneUrl = entry.getKey();
        RepositoryModel repository = entry.getValue();
        if (!repository.hasCommits) {
            logger.warn(MessageFormat.format(
                    "Skipping federated repository {0} from {1} @ {2}. Repository is EMPTY.", repository.name,
                    registration.name, registration.url));
            registration.updateStatus(repository, FederationPullStatus.SKIPPED);
            continue;
        }

        // Determine local repository name
        String repositoryName;
        if (StringUtils.isEmpty(registrationFolder)) {
            repositoryName = repository.name;
        } else {
            repositoryName = registrationFolder + "/" + repository.name;
        }

        if (registration.bare) {
            // bare repository, ensure .git suffix
            if (!repositoryName.toLowerCase().endsWith(DOT_GIT_EXT)) {
                repositoryName += DOT_GIT_EXT;
            }
        } else {
            // normal repository, strip .git suffix
            if (repositoryName.toLowerCase().endsWith(DOT_GIT_EXT)) {
                repositoryName = repositoryName.substring(0, repositoryName.indexOf(DOT_GIT_EXT));
            }
        }

        // confirm that the origin of any pre-existing repository matches
        // the clone url
        String fetchHead = null;
        Repository existingRepository = GitBlit.self().getRepository(repositoryName);
        if (existingRepository != null) {
            StoredConfig config = existingRepository.getConfig();
            config.load();
            String origin = config.getString("remote", "origin", "url");
            RevCommit commit = JGitUtils.getCommit(existingRepository,
                    org.eclipse.jgit.lib.Constants.FETCH_HEAD);
            if (commit != null) {
                fetchHead = commit.getName();
            }
            existingRepository.close();
            if (!origin.startsWith(registration.url)) {
                logger.warn(MessageFormat.format(
                        "Skipping federated repository {0} from {1} @ {2}. Origin does not match, consider EXCLUDING.",
                        repository.name, registration.name, registration.url));
                registration.updateStatus(repository, FederationPullStatus.SKIPPED);
                continue;
            }
        }

        // clone/pull this repository
        CredentialsProvider credentials = new UsernamePasswordCredentialsProvider(Constants.FEDERATION_USER,
                registration.token);
        logger.info(MessageFormat.format("Pulling federated repository {0} from {1} @ {2}", repository.name,
                registration.name, registration.url));

        CloneResult result = JGitUtils.cloneRepository(registrationFolderFile, repository.name, cloneUrl,
                registration.bare, credentials);
        Repository r = GitBlit.self().getRepository(repositoryName);
        RepositoryModel rm = GitBlit.self().getRepositoryModel(repositoryName);
        repository.isFrozen = registration.mirror;
        if (result.createdRepository) {
            // default local settings
            repository.federationStrategy = FederationStrategy.EXCLUDE;
            repository.isFrozen = registration.mirror;
            repository.showRemoteBranches = !registration.mirror;
            logger.info(MessageFormat.format("     cloning {0}", repository.name));
            registration.updateStatus(repository, FederationPullStatus.MIRRORED);
        } else {
            // fetch and update
            boolean fetched = false;
            RevCommit commit = JGitUtils.getCommit(r, org.eclipse.jgit.lib.Constants.FETCH_HEAD);
            String newFetchHead = commit.getName();
            fetched = fetchHead == null || !fetchHead.equals(newFetchHead);

            if (registration.mirror) {
                // mirror
                if (fetched) {
                    // update local branches to match the remote tracking branches
                    for (RefModel ref : JGitUtils.getRemoteBranches(r, false, -1)) {
                        if (ref.displayName.startsWith("origin/")) {
                            String branch = org.eclipse.jgit.lib.Constants.R_HEADS
                                    + ref.displayName.substring(ref.displayName.indexOf('/') + 1);
                            String hash = ref.getReferencedObjectId().getName();

                            JGitUtils.setBranchRef(r, branch, hash);
                            logger.info(MessageFormat.format("     resetting {0} of {1} to {2}", branch,
                                    repository.name, hash));
                        }
                    }

                    String newHead;
                    if (StringUtils.isEmpty(repository.HEAD)) {
                        newHead = newFetchHead;
                    } else {
                        newHead = repository.HEAD;
                    }
                    JGitUtils.setHEADtoRef(r, newHead);
                    logger.info(MessageFormat.format("     resetting HEAD of {0} to {1}", repository.name,
                            newHead));
                    registration.updateStatus(repository, FederationPullStatus.MIRRORED);
                } else {
                    // indicate no commits pulled
                    registration.updateStatus(repository, FederationPullStatus.NOCHANGE);
                }
            } else {
                // non-mirror
                if (fetched) {
                    // indicate commits pulled to origin/master
                    registration.updateStatus(repository, FederationPullStatus.PULLED);
                } else {
                    // indicate no commits pulled
                    registration.updateStatus(repository, FederationPullStatus.NOCHANGE);
                }
            }

            // preserve local settings
            repository.isFrozen = rm.isFrozen;
            repository.federationStrategy = rm.federationStrategy;

            // merge federation sets
            Set<String> federationSets = new HashSet<String>();
            if (rm.federationSets != null) {
                federationSets.addAll(rm.federationSets);
            }
            if (repository.federationSets != null) {
                federationSets.addAll(repository.federationSets);
            }
            repository.federationSets = new ArrayList<String>(federationSets);

            // merge indexed branches
            Set<String> indexedBranches = new HashSet<String>();
            if (rm.indexedBranches != null) {
                indexedBranches.addAll(rm.indexedBranches);
            }
            if (repository.indexedBranches != null) {
                indexedBranches.addAll(repository.indexedBranches);
            }
            repository.indexedBranches = new ArrayList<String>(indexedBranches);

        }
        // only repositories that are actually _cloned_ from the origin
        // Gitblit repository are marked as federated. If the origin
        // is from somewhere else, these repositories are not considered
        // "federated" repositories.
        repository.isFederated = cloneUrl.startsWith(registration.url);

        GitBlit.self().updateConfiguration(r, repository);
        r.close();
    }

    IUserService userService = null;

    try {
        // Pull USERS
        // TeamModels are automatically pulled because they are contained
        // within the UserModel. The UserService creates unknown teams
        // and updates existing teams.
        Collection<UserModel> users = FederationUtils.getUsers(registration);
        if (users != null && users.size() > 0) {
            File realmFile = new File(registrationFolderFile, registration.name + "_users.conf");
            realmFile.delete();
            userService = new ConfigUserService(realmFile);
            for (UserModel user : users) {
                userService.updateUserModel(user.username, user);

                // merge the origin permissions and origin accounts into
                // the user accounts of this Gitblit instance
                if (registration.mergeAccounts) {
                    // reparent all repository permissions if the local
                    // repositories are stored within subfolders
                    if (!StringUtils.isEmpty(registrationFolder)) {
                        List<String> permissions = new ArrayList<String>(user.repositories);
                        user.repositories.clear();
                        for (String permission : permissions) {
                            user.addRepository(registrationFolder + "/" + permission);
                        }
                    }

                    // insert new user or update local user
                    UserModel localUser = GitBlit.self().getUserModel(user.username);
                    if (localUser == null) {
                        // create new local user
                        GitBlit.self().updateUserModel(user.username, user, true);
                    } else {
                        // update repository permissions of local user
                        for (String repository : user.repositories) {
                            localUser.addRepository(repository);
                        }
                        localUser.password = user.password;
                        localUser.canAdmin = user.canAdmin;
                        GitBlit.self().updateUserModel(localUser.username, localUser, false);
                    }

                    for (String teamname : GitBlit.self().getAllTeamnames()) {
                        TeamModel team = GitBlit.self().getTeamModel(teamname);
                        if (user.isTeamMember(teamname) && !team.hasUser(user.username)) {
                            // new team member
                            team.addUser(user.username);
                            GitBlit.self().updateTeamModel(teamname, team, false);
                        } else if (!user.isTeamMember(teamname) && team.hasUser(user.username)) {
                            // remove team member
                            team.removeUser(user.username);
                            GitBlit.self().updateTeamModel(teamname, team, false);
                        }

                        // update team repositories
                        TeamModel remoteTeam = user.getTeam(teamname);
                        if (remoteTeam != null && !ArrayUtils.isEmpty(remoteTeam.repositories)) {
                            int before = team.repositories.size();
                            team.addRepositories(remoteTeam.repositories);
                            int after = team.repositories.size();
                            if (after > before) {
                                // repository count changed, update
                                GitBlit.self().updateTeamModel(teamname, team, false);
                            }
                        }
                    }
                }
            }
        }
    } catch (ForbiddenException e) {
        // ignore forbidden exceptions
    } catch (IOException e) {
        logger.warn(MessageFormat.format("Failed to retrieve USERS from federated gitblit ({0} @ {1})",
                registration.name, registration.url), e);
    }

    try {
        // Pull TEAMS
        // We explicitly pull these even though they are embedded in
        // UserModels because it is possible to use teams to specify
        // mailing lists or push scripts without specifying users.
        if (userService != null) {
            Collection<TeamModel> teams = FederationUtils.getTeams(registration);
            if (teams != null && teams.size() > 0) {
                for (TeamModel team : teams) {
                    userService.updateTeamModel(team);
                }
            }
        }
    } catch (ForbiddenException e) {
        // ignore forbidden exceptions
    } catch (IOException e) {
        logger.warn(MessageFormat.format("Failed to retrieve TEAMS from federated gitblit ({0} @ {1})",
                registration.name, registration.url), e);
    }

    try {
        // Pull SETTINGS
        Map<String, String> settings = FederationUtils.getSettings(registration);
        if (settings != null && settings.size() > 0) {
            Properties properties = new Properties();
            properties.putAll(settings);
            FileOutputStream os = new FileOutputStream(
                    new File(registrationFolderFile, registration.name + "_" + Constants.PROPERTIES_FILE));
            properties.store(os, null);
            os.close();
        }
    } catch (ForbiddenException e) {
        // ignore forbidden exceptions
    } catch (IOException e) {
        logger.warn(MessageFormat.format("Failed to retrieve SETTINGS from federated gitblit ({0} @ {1})",
                registration.name, registration.url), e);
    }

    try {
        // Pull SCRIPTS
        Map<String, String> scripts = FederationUtils.getScripts(registration);
        if (scripts != null && scripts.size() > 0) {
            for (Map.Entry<String, String> script : scripts.entrySet()) {
                String scriptName = script.getKey();
                if (scriptName.endsWith(".groovy")) {
                    scriptName = scriptName.substring(0, scriptName.indexOf(".groovy"));
                }
                File file = new File(registrationFolderFile, registration.name + "_" + scriptName + ".groovy");
                FileUtils.writeContent(file, script.getValue());
            }
        }
    } catch (ForbiddenException e) {
        // ignore forbidden exceptions
    } catch (IOException e) {
        logger.warn(MessageFormat.format("Failed to retrieve SCRIPTS from federated gitblit ({0} @ {1})",
                registration.name, registration.url), e);
    }
}

From source file:com.gitblit.models.PushLogEntry.java

License:Apache License

/**
 * Returns the list of branches changed by the push.
 * /*w  w  w.  ja  v a 2  s.  c o m*/
 * @return a list of branches
 */
public List<String> getChangedBranches() {
    return getChangedRefs(Constants.R_HEADS);
}

From source file:com.gitblit.tests.JGitUtilsTest.java

License:Apache License

@Test
public void testBranches() throws Exception {
    Repository repository = GitBlitSuite.getJGitRepository();
    assertTrue(JGitUtils.getLocalBranches(repository, true, 0).size() == 0);
    for (RefModel model : JGitUtils.getLocalBranches(repository, true, -1)) {
        assertTrue(model.getName().startsWith(Constants.R_HEADS));
        assertTrue(model.equals(model));
        assertFalse(model.equals(""));
        assertTrue(model.hashCode() == model.getReferencedObjectId().hashCode() + model.getName().hashCode());
        assertTrue(model.getShortMessage().equals(model.getShortMessage()));
    }/* ww  w.j a  va  2 s  .com*/
    for (RefModel model : JGitUtils.getRemoteBranches(repository, true, -1)) {
        assertTrue(model.getName().startsWith(Constants.R_REMOTES));
        assertTrue(model.equals(model));
        assertFalse(model.equals(""));
        assertTrue(model.hashCode() == model.getReferencedObjectId().hashCode() + model.getName().hashCode());
        assertTrue(model.getShortMessage().equals(model.getShortMessage()));
    }
    assertTrue(JGitUtils.getRemoteBranches(repository, true, 8).size() == 8);
    repository.close();
}

From source file:com.gitblit.utils.ActivityUtils.java

License:Apache License

/**
 * Gets the recent activity from the repositories for the last daysBack days
 * on the specified branch.//  w w w .ja  v a 2s. c  o  m
 *
 * @param settings
 *            the runtime settings
 * @param repositoryManager
 *            the repository manager
 * @param models
 *            the list of repositories to query
 * @param daysBack
 *            the number of days back from Now to collect
 * @param objectId
 *            the branch to retrieve. If this value is null or empty all
 *            branches are queried.
 * @param timezone
 *            the timezone for aggregating commits
 * @return
 */
public static List<Activity> getRecentActivity(IStoredSettings settings, IRepositoryManager repositoryManager,
        List<RepositoryModel> models, int daysBack, String objectId, TimeZone timezone) {

    // Activity panel shows last daysBack of activity across all
    // repositories.
    Date thresholdDate = new Date(System.currentTimeMillis() - daysBack * TimeUtils.ONEDAY);

    // Build a map of DailyActivity from the available repositories for the
    // specified threshold date.
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    df.setTimeZone(timezone);
    Calendar cal = Calendar.getInstance();
    cal.setTimeZone(timezone);

    // aggregate author exclusions
    Set<String> authorExclusions = new TreeSet<String>();
    authorExclusions.addAll(settings.getStrings(Keys.web.metricAuthorExclusions));
    for (RepositoryModel model : models) {
        if (!ArrayUtils.isEmpty(model.metricAuthorExclusions)) {
            authorExclusions.addAll(model.metricAuthorExclusions);
        }
    }

    Map<String, Activity> activity = new HashMap<String, Activity>();
    for (RepositoryModel model : models) {
        if (!model.isShowActivity()) {
            // skip this repository
            continue;
        }
        if (model.hasCommits && model.lastChange.after(thresholdDate)) {
            if (model.isCollectingGarbage) {
                continue;
            }
            Repository repository = repositoryManager.getRepository(model.name);
            List<String> branches = new ArrayList<String>();
            if (StringUtils.isEmpty(objectId)) {
                for (RefModel local : JGitUtils.getLocalBranches(repository, true, -1)) {
                    if (!local.getDate().after(thresholdDate)) {
                        // branch not recently updated
                        continue;
                    }
                    branches.add(local.getName());
                }
            } else {
                branches.add(objectId);
            }

            for (String branch : branches) {
                String shortName = branch;
                if (shortName.startsWith(Constants.R_HEADS)) {
                    shortName = shortName.substring(Constants.R_HEADS.length());
                }
                List<RepositoryCommit> commits = CommitCache.instance().getCommits(model.name, repository,
                        branch, thresholdDate);
                if (model.maxActivityCommits > 0 && commits.size() > model.maxActivityCommits) {
                    // trim commits to maximum count
                    commits = commits.subList(0, model.maxActivityCommits);
                }
                for (RepositoryCommit commit : commits) {
                    Date date = commit.getCommitDate();
                    String dateStr = df.format(date);
                    if (!activity.containsKey(dateStr)) {
                        // Normalize the date to midnight
                        cal.setTime(date);
                        cal.set(Calendar.HOUR_OF_DAY, 0);
                        cal.set(Calendar.MINUTE, 0);
                        cal.set(Calendar.SECOND, 0);
                        cal.set(Calendar.MILLISECOND, 0);
                        Activity a = new Activity(cal.getTime());
                        a.excludeAuthors(authorExclusions);
                        activity.put(dateStr, a);
                    }
                    activity.get(dateStr).addCommit(commit);
                }
            }

            // close the repository
            repository.close();
        }
    }

    List<Activity> recentActivity = new ArrayList<Activity>(activity.values());
    return recentActivity;
}