Merge pull request #43 from cryptomator/feature/remove-dagger

remove dagger

Author: overheadhunter

pom.xml

@@ -84,13 +84,6 @@
 			<version>${slf4j.version}</version>
 		</dependency>
 
-		<!-- DI -->
-		<dependency>
-			<groupId>com.google.dagger</groupId>
-			<artifactId>dagger</artifactId>
-			<version>${dagger.version}</version>
-		</dependency>
-
 		<!-- Test -->
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
@@ -115,13 +108,6 @@
 				<configuration>
 					<release>11</release>
 					<showWarnings>true</showWarnings>
-					<annotationProcessorPaths>
-						<path>
-							<groupId>com.google.dagger</groupId>
-							<artifactId>dagger-compiler</artifactId>
-							<version>${dagger.version}</version>
-						</path>
-					</annotationProcessorPaths>
 				</configuration>
 			</plugin>
 			<plugin>

src/main/java/module-info.java

@@ -4,13 +4,6 @@
 	requires org.eclipse.jetty.servlet;
 	requires com.google.common;
 	requires org.slf4j;
-	requires dagger;
-
-	// filename-based module required by dagger
-	// we will probably need to live with this for a while:
-	// https://github.com/javax-inject/javax-inject/issues/33
-	// May be provided by another lib during runtime
-	requires static javax.inject;
 
 	exports org.cryptomator.frontend.webdav;
 	exports org.cryptomator.frontend.webdav.mount;

src/main/java/org/cryptomator/frontend/webdav/DefaultServlet.java

@@ -8,30 +8,23 @@
  *******************************************************************************/
 package org.cryptomator.frontend.webdav;
 
-import java.io.IOException;
-import java.util.Collection;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Iterables;
 
-import javax.inject.Inject;
-import javax.inject.Singleton;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Collection;
 
