From 17e2d3407065a7433c7512c37a7cf7e7df63f337 Mon Sep 17 00:00:00 2001 From: James Moger Date: Fri, 16 May 2014 10:34:35 -0400 Subject: Return of Servlet3 servlet and filter loading This is a quick return of the servlet3-style code which was reverted mid-December 2013. It is not completely tested, but a casual review was done and it's looks good. The next steps should be to restore `@Inject` annotations, simplify *DaggerModule* boilerplate, and run this on a JEE container with CDI - like JBoss AS 7. --- .../java/com/gitblit/servlet/GitblitContext.java | 64 ++++-- .../gitblit/servlet/InjectionContextListener.java | 241 +++++++++++++++++++++ 2 files changed, 287 insertions(+), 18 deletions(-) create mode 100644 src/main/java/com/gitblit/servlet/InjectionContextListener.java (limited to 'src/main/java/com/gitblit/servlet') diff --git a/src/main/java/com/gitblit/servlet/GitblitContext.java b/src/main/java/com/gitblit/servlet/GitblitContext.java index d5b4092c..ac547914 100644 --- a/src/main/java/com/gitblit/servlet/GitblitContext.java +++ b/src/main/java/com/gitblit/servlet/GitblitContext.java @@ -23,13 +23,15 @@ import java.io.InputStream; import java.io.OutputStream; import java.text.MessageFormat; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; import javax.servlet.ServletContext; -import javax.servlet.ServletContextEvent; +import javax.servlet.annotation.WebListener; import com.gitblit.Constants; import com.gitblit.DaggerModule; @@ -52,20 +54,22 @@ import com.gitblit.manager.IUserManager; import com.gitblit.transport.ssh.IPublicKeyManager; import com.gitblit.utils.ContainerUtils; import com.gitblit.utils.StringUtils; +import com.gitblit.wicket.GitblitWicketFilter; import dagger.ObjectGraph; /** * This class is the main entry point for the entire webapp. It is a singleton * created manually by Gitblit GO or dynamically by the WAR/Express servlet - * container. This class instantiates and starts all managers. Servlets and - * filters are instantiated defined in web.xml and instantiated by the servlet - * container, but those servlets and filters use Dagger to manually inject their - * dependencies. + * container. This class instantiates and starts all managers. + * + * Servlets and filters are injected which allows Gitblit to be completely + * code-driven. * * @author James Moger * */ +@WebListener public class GitblitContext extends DaggerContext { private static GitblitContext gitblit; @@ -119,22 +123,11 @@ public class GitblitContext extends DaggerContext { return new Object [] { new DaggerModule() }; } - /** - * Configure Gitblit from the web.xml, if no configuration has already been - * specified. - * - * @see ServletContextListener.contextInitialize(ServletContextEvent) - */ - @Override - public final void contextInitialized(ServletContextEvent contextEvent) { - ServletContext context = contextEvent.getServletContext(); - configureContext(context); - } - /** * Prepare runtime settings and start all manager instances. */ - protected void configureContext(ServletContext context) { + @Override + protected void beforeServletInjection(ServletContext context) { ObjectGraph injector = getInjector(context); // create the runtime settings object @@ -236,6 +229,41 @@ public class GitblitContext extends DaggerContext { logger.info("----[{}]----", clazz.getName()); } + /** + * Instantiate and inject all filters and servlets into the container using + * the servlet 3 specification. + */ + @Override + protected void injectServlets(ServletContext context) { + // access restricted servlets + serve(context, Constants.R_PATH, GitServlet.class, GitFilter.class); + serve(context, Constants.GIT_PATH, GitServlet.class, GitFilter.class); + serve(context, Constants.RAW_PATH, RawServlet.class, RawFilter.class); + serve(context, Constants.PAGES, PagesServlet.class, PagesFilter.class); + serve(context, Constants.RPC_PATH, RpcServlet.class, RpcFilter.class); + serve(context, Constants.ZIP_PATH, DownloadZipServlet.class, DownloadZipFilter.class); + serve(context, Constants.SYNDICATION_PATH, SyndicationServlet.class, SyndicationFilter.class); + + // servlets + serve(context, Constants.FEDERATION_PATH, FederationServlet.class); + serve(context, Constants.SPARKLESHARE_INVITE_PATH, SparkleShareInviteServlet.class); + serve(context, Constants.BRANCH_GRAPH_PATH, BranchGraphServlet.class); + serve(context, Constants.PT_PATH, PtServlet.class); + file(context, "/robots.txt", RobotsTxtServlet.class); + file(context, "/logo.png", LogoServlet.class); + + // global filters + filter(context, "/*", ProxyFilter.class, null); + filter(context, "/*", EnforceAuthenticationFilter.class, null); + + // Wicket + String toIgnore = StringUtils.flattenStrings(getRegisteredPaths(), ","); + Map params = new HashMap(); + params.put(GitblitWicketFilter.FILTER_MAPPING_PARAM, "/*"); + params.put(GitblitWicketFilter.IGNORE_PATHS_PARAM, toIgnore); + filter(context, "/*", GitblitWicketFilter.class, params); + } + /** * Gitblit is being shutdown either because the servlet container is * shutting down or because the servlet container is re-deploying Gitblit. diff --git a/src/main/java/com/gitblit/servlet/InjectionContextListener.java b/src/main/java/com/gitblit/servlet/InjectionContextListener.java new file mode 100644 index 00000000..17de6dad --- /dev/null +++ b/src/main/java/com/gitblit/servlet/InjectionContextListener.java @@ -0,0 +1,241 @@ +/* + * Copyright 2014 gitblit.com. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.gitblit.servlet; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.List; +import java.util.Map; + +import javax.servlet.DispatcherType; +import javax.servlet.Filter; +import javax.servlet.FilterRegistration; +import javax.servlet.Servlet; +import javax.servlet.ServletContext; +import javax.servlet.ServletContextEvent; +import javax.servlet.ServletContextListener; +import javax.servlet.ServletRegistration; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Injection context listener instantiates and injects servlets, filters, and + * anything else you might want into a servlet context. This class provides + * convenience methods for servlet & filter registration and also tracks + * registered paths. + * + * @author James Moger + * + */ +public abstract class InjectionContextListener implements ServletContextListener { + + protected final Logger logger = LoggerFactory.getLogger(getClass()); + + private final List registeredPaths = new ArrayList(); + + protected final List getRegisteredPaths() { + return registeredPaths; + } + + /** + * Hook for subclasses to manipulate context initialization before + * standard initialization procedure. + * + * @param context + */ + protected void beforeServletInjection(ServletContext context) { + // NOOP + } + + /** + * Hook for subclasses to instantiate and inject servlets and filters + * into the servlet context. + * + * @param context + */ + protected abstract void injectServlets(ServletContext context); + + /** + * Hook for subclasses to manipulate context initialization after + * servlet registration. + * + * @param context + */ + protected void afterServletInjection(ServletContext context) { + // NOOP + } + + /** + * Configure Gitblit from the web.xml, if no configuration has already been + * specified. + * + * @see ServletContextListener.contextInitialize(ServletContextEvent) + */ + @Override + public final void contextInitialized(ServletContextEvent contextEvent) { + ServletContext context = contextEvent.getServletContext(); + beforeServletInjection(context); + injectServlets(context); + afterServletInjection(context); + } + + + /** + * Registers a file path. + * + * @param context + * @param file + * @param servletClass + */ + protected void file(ServletContext context, String file, Class servletClass) { + file(context, file, servletClass, null); + } + + /** + * Registers a file path with init parameters. + * + * @param context + * @param file + * @param servletClass + * @param initParams + */ + protected void file(ServletContext context, String file, Class servletClass, Map initParams) { + Servlet servlet = instantiate(context, servletClass); + ServletRegistration.Dynamic d = context.addServlet(sanitize(servletClass.getSimpleName() + file), servlet); + d.addMapping(file); + if (initParams != null) { + d.setInitParameters(initParams); + } + registeredPaths.add(file); + } + + /** + * Serves a path (trailing wildcard will be appended). + * + * @param context + * @param route + * @param servletClass + */ + protected void serve(ServletContext context, String route, Class servletClass) { + serve(context, route, servletClass, (Class) null); + } + + /** + * Serves a path (trailing wildcard will be appended) with init parameters. + * + * @param context + * @param route + * @param servletClass + * @param initParams + */ + protected void serve(ServletContext context, String route, Class servletClass, Map initParams) { + Servlet servlet = instantiate(context, servletClass); + ServletRegistration.Dynamic d = context.addServlet(sanitize(servletClass.getSimpleName() + route), servlet); + d.addMapping(route + "*"); + if (initParams != null) { + d.setInitParameters(initParams); + } + registeredPaths.add(route); + } + + /** + * Serves a path (trailing wildcard will be appended) and also maps a filter + * to that path. + * + * @param context + * @param route + * @param servletClass + * @param filterClass + */ + protected void serve(ServletContext context, String route, Class servletClass, Class filterClass) { + Servlet servlet = instantiate(context, servletClass); + ServletRegistration.Dynamic d = context.addServlet(sanitize(servletClass.getSimpleName() + route), servlet); + d.addMapping(route + "*"); + if (filterClass != null) { + filter(context, route + "*", filterClass); + } + registeredPaths.add(route); + } + + /** + * Registers a path filter. + * + * @param context + * @param route + * @param filterClass + */ + protected void filter(ServletContext context, String route, Class filterClass) { + filter(context, route, filterClass, null); + } + + /** + * Registers a path filter with init parameters. + * + * @param context + * @param route + * @param filterClass + * @param initParams + */ + protected void filter(ServletContext context, String route, Class filterClass, Map initParams) { + Filter filter = instantiate(context, filterClass); + FilterRegistration.Dynamic d = context.addFilter(sanitize(filterClass.getSimpleName() + route), filter); + d.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, route); + if (initParams != null) { + d.setInitParameters(initParams); + } + } + + /** + * Limit the generated servlet/filter names to alpha-numeric values with a + * handful of acceptable other characters. + * + * @param name + * @return a sanitized name + */ + protected String sanitize(String name) { + StringBuilder sb = new StringBuilder(); + for (char c : name.toCharArray()) { + if (Character.isLetterOrDigit(c)) { + sb.append(c); + } else if ('-' == c) { + sb.append(c); + } else if ('*' == c) { + sb.append("all"); + } else if ('.' == c) { + sb.append('.'); + } else { + sb.append('_'); + } + } + return sb.toString(); + } + + /** + * Instantiates an object. + * + * @param clazz + * @return the object + */ + protected X instantiate(ServletContext context, Class clazz) { + try { + return clazz.newInstance(); + } catch (Throwable t) { + logger.error(null, t); + } + return null; + } +} -- cgit v1.2.3