Owner editing. Frozen status. Grouped repositories. Documentation.

James Moger

2011-05-19 00afd77a2182ece3d9522d41b86b4ddd7e132288

 src/com/gitblit/GitBlit.java

@@ -1,8 +1,10 @@
package com.gitblit;



import java.io.File;

import java.io.IOException;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.Collections;

import java.util.List;



import javax.servlet.ServletContextEvent;

@@ -12,14 +14,17 @@
import org.apache.wicket.protocol.http.WebResponse;

import org.eclipse.jgit.errors.RepositoryNotFoundException;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.lib.StoredConfig;

import org.eclipse.jgit.transport.resolver.FileResolver;

import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;



import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.utils.JGitUtils;

import com.gitblit.wicket.User;

import com.gitblit.utils.StringUtils;

import com.gitblit.wicket.models.RepositoryModel;

import com.gitblit.wicket.models.UserModel;



public class GitBlit implements ServletContextListener {



@@ -29,7 +34,7 @@


   private FileResolver<Void> repositoryResolver;



   private File repositories;

   private File repositoriesFolder;



   private boolean exportAll;



@@ -64,14 +69,14 @@
      this.loginService = loginService;

   }



   public User authenticate(String username, char[] password) {

   public UserModel authenticate(String username, char[] password) {

      if (loginService == null) {

         return null;

      }

      return loginService.authenticate(username, password);

   }



   public User authenticate(Cookie[] cookies) {

   public UserModel authenticate(Cookie[] cookies) {

      if (loginService == null) {

         return null;

      }

@@ -86,19 +91,121 @@
      return null;

   }



   public void setCookie(WebResponse response, User user) {

   public void setCookie(WebResponse response, UserModel user) {

      Cookie userCookie = new Cookie(Constants.NAME, user.getCookie());

      userCookie.setMaxAge(Integer.MAX_VALUE);

      userCookie.setPath("/");

      response.addCookie(userCookie);

   }

	
   public List<String> getAllUsernames() {

      List<String> names = loginService.getAllUsernames();

      Collections.sort(names);

      return names;

   }



   public void editRepository(RepositoryModel repository, boolean isCreate) {

   public UserModel getUserModel(String username) {

      UserModel user = loginService.getUserModel(username);

      return user;

   }

	
   public List<String> getRepositoryUsers(RepositoryModel repository) {

      return loginService.getUsernamesForRole(repository.name);

   }

	
   public boolean setRepositoryUsers(RepositoryModel repository, List<String> repositoryUsers) {

      return loginService.setUsernamesForRole(repository.name, repositoryUsers);

   }



   public void editUserModel(UserModel user, boolean isCreate) throws GitBlitException {

      if (!loginService.updateUserModel(user)) {

         throw new GitBlitException(isCreate ? "Failed to add user!" : "Failed to update user!");

      }

   }



   public List<String> getRepositoryList() {

      return JGitUtils.getRepositoryList(repositoriesFolder, exportAll, storedSettings.getBoolean(Keys.git.nestedRepositories, true));

   }



   public Repository getRepository(String repositoryName) {

      Repository r = null;

      try {

         r = repositoryResolver.open(null, repositoryName);

      } catch (RepositoryNotFoundException e) {

         r = null;

         logger.error("GitBlit.getRepository(String) failed to find repository " + repositoryName);

      } catch (ServiceNotEnabledException e) {

         r = null;

         e.printStackTrace();

      }

      return r;

   }



   public List<RepositoryModel> getRepositoryModels(UserModel user) {

      List<String> list = getRepositoryList();

      List<RepositoryModel> repositories = new ArrayList<RepositoryModel>();

      for (String repo : list) {

         RepositoryModel model = getRepositoryModel(user, repo);

         if (model != null) {

            repositories.add(model);

         }

      }

      return repositories;

   }

	
   public RepositoryModel getRepositoryModel(UserModel user, String repositoryName) {

      RepositoryModel model = getRepositoryModel(repositoryName);

      if (model.accessRestriction.atLeast(AccessRestrictionType.VIEW)) {

         if (user != null && user.canAccessRepository(model.name)) {

            return model;

         }

         return null;

      } else {

         return model;

      }

   }



   public RepositoryModel getRepositoryModel(String repositoryName) {

      Repository r = getRepository(repositoryName);

      RepositoryModel model = new RepositoryModel();

      model.name = repositoryName;

      model.hasCommits = JGitUtils.hasCommits(r);

      model.lastChange = JGitUtils.getLastChange(r);

      StoredConfig config = JGitUtils.readConfig(r);

      if (config != null) {

         model.description = getConfig(config, "description", "");

         model.owner = getConfig(config, "owner", "");

         model.useTickets = getConfig(config, "useTickets", false);

         model.useDocs = getConfig(config, "useDocs", false);

         model.accessRestriction = AccessRestrictionType.fromName(getConfig(config, "accessRestriction", null));

         model.showRemoteBranches = getConfig(config, "showRemoteBranches", false);

         model.isFrozen = getConfig(config, "isFrozen", false);

      }

      r.close();

      return model;

   }

	
   private String getConfig(StoredConfig config, String field, String defaultValue) {

      String value = config.getString("gitblit", null, field);

      if (StringUtils.isEmpty(value)) {

         return defaultValue;

      }

      return value;

   }

	
   private boolean getConfig(StoredConfig config, String field, boolean defaultValue) {

      return config.getBoolean("gitblit", field, defaultValue);

   }



   public void editRepositoryModel(RepositoryModel repository, boolean isCreate) throws GitBlitException {

      Repository r = null;

      if (isCreate) {

         if (new File(repositoriesFolder, repository.name).exists()) {

            throw new GitBlitException(MessageFormat.format("Can not create repository {0} because it already exists.", repository.name));

         }

         // create repository

         logger.info("create repository " + repository.name);

         r = JGitUtils.createRepository(repositories, repository.name, true);

         r = JGitUtils.createRepository(repositoriesFolder, repository.name, true);

      } else {

         // load repository

         logger.info("edit repository " + repository.name);

@@ -109,71 +216,38 @@
         } catch (ServiceNotEnabledException e) {

            logger.error("Service not enabled", e);

         }

      }		
				
      }



      // update settings

      JGitUtils.setRepositoryDescription(r, repository.description);

      JGitUtils.setRepositoryOwner(r, repository.owner);

      JGitUtils.setRepositoryUseTickets(r, repository.useTickets);

      JGitUtils.setRepositoryUseDocs(r, repository.useDocs);

      JGitUtils.setRepositoryRestrictedAccess(r, repository.useRestrictedAccess);

   }



   public List<String> getRepositoryList() {

      return JGitUtils.getRepositoryList(repositories, exportAll, storedSettings.getBoolean(Keys.git.nestedRepositories, true));

   }



   public List<RepositoryModel> getRepositories() {

      List<String> list = getRepositoryList();

      List<RepositoryModel> repositories = new ArrayList<RepositoryModel>();

      for (String repo : list) {

         Repository r = getRepository(repo);

         String description = JGitUtils.getRepositoryDescription(r);

         String owner = JGitUtils.getRepositoryOwner(r);

         String group = JGitUtils.getRepositoryGroup(r);

         Date lastchange = JGitUtils.getLastChange(r);

         RepositoryModel model = new RepositoryModel(repo, description, owner, lastchange);

         model.group = group;

         model.useTickets = JGitUtils.getRepositoryUseTickets(r);

         model.useDocs = JGitUtils.getRepositoryUseDocs(r);

         model.useRestrictedAccess = JGitUtils.getRepositoryRestrictedAccess(r);

         r.close();

         repositories.add(model);

      }

      return repositories;

   }



   public Repository getRepository(String repositoryName) {

      Repository r = null;

      StoredConfig config = JGitUtils.readConfig(r);

      config.setString("gitblit", null, "description", repository.description);

      config.setString("gitblit", null, "owner", repository.owner);

      config.setBoolean("gitblit", null, "useTickets", repository.useTickets);

      config.setBoolean("gitblit", null, "useDocs", repository.useDocs);

      config.setString("gitblit", null, "accessRestriction", repository.accessRestriction.name());

      config.setBoolean("gitblit", null, "showRemoteBranches", repository.showRemoteBranches);

      config.setBoolean("gitblit", null, "isFrozen", repository.isFrozen);

      try {

         r = repositoryResolver.open(null, repositoryName);

      } catch (RepositoryNotFoundException e) {

         r = null;

         logger.error("Failed to find repository " + repositoryName);

         e.printStackTrace();

      } catch (ServiceNotEnabledException e) {

         r = null;

         e.printStackTrace();

         config.save();

      } catch (IOException e) {

         logger.error("Failed to save repository config!", e);

      }

      return r;

      r.close();

   }



   public void setupContext(IStoredSettings settings) {

      logger.info("Setting up GitBlit context from " + settings.toString());

   public void configureContext(IStoredSettings settings) {

      logger.info("Using configuration from " + settings.toString());

      this.storedSettings = settings;

      repositories = new File(settings.getString(Keys.git.repositoriesFolder, "repos"));

      repositoriesFolder = new File(settings.getString(Keys.git.repositoriesFolder, "repos"));

      exportAll = settings.getBoolean(Keys.git.exportAll, true);

      repositoryResolver = new FileResolver(repositories, exportAll);

      repositoryResolver = new FileResolver<Void>(repositoriesFolder, exportAll);

   }



   @Override

   public void contextInitialized(ServletContextEvent contextEvent) {

      logger.info("GitBlit context initialization by servlet container...");

      if (storedSettings == null) {

         WebXmlSettings webxmlSettings = new WebXmlSettings(contextEvent.getServletContext());

         setupContext(webxmlSettings);

      } else {

         logger.info("GitBlit context already setup by " + storedSettings.toString());

         configureContext(webxmlSettings);

      }

   }