-import org.cryptomator.frontend.webdav.WebDavServerModule.ContextPaths;
-
-import com.google.common.base.Splitter;
-import com.google.common.collect.Iterables;
-
-@Singleton
 class DefaultServlet extends HttpServlet {
 
 	private static final String METHOD_PROPFIND = "PROPFIND";
 	private static final int TARPIT_DELAY_MS = 5000;
 	private final Collection<String> contextPaths;
 
-	@Inject
-	public DefaultServlet(@ContextPaths Collection<String> contextPaths) {
+	public DefaultServlet(Collection<String> contextPaths) {
 		this.contextPaths = contextPaths;
 	}
 
@@ -60,7 +53,7 @@ protected void service(HttpServletRequest req, HttpServletResponse resp) throws
 	}
 
 	@Override
-	protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+	protected void doOptions(HttpServletRequest req, HttpServletResponse resp) {
 		resp.addHeader("DAV", "1, 2");
 		resp.addHeader("MS-Author-Via", "DAV");
 		resp.addHeader("Allow", "OPTIONS, PROPFIND, GET, HEAD");
@@ -85,7 +78,7 @@ protected void doPropfind(HttpServletRequest req, HttpServletResponse resp) thro
 	}
 
 	private boolean isRequestedResourcePathPartOfValidContextPath(String requestedResourcePath) {
-		return contextPaths.stream().filter(cp -> isParentOrSamePath(cp, requestedResourcePath)).findAny().isPresent();
+		return contextPaths.stream().anyMatch(cp -> isParentOrSamePath(cp, requestedResourcePath));
 	}
 
 	private boolean isParentOrSamePath(String path, String potentialParent) {

src/main/java/org/cryptomator/frontend/webdav/WebDavServer.java

@@ -8,46 +8,41 @@
  *******************************************************************************/
 package org.cryptomator.frontend.webdav;
 
-import java.net.InetSocketAddress;
-import java.nio.file.Path;
-import java.util.concurrent.ExecutorService;
-
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-import org.cryptomator.frontend.webdav.servlet.WebDavServletComponent;
 import org.cryptomator.frontend.webdav.servlet.WebDavServletController;
+import org.cryptomator.frontend.webdav.servlet.WebDavServletFactory;
 import org.eclipse.jetty.server.Server;
 import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.handler.ContextHandlerCollection;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.net.InetSocketAddress;
+import java.nio.file.Path;
+import java.util.concurrent.ExecutorService;
+
 /**
  * The WebDAV server, that WebDAV servlets can be added to using {@link #createWebDavServlet(Path, String)}.
  *
  * An instance of this class can be obtained via {@link #create()}.
  */
-@Singleton
 public class WebDavServer {
 
 	private static final Logger LOG = LoggerFactory.getLogger(WebDavServer.class);
 
 	private final Server server;
 	private final ExecutorService executorService;
 	private final ServerConnector localConnector;
-	private final WebDavServletFactory servletFactory;
+	private final ContextHandlerCollection servletCollectionCtx;
 
-	@Inject
-	WebDavServer(Server server, ExecutorService executorService, ServerConnector connector, WebDavServletFactory servletContextFactory) {
+	WebDavServer(Server server, ExecutorService executorService, ServerConnector connector, ContextHandlerCollection servletCollectionCtx) {
 		this.server = server;
 		this.executorService = executorService;
 		this.localConnector = connector;
-		this.servletFactory = servletContextFactory;
+		this.servletCollectionCtx = servletCollectionCtx;
 	}
 
 	public static WebDavServer create() {
-		WebDavServerComponent comp = DaggerWebDavServerComponent.create();
-		return comp.server();
+		return WebDavServerFactory.createWebDavServer();
 	}
 
 	/**
@@ -135,8 +130,7 @@ public synchronized void terminate() throws ServerLifecycleException {
 	 * @return The controller object for this new servlet
 	 */
 	public WebDavServletController createWebDavServlet(Path rootPath, String contextPath) {
-		WebDavServletComponent servletComp = servletFactory.create(rootPath, contextPath);
-		return servletComp.servlet();
+		return WebDavServletFactory.createServletController(rootPath, contextPath, localConnector, servletCollectionCtx);
 	}
 
 }

src/main/java/org/cryptomator/frontend/webdav/WebDavServerComponent.java

@@ -9,65 +9,41 @@
 package org.cryptomator.frontend.webdav;
 
 import com.google.common.base.Preconditions;
-import dagger.Module;
-import dagger.Provides;
-import org.cryptomator.frontend.webdav.mount.MounterModule;
 import org.eclipse.jetty.http.UriCompliance;
-import org.eclipse.jetty.server.Connector;
-import org.eclipse.jetty.server.HttpConfiguration;
-import org.eclipse.jetty.server.HttpConnectionFactory;
-import org.eclipse.jetty.server.Server;
-import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.*;
 import org.eclipse.jetty.server.handler.ContextHandlerCollection;
 import org.eclipse.jetty.servlet.ServletContextHandler;
 import org.eclipse.jetty.servlet.ServletHolder;
 import org.eclipse.jetty.util.thread.ExecutorThreadPool;
 
-import javax.inject.Qualifier;
-import javax.inject.Singleton;
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.Collection;
 import java.util.HashSet;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
-@Module(includes = {MounterModule.class})
-class WebDavServerModule {
+class WebDavServerFactory {
 
 	private static final int MAX_PENDING_REQUESTS = 400;
 	private static final int MAX_THREADS = 100;
 	private static final int THREAD_IDLE_SECONDS = 60;
 	private static final String ROOT_PATH = "/";
+	private static final AtomicInteger THREAD_NUM = new AtomicInteger();
 
-	private AtomicInteger threadNum = new AtomicInteger(1);
+	private WebDavServerFactory(){}
 
-	@Provides
-	@Singleton
-	ThreadPoolExecutor provideThreadPoolExecutor() {
+	private static ThreadPoolExecutor createThreadPoolExecutor() {
 		// set core pool size = MAX_THREADS and allow coreThreadTimeOut to enforce spawning threads till the maximum even if the queue is not full
 		BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(MAX_PENDING_REQUESTS);
 		ThreadPoolExecutor executor = new ThreadPoolExecutor(MAX_THREADS, MAX_THREADS, THREAD_IDLE_SECONDS, TimeUnit.SECONDS, queue);
 		executor.allowCoreThreadTimeOut(true);
 		return executor;
 	}
 
-	@Provides
-	@Singleton
-	ExecutorService provideExecutorService(ThreadPoolExecutor executorService) {
-		return executorService;
-	}
-
-	@Provides
-	@Singleton
-	ExecutorThreadPool provideThreadPool(ThreadPoolExecutor executorService) {
+	private static ExecutorThreadPool createThreadPool(ThreadPoolExecutor executorService) {
 		ExecutorThreadPool threadPool = new ExecutorThreadPool(executorService);
-		executorService.setThreadFactory(this::createServerThread);
+		executorService.setThreadFactory(WebDavServerFactory::createServerThread);
 		try {
 			threadPool.start();
 			return threadPool;
@@ -76,67 +52,51 @@ ExecutorThreadPool provideThreadPool(ThreadPoolExecutor executorService) {
 		}
 	}
 
-	private Thread createServerThread(Runnable runnable) {
-		Thread t = new Thread(runnable, String.format("webdav-%03d", threadNum.getAndIncrement()));
+	private static Thread createServerThread(Runnable runnable) {
+		Thread t = new Thread(runnable, String.format("webdav-%03d", THREAD_NUM.incrementAndGet()));
 		t.setDaemon(true);
 		return t;
 	}
 
 
-	@Provides
-	@Singleton
-	Server provideServer(ExecutorThreadPool threadPool, ContextHandlerCollection servletCollection) {
+	private static Server createServer(ExecutorThreadPool threadPool, ContextHandlerCollection servletCollection) {
 		Preconditions.checkState(threadPool.isStarted()); // otherwise addBean() will make the threadpool managed, i.e. it will be shut down when the server is stopped
 		Server server = new Server(threadPool);
 		server.setHandler(servletCollection);
 		return server;
 	}
 
-	@Provides
-	@Singleton
-	ServerConnector provideServerConnector(Server server) {
+	private static ServerConnector createServerConnector(Server server) {
 		HttpConfiguration config = new HttpConfiguration();
 		config.setUriCompliance(UriCompliance.from("0,AMBIGUOUS_PATH_SEPARATOR,AMBIGUOUS_PATH_ENCODING"));
 		ServerConnector connector = new ServerConnector(server, new HttpConnectionFactory(config));
 		server.setConnectors(new Connector[]{connector});
 		return connector;
 	}
 
-	@Provides
-	@Singleton
-	ContextHandlerCollection provideContextHandlerCollection(@CatchAll ServletContextHandler catchAllServletHandler) {
+	private static ContextHandlerCollection createContextHandlerCollection(ServletContextHandler catchAllServletHandler) {
 		ContextHandlerCollection collection = new ContextHandlerCollection();
 		collection.addHandler(catchAllServletHandler);
 		return collection;
 	}
 
-	@Provides
-	@Singleton
-	@CatchAll
-	ServletContextHandler provideServletContextHandler(DefaultServlet servlet) {
+	private static ServletContextHandler createDefaultServletContext(DefaultServlet servlet) {
 		final ServletContextHandler servletContext = new ServletContextHandler(null, ROOT_PATH, ServletContextHandler.NO_SESSIONS);
 		final ServletHolder servletHolder = new ServletHolder(ROOT_PATH, servlet);
 		servletContext.addServlet(servletHolder, ROOT_PATH);
 		return servletContext;
 	}
 
-	@Provides
-	@Singleton
-	@ContextPaths
-	Collection<String> provideContextPaths() {
-		return new HashSet<>();
-	}
-
-	@Qualifier
-	@Documented
-	@Retention(RetentionPolicy.RUNTIME)
-	@interface CatchAll {
-	}
-
-	@Qualifier
-	@Documented
-	@Retention(RetentionPolicy.RUNTIME)
-	@interface ContextPaths {
+	public static WebDavServer createWebDavServer() {
+		var contextPaths = new HashSet<String>();
+		var executorService = createThreadPoolExecutor();
+		var threadPool = createThreadPool(executorService);
+		var defaultServlet = new DefaultServlet(contextPaths);
+		var defaultServletCtx = createDefaultServletContext(defaultServlet);
+		var servletCollectionCtx = createContextHandlerCollection(defaultServletCtx);
+		var server = createServer(threadPool, servletCollectionCtx);
+		var serverConnector = createServerConnector(server);
+		return new WebDavServer(server, executorService, serverConnector, servletCollectionCtx);
 	}
 
 }