Forgot to commit UserModel with cookie field

James Moger

2012-07-11 a31cf95ac0787eb559cb78f48c52bc6b79e970d8

 src/com/gitblit/GitBlit.java

@@ -23,16 +23,21 @@
import java.io.InputStreamReader;

import java.lang.reflect.Field;

import java.text.MessageFormat;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.TimeZone;

import java.util.TreeSet;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

@@ -51,6 +56,8 @@
import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.lib.RepositoryCache.FileKey;

import org.eclipse.jgit.lib.StoredConfig;

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

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

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

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

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

@@ -69,11 +76,13 @@
import com.gitblit.models.FederationSet;

import com.gitblit.models.Metric;

import com.gitblit.models.RepositoryModel;

import com.gitblit.models.SearchResult;

import com.gitblit.models.ServerSettings;

import com.gitblit.models.ServerStatus;

import com.gitblit.models.SettingModel;

import com.gitblit.models.TeamModel;

import com.gitblit.models.UserModel;

import com.gitblit.utils.ArrayUtils;

import com.gitblit.utils.ByteFormat;

import com.gitblit.utils.FederationUtils;

import com.gitblit.utils.JGitUtils;

@@ -101,7 +110,7 @@
public class GitBlit implements ServletContextListener {



   private static GitBlit gitblit;



	
   private final Logger logger = LoggerFactory.getLogger(GitBlit.class);



   private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(5);

@@ -121,8 +130,6 @@


   private File repositoriesFolder;



   private boolean exportAll = true;



   private IUserService userService;



   private IStoredSettings settings;

@@ -132,6 +139,10 @@
   private ServerStatus serverStatus;



   private MailExecutor mailExecutor;

	
   private LuceneExecutor luceneExecutor;

	
   private TimeZone timezone;



