Fixed string encoding regression introduced with fix for BOM

James Moger

2012-08-18 12c7592c32b89b4687c92923fbd4d9a53af08346

 src/com/gitblit/GitBlit.java

@@ -39,10 +39,12 @@
import java.util.TimeZone;

import java.util.TreeSet;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicReference;



import javax.mail.Message;

import javax.mail.MessagingException;

@@ -58,6 +60,7 @@
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.ServiceMayNotContinueException;

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

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

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

@@ -68,6 +71,7 @@
import org.slf4j.LoggerFactory;



import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.Constants.AuthorizationControl;

import com.gitblit.Constants.FederationRequest;

import com.gitblit.Constants.FederationStrategy;

import com.gitblit.Constants.FederationToken;

@@ -123,6 +127,10 @@
   private final ObjectCache<Long> repositorySizeCache = new ObjectCache<Long>();



   private final ObjectCache<List<Metric>> repositoryMetricsCache = new ObjectCache<List<Metric>>();

	
   private final List<String> repositoryListCache = new CopyOnWriteArrayList<String>();

	
   private final AtomicReference<String> repositoryListSettingsChecksum = new AtomicReference<String>("");



   private RepositoryResolver<Void> repositoryResolver;



@@ -512,9 +520,15 @@
            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);

@@ -715,15 +729,73 @@
   public boolean deleteTeam(String teamname) {

      return userService.deleteTeam(teamname);

   }

	
   /**

    * Adds the repository to the list of cached repositories if Gitblit is

    * configured to cache the repository list.

    * 
    * @param name

    */

   private void addToCachedRepositoryList(String name) {

      if (settings.getBoolean(Keys.git.cacheRepositoryList, true)) {

         repositoryListCache.add(name);

      }

   }



   /**

    * Clears all the cached data for the specified repository.

    * 

    * @param repositoryName

    * @param isDeleted

    */

   public void clearRepositoryCache(String repositoryName) {

   private void clearRepositoryCache(String repositoryName, boolean isDeleted) {

      repositorySizeCache.remove(repositoryName);

      repositoryMetricsCache.remove(repositoryName);

		
      if (isDeleted) {

         repositoryListCache.remove(repositoryName);

      }

   }

	
   /**

    * Resets the repository list cache.

    * 
    */

   public void resetRepositoryListCache() {

      logger.info("Repository cache manually reset");

      repositoryListCache.clear();

   }

	
   /**

    * Calculate the checksum of settings that affect the repository list cache.

    * @return a checksum

    */

   private String getRepositoryListSettingsChecksum() {

      StringBuilder ns = new StringBuilder();

      ns.append(settings.getString(Keys.git.cacheRepositoryList, "")).append('\n');

      ns.append(settings.getString(Keys.git.onlyAccessBareRepositories, "")).append('\n');

      ns.append(settings.getString(Keys.git.searchRepositoriesSubfolders, "")).append('\n');

      ns.append(settings.getString(Keys.git.searchRecursionDepth, "")).append('\n');

      ns.append(settings.getString(Keys.git.searchExclusions, "")).append('\n');

      String checksum = StringUtils.getSHA1(ns.toString());

      return checksum;

   }

	
   /**

    * Compare the last repository list setting checksum to the current checksum.

    * If different then clear the cache so that it may be rebuilt.

    * 
    * @return true if the cached repository list is valid since the last check

    */

   private boolean isValidRepositoryList() {

      String newChecksum = getRepositoryListSettingsChecksum();

      boolean valid = newChecksum.equals(repositoryListSettingsChecksum.get());

      repositoryListSettingsChecksum.set(newChecksum);

      if (!valid && settings.getBoolean(Keys.git.cacheRepositoryList,  true)) {

         logger.info("Repository list settings have changed. Clearing repository list cache.");

         repositoryListCache.clear();

      }

      return valid;

   }



   /**

@@ -733,9 +805,46 @@
    * @return list of all repositories

    */

   public List<String> getRepositoryList() {

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

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

      if (repositoryListCache.size() == 0 || !isValidRepositoryList()) {

         // we are not caching OR we have not yet cached OR the cached list is invalid

         long startTime = System.currentTimeMillis();

         List<String> repositories = JGitUtils.getRepositoryList(repositoriesFolder, 
               settings.getBoolean(Keys.git.onlyAccessBareRepositories, false),

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

               settings.getInteger(Keys.git.searchRecursionDepth, -1),

               settings.getStrings(Keys.git.searchExclusions));



         if (!settings.getBoolean(Keys.git.cacheRepositoryList,  true)) {

            // we are not caching

            StringUtils.sortRepositorynames(repositories);

            return repositories;

         } else {

            // we are caching this list

            String msg = "{0} repositories identified in {1} msecs";



            // optionally (re)calculate repository sizes

            if (getBoolean(Keys.web.showRepositorySizes, true)) {

               msg = "{0} repositories identified with calculated folder sizes in {1} msecs";

               for (String repository : repositories) {

                  RepositoryModel model = getRepositoryModel(repository);

                  if (!model.skipSizeCalculation) {

                     calculateSize(model);

                  }

               }

            }

				
            // update cache

            repositoryListCache.addAll(repositories);

				
            long duration = System.currentTimeMillis() - startTime;

            logger.info(MessageFormat.format(msg, repositoryListCache.size(), duration));

         }

      }

		
      // return sorted copy of cached list

      List<String> list = new ArrayList<String>(repositoryListCache);		
      StringUtils.sortRepositorynames(list);

      return list;

   }



   /**

@@ -777,6 +886,12 @@
            logger.error("GitBlit.getRepository(String) failed to find "

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

         }

      } catch (ServiceMayNotContinueException e) {

         r = null;

         if (logError) {

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

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

         }

      }

      return r;

   }

@@ -788,6 +903,7 @@
    * @return list of repository models accessible to user

    */

   public List<RepositoryModel> getRepositoryModels(UserModel user) {

      long methodStart = System.currentTimeMillis();

      List<String> list = getRepositoryList();

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

      for (String repo : list) {

@@ -807,9 +923,15 @@
            }

         }

         long duration = System.currentTimeMillis() - startTime;

         logger.info(MessageFormat.format("{0} repository sizes calculated in {1} msecs",

         if (duration > 250) {

            // only log calcualtion time if > 250 msecs

            logger.info(MessageFormat.format("{0} repository sizes calculated in {1} msecs",

               repoCount, duration));

         }

      }

      long duration = System.currentTimeMillis() - methodStart;

      logger.info(MessageFormat.format("{0} repository models loaded for {1} in {2} msecs",

            repositories.size(), user == null ? "anonymous" : user.username, duration));

      return repositories;

   }



@@ -853,7 +975,8 @@
      model.hasCommits = JGitUtils.hasCommits(r);

      model.lastChange = JGitUtils.getLastChange(r);

      model.isBare = r.isBare();

      StoredConfig config = JGitUtils.readConfig(r);

		
      StoredConfig config = r.getConfig();

      if (config != null) {

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

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

@@ -861,6 +984,8 @@
         model.useDocs = getConfig(config, "useDocs", false);

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

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

         model.authorizationControl = AuthorizationControl.fromName(getConfig(config,

               "authorizationControl", settings.getString(Keys.git.defaultAuthorizationControl, null)));

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

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

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

@@ -891,6 +1016,21 @@
      model.availableRefs = JGitUtils.getAvailableHeadTargets(r);

      r.close();

      return model;

   }

	
   /**

    * Determines if this server has the requested repository.

    * 
    * @param name

    * @return true if the repository exists

    */

   public boolean hasRepository(String repositoryName) {

      Repository r = getRepository(repositoryName, false);

      if (r == null) {

         return false;

      }

      r.close();

      return true;

   }



   /**

@@ -1029,6 +1169,9 @@
         // create repository

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

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

			
         // add name to cache

         addToCachedRepositoryList(repository.name);

      } else {

         // rename repository

         if (!repositoryName.equalsIgnoreCase(repository.name)) {

@@ -1068,7 +1211,10 @@
            }



            // clear the cache

            clearRepositoryCache(repositoryName);

            clearRepositoryCache(repositoryName, true);

				
            // add new name to repository list cache

            addToCachedRepositoryList(repository.name);

         }



         // load repository

@@ -1081,6 +1227,8 @@
            logger.error("Service not authorized", e);

         } catch (ServiceNotEnabledException e) {

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

         } catch (ServiceMayNotContinueException e) {

            logger.error("Service may not continue", e);

         }

      }



@@ -1094,7 +1242,7 @@
                  repository.name, currentRef, repository.HEAD));

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

               // clear the cache

               clearRepositoryCache(repository.name);

               clearRepositoryCache(repository.name, false);

            }

         }



@@ -1102,7 +1250,7 @@
         r.close();

      }

   }



	
   /**

    * Updates the Gitblit configuration for the specified repository.

    * 

@@ -1112,12 +1260,13 @@
    *            the Gitblit repository model

    */

   public void updateConfiguration(Repository r, RepositoryModel repository) {

      StoredConfig config = JGitUtils.readConfig(r);

      StoredConfig config = r.getConfig();

      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.setString(Constants.CONFIG_GITBLIT, null, "authorizationControl", repository.authorizationControl.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);

@@ -1189,6 +1338,9 @@
   public boolean deleteRepository(String repositoryName) {

      try {

         closeRepository(repositoryName);

         // clear the repository cache

         clearRepositoryCache(repositoryName, true);			


         File folder = new File(repositoriesFolder, repositoryName);

         if (folder.exists() && folder.isDirectory()) {

            FileUtils.delete(folder, FileUtils.RECURSIVE | FileUtils.RETRY);

@@ -1196,9 +1348,6 @@
               return true;

            }

         }



         // clear the repository cache

         clearRepositoryCache(repositoryName);

      } catch (Throwable t) {

         logger.error(MessageFormat.format("Failed to delete repository {0}", repositoryName), t);

      }

@@ -1917,6 +2066,15 @@
      repositoriesFolder = getRepositoriesFolder();

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

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



      // calculate repository list settings checksum for future config changes

      repositoryListSettingsChecksum.set(getRepositoryListSettingsChecksum());



      // build initial repository list

      if (settings.getBoolean(Keys.git.cacheRepositoryList,  true)) {

         logger.info("Identifying available repositories...");

         getRepositoryList();

      }

      

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

      logTimezone(Constants.NAME, getTimezone());