Allow setting handler externally from JettyServerCreator (#22)

* Allow setting handler externally from JettyServerCreator

* Make setHandler static and add a test

pom.xml

@@ -121,9 +121,9 @@
 
  <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
- <hk2-bridge.version>2.6.0</hk2-bridge.version>
- <jersey.version>2.29</jersey.version>
- <jetty.version>9.4.19.v20190610</jetty.version>
+ <hk2-bridge.version>2.6.1</hk2-bridge.version>
+ <jersey.version>2.30.1</jersey.version>
+ <jetty.version>9.4.28.v20200408</jetty.version>
  <guice.version>4.2.2</guice.version>
  <slf4j.version>1.7.26</slf4j.version>
  <jackson.version>2.10.2</jackson.version>

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

@@ -5,8 +5,12 @@
 import com.google.inject.servlet.GuiceServletContextListener;
 import io.logz.guice.jersey.configuration.JerseyConfiguration;
 import io.logz.guice.jersey.configuration.ServerConnectorConfiguration;
+import org.eclipse.jetty.server.Handler;
 import org.eclipse.jetty.server.Server;
 import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.handler.HandlerCollection;
+import org.eclipse.jetty.server.handler.HandlerList;
+import org.eclipse.jetty.server.handler.HandlerWrapper;
 import org.eclipse.jetty.servlet.ServletHolder;
 import org.eclipse.jetty.webapp.WebAppContext;
 import org.glassfish.jersey.servlet.ServletContainer;
@@ -74,7 +78,23 @@ protected Injector getInjector() {
  }
  });
 
- server.setHandler(webAppContext);
+ setHandler(server, webAppContext);
+ }
+
+ private static void setHandler(HandlerWrapper handlerWrapper, Handler handlerToAdd) {
+ Handler currentInnerHandler = handlerWrapper.getHandler();
+ if (currentInnerHandler == null) {
+ handlerWrapper.setHandler(handlerToAdd);
+ } else if (currentInnerHandler instanceof HandlerCollection) {
+ ((HandlerCollection) currentInnerHandler).addHandler(handlerToAdd);
+ } else if (currentInnerHandler instanceof HandlerWrapper) {
+ setHandler((HandlerWrapper) currentInnerHandler, handlerToAdd);
+ } else {
+ HandlerList handlerList = new HandlerList();
+ handlerList.addHandler(currentInnerHandler);
+ handlerList.addHandler(handlerToAdd);
+ handlerWrapper.setHandler(handlerWrapper);
+ }
  }
 
 }

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

@@ -7,6 +7,8 @@
 import io.logz.guice.jersey.resources.recursive.FooResource;
 import io.logz.guice.jersey.supplier.JerseyServerSupplier;
 import me.alexpanov.net.FreePortFinder;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.StatisticsHandler;
 import org.glassfish.jersey.server.ResourceConfig;
 import org.junit.Test;
 
@@ -15,7 +17,9 @@
 import javax.ws.rs.client.WebTarget;
 import javax.ws.rs.core.Response;
 import java.net.Socket;
+import java.util.concurrent.TimeUnit;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 
@@ -96,14 +100,39 @@ public void testHostConfiguration() throws Exception {
  .addResourceClass(TestResource.class);
 
  JerseyServerSupplier.createServerAndTest(configurationBuilder, target -> assertNoAccessFromIp(target, address, port));
+ }
+
+ @Test
+ public void testServerHandlerCanBeConfiguredFromJettyServerCreator() throws Exception {
+ JerseyConfigurationBuilder configurationBuilder = JerseyConfiguration.builder()
+ .addResourceClass(TestResource.class);
+
+ StatisticsHandler statisticsHandler = new StatisticsHandler();
+ JettyServerCreator jettyServerCreator = () -> {
+ Server server = new Server();
+ server.setHandler(statisticsHandler);
 
+ return server;
+ };
+
+ JerseyServerSupplier.createServerAndTest(configurationBuilder, jettyServerCreator, target -> {
+ assertThat(statisticsHandler.getRequests()).isEqualTo(0);
+
+ String testResourceResponse = target.path(TestResource.PATH).request().get().readEntity(String.class);
+ assertEquals(TestResource.MESSAGE, testResourceResponse);
+
+ assertThat(statisticsHandler.getRequests()).isEqualTo(1);
+ });
  }
 
  private void assertNoAccessFromIp(WebTarget target, String address, int port) {
  String testResourceResponse = target.path(TestResource.PATH).request().get().readEntity(String.class);
  assertEquals(TestResource.MESSAGE, testResourceResponse);
 
- WebTarget targetWithIpAddress = ClientBuilder.newClient().target("http:https://" + address + ":" + port);
+ WebTarget targetWithIpAddress = ClientBuilder.newBuilder()
+ .connectTimeout(5, TimeUnit.SECONDS)
+ .build()
+ .target("http:https://" + address + ":" + port);
  assertThatThrownBy(() -> targetWithIpAddress.path(TestResource.PATH).request().get()).isInstanceOf(ProcessingException.class);
  }
 

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

@@ -4,9 +4,11 @@
 import com.google.inject.Module;
 import io.logz.guice.jersey.JerseyModule;
 import io.logz.guice.jersey.JerseyServer;
+import io.logz.guice.jersey.JettyServerCreator;
 import io.logz.guice.jersey.configuration.JerseyConfiguration;
 import io.logz.guice.jersey.configuration.JerseyConfigurationBuilder;
 import me.alexpanov.net.FreePortFinder;
+import org.eclipse.jetty.server.Server;
 import org.glassfish.jersey.server.ResourceConfig;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -29,11 +31,17 @@ public static void createServerAndTest(ResourceConfig resourceConfig, Tester tes
  }
 
  public static void createServerAndTest(JerseyConfigurationBuilder configurationBuilder, Tester tester) throws Exception {
+ createServerAndTest(configurationBuilder, Server::new, tester);
+ }
+
+ public static void createServerAndTest(JerseyConfigurationBuilder configurationBuilder,
+ JettyServerCreator jettyServerCreator,
+ Tester tester) throws Exception {
  int port = FreePortFinder.findFreeLocalPort();
  configurationBuilder.addPort(port);
  JerseyConfiguration configuration = configurationBuilder.build();
 
- JerseyServer server = createServer(configuration);
+ JerseyServer server = createServer(configuration, jettyServerCreator);
  try {
  server.start();
  LOGGER.info("Started server on port: {}", port);
@@ -46,9 +54,9 @@ public static void createServerAndTest(JerseyConfigurationBuilder configurationB
  }
  }
 
- private static JerseyServer createServer(JerseyConfiguration configuration) {
+ private static JerseyServer createServer(JerseyConfiguration configuration, JettyServerCreator jettyServerCreator) {
  List<Module> modules = new ArrayList<>();
- modules.add(new JerseyModule(configuration));
+ modules.add(new JerseyModule(configuration, jettyServerCreator));
 
  return Guice.createInjector(modules)
  .getInstance(JerseyServer.class);