From 797bc67989bb7b66564827edd566f15ab640a7ee Mon Sep 17 00:00:00 2001
From: James Moger <james.moger@gitblit.com>
Date: Tue, 31 Jan 2012 21:41:54 -0500
Subject: [PATCH] Fixed type in CentOS script
---
src/com/gitblit/utils/JGitUtils.java | 194 +++++++++++++++++++++++++++++++++++++++++-------
1 files changed, 165 insertions(+), 29 deletions(-)
diff --git a/src/com/gitblit/utils/JGitUtils.java b/src/com/gitblit/utils/JGitUtils.java
index 2a99c97..319aca5 100644
--- a/src/com/gitblit/utils/JGitUtils.java
+++ b/src/com/gitblit/utils/JGitUtils.java
@@ -47,15 +47,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;
@@ -335,7 +340,7 @@
String repository = StringUtils.getRelativePath(basePath,
file.getAbsolutePath());
list.add(repository);
- } else if (searchSubfolders) {
+ } else if (searchSubfolders && file.canRead()) {
// look for repositories in subfolders
list.addAll(getRepositoryList(basePath, file, exportAll, searchSubfolders));
}
@@ -1151,6 +1156,100 @@
}
/**
+ * 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 detached HEADs
+ */
+ public static String getSymbolicHeadTarget(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 HEAD symbolic ref name for a repository. The HEAD will
+ * be detached if the name does not reference a branch.
+ *
+ * @param repository
+ * @param name
+ */
+ public static void setSymbolicHeadTarget(Repository repository, String name) {
+ try {
+ boolean detach = !name.startsWith(Constants.R_HEADS); // detach if not a branch
+ RefUpdate.Result result;
+ RefUpdate head = repository.updateRef(Constants.HEAD, detach);
+ if (detach) { // Tag
+ RevCommit commit = getCommit(repository, name);
+ head.setNewObjectId(commit.getId());
+ result = head.forceUpdate();
+ } else {
+ result = head.link(name);
+ }
+ switch (result) {
+ case NEW:
+ case FORCED:
+ case NO_CHANGE:
+ case FAST_FORWARD:
+ break;
+ default:
+ LOGGER.error(MessageFormat.format("{0} symbolic HEAD update to {1} returned result {2}",
+ repository.getDirectory().getAbsolutePath(), name, result));
+ }
+ } catch (Throwable t) {
+ error(t, repository, "{0} failed to set symbolic HEAD to {1}", name);
+ }
+ }
+
+ /**
+ * Get the full branch and tag ref names for any potential symbolic head targets.
+ *
+ * @param repository
+ * @return a list of ref names
+ */
+ public static List<String> getAvailableHeadTargets(Repository repository) {
+ List<String> targets = new ArrayList<String>();
+ List<RefModel> branchModels = JGitUtils.getLocalBranches(repository, true, -1);
+ if (branchModels.size() > 0) {
+ for (RefModel branchModel : branchModels) {
+ targets.add(branchModel.getName());
+ }
+ }
+ List<RefModel> tagModels = JGitUtils.getTags(repository, true, -1);
+ if (tagModels.size() > 0) {
+ for (RefModel tagModel : tagModels) {
+ targets.add(tagModel.getName());
+ }
+ }
+ return targets;
+ }
+
+ /**
* Returns all refs grouped by their associated object id.
*
* @param repository
@@ -1360,37 +1459,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("NEWBRANCH", 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