   public GitBlit() {

      if (gitblit == null) {

@@ -160,6 +171,33 @@
   public static boolean isGO() {

      return self().settings instanceof FileSettings;

   }

	
   /**

    * Returns the preferred timezone for the Gitblit instance.

    * 
    * @return a timezone

    */

   public static TimeZone getTimezone() {

      if (self().timezone == null) {

         String tzid = getString("web.timezone", null);

         if (StringUtils.isEmpty(tzid)) {

            self().timezone = TimeZone.getDefault();

            return self().timezone;

         }

         self().timezone = TimeZone.getTimeZone(tzid);

      }

      return self().timezone;

   }

	
   /**

    * Returns the user-defined blob encodings.

    * 
    * @return an array of encodings, may be empty

    */

   public static String [] getEncodings() {

      return getStrings(Keys.web.blobEncodings).toArray(new String[0]);

   }

	


   /**

    * Returns the boolean value for the specified key. If the key does not

@@ -226,6 +264,17 @@
    */

   public static List<String> getStrings(String key) {

      return self().settings.getStrings(key);

   }



   /**

    * Returns a map of space-separated key-value pairs from the specified key.

    * 
    * @see IStoredSettings.getStrings(String key)

    * @param name

    * @return map of string, string

    */

   public static Map<String, String> getMap(String key) {

      return self().settings.getMap(key);

   }



   /**

@@ -351,6 +400,38 @@
      this.userService = userService;

      this.userService.setup(settings);

   }

	
   /**

    * 
    * @return true if the user service supports credential changes

    */

   public boolean supportsCredentialChanges() {

      return userService.supportsCredentialChanges();

   }



   /**

    * 
    * @return true if the user service supports display name changes

    */

   public boolean supportsDisplayNameChanges() {

      return userService.supportsDisplayNameChanges();

   }



   /**

    * 
    * @return true if the user service supports email address changes

    */

   public boolean supportsEmailAddressChanges() {

      return userService.supportsEmailAddressChanges();

   }



   /**

    * 
    * @return true if the user service supports team membership changes

    */

   public boolean supportsTeamMembershipChanges() {

      return userService.supportsTeamMembershipChanges();

   }



   /**

    * Authenticate a user based on a username and password.

@@ -431,13 +512,31 @@
            userCookie = new Cookie(Constants.NAME, "");

         } else {

            // set cookie for login

            char[] cookie = userService.getCookie(user);

            userCookie = new Cookie(Constants.NAME, new String(cookie));

            userCookie.setMaxAge(Integer.MAX_VALUE);

            String cookie = userService.getCookie(user);

            if (StringUtils.isEmpty(cookie)) {

               // create empty cookie

               userCookie = new Cookie(Constants.NAME, "");

            } else {

               // create real cookie

               userCookie = new Cookie(Constants.NAME, cookie);

               userCookie.setMaxAge(Integer.MAX_VALUE);

            }

         }

         userCookie.setPath("/");

         response.addCookie(userCookie);

      }

   }

	
   /**

    * Logout a user.

    * 
    * @param user

    */

   public void logout(UserModel user) {

      if (userService == null) {

         return;

      }

      userService.logout(user);

   }



   /**

@@ -448,8 +547,18 @@
    */

   public List<String> getAllUsernames() {

      List<String> names = new ArrayList<String>(userService.getAllUsernames());

      Collections.sort(names);

      return names;

   }



   /**

    * Returns the list of all users available to the login service.

    * 
    * @see IUserService.getAllUsernames()

    * @return list of all usernames

    */

   public List<UserModel> getAllUsers() {

      List<UserModel> users = userService.getAllUsers();

      return users;

   }



   /**

@@ -532,7 +641,17 @@
    */

   public List<String> getAllTeamnames() {

      List<String> teams = new ArrayList<String>(userService.getAllTeamNames());

      Collections.sort(teams);

      return teams;

   }



   /**

    * Returns the list of available teams that a user or repository may be

    * assigned to.

    * 
    * @return the list of teams

    */

   public List<TeamModel> getAllTeams() {

      List<TeamModel> teams = userService.getAllTeams();

      return teams;

   }



@@ -620,7 +739,8 @@
    * @return list of all repositories

    */

   public List<String> getRepositoryList() {

      return JGitUtils.getRepositoryList(repositoriesFolder, exportAll,

      return JGitUtils.getRepositoryList(repositoriesFolder, 
            settings.getBoolean(Keys.git.onlyAccessBareRepositories, false),

            settings.getBoolean(Keys.git.searchRepositoriesSubfolders, true));

   }



@@ -631,21 +751,38 @@
    * @return repository or null

    */

   public Repository getRepository(String repositoryName) {

      return getRepository(repositoryName, true);

   }



   /**

    * Returns the JGit repository for the specified name.

    * 
    * @param repositoryName

    * @param logError

    * @return repository or null

    */

   public Repository getRepository(String repositoryName, boolean logError) {

      Repository r = null;

      try {

         r = repositoryResolver.open(null, repositoryName);

      } catch (RepositoryNotFoundException e) {

         r = null;

         logger.error("GitBlit.getRepository(String) failed to find "

               + new File(repositoriesFolder, repositoryName).getAbsolutePath());

         if (logError) {

            logger.error("GitBlit.getRepository(String) failed to find "

                  + new File(repositoriesFolder, repositoryName).getAbsolutePath());

         }

      } catch (ServiceNotAuthorizedException e) {

         r = null;

         logger.error("GitBlit.getRepository(String) failed to find "

               + new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);

         if (logError) {

            logger.error("GitBlit.getRepository(String) failed to find "

                  + new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);

         }

      } catch (ServiceNotEnabledException e) {

         r = null;

         logger.error("GitBlit.getRepository(String) failed to find "

               + new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);

         if (logError) {

            logger.error("GitBlit.getRepository(String) failed to find "

                  + new File(repositoriesFolder, repositoryName).getAbsolutePath(), e);

         }

      }

      return r;

   }

@@ -720,7 +857,8 @@
      RepositoryModel model = new RepositoryModel();

      model.name = repositoryName;

      model.hasCommits = JGitUtils.hasCommits(r);

      model.lastChange = JGitUtils.getLastChange(r, null);

      model.lastChange = JGitUtils.getLastChange(r);

      model.isBare = r.isBare();

      StoredConfig config = JGitUtils.readConfig(r);

      if (config != null) {

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

@@ -728,7 +866,7 @@
         model.useTickets = getConfig(config, "useTickets", false);

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

         model.accessRestriction = AccessRestrictionType.fromName(getConfig(config,

               "accessRestriction", null));

               "accessRestriction", settings.getString(Keys.git.defaultAccessRestriction, null)));

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

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

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

@@ -737,16 +875,26 @@
         model.federationStrategy = FederationStrategy.fromName(getConfig(config,

               "federationStrategy", null));

         model.federationSets = new ArrayList<String>(Arrays.asList(config.getStringList(

               "gitblit", null, "federationSets")));

               Constants.CONFIG_GITBLIT, null, "federationSets")));

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

         model.origin = config.getString("remote", "origin", "url");

         model.preReceiveScripts = new ArrayList<String>(Arrays.asList(config.getStringList(

               "gitblit", null, "preReceiveScript")));

               Constants.CONFIG_GITBLIT, null, "preReceiveScript")));

         model.postReceiveScripts = new ArrayList<String>(Arrays.asList(config.getStringList(

               "gitblit", null, "postReceiveScript")));

               Constants.CONFIG_GITBLIT, null, "postReceiveScript")));

         model.mailingLists = new ArrayList<String>(Arrays.asList(config.getStringList(

               "gitblit", null, "mailingList")));

               Constants.CONFIG_GITBLIT, null, "mailingList")));

         model.indexedBranches = new ArrayList<String>(Arrays.asList(config.getStringList(

               Constants.CONFIG_GITBLIT, null, "indexBranch")));

			
         // Custom defined properties

         model.customFields = new LinkedHashMap<String, String>();

         for (String aProperty : config.getNames(Constants.CONFIG_GITBLIT, Constants.CONFIG_CUSTOM_FIELDS)) {

            model.customFields.put(aProperty, config.getString(Constants.CONFIG_GITBLIT, Constants.CONFIG_CUSTOM_FIELDS, aProperty));

         }

      }

      model.HEAD = JGitUtils.getHEADRef(r);

      model.availableRefs = JGitUtils.getAvailableHeadTargets(r);

      r.close();

      return model;

   }

