Preliminary implementation of server-side forking (issue 137)

James Moger

2012-09-29 1e1b85270f93b3bca624c99b478f3a9a23be2395

 src/com/gitblit/wicket/pages/RepositoryPage.java

@@ -19,58 +19,87 @@
import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;



import org.apache.wicket.Component;

import org.apache.wicket.PageParameters;

import org.apache.wicket.RedirectException;

import org.apache.wicket.markup.html.basic.Label;

import org.apache.wicket.markup.html.form.DropDownChoice;

import org.apache.wicket.markup.html.form.StatelessForm;

import org.apache.wicket.markup.html.form.TextField;

import org.apache.wicket.markup.html.link.ExternalLink;

import org.apache.wicket.markup.html.link.Link;

import org.apache.wicket.markup.html.panel.Fragment;

import org.apache.wicket.model.IModel;

import org.apache.wicket.model.Model;

import org.apache.wicket.protocol.http.RequestUtils;

import org.apache.wicket.request.target.basic.RedirectRequestTarget;

import org.eclipse.jgit.diff.DiffEntry.ChangeType;

import org.eclipse.jgit.lib.PersonIdent;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.revwalk.RevCommit;



import com.gitblit.Constants;

import com.gitblit.GitBlit;

import com.gitblit.Keys;

import com.gitblit.PagesServlet;

import com.gitblit.SyndicationServlet;

import com.gitblit.models.ProjectModel;

import com.gitblit.models.RepositoryModel;

import com.gitblit.models.SubmoduleModel;

import com.gitblit.models.UserModel;

import com.gitblit.utils.ArrayUtils;

import com.gitblit.utils.JGitUtils;

import com.gitblit.utils.JGitUtils.SearchType;

import com.gitblit.utils.StringUtils;

import com.gitblit.utils.TicgitUtils;

import com.gitblit.wicket.GitBlitWebSession;

import com.gitblit.wicket.PageRegistration;

import com.gitblit.wicket.PageRegistration.OtherPageLink;

import com.gitblit.wicket.SessionlessForm;

import com.gitblit.wicket.WicketUtils;

import com.gitblit.wicket.panels.BasePanel.JavascriptEventConfirmation;

import com.gitblit.wicket.panels.LinkPanel;

import com.gitblit.wicket.panels.NavigationPanel;

import com.gitblit.wicket.panels.RefsPanel;



public abstract class RepositoryPage extends BasePage {



   protected final String projectName;

   protected final String repositoryName;

   protected final String objectId;



	
   private transient Repository r;



   private RepositoryModel m;



   private Map<String, SubmoduleModel> submodules;

	
   private final Map<String, PageRegistration> registeredPages;



   private boolean showAdmin;

