Centralize default branch/HEAD resolution (issue-14)
If an object id was not specified Gitblit used HEAD to perform the
operation. This breaks under some conditions like working with a
repository that does not have any commits on master but does have
commits on a vcs-import branch.
The new approach is to centralize the resolution of unspecified object
ids to a common method which resolves HEAD first but uses the most
recently modified branch if HEAD points to nothing.
This commit also includes a non-functional method for creating an empty
branch. I couldn't figure out how to make JGit create an orphaned
branch.
| | |
| | | ## Git:Blit realm file format: username=password,\#permission,repository1,repository2...
|
| | | #Tue Jun 07 20:57:42 EDT 2011
|
| | | ## Gitblit realm file format: username=password,\#permission,repository1,repository2...
|
| | | #Fri Jul 22 14:27:08 EDT 2011
|
| | | admin=admin,\#admin
|
| | |
| | |
|
| | | **%VERSION%** ([go](http://code.google.com/p/gitblit/downloads/detail?name=%GO%)|[war](http://code.google.com/p/gitblit/downloads/detail?name=%WAR%)) based on [%JGIT%][jgit] *released %BUILDDATE%*
|
| | |
|
| | | - fixed: repositories with a HEAD that pointed to an empty branch caused internal errors (issue 14)
|
| | | - fixed: bare-cloned repositories were listed as (empty) and were not clickable (issue 13)
|
| | | - fixed: default port for Gitblit GO is now 8443 to be more linux/os x friendly (issue 12)
|
| | | - fixed: forward-slashes ('/', %2F) can be encoded using a custom character to workaround some servlet container default security measures for proxy servers (issue 11)<br/>**New:** *web.forwardSlashCharacter = /*
|
| | |
| | | ### Current Release
|
| | | **%VERSION%** ([go](http://code.google.com/p/gitblit/downloads/detail?name=%GO%)|[war](http://code.google.com/p/gitblit/downloads/detail?name=%WAR%)) based on [%JGIT%][jgit] *released %BUILDDATE%*
|
| | |
|
| | | - fixed: repositories with a HEAD that pointed to an empty branch caused internal errors (issue 14)
|
| | | - fixed: bare-cloned repositories were listed as (empty) and were not clickable (issue 13)
|
| | | - fixed: default port for Gitblit GO is now 8443 to be more linux/os x friendly (issue 12)
|
| | | - fixed: forward-slashes ('/', %2F) can be encoded using a custom character to workaround some servlet container default security measures for proxy servers (issue 11)<br/>**New:** *web.forwardSlashCharacter = /*
|
| | |
| | |
|
| | | private static Logger logger;
|
| | |
|
| | | public static void main(String[] args) {
|
| | | public static void main(String... args) {
|
| | | Params params = new Params();
|
| | | JCommander jc = new JCommander(params);
|
| | | try {
|
| | |
| | | import org.eclipse.jgit.diff.DiffFormatter;
|
| | | import org.eclipse.jgit.diff.RawText;
|
| | | import org.eclipse.jgit.diff.RawTextComparator;
|
| | | import org.eclipse.jgit.lib.Constants;
|
| | | import org.eclipse.jgit.lib.ObjectId;
|
| | | import org.eclipse.jgit.lib.Repository;
|
| | | import org.eclipse.jgit.revwalk.RevCommit;
|
| | | import org.eclipse.jgit.revwalk.RevTree;
|
| | |
| | | RevTree commitTree = commit.getTree();
|
| | | RevTree baseTree;
|
| | | if (baseCommit == null) {
|
| | | if (commit.getParentCount() > 0) {
|
| | | final RevWalk rw = new RevWalk(repository);
|
| | | RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
|
| | | rw.dispose();
|
| | | baseTree = parent.getTree();
|
| | | } else {
|
| | | // FIXME initial commit. no parent?!
|
| | | baseTree = commitTree;
|
| | | }
|
| | | } else {
|
| | | baseTree = baseCommit.getTree();
|
| | | }
|
| | |
| | | RevTree commitTree = commit.getTree();
|
| | | RevTree baseTree;
|
| | | if (baseCommit == null) {
|
| | | if (commit.getParentCount() > 0) {
|
| | | final RevWalk rw = new RevWalk(repository);
|
| | | RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
|
| | | baseTree = parent.getTree();
|
| | | } else {
|
| | | // FIXME initial commit. no parent?!
|
| | | baseTree = commitTree;
|
| | | }
|
| | | } else {
|
| | | baseTree = baseCommit.getTree();
|
| | | }
|
| | |
| | | public static List<AnnotatedLine> blame(Repository repository, String blobPath, String objectId) {
|
| | | List<AnnotatedLine> lines = new ArrayList<AnnotatedLine>();
|
| | | try {
|
| | | ObjectId object;
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | objectId = Constants.HEAD;
|
| | | object = JGitUtils.getDefaultBranch(repository);
|
| | | } else {
|
| | | object = repository.resolve(objectId);
|
| | | }
|
| | | BlameCommand blameCommand = new BlameCommand(repository);
|
| | | blameCommand.setFilePath(blobPath);
|
| | | blameCommand.setStartCommit(repository.resolve(objectId));
|
| | | blameCommand.setStartCommit(object);
|
| | | BlameResult blameResult = blameCommand.call();
|
| | | RawText rawText = blameResult.getResultContents();
|
| | | int length = rawText.size();
|
| | |
| | | package com.gitblit.utils;
|
| | |
|
| | | import java.io.BufferedReader;
|
| | | import java.io.BufferedWriter;
|
| | | import java.io.File;
|
| | | import java.io.FileInputStream;
|
| | | import java.io.FileOutputStream;
|
| | | import java.io.InputStreamReader;
|
| | | import java.io.OutputStreamWriter;
|
| | | import java.nio.charset.Charset;
|
| | |
|
| | | /**
|
| | |
| | | }
|
| | |
|
| | | /**
|
| | | * Writes the string content to the file.
|
| | | * |
| | | * @param file
|
| | | * @param content
|
| | | */
|
| | | public static void writeContent(File file, String content) {
|
| | | try {
|
| | | OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream(file),
|
| | | Charset.forName("UTF-8")); |
| | | BufferedWriter writer = new BufferedWriter(os);
|
| | | writer.append(content);
|
| | | writer.close();
|
| | | } catch (Throwable t) {
|
| | | System.err.println("Failed to write content of " + file.getAbsolutePath());
|
| | | t.printStackTrace();
|
| | | }
|
| | | }
|
| | |
|
| | | /**
|
| | | * Recursively traverses a folder and its subfolders to calculate the total
|
| | | * size in bytes.
|
| | | *
|
| | |
| | | import java.io.InputStream;
|
| | | import java.io.OutputStream;
|
| | | import java.nio.charset.Charset;
|
| | | import java.text.MessageFormat;
|
| | | import java.util.ArrayList;
|
| | | import java.util.Arrays;
|
| | | import java.util.Collection;
|
| | |
| | | public class JGitUtils {
|
| | |
|
| | | static final Logger LOGGER = LoggerFactory.getLogger(JGitUtils.class);
|
| | |
|
| | | /**
|
| | | * Log an error message and exception.
|
| | | * |
| | | * @param t
|
| | | * @param repository
|
| | | * if repository is not null it MUST be the {0} parameter in the
|
| | | * pattern.
|
| | | * @param pattern
|
| | | * @param objects
|
| | | */
|
| | | private static void error(Throwable t, Repository repository, String pattern, Object... objects) {
|
| | | List<Object> parameters = new ArrayList<Object>();
|
| | | if (objects != null && objects.length > 0) {
|
| | | for (Object o : objects) {
|
| | | parameters.add(o);
|
| | | }
|
| | | }
|
| | | if (repository != null) {
|
| | | parameters.add(0, repository.getDirectory().getAbsolutePath());
|
| | | }
|
| | | LOGGER.error(MessageFormat.format(pattern, parameters.toArray()), t);
|
| | | }
|
| | |
|
| | | /**
|
| | | * Returns the displayable name of the person in the form "Real Name <email
|
| | |
| | | if (!hasCommits(repository)) {
|
| | | return null;
|
| | | }
|
| | | if (StringUtils.isEmpty(branch)) {
|
| | | branch = Constants.HEAD;
|
| | | }
|
| | | RevCommit commit = null;
|
| | | try {
|
| | | // resolve branch
|
| | | ObjectId branchObject;
|
| | | if (StringUtils.isEmpty(branch)) {
|
| | | branchObject = getDefaultBranch(repository);
|
| | | } else {
|
| | | branchObject = repository.resolve(branch);
|
| | | }
|
| | |
|
| | | RevWalk walk = new RevWalk(repository);
|
| | | walk.sort(RevSort.REVERSE);
|
| | | RevCommit head = walk.parseCommit(repository.resolve(branch));
|
| | | RevCommit head = walk.parseCommit(branchObject);
|
| | | walk.markStart(head);
|
| | | commit = walk.next();
|
| | | walk.dispose();
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to determine first commit", t);
|
| | | error(t, repository, "{0} failed to determine first commit");
|
| | | }
|
| | | return commit;
|
| | | }
|
| | |
| | | *
|
| | | * @param repository
|
| | | * @param branch
|
| | | * if unspecified, HEAD is assumed.
|
| | | * if unspecified, all branches are checked.
|
| | | * @return
|
| | | */
|
| | | public static Date getLastChange(Repository repository, String branch) {
|
| | |
| | | return new Date(repository.getDirectory().lastModified());
|
| | | }
|
| | | if (StringUtils.isEmpty(branch)) {
|
| | | List<RefModel> branchModels = getLocalBranches(repository, true, -1);
|
| | | if (branchModels.size() > 0) {
|
| | | // find most recent branch update
|
| | | Date lastChange = new Date(0);
|
| | | for (RefModel branchModel : branchModels) {
|
| | | if (branchModel.getDate().after(lastChange)) {
|
| | | lastChange = branchModel.getDate();
|
| | | }
|
| | | }
|
| | | return lastChange;
|
| | | } else {
|
| | | // try to find head
|
| | | branch = Constants.HEAD;
|
| | | }
|
| | | }
|
| | |
|
| | | // lookup specified branch
|
| | | RevCommit commit = getCommit(repository, branch);
|
| | | return getCommitDate(commit);
|
| | | }
|
| | |
| | | * Retrieves a Java Date from a Git commit.
|
| | | *
|
| | | * @param commit
|
| | | * @return date of the commit
|
| | | * @return date of the commit or Date(0) if the commit is null
|
| | | */
|
| | | public static Date getCommitDate(RevCommit commit) {
|
| | | if (commit == null) {
|
| | | return new Date(0);
|
| | | }
|
| | | return new Date(commit.getCommitTime() * 1000L);
|
| | | }
|
| | |
|
| | |
| | | }
|
| | | RevCommit commit = null;
|
| | | try {
|
| | | // resolve object id
|
| | | ObjectId branchObject;
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | objectId = Constants.HEAD;
|
| | | branchObject = getDefaultBranch(repository);
|
| | | } else {
|
| | | branchObject = repository.resolve(objectId);
|
| | | }
|
| | | ObjectId object = repository.resolve(objectId);
|
| | | RevWalk walk = new RevWalk(repository);
|
| | | RevCommit rev = walk.parseCommit(object);
|
| | | RevCommit rev = walk.parseCommit(branchObject);
|
| | | commit = rev;
|
| | | walk.dispose();
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to get commit " + objectId, t);
|
| | | error(t, repository, "{0} failed to get commit {1}", objectId);
|
| | | }
|
| | | return commit;
|
| | | }
|
| | |
| | | byte[] content = null;
|
| | | try {
|
| | | if (tree == null) {
|
| | | ObjectId object = repository.resolve(Constants.HEAD);
|
| | | ObjectId object = getDefaultBranch(repository);
|
| | | RevCommit commit = rw.parseCommit(object);
|
| | | tree = commit.getTree();
|
| | | }
|
| | |
| | | content = os.toByteArray();
|
| | | }
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Can't find " + path + " in tree " + tree.name(), t);
|
| | | error(t, repository, "{0} can't find {1} in tree {2}", path, tree.name());
|
| | | } finally {
|
| | | rw.dispose();
|
| | | tw.release();
|
| | |
| | | in.close();
|
| | | content = os.toByteArray();
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Can't find blob " + objectId, t);
|
| | | error(t, repository, "{0} can't find blob {1}", objectId);
|
| | | } finally {
|
| | | rw.dispose();
|
| | | }
|
| | |
| | | return list;
|
| | | }
|
| | | if (commit == null) {
|
| | | commit = getCommit(repository, Constants.HEAD);
|
| | | commit = getCommit(repository, null);
|
| | | }
|
| | | final TreeWalk tw = new TreeWalk(repository);
|
| | | try {
|
| | |
| | | }
|
| | | }
|
| | | } catch (IOException e) {
|
| | | LOGGER.error("Failed to get files for commit " + commit.getName(), e);
|
| | | error(e, repository, "{0} failed to get files for commit {1}", commit.getName());
|
| | | } finally {
|
| | | tw.release();
|
| | | }
|
| | |
| | | RevWalk rw = new RevWalk(repository);
|
| | | try {
|
| | | if (commit == null) {
|
| | | ObjectId object = repository.resolve(Constants.HEAD);
|
| | | ObjectId object = getDefaultBranch(repository);
|
| | | commit = rw.parseCommit(object);
|
| | | }
|
| | |
|
| | |
| | | }
|
| | | }
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("failed to determine files in commit!", t);
|
| | | error(t, repository, "{0} failed to determine files in commit!");
|
| | | } finally {
|
| | | rw.dispose();
|
| | | }
|
| | |
| | | if (!hasCommits(repository)) {
|
| | | return list;
|
| | | }
|
| | | RevCommit commit = getCommit(repository, Constants.HEAD);
|
| | | RevCommit commit = getCommit(repository, null);
|
| | | final TreeWalk tw = new TreeWalk(repository);
|
| | | try {
|
| | | tw.addTree(commit.getTree());
|
| | |
| | | list.add(getPathModel(tw, null, commit));
|
| | | }
|
| | | } catch (IOException e) {
|
| | | LOGGER.error("Failed to get documents for commit " + commit.getName(), e);
|
| | | error(e, repository, "{0} failed to get documents for commit {1}", commit.getName());
|
| | | } finally {
|
| | | tw.release();
|
| | | }
|
| | |
| | | size = tw.getObjectReader().getObjectSize(tw.getObjectId(0), Constants.OBJ_BLOB);
|
| | | }
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to retrieve blob size", t);
|
| | | error(t, null, "failed to retrieve blob size for " + tw.getPathString());
|
| | | }
|
| | | return new PathModel(name, tw.getPathString(), size, tw.getFileMode(0).getBits(),
|
| | | commit.getName());
|
| | |
| | | * @return list of commits
|
| | | */
|
| | | public static List<RevCommit> getRevLog(Repository repository, int maxCount) {
|
| | | return getRevLog(repository, Constants.HEAD, 0, maxCount);
|
| | | return getRevLog(repository, null, 0, maxCount);
|
| | | }
|
| | |
|
| | | /**
|
| | |
| | | return list;
|
| | | }
|
| | | try {
|
| | | // resolve branch
|
| | | ObjectId branchObject;
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | objectId = Constants.HEAD;
|
| | | branchObject = getDefaultBranch(repository);
|
| | | } else {
|
| | | branchObject = repository.resolve(objectId);
|
| | | }
|
| | |
|
| | | RevWalk rw = new RevWalk(repository);
|
| | | ObjectId object = repository.resolve(objectId);
|
| | | rw.markStart(rw.parseCommit(object));
|
| | | rw.markStart(rw.parseCommit(branchObject));
|
| | | if (!StringUtils.isEmpty(path)) {
|
| | | TreeFilter filter = AndTreeFilter.create(
|
| | | PathFilterGroup.createFromStrings(Collections.singleton(path)),
|
| | |
| | | }
|
| | | rw.dispose();
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to get revlog", t);
|
| | | error(t, repository, "{0} failed to get {1} revlog for path {2}", objectId, path);
|
| | | }
|
| | | return list;
|
| | | }
|
| | |
| | | return list;
|
| | | }
|
| | | try {
|
| | | // resolve branch
|
| | | ObjectId branchObject;
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | objectId = Constants.HEAD;
|
| | | branchObject = getDefaultBranch(repository);
|
| | | } else {
|
| | | branchObject = repository.resolve(objectId);
|
| | | }
|
| | |
|
| | | RevWalk rw = new RevWalk(repository);
|
| | | rw.setRevFilter(new RevFilter() {
|
| | |
|
| | |
| | | }
|
| | |
|
| | | });
|
| | | ObjectId object = repository.resolve(objectId);
|
| | | rw.markStart(rw.parseCommit(object));
|
| | | rw.markStart(rw.parseCommit(branchObject));
|
| | | Iterable<RevCommit> revlog = rw;
|
| | | if (offset > 0) {
|
| | | int count = 0;
|
| | |
| | | }
|
| | | rw.dispose();
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to search revlogs", t);
|
| | | error(t, repository, "{0} failed to {1} search revlogs for {2}", type.name(), value);
|
| | | }
|
| | | return list;
|
| | | }
|
| | |
|
| | | /**
|
| | | * Returns the default branch to use for a repository. Normally returns
|
| | | * whatever branch HEAD points to, but if HEAD points to nothing it returns
|
| | | * the most recently updated branch.
|
| | | * |
| | | * @param repository
|
| | | * @return the objectid of a branch
|
| | | * @throws Exception
|
| | | */
|
| | | public static ObjectId getDefaultBranch(Repository repository) throws Exception {
|
| | | ObjectId object = repository.resolve(Constants.HEAD);
|
| | | if (object == null) {
|
| | | // no HEAD
|
| | | // perhaps non-standard repository, try local branches
|
| | | List<RefModel> branchModels = getLocalBranches(repository, true, -1);
|
| | | if (branchModels.size() > 0) {
|
| | | // use most recently updated branch
|
| | | RefModel branch = null;
|
| | | Date lastDate = new Date(0);
|
| | | for (RefModel branchModel : branchModels) {
|
| | | if (branchModel.getDate().after(lastDate)) {
|
| | | branch = branchModel;
|
| | | lastDate = branch.getDate();
|
| | | }
|
| | | }
|
| | | object = branch.getReferencedObjectId();
|
| | | }
|
| | | }
|
| | | return object;
|
| | | }
|
| | |
|
| | | /**
|
| | |
| | | list = new ArrayList<RefModel>(list.subList(0, maxCount));
|
| | | }
|
| | | } catch (IOException e) {
|
| | | LOGGER.error("Failed to retrieve " + refs, e);
|
| | | error(e, repository, "{0} failed to retrieve {1}", refs);
|
| | | }
|
| | | return list;
|
| | | }
|
| | |
| | | }
|
| | |
|
| | | /**
|
| | | * Create an orphaned branch in a repository. This code does not work.
|
| | | * |
| | | * @param repository
|
| | | * @param name
|
| | | * @return
|
| | | */
|
| | | public static boolean createOrphanBranch(Repository repository, String name) {
|
| | | return true;
|
| | | // boolean success = false;
|
| | | // try {
|
| | | // ObjectId prev = repository.resolve(Constants.HEAD + "^1");
|
| | | // // create the orphan branch
|
| | | // RefUpdate orphanRef = repository.updateRef(Constants.R_HEADS + name);
|
| | | // orphanRef.setNewObjectId(prev);
|
| | | // orphanRef.setExpectedOldObjectId(ObjectId.zeroId());
|
| | | // Result updateResult = orphanRef.update();
|
| | | //
|
| | | // switch (updateResult) {
|
| | | // case NEW:
|
| | | // success = true;
|
| | | // break;
|
| | | // case NO_CHANGE:
|
| | | // default:
|
| | | // break;
|
| | | // }
|
| | | //
|
| | | // } catch (Throwable t) {
|
| | | // error(t, repository, "{0} failed to create orphaned branch {1}",
|
| | | // name);
|
| | | // }
|
| | | // return success;
|
| | | }
|
| | |
|
| | | /**
|
| | | * Returns a StoredConfig object for the repository.
|
| | | *
|
| | | * @param repository
|
| | |
| | | try {
|
| | | c.load();
|
| | | } catch (ConfigInvalidException cex) {
|
| | | LOGGER.error("Repository configuration is invalid!", cex);
|
| | | error(cex, repository, "{0} configuration is invalid!");
|
| | | } catch (IOException cex) {
|
| | | LOGGER.error("Could not open repository configuration!", cex);
|
| | | error(cex, repository, "Could not open configuration for {0}!");
|
| | | }
|
| | | return c;
|
| | | }
|
| | |
| | | zos.finish();
|
| | | success = true;
|
| | | } catch (IOException e) {
|
| | | LOGGER.error("Failed to zip files from commit " + commit.getName(), e);
|
| | | error(e, repository, "{0} failed to zip files from commit {1}", commit.getName());
|
| | | } finally {
|
| | | tw.release();
|
| | | rw.dispose();
|
| | |
| | | package com.gitblit.utils;
|
| | |
|
| | | import java.text.DateFormat;
|
| | | import java.text.MessageFormat;
|
| | | import java.text.SimpleDateFormat;
|
| | | import java.util.ArrayList;
|
| | | import java.util.Collections;
|
| | |
| | | private static final Logger LOGGER = LoggerFactory.getLogger(MetricUtils.class);
|
| | |
|
| | | /**
|
| | | * Log an error message and exception.
|
| | | * |
| | | * @param t
|
| | | * @param repository
|
| | | * if repository is not null it MUST be the {0} parameter in the
|
| | | * pattern.
|
| | | * @param pattern
|
| | | * @param objects
|
| | | */
|
| | | private static void error(Throwable t, Repository repository, String pattern, Object... objects) {
|
| | | List<Object> parameters = new ArrayList<Object>();
|
| | | if (objects != null && objects.length > 0) {
|
| | | for (Object o : objects) {
|
| | | parameters.add(o);
|
| | | }
|
| | | }
|
| | | if (repository != null) {
|
| | | parameters.add(0, repository.getDirectory().getAbsolutePath());
|
| | | }
|
| | | LOGGER.error(MessageFormat.format(pattern, parameters.toArray()), t);
|
| | | }
|
| | |
|
| | | /**
|
| | | * Returns the list of metrics for the specified commit reference, branch,
|
| | | * or tag within the repository. If includeTotal is true, the total of all
|
| | | * the metrics will be included as the first element in the returned list.
|
| | |
| | | boolean includeTotal, String dateFormat) {
|
| | | Metric total = new Metric("TOTAL");
|
| | | final Map<String, Metric> metricMap = new HashMap<String, Metric>();
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | objectId = Constants.HEAD;
|
| | | }
|
| | |
|
| | | if (JGitUtils.hasCommits(repository)) {
|
| | | final List<RefModel> tags = JGitUtils.getTags(repository, true, -1);
|
| | | final Map<ObjectId, RefModel> tagMap = new HashMap<ObjectId, RefModel>();
|
| | |
| | | }
|
| | | RevWalk revWalk = null;
|
| | | try {
|
| | | // resolve branch
|
| | | ObjectId branchObject;
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | branchObject = JGitUtils.getDefaultBranch(repository);
|
| | | } else {
|
| | | branchObject = repository.resolve(objectId);
|
| | | }
|
| | | |
| | | revWalk = new RevWalk(repository);
|
| | | ObjectId object = repository.resolve(objectId);
|
| | | RevCommit lastCommit = revWalk.parseCommit(object);
|
| | | RevCommit lastCommit = revWalk.parseCommit(branchObject);
|
| | | revWalk.markStart(lastCommit);
|
| | |
|
| | | DateFormat df;
|
| | | if (StringUtils.isEmpty(dateFormat)) {
|
| | | // dynamically determine date format
|
| | | RevCommit firstCommit = JGitUtils.getFirstCommit(repository, Constants.HEAD);
|
| | | RevCommit firstCommit = JGitUtils.getFirstCommit(repository, branchObject.getName());
|
| | | int diffDays = (lastCommit.getCommitTime() - firstCommit.getCommitTime())
|
| | | / (60 * 60 * 24);
|
| | | total.duration = diffDays;
|
| | |
| | | }
|
| | | }
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to mine log history for date metrics", t);
|
| | | error(t, repository, "{0} failed to mine log history for date metrics of {1}",
|
| | | objectId);
|
| | | } finally {
|
| | | if (revWalk != null) {
|
| | | revWalk.dispose();
|
| | |
| | | public static List<Metric> getAuthorMetrics(Repository repository, String objectId,
|
| | | boolean byEmailAddress) {
|
| | | final Map<String, Metric> metricMap = new HashMap<String, Metric>();
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | objectId = Constants.HEAD;
|
| | | }
|
| | | if (JGitUtils.hasCommits(repository)) {
|
| | | try {
|
| | | RevWalk walk = new RevWalk(repository);
|
| | | ObjectId object = repository.resolve(objectId);
|
| | | RevCommit lastCommit = walk.parseCommit(object);
|
| | | // resolve branch
|
| | | ObjectId branchObject;
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | branchObject = JGitUtils.getDefaultBranch(repository);
|
| | | } else {
|
| | | branchObject = repository.resolve(objectId);
|
| | | }
|
| | | RevCommit lastCommit = walk.parseCommit(branchObject);
|
| | | walk.markStart(lastCommit);
|
| | |
|
| | | Iterable<RevCommit> revlog = walk;
|
| | |
| | | m.count++;
|
| | | }
|
| | | } catch (Throwable t) {
|
| | | LOGGER.error("Failed to mine log history for author metrics", t);
|
| | | error(t, repository, "{0} failed to mine log history for author metrics of {1}",
|
| | | objectId);
|
| | | }
|
| | | }
|
| | | List<String> keys = new ArrayList<String>(metricMap.keySet());
|
| | |
| | | if (StringUtils.isEmpty(path)) {
|
| | | return newObjectParameter(repositoryName, objectId);
|
| | | }
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | return new PageParameters("r=" + repositoryName + ",f=" + path);
|
| | | }
|
| | | return new PageParameters("r=" + repositoryName + ",h=" + objectId + ",f=" + path);
|
| | | }
|
| | |
|
| | |
| | | int pageNumber) {
|
| | | if (pageNumber <= 1) {
|
| | | return newObjectParameter(repositoryName, objectId);
|
| | | }
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | return new PageParameters("r=" + repositoryName + ",page=" + pageNumber);
|
| | | }
|
| | | return new PageParameters("r=" + repositoryName + ",h=" + objectId + ",page=" + pageNumber);
|
| | | }
|
| | |
| | | if (pageNumber <= 1) {
|
| | | return newObjectParameter(repositoryName, objectId);
|
| | | }
|
| | | if (StringUtils.isEmpty(objectId)) {
|
| | | return new PageParameters("r=" + repositoryName + ",f=" + path + ",page=" + pageNumber);
|
| | | }
|
| | | return new PageParameters("r=" + repositoryName + ",h=" + objectId + ",f=" + path
|
| | | + ",page=" + pageNumber);
|
| | | }
|
| | |
|
| | | public static PageParameters newBlobDiffParameter(String repositoryName, String baseCommitId,
|
| | | String commitId, String path) {
|
| | | if (StringUtils.isEmpty(commitId)) {
|
| | | return new PageParameters("r=" + repositoryName + ",f=" + path + ",hb=" + baseCommitId);
|
| | | }
|
| | | return new PageParameters("r=" + repositoryName + ",h=" + commitId + ",f=" + path + ",hb="
|
| | | + baseCommitId);
|
| | | }
|
| | |
| | |
|
| | | public static PageParameters newSearchParameter(String repositoryName, String commitId,
|
| | | String search, SearchType type, int pageNumber) {
|
| | | if (StringUtils.isEmpty(commitId)) {
|
| | | return new PageParameters("r=" + repositoryName + ",s=" + search + ",st=" + type.name()
|
| | | + ",page=" + pageNumber);
|
| | | }
|
| | | return new PageParameters("r=" + repositoryName + ",h=" + commitId + ",s=" + search
|
| | | + ",st=" + type.name() + ",page=" + pageNumber);
|
| | | }
|
| | |
| | | }
|
| | |
|
| | | public static String getObject(PageParameters params) {
|
| | | return params.getString("h", Constants.HEAD);
|
| | | return params.getString("h", null);
|
| | | }
|
| | |
|
| | | public static String getPath(PageParameters params) {
|
| | |
| | | if (timeZone != null) {
|
| | | df.setTimeZone(timeZone);
|
| | | }
|
| | | String dateString = df.format(date);
|
| | | String dateString;
|
| | | if (date.getTime() == 0) {
|
| | | dateString = "--";
|
| | | } else {
|
| | | dateString = df.format(date);
|
| | | }
|
| | | String title = TimeUtils.timeAgo(date);
|
| | | Label label = new Label(wicketId, dateString);
|
| | | WicketUtils.setHtmlTooltip(label, title);
|
| | |
| | |
|
| | | if (entry.isTree()) {
|
| | | item.add(new LinkPanel("pathName", null, entry.path, TreePage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | } else {
|
| | | item.add(new LinkPanel("pathName", "list", entry.path, BlobPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | }
|
| | |
|
| | | item.add(new BookmarkablePageLink<Void>("patch", PatchPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("view", BlobPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("blame", BlamePage.class,
|
| | | newPathParameter(entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
|
| | | newPathParameter(entry.path)).setEnabled(!entry.changeType
|
| | | .equals(ChangeType.ADD)));
|
| | | item.add(new BookmarkablePageLink<Void>("patch", PatchPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("view", BlobPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("blame", BlamePage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path))
|
| | | .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
|
| | |
|
| | | WicketUtils.setAlternatingBackground(item, counter);
|
| | | counter++;
|
| | |
| | | item.add(changeType);
|
| | | if (entry.isTree()) {
|
| | | item.add(new LinkPanel("pathName", null, entry.path, TreePage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | } else {
|
| | | item.add(new LinkPanel("pathName", "list", entry.path, BlobPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | }
|
| | |
|
| | | item.add(new BookmarkablePageLink<Void>("diff", BlobDiffPage.class,
|
| | | newPathParameter(entry.path)).setEnabled(!entry.changeType
|
| | | .equals(ChangeType.ADD) && !entry.changeType.equals(ChangeType.DELETE)));
|
| | | item.add(new BookmarkablePageLink<Void>("view", BlobPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("blame", BlamePage.class,
|
| | | newPathParameter(entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
|
| | | newPathParameter(entry.path)).setEnabled(!entry.changeType
|
| | | .equals(ChangeType.ADD)));
|
| | | item.add(new BookmarkablePageLink<Void>("diff", BlobDiffPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path))
|
| | | .setEnabled(!entry.changeType.equals(ChangeType.ADD)
|
| | | && !entry.changeType.equals(ChangeType.DELETE)));
|
| | | item.add(new BookmarkablePageLink<Void>("view", BlobPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("blame", BlamePage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | item.add(new BookmarkablePageLink<Void>("history", HistoryPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path))
|
| | | .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
|
| | |
|
| | | WicketUtils.setAlternatingBackground(item, counter);
|
| | | counter++;
|
| | |
| | | PathModel entry = item.getModelObject();
|
| | | item.add(WicketUtils.newImage("docIcon", "file_world_16x16.png"));
|
| | | item.add(new Label("docSize", byteFormat.format(entry.size)));
|
| | | item.add(new LinkPanel("docName", "list", entry.name, BlobPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | item.add(new LinkPanel("docName", "list", entry.name, BlobPage.class, WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | |
|
| | | // links
|
| | | item.add(new BookmarkablePageLink<Void>("view", BlobPage.class, WicketUtils
|
| | |
| | | return WicketUtils.newObjectParameter(repositoryName, commitId);
|
| | | }
|
| | |
|
| | | protected PageParameters newPathParameter(String path) {
|
| | | return WicketUtils.newPathParameter(repositoryName, objectId, path);
|
| | | }
|
| | |
|
| | | private static class PageRegistration implements Serializable {
|
| | | private static final long serialVersionUID = 1L;
|
| | |
|
| | |
| | | };
|
| | | add(ticketsView);
|
| | | }
|
| | | |
| | | protected PageParameters newPathParameter(String path) {
|
| | | return WicketUtils.newPathParameter(repositoryName, objectId, path);
|
| | | }
|
| | |
|
| | | @Override
|
| | | protected String getPageName() {
|
| | |
| | | item.add(WicketUtils.newBlankImage("pathIcon"));
|
| | | item.add(new Label("pathSize", ""));
|
| | | item.add(new LinkPanel("pathName", null, entry.name, TreePage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils
|
| | | .newPathParameter(repositoryName, entry.commitId, entry.path)));
|
| | | item.add(new Label("pathLinks", ""));
|
| | | } else {
|
| | | if (entry.isTree()) {
|
| | |
| | | item.add(WicketUtils.newImage("pathIcon", "folder_16x16.png"));
|
| | | item.add(new Label("pathSize", ""));
|
| | | item.add(new LinkPanel("pathName", "list", entry.name, TreePage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils.newPathParameter(repositoryName, entry.commitId,
|
| | | entry.path)));
|
| | |
|
| | | // links
|
| | | Fragment links = new Fragment("pathLinks", "treeLinks", this);
|
| | |
| | | item.add(WicketUtils.getFileImage("pathIcon", entry.name));
|
| | | item.add(new Label("pathSize", byteFormat.format(entry.size)));
|
| | | item.add(new LinkPanel("pathName", "list", entry.name, BlobPage.class,
|
| | | newPathParameter(entry.path)));
|
| | | WicketUtils.newPathParameter(repositoryName, entry.commitId,
|
| | | entry.path)));
|
| | |
|
| | | // links
|
| | | Fragment links = new Fragment("pathLinks", "blobLinks", this);
|
| | |
| | | import org.apache.wicket.markup.repeater.data.DataView;
|
| | | import org.apache.wicket.markup.repeater.data.ListDataProvider;
|
| | | import org.apache.wicket.model.StringResourceModel;
|
| | | import org.eclipse.jgit.lib.Constants;
|
| | | import org.eclipse.jgit.lib.Repository;
|
| | |
|
| | | import com.gitblit.SyndicationServlet;
|
| | |
| | | this, null), BranchesPage.class, WicketUtils.newRepositoryParameter(model.name)));
|
| | | }
|
| | | // We always have 1 branch
|
| | | hasBranches = branches.size() > 1;
|
| | | hasBranches = (branches.size() > 1)
|
| | | || ((branches.size() == 1) && !branches.get(0).displayName
|
| | | .equalsIgnoreCase(Constants.HEAD));
|
| | | }
|
| | |
|
| | | public BranchesPanel hideIfEmpty() {
|
| | |
| | |
|
| | | row.add(new Label("repositoryOwner", entry.owner));
|
| | |
|
| | | String lastChange = TimeUtils.timeAgo(entry.lastChange);
|
| | | String lastChange;
|
| | | if (entry.lastChange.getTime() == 0) {
|
| | | lastChange = "--";
|
| | | } else {
|
| | | lastChange = TimeUtils.timeAgo(entry.lastChange);
|
| | | }
|
| | | Label lastChangeLabel = new Label("repositoryLastChange", lastChange);
|
| | | row.add(lastChangeLabel);
|
| | | WicketUtils.setCssClass(lastChangeLabel, TimeUtils.timeAgoCss(entry.lastChange));
|
| | |
| | | assertTrue("Helloworld model is null!", model != null);
|
| | | assertTrue(model.toString().equals(
|
| | | GitBlitSuite.getHelloworldRepository().getDirectory().getName()));
|
| | | assertEquals("" + GitBlit.self().calculateSize(model), GitBlit.self().calculateSize(model),
|
| | | 22004L);
|
| | | assertTrue(GitBlit.self().calculateSize(model) > 22000L);
|
| | | }
|
| | |
|
| | | public void testUserModel() throws Exception {
|
| | |
| | | import org.eclipse.jgit.lib.RepositoryCache.FileKey;
|
| | | import org.eclipse.jgit.revwalk.RevCommit;
|
| | | import org.eclipse.jgit.util.FS;
|
| | | import org.eclipse.jgit.util.FileUtils;
|
| | |
|
| | | import com.gitblit.GitBlit;
|
| | | import com.gitblit.Keys;
|
| | |
| | | .equals("183474d554e6f68478a02d9d7888b67a9338cdff"));
|
| | | }
|
| | |
|
| | | public void testCreateOrphanedBranch() throws Exception {
|
| | | Repository repository = JGitUtils.createRepository(GitBlitSuite.REPOSITORIES, "orphantest"); |
| | | assertTrue(JGitUtils.createOrphanBranch(repository,
|
| | | "x" + Long.toHexString(System.currentTimeMillis()).toUpperCase()));
|
| | | FileUtils.delete(repository.getDirectory(), FileUtils.RECURSIVE);
|
| | | }
|
| | |
|
| | | public void testStringContent() throws Exception {
|
| | | Repository repository = GitBlitSuite.getHelloworldRepository();
|
| | | String contentA = JGitUtils.getStringContent(repository, null, "java.java");
|
| | |
| | | assertTrue(zipFileB.length() > 0);
|
| | | zipFileB.delete();
|
| | | }
|
| | |
|
| | | } |