From 0e44acbb2fec928a1606dc60f427a148fff405c9 Mon Sep 17 00:00:00 2001
From: Mohamed Ragab <moragab@gmail.com>
Date: Wed, 02 May 2012 11:15:01 -0400
Subject: [PATCH] Added a script to facilitate setting the proxy host and port and no proxy hosts, and then it concatenates all the java system properties for setting the java proxy configurations and puts the resulting string in an environment variable JAVA_PROXY_CONFIG, modified the scirpts gitblit, gitblit-ubuntu, and gitblit-centos to source the java-proxy-config.sh script and then include the resulting java proxy configuration in the java command
---
src/com/gitblit/utils/JGitUtils.java | 391 +++++++++++++++++++++++++++++++++++++++++--------------
1 files changed, 291 insertions(+), 100 deletions(-)
diff --git a/src/com/gitblit/utils/JGitUtils.java b/src/com/gitblit/utils/JGitUtils.java
index e73ee80..72e948c 100644
--- a/src/com/gitblit/utils/JGitUtils.java
+++ b/src/com/gitblit/utils/JGitUtils.java
@@ -24,7 +24,6 @@
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
@@ -37,8 +36,6 @@
import org.eclipse.jgit.api.CloneCommand;
import org.eclipse.jgit.api.FetchCommand;
import org.eclipse.jgit.api.Git;
-import org.eclipse.jgit.api.ResetCommand;
-import org.eclipse.jgit.api.ResetCommand.ResetType;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffEntry.ChangeType;
import org.eclipse.jgit.diff.DiffFormatter;
@@ -47,15 +44,20 @@
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.StopWalkException;
+import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryCache.FileKey;
import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.lib.TreeFormatter;
import org.eclipse.jgit.revwalk.RevBlob;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevObject;
@@ -249,27 +251,6 @@
}
/**
- * Reset HEAD to the latest remote tracking commit.
- *
- * @param repository
- * @param remoteRef
- * the remote tracking reference (e.g. origin/master)
- * @return Ref
- * @throws Exception
- */
- public static Ref resetHEAD(Repository repository, String remoteRef) throws Exception {
- if (!remoteRef.startsWith(Constants.R_REMOTES)) {
- remoteRef = Constants.R_REMOTES + remoteRef;
- }
- Git git = new Git(repository);
- ResetCommand reset = git.reset();
- reset.setMode(ResetType.SOFT);
- reset.setRef(remoteRef);
- Ref result = reset.call();
- return result;
- }
-
- /**
* Creates a bare repository.
*
* @param repositoriesFolder
@@ -285,21 +266,21 @@
* Returns a list of repository names in the specified folder.
*
* @param repositoriesFolder
- * @param exportAll
- * if true, all repositories are listed. If false only the
- * repositories with a "git-daemon-export-ok" file are included
+ * @param onlyBare
+ * if true, only bare repositories repositories are listed. If
+ * false all repositories are included.
* @param searchSubfolders
* recurse into subfolders to find grouped repositories
* @return list of repository names
*/
- public static List<String> getRepositoryList(File repositoriesFolder, boolean exportAll,
+ public static List<String> getRepositoryList(File repositoriesFolder, boolean onlyBare,
boolean searchSubfolders) {
List<String> list = new ArrayList<String>();
if (repositoriesFolder == null || !repositoriesFolder.exists()) {
return list;
}
list.addAll(getRepositoryList(repositoriesFolder.getAbsolutePath(), repositoriesFolder,
- exportAll, searchSubfolders));
+ onlyBare, searchSubfolders));
StringUtils.sortRepositorynames(list);
return list;
}
@@ -311,33 +292,30 @@
* basePath is stripped from the repository name as repositories
* are relative to this path
* @param searchFolder
- * @param exportAll
- * if true all repositories are listed. If false only the
- * repositories with a "git-daemon-export-ok" file are included
+ * @param onlyBare
+ * if true only bare repositories will be listed. if false all
+ * repositories are included.
* @param searchSubfolders
* recurse into subfolders to find grouped repositories
* @return
*/
private static List<String> getRepositoryList(String basePath, File searchFolder,
- boolean exportAll, boolean searchSubfolders) {
+ boolean onlyBare, boolean searchSubfolders) {
+ File baseFile = new File(basePath);
List<String> list = new ArrayList<String>();
for (File file : searchFolder.listFiles()) {
if (file.isDirectory()) {
File gitDir = FileKey.resolve(new File(searchFolder, file.getName()), FS.DETECTED);
if (gitDir != null) {
- boolean exportRepository = exportAll
- || new File(gitDir, "git-daemon-export-ok").exists();
-
- if (!exportRepository) {
+ if (onlyBare && gitDir.getName().equals(".git")) {
continue;
}
// determine repository name relative to base path
- String repository = StringUtils.getRelativePath(basePath,
- file.getAbsolutePath());
+ String repository = FileUtils.getRelativePath(baseFile, file);
list.add(repository);
- } else if (searchSubfolders) {
+ } else if (searchSubfolders && file.canRead()) {
// look for repositories in subfolders
- list.addAll(getRepositoryList(basePath, file, exportAll, searchSubfolders));
+ list.addAll(getRepositoryList(basePath, file, onlyBare, searchSubfolders));
}
}
}
@@ -422,11 +400,9 @@
* last modified date of the repository folder is returned.
*
* @param repository
- * @param branch
- * if unspecified, all branches are checked.
* @return
*/
- public static Date getLastChange(Repository repository, String branch) {
+ public static Date getLastChange(Repository repository) {
if (!hasCommits(repository)) {
// null repository
if (repository == null) {
@@ -435,26 +411,21 @@
// fresh repository
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);
+ 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;
+ }
+
+ // default to the repository folder modification date
+ return new Date(repository.getDirectory().lastModified());
}
/**
@@ -727,6 +698,10 @@
list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 0, diff
.getNewMode().getBits(), commit.getId().getName(), diff
.getChangeType()));
+ } else if (diff.getChangeType().equals(ChangeType.RENAME)) {
+ list.add(new PathChangeModel(diff.getOldPath(), diff.getNewPath(), 0, diff
+ .getNewMode().getBits(), commit.getId().getName(), diff
+ .getChangeType()));
} else {
list.add(new PathChangeModel(diff.getNewPath(), diff.getNewPath(), 0, diff
.getNewMode().getBits(), commit.getId().getName(), diff
@@ -743,25 +718,40 @@
}
/**
- * Returns the list of files in the repository that match one of the
- * specified extensions. This is a CASE-SENSITIVE search. If the repository
- * does not exist or is empty, an empty list is returned.
+ * Returns the list of files in the repository on the default branch that
+ * match one of the specified extensions. This is a CASE-SENSITIVE search.
+ * If the repository does not exist or is empty, an empty list is returned.
*
* @param repository
* @param extensions
* @return list of files in repository with a matching extension
*/
public static List<PathModel> getDocuments(Repository repository, List<String> extensions) {
+ return getDocuments(repository, extensions, null);
+ }
+
+ /**
+ * Returns the list of files in the repository in the specified commit that
+ * match one of the specified extensions. This is a CASE-SENSITIVE search.
+ * If the repository does not exist or is empty, an empty list is returned.
+ *
+ * @param repository
+ * @param extensions
+ * @param objectId
+ * @return list of files in repository with a matching extension
+ */
+ public static List<PathModel> getDocuments(Repository repository, List<String> extensions,
+ String objectId) {
List<PathModel> list = new ArrayList<PathModel>();
if (!hasCommits(repository)) {
return list;
}
- RevCommit commit = getCommit(repository, null);
+ RevCommit commit = getCommit(repository, objectId);
final TreeWalk tw = new TreeWalk(repository);
try {
tw.addTree(commit.getTree());
if (extensions != null && extensions.size() > 0) {
- Collection<TreeFilter> suffixFilters = new ArrayList<TreeFilter>();
+ List<TreeFilter> suffixFilters = new ArrayList<TreeFilter>();
for (String extension : extensions) {
if (extension.charAt(0) == '.') {
suffixFilters.add(PathSuffixFilter.create("\\" + extension));
@@ -770,7 +760,12 @@
suffixFilters.add(PathSuffixFilter.create("\\." + extension));
}
}
- TreeFilter filter = OrTreeFilter.create(suffixFilters);
+ TreeFilter filter;
+ if (suffixFilters.size() == 1) {
+ filter = suffixFilters.get(0);
+ } else {
+ filter = OrTreeFilter.create(suffixFilters);
+ }
tw.setFilter(filter);
tw.setRecursive(true);
}
@@ -941,6 +936,9 @@
} else {
branchObject = repository.resolve(objectId);
}
+ if (branchObject == null) {
+ return list;
+ }
RevWalk rw = new RevWalk(repository);
rw.markStart(rw.parseCommit(branchObject));
@@ -1001,7 +999,14 @@
RevWalk rw = new RevWalk(repository);
rw.markStart(rw.parseCommit(endRange));
- rw.markUninteresting(rw.parseCommit(startRange));
+ if (startRange.equals(ObjectId.zeroId())) {
+ // maybe this is a tag or an orphan branch
+ list.add(rw.parseCommit(endRange));
+ rw.dispose();
+ return list;
+ } else {
+ rw.markUninteresting(rw.parseCommit(startRange));
+ }
Iterable<RevCommit> revlog = rw;
for (RevCommit rev : revlog) {
@@ -1144,6 +1149,98 @@
}
/**
+ * Returns the target of the symbolic HEAD reference for a repository.
+ * Normally returns a branch reference name, but when HEAD is detached,
+ * the commit is matched against the known tags. The most recent matching
+ * tag ref name will be returned if it references the HEAD commit. If
+ * no match is found, the SHA1 is returned.
+ *
+ * @param repository
+ * @return the ref name or the SHA1 for a detached HEAD
+ */
+ public static String getHEADRef(Repository repository) {
+ String target = null;
+ try {
+ target = repository.getFullBranch();
+ if (!target.startsWith(Constants.R_HEADS)) {
+ // refers to an actual commit, probably a tag
+ // find latest tag that matches the commit, if any
+ List<RefModel> tagModels = getTags(repository, true, -1);
+ if (tagModels.size() > 0) {
+ RefModel tag = null;
+ Date lastDate = new Date(0);
+ for (RefModel tagModel : tagModels) {
+ if (tagModel.getReferencedObjectId().getName().equals(target) &&
+ tagModel.getDate().after(lastDate)) {
+ tag = tagModel;
+ lastDate = tag.getDate();
+ }
+ }
+ target = tag.getName();
+ }
+ }
+ } catch (Throwable t) {
+ error(t, repository, "{0} failed to get symbolic HEAD target");
+ }
+ return target;
+ }
+
+ /**
+ * Sets the symbolic ref HEAD to the specified target ref. The
+ * HEAD will be detached if the target ref is not a branch.
+ *
+ * @param repository
+ * @param targetRef
+ * @return true if successful
+ */
+ public static boolean setHEADtoRef(Repository repository, String targetRef) {
+ try {
+ // detach HEAD if target ref is not a branch
+ boolean detach = !targetRef.startsWith(Constants.R_HEADS);
+ RefUpdate.Result result;
+ RefUpdate head = repository.updateRef(Constants.HEAD, detach);
+ if (detach) { // Tag
+ RevCommit commit = getCommit(repository, targetRef);
+ head.setNewObjectId(commit.getId());
+ result = head.forceUpdate();
+ } else {
+ result = head.link(targetRef);
+ }
+ switch (result) {
+ case NEW:
+ case FORCED:
+ case NO_CHANGE:
+ case FAST_FORWARD:
+ return true;
+ default:
+ LOGGER.error(MessageFormat.format("{0} HEAD update to {1} returned result {2}",
+ repository.getDirectory().getAbsolutePath(), targetRef, result));
+ }
+ } catch (Throwable t) {
+ error(t, repository, "{0} failed to set HEAD to {1}", targetRef);
+ }
+ return false;
+ }
+
+ /**
+ * Get the full branch and tag ref names for any potential HEAD targets.
+ *
+ * @param repository
+ * @return a list of ref names
+ */
+ public static List<String> getAvailableHeadTargets(Repository repository) {
+ List<String> targets = new ArrayList<String>();
+ for (RefModel branchModel : JGitUtils.getLocalBranches(repository, true, -1)) {
+ targets.add(branchModel.getName());
+ }
+
+ for (RefModel tagModel : JGitUtils.getTags(repository, true, -1)) {
+ targets.add(tagModel.getName());
+ }
+ return targets;
+ }
+
+ /**
* Returns all refs grouped by their associated object id.
*
* @param repository
@@ -1277,6 +1374,50 @@
}
/**
+ * Returns a RefModel for the gh-pages branch in the repository. If the
+ * branch can not be found, null is returned.
+ *
+ * @param repository
+ * @return a refmodel for the gh-pages branch or null
+ */
+ public static RefModel getPagesBranch(Repository repository) {
+ return getBranch(repository, "gh-pages");
+ }
+
+ /**
+ * Returns a RefModel for a specific branch name in the repository. If the
+ * branch can not be found, null is returned.
+ *
+ * @param repository
+ * @return a refmodel for the branch or null
+ */
+ public static RefModel getBranch(Repository repository, String name) {
+ RefModel branch = null;
+ try {
+ // search for the branch in local heads
+ for (RefModel ref : JGitUtils.getLocalBranches(repository, false, -1)) {
+ if (ref.displayName.endsWith(name)) {
+ branch = ref;
+ break;
+ }
+ }
+
+ // search for the branch in remote heads
+ if (branch == null) {
+ for (RefModel ref : JGitUtils.getRemoteBranches(repository, false, -1)) {
+ if (ref.displayName.endsWith(name)) {
+ branch = ref;
+ break;
+ }
+ }
+ }
+ } catch (Throwable t) {
+ LOGGER.error(MessageFormat.format("Failed to find {0} branch!", name), t);
+ }
+ return branch;
+ }
+
+ /**
* Returns the list of notes entered about the commit from the refs/notes
* namespace. If the repository does not exist or is empty, an empty list is
* returned.
@@ -1293,10 +1434,23 @@
List<RefModel> noteBranches = getNoteBranches(repository, true, -1);
for (RefModel notesRef : noteBranches) {
RevTree notesTree = JGitUtils.getCommit(repository, notesRef.getName()).getTree();
+ // flat notes list
+ String notePath = commit.getName();
+ String text = getStringContent(repository, notesTree, notePath);
+ if (!StringUtils.isEmpty(text)) {
+ List<RevCommit> history = getRevLog(repository, notesRef.getName(), notePath, 0, -1);
+ RefModel noteRef = new RefModel(notesRef.displayName, null, history.get(history
+ .size() - 1));
+ GitNote gitNote = new GitNote(noteRef, text);
+ list.add(gitNote);
+ continue;
+ }
+
+ // folder structure
StringBuilder sb = new StringBuilder(commit.getName());
sb.insert(2, '/');
- String notePath = sb.toString();
- String text = getStringContent(repository, notesTree, notePath);
+ notePath = sb.toString();
+ text = getStringContent(repository, notesTree, notePath);
if (!StringUtils.isEmpty(text)) {
List<RevCommit> history = getRevLog(repository, notesRef.getName(), notePath, 0, -1);
RefModel noteRef = new RefModel(notesRef.displayName, null, history.get(history
@@ -1309,37 +1463,74 @@
}
/**
- * Create an orphaned branch in a repository. This code does not work.
+ * Create an orphaned branch in a repository.
*
* @param repository
- * @param name
- * @return
+ * @param branchName
+ * @param author
+ * if unspecified, Gitblit will be the author of this new branch
+ * @return true if successful
*/
- 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;
+ public static boolean createOrphanBranch(Repository repository, String branchName,
+ PersonIdent author) {
+ boolean success = false;
+ String message = "Created branch " + branchName;
+ if (author == null) {
+ author = new PersonIdent("Gitblit", "gitblit@localhost");
+ }
+ try {
+ ObjectInserter odi = repository.newObjectInserter();
+ try {
+ // Create a blob object to insert into a tree
+ ObjectId blobId = odi.insert(Constants.OBJ_BLOB,
+ message.getBytes(Constants.CHARACTER_ENCODING));
+
+ // Create a tree object to reference from a commit
+ TreeFormatter tree = new TreeFormatter();
+ tree.append(".branch", FileMode.REGULAR_FILE, blobId);
+ ObjectId treeId = odi.insert(tree);
+
+ // Create a commit object
+ CommitBuilder commit = new CommitBuilder();
+ commit.setAuthor(author);
+ commit.setCommitter(author);
+ commit.setEncoding(Constants.CHARACTER_ENCODING);
+ commit.setMessage(message);
+ commit.setTreeId(treeId);
+
+ // Insert the commit into the repository
+ ObjectId commitId = odi.insert(commit);
+ odi.flush();
+
+ RevWalk revWalk = new RevWalk(repository);
+ try {
+ RevCommit revCommit = revWalk.parseCommit(commitId);
+ if (!branchName.startsWith("refs/")) {
+ branchName = "refs/heads/" + branchName;
+ }
+ RefUpdate ru = repository.updateRef(branchName);
+ ru.setNewObjectId(commitId);
+ ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
+ Result rc = ru.forceUpdate();
+ switch (rc) {
+ case NEW:
+ case FORCED:
+ case FAST_FORWARD:
+ success = true;
+ break;
+ default:
+ success = false;
+ }
+ } finally {
+ revWalk.release();
+ }
+ } finally {
+ odi.release();
+ }
+ } catch (Throwable t) {
+ error(t, repository, "Failed to create orphan branch {1} in repository {0}", branchName);
+ }
+ return success;
}
/**
--
Gitblit v1.9.1