   private boolean isOwner;

	
   public RepositoryPage(PageParameters params) {

      super(params);

      repositoryName = WicketUtils.getRepositoryName(params);

      String root =StringUtils.getFirstPathElement(repositoryName);

      if (StringUtils.isEmpty(root)) {

         projectName = GitBlit.getString(Keys.web.repositoryRootGroupName, "main");

      } else {

         projectName = root;

      }

      objectId = WicketUtils.getObject(params);



		
      if (StringUtils.isEmpty(repositoryName)) {

         error(MessageFormat.format("Repository not specified for {0}!", getPageName()), true);

         error(MessageFormat.format(getString("gb.repositoryNotSpecifiedFor"), getPageName()), true);

      }



      if (!getRepositoryModel().hasCommits) {

         setResponsePage(EmptyRepositoryPage.class, params);

      }



      // register the available page links for this page and user

@@ -112,6 +141,17 @@
      Repository r = getRepository();

      RepositoryModel model = getRepositoryModel();



      // forks list button

      if (StringUtils.isEmpty(model.originRepository)) {

         if (!ArrayUtils.isEmpty(model.forks)) {

            // this origin repository has forks

            pages.put("forks", new PageRegistration("gb.forks", ForksPage.class, params));

         }

      } else {

         // this is a fork of another repository

         pages.put("forks", new PageRegistration("gb.forks", ForksPage.class, params));

      }

		
      // per-repository extra page links

      if (model.useTickets && TicgitUtils.getTicketsBranch(r) != null) {

         pages.put("tickets", new PageRegistration("gb.tickets", TicketsPage.class, params));

@@ -119,18 +159,24 @@
      if (model.useDocs) {

         pages.put("docs", new PageRegistration("gb.docs", DocsPage.class, params));

      }

      if (JGitUtils.getPagesBranch(r) != null) {

         OtherPageLink pagesLink = new OtherPageLink("gb.pages", PagesServlet.asLink(

               getRequest().getRelativePathPrefixToContextRoot(), repositoryName, null));

         pages.put("pages", pagesLink);

      }



      // Conditionally add edit link

      final boolean showAdmin;

      showAdmin = false;

      if (GitBlit.getBoolean(Keys.web.authenticateAdminPages, true)) {

         boolean allowAdmin = GitBlit.getBoolean(Keys.web.allowAdministration, false);

         showAdmin = allowAdmin && GitBlitWebSession.get().canAdmin();

      } else {

         showAdmin = GitBlit.getBoolean(Keys.web.allowAdministration, false);

      }

      if (showAdmin

            || GitBlitWebSession.get().isLoggedIn()

      isOwner = GitBlitWebSession.get().isLoggedIn()

            && (model.owner != null && model.owner.equalsIgnoreCase(GitBlitWebSession.get()

                  .getUser().username))) {

                  .getUsername()));

      if (showAdmin || isOwner) {

         pages.put("edit", new PageRegistration("gb.edit", EditRepositoryPage.class, params));

      }

      return pages;

@@ -138,10 +184,100 @@


   @Override

   protected void setupPage(String repositoryName, String pageName) {

      add(new LinkPanel("repositoryName", null, repositoryName, SummaryPage.class,

      String projectName = StringUtils.getFirstPathElement(repositoryName);

      ProjectModel project = GitBlit.self().getProjectModel(projectName);

      if (project.isUserProject()) {

         // user-as-project

         add(new LinkPanel("projectTitle", null, project.getDisplayName(),

               UserPage.class, WicketUtils.newUsernameParameter(project.name.substring(1))));

      } else {

         // project

         add(new LinkPanel("projectTitle", null, project.name,

               ProjectPage.class, WicketUtils.newProjectParameter(project.name)));

      }

		
      String name = StringUtils.stripDotGit(repositoryName);

      if (!StringUtils.isEmpty(projectName) && name.startsWith(projectName)) {

         name = name.substring(projectName.length() + 1);

      }

      add(new LinkPanel("repositoryName", null, name, SummaryPage.class,

            WicketUtils.newRepositoryParameter(repositoryName)));

      add(new Label("pageName", pageName));

      add(new Label("pageName", pageName).setRenderBodyOnly(true));

		
      // indicate origin repository

      RepositoryModel model = getRepositoryModel();

      if (StringUtils.isEmpty(model.originRepository)) {

         add(new Label("originRepository").setVisible(false));

      } else {

         Fragment forkFrag = new Fragment("originRepository", "originFragment", this);

         forkFrag.add(new LinkPanel("originRepository", null, StringUtils.stripDotGit(model.originRepository), 
               SummaryPage.class, WicketUtils.newRepositoryParameter(model.originRepository)));

         add(forkFrag);

      }

		
      if (getRepositoryModel().isBare) {

         add(new Label("workingCopyIndicator").setVisible(false));

      } else {

         Fragment wc = new Fragment("workingCopyIndicator", "workingCopyFragment", this);

         Label lbl = new Label("workingCopy", getString("gb.workingCopy"));

         WicketUtils.setHtmlTooltip(lbl,  getString("gb.workingCopyWarning"));

         wc.add(lbl);

         add(wc);

      }

		
      if (getRepositoryModel().allowForks) {

         add(new Label("forksProhibitedIndicator").setVisible(false));

      } else {

         Fragment wc = new Fragment("forksProhibitedIndicator", "forksProhibitedFragment", this);

         Label lbl = new Label("forksProhibited", getString("gb.forksProhibited"));

         WicketUtils.setHtmlTooltip(lbl,  getString("gb.forksProhibitedWarning"));

         wc.add(lbl);

         add(wc);

      }

		
      UserModel user = GitBlitWebSession.get().getUser();

		
      // fork button

      if (user != null) {			
         final String clonedRepo = MessageFormat.format("~{0}/{1}.git", user.username, StringUtils.stripDotGit(StringUtils.getLastPathElement(model.name)));

         boolean hasClone = GitBlit.self().hasRepository(clonedRepo) && !getRepositoryModel().name.equals(clonedRepo);

         if (user.canForkRepository(model) && !hasClone) {

            Link<Void> forkLink = new Link<Void>("forkLink") {



               private static final long serialVersionUID = 1L;



               @Override

               public void onClick() {

                  RepositoryModel model = getRepositoryModel();

                  if (GitBlit.self().fork(model, GitBlitWebSession.get().getUser())) {

                     throw new RedirectException(SummaryPage.class, WicketUtils.newRepositoryParameter(clonedRepo));

                  } else {

                     error(MessageFormat.format(getString("gb.repositoryForkFailed"), model));

                  }

               }

            };

            forkLink.add(new JavascriptEventConfirmation("onclick", MessageFormat.format(

                  getString("gb.forkRepository"), getRepositoryModel())));

            add(forkLink);

         } else {

            // user not allowed to fork or fork already exists or repo forbids forking

            add(new ExternalLink("forkLink", "").setVisible(false));

         }

			
         if (hasClone) {

            // user has clone

            String url = getRequestCycle().urlFor(SummaryPage.class, WicketUtils.newRepositoryParameter(clonedRepo)).toString();

            add(new ExternalLink("myForkLink", url));

         } else {

            // user does not have clone

            add(new ExternalLink("myForkLink", "").setVisible(false));

         }

      } else {

         // server prohibits forking

         add(new ExternalLink("forkLink", "").setVisible(false));

         add(new ExternalLink("myForkLink", "").setVisible(false));

      }

		
      super.setupPage(repositoryName, pageName);

   }



@@ -155,7 +291,7 @@
      if (r == null) {

         Repository r = GitBlit.self().getRepository(repositoryName);

         if (r == null) {

            error("Can not load repository " + repositoryName, true);

            error(getString("gb.canNotLoadRepository") + " " + repositoryName, true);

            return null;

         }

         this.r = r;

@@ -168,7 +304,13 @@
         RepositoryModel model = GitBlit.self().getRepositoryModel(

               GitBlitWebSession.get().getUser(), repositoryName);

         if (model == null) {

            authenticationError("Unauthorized access for repository " + repositoryName);

            if (GitBlit.self().hasRepository(repositoryName)) {

               // has repository, but unauthorized

               authenticationError(getString("gb.unauthorizedAccessForRepository") + " " + repositoryName);

            } else {

               // does not have repository

               error(getString("gb.canNotLoadRepository") + " " + repositoryName, true);

            }

            return null;

         }

         m = model;

@@ -179,10 +321,87 @@
   protected RevCommit getCommit() {

      RevCommit commit = JGitUtils.getCommit(r, objectId);

      if (commit == null) {

         error(MessageFormat.format("Failed to find commit \"{0}\" in {1} for {2} page!",

         error(MessageFormat.format(getString("gb.failedToFindCommit"),

               objectId, repositoryName, getPageName()), true);

      }

      getSubmodules(commit);

      return commit;

   }

	
   private Map<String, SubmoduleModel> getSubmodules(RevCommit commit) {	
      if (submodules == null) {

         submodules = new HashMap<String, SubmoduleModel>();

         for (SubmoduleModel model : JGitUtils.getSubmodules(r, commit.getTree())) {

            submodules.put(model.path, model);

         }

      }

      return submodules;

   }

	
   protected Map<String, SubmoduleModel> getSubmodules() {

      return submodules;

   }

	
   protected SubmoduleModel getSubmodule(String path) {

      SubmoduleModel model = submodules.get(path);

      if (model == null) {

         // undefined submodule?!

         model = new SubmoduleModel(path.substring(path.lastIndexOf('/') + 1), path, path);

         model.hasSubmodule = false;

         model.gitblitPath = model.name;

         return model;

      } else {

         // extract the repository name from the clone url

         List<String> patterns = GitBlit.getStrings(Keys.git.submoduleUrlPatterns);

         String submoduleName = StringUtils.extractRepositoryPath(model.url, patterns.toArray(new String[0]));

			
         // determine the current path for constructing paths relative

         // to the current repository

         String currentPath = "";

         if (repositoryName.indexOf('/') > -1) {

            currentPath = repositoryName.substring(0, repositoryName.lastIndexOf('/') + 1);

         }



         // try to locate the submodule repository

         // prefer bare to non-bare names

         List<String> candidates = new ArrayList<String>();



         // relative

         candidates.add(currentPath + StringUtils.stripDotGit(submoduleName));

         candidates.add(candidates.get(candidates.size() - 1) + ".git");



         // relative, no subfolder

         if (submoduleName.lastIndexOf('/') > -1) {

            String name = submoduleName.substring(submoduleName.lastIndexOf('/') + 1);

            candidates.add(currentPath + StringUtils.stripDotGit(name));

            candidates.add(currentPath + candidates.get(candidates.size() - 1) + ".git");

         }



         // absolute

         candidates.add(StringUtils.stripDotGit(submoduleName));

         candidates.add(candidates.get(candidates.size() - 1) + ".git");



         // absolute, no subfolder

         if (submoduleName.lastIndexOf('/') > -1) {

            String name = submoduleName.substring(submoduleName.lastIndexOf('/') + 1);

            candidates.add(StringUtils.stripDotGit(name));

            candidates.add(candidates.get(candidates.size() - 1) + ".git");

         }



         // create a unique, ordered set of candidate paths

         Set<String> paths = new LinkedHashSet<String>(candidates);

         for (String candidate : paths) {

            if (GitBlit.self().hasRepository(candidate)) {

               model.hasSubmodule = true;

               model.gitblitPath = candidate;

               return model;

            }

         }

			
         // we do not have a copy of the submodule, but we need a path

         model.gitblitPath = candidates.get(0);

         return model;

      }		
   }



   protected String getShortObjectId(String objectId) {

@@ -190,15 +409,15 @@
   }



   protected void addRefs(Repository r, RevCommit c) {

      add(new RefsPanel("refsPanel", repositoryName, c, JGitUtils.getAllRefs(r)));

      add(new RefsPanel("refsPanel", repositoryName, c, JGitUtils.getAllRefs(r, getRepositoryModel().showRemoteBranches)));

   }



   protected void addFullText(String wicketId, String text, boolean substituteRegex) {

      String html;

      String html = StringUtils.escapeForHtml(text, true);

      if (substituteRegex) {

         html = GitBlit.self().processCommitMessage(repositoryName, text);

      } else {

         html = StringUtils.breakLinesForHtml(text);

         html = StringUtils.breakLinesForHtml(html);

      }

      add(new Label(wicketId, html).setEscapeModelStrings(false));

   }

@@ -206,46 +425,46 @@
   protected abstract String getPageName();



   protected Component createPersonPanel(String wicketId, PersonIdent identity,

         SearchType searchType) {

         Constants.SearchType searchType) {

      String name = identity == null ? "" : identity.getName();

      String address = identity == null ? "" : identity.getEmailAddress();

      boolean showEmail = GitBlit.getBoolean(Keys.web.showEmailAddresses, false);

      if (!showEmail || StringUtils.isEmpty(identity.getName())

            || StringUtils.isEmpty(identity.getEmailAddress())) {

         String value = identity.getName();

      if (!showEmail || StringUtils.isEmpty(name) || StringUtils.isEmpty(address)) {

         String value = name;

         if (StringUtils.isEmpty(value)) {

            if (showEmail) {

               value = identity.getEmailAddress();

               value = address;

            } else {

               value = getString("gb.missingUsername");

            }

         }

         Fragment partial = new Fragment(wicketId, "partialPersonIdent", this);

         LinkPanel link = new LinkPanel("personName", "list", value, SearchPage.class,

         LinkPanel link = new LinkPanel("personName", "list", value, GitSearchPage.class,

               WicketUtils.newSearchParameter(repositoryName, objectId, value, searchType));

         setPersonSearchTooltip(link, value, searchType);

         partial.add(link);

         return partial;

      } else {

         Fragment fullPerson = new Fragment(wicketId, "fullPersonIdent", this);

         LinkPanel nameLink = new LinkPanel("personName", "list", identity.getName(),

               SearchPage.class, WicketUtils.newSearchParameter(repositoryName, objectId,

                     identity.getName(), searchType));

         setPersonSearchTooltip(nameLink, identity.getName(), searchType);

         LinkPanel nameLink = new LinkPanel("personName", "list", name, GitSearchPage.class,

               WicketUtils.newSearchParameter(repositoryName, objectId, name, searchType));

         setPersonSearchTooltip(nameLink, name, searchType);

         fullPerson.add(nameLink);



         LinkPanel addressLink = new LinkPanel("personAddress", "list", "<"

               + identity.getEmailAddress() + ">", SearchPage.class,

               WicketUtils.newSearchParameter(repositoryName, objectId,

                     identity.getEmailAddress(), searchType));

         setPersonSearchTooltip(addressLink, identity.getEmailAddress(), searchType);

         LinkPanel addressLink = new LinkPanel("personAddress", "hidden-phone list", "<" + address + ">",

               GitSearchPage.class, WicketUtils.newSearchParameter(repositoryName, objectId,

                     address, searchType));

         setPersonSearchTooltip(addressLink, address, searchType);

         fullPerson.add(addressLink);

         return fullPerson;

      }

   }



   protected void setPersonSearchTooltip(Component component, String value, SearchType searchType) {

      if (searchType.equals(SearchType.AUTHOR)) {

   protected void setPersonSearchTooltip(Component component, String value,

         Constants.SearchType searchType) {

      if (searchType.equals(Constants.SearchType.AUTHOR)) {

         WicketUtils.setHtmlTooltip(component, getString("gb.searchForAuthor") + " " + value);

      } else if (searchType.equals(SearchType.COMMITTER)) {

      } else if (searchType.equals(Constants.SearchType.COMMITTER)) {

         WicketUtils.setHtmlTooltip(component, getString("gb.searchForCommitter") + " " + value);

      }

   }

@@ -292,20 +511,29 @@
      return WicketUtils.newObjectParameter(repositoryName, commitId);

   }



   private static class SearchForm extends StatelessForm<Void> implements Serializable {

   public boolean isShowAdmin() {

      return showAdmin;

   }

	
   public boolean isOwner() {

      return isOwner;

   }

	
   private class SearchForm extends SessionlessForm<Void> implements Serializable {

      private static final long serialVersionUID = 1L;



      private final String repositoryName;



      private final IModel<String> searchBoxModel = new Model<String>("");



      private final IModel<SearchType> searchTypeModel = new Model<SearchType>(SearchType.COMMIT);

      private final IModel<Constants.SearchType> searchTypeModel = new Model<Constants.SearchType>(

            Constants.SearchType.COMMIT);



      public SearchForm(String id, String repositoryName) {

         super(id);

         super(id, RepositoryPage.this.getClass(), RepositoryPage.this.getPageParameters());

         this.repositoryName = repositoryName;

         DropDownChoice<SearchType> searchType = new DropDownChoice<SearchType>("searchType",

               Arrays.asList(SearchType.values()));

         DropDownChoice<Constants.SearchType> searchType = new DropDownChoice<Constants.SearchType>(

               "searchType", Arrays.asList(Constants.SearchType.values()));

         searchType.setModel(searchTypeModel);

         add(searchType.setVisible(GitBlit.getBoolean(Keys.web.showSearchTypeSelection, false)));

         TextField<String> searchBox = new TextField<String>("searchBox", searchBoxModel);

@@ -321,13 +549,12 @@


      @Override

      public void onSubmit() {

         SearchType searchType = searchTypeModel.getObject();

         Constants.SearchType searchType = searchTypeModel.getObject();

         String searchString = searchBoxModel.getObject();

         if (searchString == null) {

            // FIXME IE intermittently has no searchString. Wicket bug?

            return;

         }

         for (SearchType type : SearchType.values()) {

         for (Constants.SearchType type : Constants.SearchType.values()) {

            if (searchString.toLowerCase().startsWith(type.name().toLowerCase() + ":")) {

               searchType = type;

               searchString = searchString.substring(type.name().toLowerCase().length() + 1)

@@ -335,8 +562,19 @@
               break;

            }

         }

         setResponsePage(SearchPage.class,

               WicketUtils.newSearchParameter(repositoryName, null, searchString, searchType));

         Class<? extends BasePage> searchPageClass = GitSearchPage.class;

         RepositoryModel model = GitBlit.self().getRepositoryModel(repositoryName);

         if (GitBlit.getBoolean(Keys.web.allowLuceneIndexing, true)

               && !ArrayUtils.isEmpty(model.indexedBranches)) {

            // this repository is Lucene-indexed

            searchPageClass = LuceneSearchPage.class;

         }

         // use an absolute url to workaround Wicket-Tomcat problems with

         // mounted url parameters (issue-111)

         PageParameters params = WicketUtils.newSearchParameter(repositoryName, null, searchString, searchType);

         String relativeUrl = urlFor(searchPageClass, params).toString();

         String absoluteUrl = RequestUtils.toAbsolutePath(relativeUrl);

         getRequestCycle().setRequestTarget(new RedirectRequestTarget(absoluteUrl));

      }

   }

}