@@ -803,6 +951,9 @@
            repository.close();

         }

      }

		
      // close any open index writer/searcher in the Lucene executor

      luceneExecutor.close(repositoryName);

   }



   /**

@@ -819,7 +970,7 @@
      if (repositoryMetricsCache.hasCurrent(model.name, model.lastChange)) {

         return new ArrayList<Metric>(repositoryMetricsCache.getObject(model.name));

      }

      List<Metric> metrics = MetricUtils.getDateMetrics(repository, null, true, null);

      List<Metric> metrics = MetricUtils.getDateMetrics(repository, null, true, null, getTimezone());

      repositoryMetricsCache.updateObject(model.name, model.lastChange, metrics);

      return new ArrayList<Metric>(metrics);

   }

@@ -834,7 +985,7 @@
    * @return field value or defaultValue

    */

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

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

      String value = config.getString(Constants.CONFIG_GITBLIT, null, field);

      if (StringUtils.isEmpty(value)) {

         return defaultValue;

      }

@@ -842,7 +993,7 @@
   }



   /**

    * Returns the gitblit boolean vlaue for the specified key. If key is not

    * Returns the gitblit boolean value for the specified key. If key is not

    * set, returns defaultValue.

    * 

    * @param config

@@ -851,7 +1002,7 @@
    * @return field value or defaultValue

    */

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

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

      return config.getBoolean(Constants.CONFIG_GITBLIT, field, defaultValue);

   }



   /**

@@ -905,6 +1056,11 @@
                           .format("Can not rename repository ''{0}'' to ''{1}'' because ''{1}'' already exists.",

                                 repositoryName, repository.name));

            }

            File parentFile = destFolder.getParentFile();

            if (!parentFile.exists() && !parentFile.mkdirs()) {

               throw new GitBlitException(MessageFormat.format(

                     "Failed to create folder ''{0}''", parentFile.getAbsolutePath()));

            }

            if (!folder.renameTo(destFolder)) {

               throw new GitBlitException(MessageFormat.format(

                     "Failed to rename repository ''{0}'' to ''{1}''.", repositoryName,

@@ -937,6 +1093,18 @@
      // update settings

      if (r != null) {

         updateConfiguration(r, repository);

         // only update symbolic head if it changes

         String currentRef = JGitUtils.getHEADRef(r);

         if (!StringUtils.isEmpty(repository.HEAD) && !repository.HEAD.equals(currentRef)) {

            logger.info(MessageFormat.format("Relinking {0} HEAD from {1} to {2}", 
                  repository.name, currentRef, repository.HEAD));

            if (JGitUtils.setHEADtoRef(r, repository.HEAD)) {

               // clear the cache

               clearRepositoryCache(repository.name);

            }

         }



         // close the repository object

         r.close();

      }

   }

@@ -951,34 +1119,58 @@
    */

   public void updateConfiguration(Repository r, RepositoryModel repository) {

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

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

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

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

      config.setStringList("gitblit", null, "federationSets", repository.federationSets);

      config.setString("gitblit", null, "federationStrategy",

      config.setString(Constants.CONFIG_GITBLIT, null, "description", repository.description);

      config.setString(Constants.CONFIG_GITBLIT, null, "owner", repository.owner);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "useTickets", repository.useTickets);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "useDocs", repository.useDocs);

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

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "showRemoteBranches", repository.showRemoteBranches);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "isFrozen", repository.isFrozen);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "showReadme", repository.showReadme);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "skipSizeCalculation", repository.skipSizeCalculation);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "skipSummaryMetrics", repository.skipSummaryMetrics);

      config.setString(Constants.CONFIG_GITBLIT, null, "federationStrategy",

            repository.federationStrategy.name());

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

      if (repository.preReceiveScripts != null) {

         config.setStringList("gitblit", null, "preReceiveScript", repository.preReceiveScripts);

      config.setBoolean(Constants.CONFIG_GITBLIT, null, "isFederated", repository.isFederated);



      updateList(config, "federationSets", repository.federationSets);

      updateList(config, "preReceiveScript", repository.preReceiveScripts);

      updateList(config, "postReceiveScript", repository.postReceiveScripts);

      updateList(config, "mailingList", repository.mailingLists);

      updateList(config, "indexBranch", repository.indexedBranches);

		
      // User Defined Properties

      if (repository.customFields != null) {

         if (repository.customFields.size() == 0) {

            // clear section

            config.unsetSection(Constants.CONFIG_GITBLIT, Constants.CONFIG_CUSTOM_FIELDS);

         } else {

            for (Entry<String, String> property : repository.customFields.entrySet()) {

               // set field

               String key = property.getKey();

               String value = property.getValue();

               config.setString(Constants.CONFIG_GITBLIT, Constants.CONFIG_CUSTOM_FIELDS, key, value);

            }

         }

      }

      if (repository.postReceiveScripts != null) {

         config.setStringList("gitblit", null, "postReceiveScript",

               repository.postReceiveScripts);

      }

      if (repository.mailingLists != null) {

         config.setStringList("gitblit", null, "mailingList", repository.mailingLists);

      }



      try {

         config.save();

      } catch (IOException e) {

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

      }

   }

	
   private void updateList(StoredConfig config, String field, List<String> list) {

      // a null list is skipped, not cleared

      // this is for RPC administration where an older manager might be used

      if (list == null) {

         return;

      }

      if (ArrayUtils.isEmpty(list)) {

         config.unset(Constants.CONFIG_GITBLIT, null, field);

      } else {

         config.setStringList(Constants.CONFIG_GITBLIT, null, field, list);

      }

   }



