Extract services manager into a top-level injectable manager

James Moger

2014-07-02 7d3a31514afbe88664081b4ea57cd7939de99014

 src/main/java/com/gitblit/GitBlit.java

@@ -24,11 +24,8 @@
import java.util.List;
import java.util.Set;

import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import com.google.inject.Inject;

import com.gitblit.Constants.AccessPermission;
import com.gitblit.Constants.Transport;
import com.gitblit.manager.GitblitManager;
import com.gitblit.manager.IAuthenticationManager;
import com.gitblit.manager.IFederationManager;
@@ -39,9 +36,7 @@
import com.gitblit.manager.IRepositoryManager;
import com.gitblit.manager.IRuntimeManager;
import com.gitblit.manager.IUserManager;
import com.gitblit.manager.ServicesManager;
import com.gitblit.models.RepositoryModel;
import com.gitblit.models.RepositoryUrl;
import com.gitblit.models.UserModel;
import com.gitblit.tickets.ITicketService;
import com.gitblit.tickets.NullTicketService;
@@ -61,8 +56,6 @@
public class GitBlit extends GitblitManager {

   private final Injector injector;

   private final ServicesManager servicesManager;

   private ITicketService ticketService;

@@ -89,15 +82,11 @@
            federationManager);

      this.injector = Guice.createInjector(getModules());

      this.servicesManager = new ServicesManager(this);
   }

   @Override
   public GitBlit start() {
      super.start();
      logger.info("Starting services manager...");
      servicesManager.start();
      configureTicketService();
      return this;
   }
@@ -105,182 +94,12 @@
   @Override
   public GitBlit stop() {
      super.stop();
      servicesManager.stop();
      ticketService.stop();
      return this;
   }

   @Override
   public boolean isServingRepositories() {
      return servicesManager.isServingRepositories();
   }

   @Override
   public boolean isServingHTTP() {
      return servicesManager.isServingHTTP();
   }

   @Override
   public boolean isServingGIT() {
      return servicesManager.isServingGIT();
   }

   @Override
   public boolean isServingSSH() {
      return servicesManager.isServingSSH();
   }

   protected AbstractModule [] getModules() {
      return new AbstractModule [] { new GitBlitModule()};
   }

   protected boolean acceptPush(Transport byTransport) {
      if (byTransport == null) {
         logger.info("Unknown transport, push rejected!");
         return false;
      }

      Set<Transport> transports = new HashSet<Transport>();
      for (String value : getSettings().getStrings(Keys.git.acceptedPushTransports)) {
         Transport transport = Transport.fromString(value);
         if (transport == null) {
            logger.info(String.format("Ignoring unknown registered transport %s", value));
            continue;
         }

         transports.add(transport);
      }

      if (transports.isEmpty()) {
         // no transports are explicitly specified, all are acceptable
         return true;
      }

      // verify that the transport is permitted
      return transports.contains(byTransport);
   }

   /**
    * Returns a list of repository URLs and the user access permission.
    *
    * @param request
    * @param user
    * @param repository
    * @return a list of repository urls
    */
   @Override
   public List<RepositoryUrl> getRepositoryUrls(HttpServletRequest request, UserModel user, RepositoryModel repository) {
      if (user == null) {
         user = UserModel.ANONYMOUS;
      }
      String username = StringUtils.encodeUsername(UserModel.ANONYMOUS.equals(user) ? "" : user.username);

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

      // http/https url
      if (settings.getBoolean(Keys.git.enableGitServlet, true)) {
         AccessPermission permission = user.getRepositoryPermission(repository).permission;
         if (permission.exceeds(AccessPermission.NONE)) {
            Transport transport = Transport.fromString(request.getScheme());
            if (permission.atLeast(AccessPermission.PUSH) && !acceptPush(transport)) {
               // downgrade the repo permission for this transport
               // because it is not an acceptable PUSH transport
               permission = AccessPermission.CLONE;
            }
            list.add(new RepositoryUrl(getRepositoryUrl(request, username, repository), permission));
         }
      }

      // ssh daemon url
      String sshDaemonUrl = servicesManager.getSshDaemonUrl(request, user, repository);
      if (!StringUtils.isEmpty(sshDaemonUrl)) {
         AccessPermission permission = user.getRepositoryPermission(repository).permission;
         if (permission.exceeds(AccessPermission.NONE)) {
            if (permission.atLeast(AccessPermission.PUSH) && !acceptPush(Transport.SSH)) {
               // downgrade the repo permission for this transport
               // because it is not an acceptable PUSH transport
               permission = AccessPermission.CLONE;
            }

            list.add(new RepositoryUrl(sshDaemonUrl, permission));
         }
      }

      // git daemon url
      String gitDaemonUrl = servicesManager.getGitDaemonUrl(request, user, repository);
      if (!StringUtils.isEmpty(gitDaemonUrl)) {
         AccessPermission permission = servicesManager.getGitDaemonAccessPermission(user, repository);
         if (permission.exceeds(AccessPermission.NONE)) {
            if (permission.atLeast(AccessPermission.PUSH) && !acceptPush(Transport.GIT)) {
               // downgrade the repo permission for this transport
               // because it is not an acceptable PUSH transport
               permission = AccessPermission.CLONE;
            }
            list.add(new RepositoryUrl(gitDaemonUrl, permission));
         }
      }

      // add all other urls
      // {0} = repository
      // {1} = username
      for (String url : settings.getStrings(Keys.web.otherUrls)) {
         if (url.contains("{1}")) {
            // external url requires username, only add url IF we have one
            if (!StringUtils.isEmpty(username)) {
               list.add(new RepositoryUrl(MessageFormat.format(url, repository.name, username), null));
            }
         } else {
            // external url does not require username
            list.add(new RepositoryUrl(MessageFormat.format(url, repository.name), null));
         }
      }

      // sort transports by highest permission and then by transport security
      Collections.sort(list, new Comparator<RepositoryUrl>() {

         @Override
         public int compare(RepositoryUrl o1, RepositoryUrl o2) {
            if (!o1.isExternal() && o2.isExternal()) {
               // prefer Gitblit over external
               return -1;
            } else if (o1.isExternal() && !o2.isExternal()) {
               // prefer Gitblit over external
               return 1;
            } else if (o1.isExternal() && o2.isExternal()) {
               // sort by Transport ordinal
               return o1.transport.compareTo(o2.transport);
            } else if (o1.permission.exceeds(o2.permission)) {
               // prefer highest permission
               return -1;
            } else if (o2.permission.exceeds(o1.permission)) {
               // prefer highest permission
               return 1;
            }

            // prefer more secure transports
            return o1.transport.compareTo(o2.transport);
         }
      });

      // consider the user's transport preference
      RepositoryUrl preferredUrl = null;
      Transport preferredTransport = user.getPreferences().getTransport();
      if (preferredTransport != null) {
         Iterator<RepositoryUrl> itr = list.iterator();
         while (itr.hasNext()) {
            RepositoryUrl url = itr.next();
            if (url.transport.equals(preferredTransport)) {
               itr.remove();
               preferredUrl = url;
               break;
            }
         }
      }
      if (preferredUrl != null) {
         list.add(0, preferredUrl);
      }

      return list;
   }

   /**