Fixed symlink absolute path/canonical path mixup with JGit (issue 78)

James Moger

2012-03-28 1aa6e081ffe319ff3ddfa246783cb65dc1c71b3b

 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,21 +44,27 @@
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;

import org.eclipse.jgit.revwalk.RevSort;

import org.eclipse.jgit.revwalk.RevTree;

import org.eclipse.jgit.revwalk.RevWalk;

import org.eclipse.jgit.revwalk.filter.CommitTimeRevFilter;

import org.eclipse.jgit.revwalk.filter.RevFilter;

import org.eclipse.jgit.storage.file.FileRepository;

import org.eclipse.jgit.transport.CredentialsProvider;

@@ -248,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

@@ -284,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;

   }

@@ -310,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));

            }

         }

      }

@@ -421,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) {

@@ -434,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());

   }



   /**

@@ -467,6 +439,19 @@
         return new Date(0);

      }

      return new Date(commit.getCommitTime() * 1000L);

   }



   /**

    * Retrieves a Java Date from a Git commit.

    * 
    * @param commit

    * @return date of the commit or Date(0) if the commit is null

    */

   public static Date getAuthorDate(RevCommit commit) {

      if (commit == null) {

         return new Date(0);

      }

      return commit.getAuthorIdent().getWhen();

   }



   /**

@@ -713,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

@@ -729,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));

@@ -756,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);

         }

@@ -824,6 +833,45 @@
   }



   /**

    * Returns a list of commits since the minimum date starting from the

    * specified object id.

    * 
    * @param repository

    * @param objectId

    *            if unspecified, HEAD is assumed.

    * @param minimumDate

    * @return list of commits

    */

   public static List<RevCommit> getRevLog(Repository repository, String objectId, Date minimumDate) {

      List<RevCommit> list = new ArrayList<RevCommit>();

      if (!hasCommits(repository)) {

         return list;

      }

      try {

         // resolve branch

         ObjectId branchObject;

         if (StringUtils.isEmpty(objectId)) {

            branchObject = getDefaultBranch(repository);

         } else {

            branchObject = repository.resolve(objectId);

         }



         RevWalk rw = new RevWalk(repository);

         rw.markStart(rw.parseCommit(branchObject));

         rw.setRevFilter(CommitTimeRevFilter.after(minimumDate));

         Iterable<RevCommit> revlog = rw;

         for (RevCommit rev : revlog) {

            list.add(rev);

         }

         rw.dispose();

      } catch (Throwable t) {

         error(t, repository, "{0} failed to get {1} revlog for minimum date {2}", objectId,

               minimumDate);

      }

      return list;

   }



   /**

    * Returns a list of commits starting from HEAD and working backwards.

    * 

    * @param repository

@@ -888,6 +936,9 @@
         } else {

            branchObject = repository.resolve(objectId);

         }

         if (branchObject == null) {

            return list;

         }



         RevWalk rw = new RevWalk(repository);

         rw.markStart(rw.parseCommit(branchObject));

@@ -920,6 +971,50 @@
         rw.dispose();

      } catch (Throwable t) {

         error(t, repository, "{0} failed to get {1} revlog for path {2}", objectId, path);

      }

      return list;

   }



   /**

    * Returns a list of commits for the repository within the range specified

    * by startRangeId and endRangeId. If the repository does not exist or is

    * empty, an empty list is returned.

    * 
    * @param repository

    * @param startRangeId

    *            the first commit (not included in results)

    * @param endRangeId

    *            the end commit (included in results)

    * @return a list of commits

    */

   public static List<RevCommit> getRevLog(Repository repository, String startRangeId,

         String endRangeId) {

      List<RevCommit> list = new ArrayList<RevCommit>();

      if (!hasCommits(repository)) {

         return list;

      }

      try {

         ObjectId endRange = repository.resolve(endRangeId);

         ObjectId startRange = repository.resolve(startRangeId);



         RevWalk rw = new RevWalk(repository);

         rw.markStart(rw.parseCommit(endRange));

         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) {

            list.add(rev);

         }

         rw.dispose();

      } catch (Throwable t) {

         error(t, repository, "{0} failed to get revlog for {1}..{2}", startRangeId, endRangeId);

      }

      return list;

   }

@@ -1051,6 +1146,98 @@
         }

      }

      return object;

   }



   /**

    * 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;

   }



   /**

@@ -1187,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.

@@ -1203,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

@@ -1219,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;

   }



   /**