Expose API for configuring the WebAppContext in Jetty (#29)

.gitignore

@@ -77,6 +77,7 @@ Temporary Items
 .directory
 .Trash-*
 .nfs*
+target
 
 # Avoid ignoring Maven wrapper jar file (.jar files are usually ignored)
 !/.mvn/wrapper/maven-wrapper.jar

pom.xml

@@ -4,7 +4,7 @@
 
  <groupId>io.logz</groupId>
  <artifactId>guice-jersey</artifactId>
- <version>1.0.14-SNAPSHOT</version>
+ <version>1.0.15-SNAPSHOT</version>
 
  <packaging>jar</packaging>
  <name>guice-jersey</name>

src/main/java/io/logz/guice/jersey/JerseyModule.java

@@ -5,6 +5,7 @@
 import com.google.inject.Provider;
 import com.google.inject.servlet.ServletModule;
 import io.logz.guice.jersey.configuration.JerseyConfiguration;
+import io.logz.guice.jersey.configuration.JerseyWebApplicationConfigurator;
 import org.eclipse.jetty.server.Server;
 
 import java.util.Objects;
@@ -13,21 +14,27 @@ public class JerseyModule extends AbstractModule {
 
  private final JerseyConfiguration jerseyConfiguration;
  private final JettyServerCreator jettyServerCreator;
+ private final JerseyWebApplicationConfigurator jerseyWebApplicationConfigurator;
 
  public JerseyModule(JerseyConfiguration jerseyConfiguration) {
  this(jerseyConfiguration, Server::new);
  }
 
  public JerseyModule(JerseyConfiguration jerseyConfiguration, JettyServerCreator jettyServerCreator) {
+ this(jerseyConfiguration, jettyServerCreator, null);
+ }
+
+ public JerseyModule(JerseyConfiguration jerseyConfiguration, JettyServerCreator jettyServerCreator, JerseyWebApplicationConfigurator jerseyWebApplicationConfigurator) {
  this.jerseyConfiguration = Objects.requireNonNull(jerseyConfiguration);
  this.jettyServerCreator = Objects.requireNonNull(jettyServerCreator);
+ this.jerseyWebApplicationConfigurator = jerseyWebApplicationConfigurator;
  }
 
  protected void configure() {
  Provider<Injector> injectorProvider = getProvider(Injector.class);
 
  install(new ServletModule());
- bind(JerseyServer.class).toInstance(new JerseyServer(jerseyConfiguration, injectorProvider::get, jettyServerCreator));
+ bind(JerseyServer.class).toInstance(new JerseyServer(jerseyConfiguration, injectorProvider::get, jettyServerCreator, jerseyWebApplicationConfigurator));
  bind(JerseyConfiguration.class).toInstance(jerseyConfiguration);
  }
 

src/main/java/io/logz/guice/jersey/JerseyServer.java

@@ -1,11 +1,10 @@
 package io.logz.guice.jersey;
 
 import com.google.inject.Injector;
-import com.google.inject.servlet.GuiceFilter;
 import com.google.inject.servlet.GuiceServletContextListener;
 import io.logz.guice.jersey.configuration.JerseyConfiguration;
+import io.logz.guice.jersey.configuration.JerseyWebApplicationConfigurator;
 import io.logz.guice.jersey.configuration.ServerConnectorConfiguration;
-import org.eclipse.jetty.server.Connector;
 import org.eclipse.jetty.server.Handler;
 import org.eclipse.jetty.server.HttpConnectionFactory;
 import org.eclipse.jetty.server.Server;
@@ -19,9 +18,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.servlet.DispatcherType;
 import java.util.Collections;
-import java.util.EnumSet;
 import java.util.List;
 import java.util.function.Supplier;
 
@@ -30,15 +27,18 @@ public class JerseyServer {
  private static final Logger LOGGER = LoggerFactory.getLogger(JerseyServer.class);
 
  private final JerseyConfiguration jerseyConfiguration;
+ private final JerseyWebApplicationConfigurator jerseyWebApplicationConfigurator;
  private final Supplier<Injector> injectorSupplier;
  private final Server server;
 
  JerseyServer(JerseyConfiguration jerseyConfiguration,
  Supplier<Injector> injectorSupplier,
- JettyServerCreator jettyServerCreator) {
+ JettyServerCreator jettyServerCreator,
+ JerseyWebApplicationConfigurator jerseyWebApplicationConfigurator) {
  this.jerseyConfiguration = jerseyConfiguration;
  this.injectorSupplier = injectorSupplier;
  this.server = jettyServerCreator.create();
+ this.jerseyWebApplicationConfigurator = jerseyWebApplicationConfigurator;
 
  configureServer();
  }
@@ -65,10 +65,10 @@ private void configureServer() {
  });
 
  WebAppContext webAppContext = new WebAppContext();
+ if (jerseyWebApplicationConfigurator != null)
+ jerseyWebApplicationConfigurator.configure(webAppContext);
  webAppContext.setServer(server);
 
- webAppContext.addFilter(GuiceFilter.class, "/*", EnumSet.allOf(DispatcherType.class));
-
  ServletHolder holder = new ServletHolder(ServletContainer.class);
  holder.setInitParameter("javax.ws.rs.Application", GuiceJerseyResourceConfig.class.getName());
 

src/main/java/io/logz/guice/jersey/configuration/JerseyWebApplicationConfigurator.java

@@ -0,0 +1,12 @@
+package io.logz.guice.jersey.configuration;
+
+import org.eclipse.jetty.webapp.WebAppContext;
+
+/**
+ * Implement to provide additional configuration for the underlying {@link org.eclipse.jetty.webapp.WebAppContext},
+ * like adding a {@link javax.servlet.Filter} or {@link java.util.EventListener}, etc.
+ */
+@FunctionalInterface
+public interface JerseyWebApplicationConfigurator {
+ void configure(WebAppContext webAppContext);
+}

src/test/java/io/logz/guice/jersey/JettyFilterRegistrationTest.java

@@ -0,0 +1,45 @@
+package io.logz.guice.jersey;
+
+import io.logz.guice.jersey.configuration.JerseyConfiguration;
+import io.logz.guice.jersey.configuration.JerseyConfigurationBuilder;
+import io.logz.guice.jersey.filters.AddHeaderJettyFilter;
+import io.logz.guice.jersey.resources.TestResource;
+import io.logz.guice.jersey.supplier.JerseyServerSupplier;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.FilterHolder;
+import org.junit.Test;
+
+import javax.servlet.DispatcherType;
+import javax.ws.rs.core.Response;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class JettyFilterRegistrationTest {
+
+ @Test
+ public void testJettyFilter() throws Exception {
+ JerseyConfigurationBuilder configurationBuilder = JerseyConfiguration.builder()
+ .addResourceClass(TestResource.class);
+
+ String myTestValue = "param";
+
+ JerseyServerSupplier.Tester tester = target -> {
+ Response response = target.path(TestResource.PATH).request().get();
+ String headerParamValue = response.getHeaderString(AddHeaderJettyFilter.TEST_HEADER);
+ String responseBody = response.readEntity(String.class);
+ assertEquals(TestResource.MESSAGE, responseBody);
+ assertEquals(headerParamValue, myTestValue);
+ };
+
+ JerseyServerSupplier.createServerAndTest(configurationBuilder, Server::new, tester, webAppContext -> {
+ FilterHolder filterHolder = new FilterHolder(AddHeaderJettyFilter.class);
+ Map<String, String> initParams = new HashMap<>();
+ initParams.put(AddHeaderJettyFilter.INIT_PARAM_KEY, myTestValue);
+ filterHolder.setInitParameters(initParams);
+ webAppContext.addFilter(filterHolder, "/*", EnumSet.allOf(DispatcherType.class));
+ });
+ }
+}

src/test/java/io/logz/guice/jersey/filters/AddHeaderJettyFilter.java

@@ -0,0 +1,33 @@
+package io.logz.guice.jersey.filters;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+public class AddHeaderJettyFilter implements Filter {
+
+ public static final String TEST_HEADER = "X-JETTY-FILTER-TEST-HEADER";
+ public static final String INIT_PARAM_KEY = "INIT_PARAM_KEY";
+ private String initParamValue;
+
+ @Override
+ public void init(FilterConfig filterConfig) {
+ initParamValue = filterConfig.getInitParameter(INIT_PARAM_KEY);
+ }
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+ ((HttpServletResponse) response).addHeader(TEST_HEADER, initParamValue);
+ chain.doFilter(request, response);
+ }
+
+ @Override
+ public void destroy() {
+
+ }
+}

src/test/java/io/logz/guice/jersey/supplier/JerseyServerSupplier.java

@@ -7,6 +7,7 @@
 import io.logz.guice.jersey.JettyServerCreator;
 import io.logz.guice.jersey.configuration.JerseyConfiguration;
 import io.logz.guice.jersey.configuration.JerseyConfigurationBuilder;
+import io.logz.guice.jersey.configuration.JerseyWebApplicationConfigurator;
 import me.alexpanov.net.FreePortFinder;
 import org.eclipse.jetty.server.Server;
 import org.glassfish.jersey.server.ResourceConfig;
@@ -49,7 +50,7 @@ public static void createServerAndTest(JerseyConfigurationBuilder configurationB
  int port) throws Exception {
  JerseyConfiguration configuration = configurationBuilder.build();
 
- JerseyServer server = createServer(configuration, jettyServerCreator);
+ JerseyServer server = createServer(configuration, jettyServerCreator, null);
  try {
  server.start();
  LOGGER.info("Started server on port: {}", port);
@@ -62,9 +63,31 @@ public static void createServerAndTest(JerseyConfigurationBuilder configurationB
  }
  }
 
- private static JerseyServer createServer(JerseyConfiguration configuration, JettyServerCreator jettyServerCreator) {
+ public static void createServerAndTest(JerseyConfigurationBuilder configurationBuilder,
+ JettyServerCreator jettyServerCreator,
+ Tester tester,
+ JerseyWebApplicationConfigurator jerseyWebApplicationConfigurator) throws Exception {
+ int port = FreePortFinder.findFreeLocalPort();
+ configurationBuilder.addPort(port);
+ JerseyConfiguration configuration = configurationBuilder.build();
+
+ JerseyServer server = createServer(configuration, jettyServerCreator, jerseyWebApplicationConfigurator);
+ try {
+ server.start();
+ LOGGER.info("Started server on port: {}", port);
+
+ Client client = ClientBuilder.newClient();
+ WebTarget target = client.target("http:https://localhost:" + port).path(configuration.getContextPath());
+ tester.test(target);
+ } finally {
+ server.stop();
+ }
+ }
+
+
+ private static JerseyServer createServer(JerseyConfiguration configuration, JettyServerCreator jettyServerCreator, JerseyWebApplicationConfigurator jerseyWebApplicationConfigurator) {
  List<Module> modules = new ArrayList<>();
- modules.add(new JerseyModule(configuration, jettyServerCreator));
+ modules.add(new JerseyModule(configuration, jettyServerCreator, jerseyWebApplicationConfigurator));
 
  return Guice.createInjector(modules)
  .getInstance(JerseyServer.class);