@@ -1227,6 +1419,7 @@
      case PULL_TEAMS:

         return token.equals(all) || token.equals(unr);

      case PULL_SETTINGS:

      case PULL_SCRIPTS:

         return token.equals(all);

      }

      return false;

@@ -1439,13 +1632,12 @@
   }



   /**

    * Returns the list of all available Groovy push hook scripts that are not

    * already specified globally for all repositories. Script files must have

    * Returns the list of all Groovy push hook scripts. Script files must have

    * .groovy extension

    * 

    * @return list of available hook scripts

    */

   public List<String> getAvailableScripts() {

   public List<String> getAllScripts() {

      File groovyFolder = getGroovyScriptsFolder();

      File[] files = groovyFolder.listFiles(new FileFilter() {

         @Override

@@ -1453,55 +1645,129 @@
            return pathname.isFile() && pathname.getName().endsWith(".groovy");

         }

      });



      Set<String> globals = new HashSet<String>();

      String[] keys = { Keys.groovy.preReceiveScripts, Keys.groovy.postReceiveScripts };

      for (String key : keys) {

         for (String script : getStrings(key)) {

            if (script.endsWith(".groovy")) {

               globals.add(script.substring(0, script.lastIndexOf('.')));

            } else {

               globals.add(script);

            }

         }

      }



      // create list of available scripts by excluding scripts that are

      // globally specified

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

      if (files != null) {

         for (File file : files) {

            String script = file.getName().substring(0, file.getName().lastIndexOf('.'));

            if (!globals.contains(script)) {

               scripts.add(script);

            }

            scripts.add(script);

         }

      }

      return scripts;

   }



   /**

    * Returns the list of pre-receive scripts the repository inherited from the

    * global settings and team affiliations.

    * 
    * @param repository

    *            if null only the globally specified scripts are returned

    * @return a list of scripts

    */

   public List<String> getPreReceiveScriptsInherited(RepositoryModel repository) {

      Set<String> scripts = new LinkedHashSet<String>();

      // Globals

      for (String script : getStrings(Keys.groovy.preReceiveScripts)) {

         if (script.endsWith(".groovy")) {

            scripts.add(script.substring(0, script.lastIndexOf('.')));

         } else {

            scripts.add(script);

         }

      }



      // Team Scripts

      if (repository != null) {

         for (String teamname : userService.getTeamnamesForRepositoryRole(repository.name)) {

            TeamModel team = userService.getTeamModel(teamname);

            scripts.addAll(team.preReceiveScripts);

         }

      }

      return new ArrayList<String>(scripts);

   }



   /**

    * Returns the list of all available Groovy pre-receive push hook scripts

    * that are not already inherited by the repository. Script files must have

    * .groovy extension

    * 
    * @param repository

    *            optional parameter

    * @return list of available hook scripts

    */

   public List<String> getPreReceiveScriptsUnused(RepositoryModel repository) {

      Set<String> inherited = new TreeSet<String>(getPreReceiveScriptsInherited(repository));



      // create list of available scripts by excluding inherited scripts

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

      for (String script : getAllScripts()) {

         if (!inherited.contains(script)) {

            scripts.add(script);

         }

      }

      return scripts;

   }



   /**

    * Returns the list of post-receive scripts the repository inherited from

    * the global settings and team affiliations.

    * 
    * @param repository

    *            if null only the globally specified scripts are returned

    * @return a list of scripts

    */

   public List<String> getPostReceiveScriptsInherited(RepositoryModel repository) {

      Set<String> scripts = new LinkedHashSet<String>();

      // Global Scripts

      for (String script : getStrings(Keys.groovy.postReceiveScripts)) {

         if (script.endsWith(".groovy")) {

            scripts.add(script.substring(0, script.lastIndexOf('.')));

         } else {

            scripts.add(script);

         }

      }

      // Team Scripts

      if (repository != null) {

         for (String teamname : userService.getTeamnamesForRepositoryRole(repository.name)) {

            TeamModel team = userService.getTeamModel(teamname);

            scripts.addAll(team.postReceiveScripts);

         }

      }

      return new ArrayList<String>(scripts);

   }



   /**

    * Returns the list of unused Groovy post-receive push hook scripts that are

    * not already inherited by the repository. Script files must have .groovy

    * extension

    * 
    * @param repository

    *            optional parameter

    * @return list of available hook scripts

    */

   public List<String> getPostReceiveScriptsUnused(RepositoryModel repository) {

      Set<String> inherited = new TreeSet<String>(getPostReceiveScriptsInherited(repository));



      // create list of available scripts by excluding inherited scripts

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

      for (String script : getAllScripts()) {

         if (!inherited.contains(script)) {

            scripts.add(script);

         }

      }

      return scripts;

   }

   

   public List<String> getInheritedPreReceiveScripts(RepositoryModel repository) {

      Set<String> globals = new HashSet<String>();

      for (String script : getStrings(Keys.groovy.preReceiveScripts)) {

         if (script.endsWith(".groovy")) {

            globals.add(script.substring(0, script.lastIndexOf('.')));

         } else {

            globals.add(script);

         }

      }

      return new ArrayList<String>(globals);

   }

	
   public List<String> getInheritedPostReceiveScripts(RepositoryModel repository) {

      Set<String> globals = new HashSet<String>();

      for (String script : getStrings(Keys.groovy.postReceiveScripts)) {

         if (script.endsWith(".groovy")) {

            globals.add(script.substring(0, script.lastIndexOf('.')));

         } else {

            globals.add(script);

         }

      }

      return new ArrayList<String>(globals);

   /**

    * Search the specified repositories using the Lucene query.

    * 
    * @param query

    * @param page

    * @param pageSize

    * @param repositories

    * @return

    */

   public List<SearchResult> search(String query, int page, int pageSize, List<String> repositories) {		
      List<SearchResult> srs = luceneExecutor.search(query, page, pageSize, repositories);

      return srs;

   }



   /**

@@ -1563,11 +1829,15 @@
      // ensure that the current values are updated in the setting models

      for (String key : settings.getAllKeys(null)) {

         SettingModel setting = settingsModel.get(key);

         if (setting != null) {

            setting.currentValue = settings.getString(key, "");

         if (setting == null) {

            // unreferenced setting, create a setting model

            setting = new SettingModel();

            setting.name = key;

            settingsModel.add(setting);

         }

         setting.currentValue = settings.getString(key, "");			
      }

      settingsModel.pushScripts = getAvailableScripts();

      settingsModel.pushScripts = getAllScripts();

      return settingsModel;

   }



@@ -1580,6 +1850,10 @@
    */

   private ServerSettings loadSettingModels() {

      ServerSettings settingsModel = new ServerSettings();

      settingsModel.supportsCredentialChanges = userService.supportsCredentialChanges();

      settingsModel.supportsDisplayNameChanges = userService.supportsDisplayNameChanges();

      settingsModel.supportsEmailAddressChanges = userService.supportsEmailAddressChanges();

      settingsModel.supportsTeamMembershipChanges = userService.supportsTeamMembershipChanges();

      try {

         // Read bundled Gitblit properties to extract setting descriptions.

         // This copy is pristine and only used for populating the setting

@@ -1648,29 +1922,64 @@
      this.settings = settings;

      repositoriesFolder = getRepositoriesFolder();

      logger.info("Git repositories folder " + repositoriesFolder.getAbsolutePath());

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

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

		
      logTimezone("JVM", TimeZone.getDefault());

      logTimezone(Constants.NAME, getTimezone());



      serverStatus = new ServerStatus(isGO());

      String realm = settings.getString(Keys.realm.userService, "users.properties");

      IUserService loginService = null;

      try {

         // check to see if this "file" is a login service class

         Class<?> realmClass = Class.forName(realm);

         if (IUserService.class.isAssignableFrom(realmClass)) {

            loginService = (IUserService) realmClass.newInstance();

         }

         loginService = (IUserService) realmClass.newInstance();

      } catch (Throwable t) {

         loginService = new GitblitUserService();

      }

      setUserService(loginService);

      mailExecutor = new MailExecutor(settings);

      if (mailExecutor.isReady()) {

         logger.info("Mail executor is scheduled to process the message queue every 2 minutes.");

         scheduledExecutor.scheduleAtFixedRate(mailExecutor, 1, 2, TimeUnit.MINUTES);

      } else {

         logger.warn("Mail server is not properly configured.  Mail services disabled.");

      }

      luceneExecutor = new LuceneExecutor(settings, repositoriesFolder);

      logger.info("Lucene executor is scheduled to process indexed branches every 2 minutes.");

      scheduledExecutor.scheduleAtFixedRate(luceneExecutor, 1, 2, TimeUnit.MINUTES);

      if (startFederation) {

         configureFederation();

      }

		
      // Configure JGit

      WindowCacheConfig cfg = new WindowCacheConfig();

		
      cfg.setPackedGitWindowSize(settings.getFilesize(Keys.git.packedGitWindowSize, cfg.getPackedGitWindowSize()));

      cfg.setPackedGitLimit(settings.getFilesize(Keys.git.packedGitLimit, cfg.getPackedGitLimit()));

      cfg.setDeltaBaseCacheLimit(settings.getFilesize(Keys.git.deltaBaseCacheLimit, cfg.getDeltaBaseCacheLimit()));

      cfg.setPackedGitOpenFiles(settings.getFilesize(Keys.git.packedGitOpenFiles, cfg.getPackedGitOpenFiles()));

      cfg.setStreamFileThreshold(settings.getFilesize(Keys.git.streamFileThreshold, cfg.getStreamFileThreshold()));

      cfg.setPackedGitMMAP(settings.getBoolean(Keys.git.packedGitMmap, cfg.isPackedGitMMAP()));

		
      try {

         WindowCache.reconfigure(cfg);

         logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.packedGitWindowSize, cfg.getPackedGitWindowSize()));

         logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.packedGitLimit, cfg.getPackedGitLimit()));

         logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.deltaBaseCacheLimit, cfg.getDeltaBaseCacheLimit()));

         logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.packedGitOpenFiles, cfg.getPackedGitOpenFiles()));

         logger.debug(MessageFormat.format("{0} = {1,number,0}", Keys.git.streamFileThreshold, cfg.getStreamFileThreshold()));

         logger.debug(MessageFormat.format("{0} = {1}", Keys.git.packedGitMmap, cfg.isPackedGitMMAP()));

      } catch (IllegalArgumentException e) {

         logger.error("Failed to configure JGit parameters!", e);

      }

   }

	
   private void logTimezone(String type, TimeZone zone) {

      SimpleDateFormat df = new SimpleDateFormat("z Z");

      df.setTimeZone(zone);

      String offset = df.format(new Date());

      logger.info(type + " timezone is " + zone.getID() + " (" + offset + ")");

   }



   /**

@@ -1682,27 +1991,46 @@
   @Override

   public void contextInitialized(ServletContextEvent contextEvent) {

      servletContext = contextEvent.getServletContext();

      settingsModel = loadSettingModels();

      if (settings == null) {

         // Gitblit WAR is running in a servlet container

         ServletContext context = contextEvent.getServletContext();

         WebXmlSettings webxmlSettings = new WebXmlSettings(context);



         // 0.7.0 web.properties in the deployed war folder

         File overrideFile = new File(context.getRealPath("/WEB-INF/web.properties"));

         if (overrideFile.exists()) {

            webxmlSettings.applyOverrides(overrideFile);

         String webProps = context.getRealPath("/WEB-INF/web.properties");

         if (!StringUtils.isEmpty(webProps)) {

            File overrideFile = new File(webProps);

            if (overrideFile.exists()) {

               webxmlSettings.applyOverrides(overrideFile);

            }

         }

			


         // 0.8.0 gitblit.properties file located outside the deployed war

         // folder lie, for example, on RedHat OpenShift.

         overrideFile = getFileOrFolder("gitblit.properties");

         File overrideFile = getFileOrFolder("gitblit.properties");

         if (!overrideFile.getPath().equals("gitblit.properties")) {

            webxmlSettings.applyOverrides(overrideFile);

         }

         configureContext(webxmlSettings, true);

      }



         // Copy the included scripts to the configured groovy folder

         File localScripts = getFileOrFolder(Keys.groovy.scriptsFolder, "groovy");

         if (!localScripts.exists()) {

            File includedScripts = new File(context.getRealPath("/WEB-INF/groovy"));

            if (!includedScripts.equals(localScripts)) {

               try {

                  com.gitblit.utils.FileUtils.copy(localScripts, includedScripts.listFiles());

               } catch (IOException e) {

                  logger.error(MessageFormat.format(

                        "Failed to copy included Groovy scripts from {0} to {1}",

                        includedScripts, localScripts));

               }

            }

         }

      }

		
      settingsModel = loadSettingModels();

      serverStatus.servletContainer = servletContext.getServerInfo();

   }



@@ -1714,5 +2042,6 @@
   public void contextDestroyed(ServletContextEvent contextEvent) {

      logger.info("Gitblit context destroyed by servlet container.");

      scheduledExecutor.shutdownNow();

      luceneExecutor.close();

   }

}