[톰캣 구현하기 - 3, 4단계] 히이로(문제웅) 미션 제출합니다.

study/src/main/resources/application.yml

@@ -4,9 +4,9 @@ handlebars:
 server:
   tomcat:
     accept-count: 1
-    max-connections: 1
+    max-connections: 10
     threads:
-      max: 2
+      max: 10
   compression:
     enabled: true
     min-response-size: 10

study/src/test/java/thread/stage0/SynchronizationTest.java

@@ -41,7 +41,7 @@ private static final class SynchronizedMethods {
 
         private int sum = 0;
 
-        public void calculate() {
+        public synchronized void calculate() {
             setSum(getSum() + 1);
         }
 

study/src/test/java/thread/stage0/ThreadPoolsTest.java

@@ -31,8 +31,8 @@ void testNewFixedThreadPool() {
         executor.submit(logWithSleep("hello fixed thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
-        final int expectedQueueSize = 0;
+        final int expectedPoolSize = 2;
+        final int expectedQueueSize = 1;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());
         assertThat(expectedQueueSize).isEqualTo(executor.getQueue().size());
@@ -46,7 +46,7 @@ void testNewCachedThreadPool() {
         executor.submit(logWithSleep("hello cached thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
+        final int expectedPoolSize = 3;
         final int expectedQueueSize = 0;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());

study/src/test/java/thread/stage1/ConcurrencyTest.java

@@ -1,9 +1,9 @@
 package thread.stage1;
 
-import org.junit.jupiter.api.Test;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
+import org.junit.jupiter.api.Test;
+
 /**
  * 스레드를 다룰 때 어떤 상황을 조심해야 할까?
  * - 상태를 가진 한 객체를 여러 스레드에서 동시에 접근할 경우

study/src/test/java/thread/stage1/UserServlet.java

@@ -11,7 +11,7 @@ public void service(final User user) {
         join(user);
     }
 
-    private void join(final User user) {
+    private synchronized void join(final User user) {
         if (!users.contains(user)) {
             users.add(user);
         }

study/src/test/java/thread/stage2/AppTest.java

@@ -39,7 +39,7 @@ void test() throws Exception {
             thread.join();
         }
 
-        assertThat(count.intValue()).isEqualTo(2);
+        assertThat(count.intValue()).isEqualTo(10);
     }
 
     private static void incrementIfOk(final HttpResponse<String> response) {

tomcat/src/main/java/nextstep/org/apache/catalina/Context.java

@@ -0,0 +1,36 @@
+package nextstep.org.apache.catalina;
+
+import java.util.HashMap;
+import java.util.Map;
+import nextstep.org.apache.catalina.servlet.DefaultServlet;
+import nextstep.org.apache.catalina.servlet.LoginServlet;
+import nextstep.org.apache.catalina.servlet.RegisterServlet;
+import nextstep.org.apache.catalina.servlet.Servlet;
+
+public class Context {
+
+    private static final Map<String, Servlet> servletMappings;
+    private static final String EXTENSION_DELIMITER = ".";
+
+    static {
+        servletMappings = new HashMap<>();
+        servletMappings.put("/login", new LoginServlet());
+        servletMappings.put("/register", new RegisterServlet());
+        servletMappings.put("default", new DefaultServlet());
+    }
+
+    public Servlet getServlet(String pathInfo) {
+        if (servletMappings.containsKey(removeExtension(pathInfo))) {
+            return servletMappings.get(removeExtension(pathInfo));
+        }
+        return servletMappings.get("default");
+    }
+
+    private String removeExtension(String pathInfo) {
+        int idx = pathInfo.indexOf(EXTENSION_DELIMITER);
+        if (idx == -1) {
+            return pathInfo;
+        }
+        return pathInfo.substring(0,idx);
+    }
+}

tomcat/src/main/java/nextstep/org/apache/catalina/Manager.java

@@ -1,7 +1,7 @@
 package nextstep.org.apache.catalina;
 
 import java.io.IOException;
-import nextstep.org.apache.coyote.http11.Session;
+import nextstep.org.apache.catalina.session.Session;
 
 /**
  * A <b>Manager</b> manages the pool of Sessions that are associated with a

tomcat/src/main/java/nextstep/org/apache/catalina/connector/Connector.java

@@ -1,29 +1,36 @@
 package nextstep.org.apache.catalina.connector;
 
-import nextstep.org.apache.coyote.http11.Http11Processor;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import nextstep.org.apache.catalina.Context;
+import nextstep.org.apache.coyote.http11.Http11Processor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class Connector implements Runnable {
 
     private static final Logger log = LoggerFactory.getLogger(Connector.class);
 
     private static final int DEFAULT_PORT = 8080;
     private static final int DEFAULT_ACCEPT_COUNT = 100;
+    private static final int MAX_THREADS_COUNT = 250;
 
+    private final Context context;
+    private final ThreadPoolExecutor threadPoolExecutor;
     private final ServerSocket serverSocket;
     private boolean stopped;
 
-    public Connector() {
-        this(DEFAULT_PORT, DEFAULT_ACCEPT_COUNT);
+    public Connector(Context context) {
+        this(context, DEFAULT_PORT, DEFAULT_ACCEPT_COUNT, MAX_THREADS_COUNT);
     }
 
-    public Connector(final int port, final int acceptCount) {
+    public Connector(Context context, final int port, final int acceptCount, final int maxThreads) {
+        this.context = context;
+        this.threadPoolExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(maxThreads);
         this.serverSocket = createServerSocket(port, acceptCount);
         this.stopped = false;
     }
@@ -66,8 +73,8 @@ private void process(final Socket connection) {
         if (connection == null) {
             return;
         }
-        var processor = new Http11Processor(connection);
-        new Thread(processor).start();
+        var processor = new Http11Processor(context, connection);
+        this.threadPoolExecutor.submit(processor);
     }
 
     public void stop() {

tomcat/src/main/java/nextstep/org/apache/coyote/http11/HttpCookie.java → tomcat/src/main/java/nextstep/org/apache/catalina/cookie/Cookies.java

@@ -1,14 +1,15 @@
-package nextstep.org.apache.coyote.http11;
+package nextstep.org.apache.catalina.cookie;
 
 import static nextstep.org.apache.coyote.http11.HttpUtil.parseMultipleValues;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Collectors;
+import nextstep.org.apache.coyote.http11.HttpHeader;
 
-public class HttpCookie {
+public class Cookies {
 
-    private static final String SET_COOKIE_HEADER = "Set-Cookie: %s \r\n";
+    private static final String SET_COOKIE_HEADER_FORMAT = "%s: %s \r\n";
     private static final String COOKIE_VALUES_DELIMITER = "; ";
     private static final String COOKIE_KEY_VALUE_DELIMITER = "=";
 
@@ -36,9 +37,17 @@ public boolean hasCookie(String key) {
     }
 
     public String createSetCookieHeader() {
-        String cookies = cookie.entrySet().stream()
+        return cookie.entrySet().stream()
                 .map(entry -> entry.getKey() + COOKIE_KEY_VALUE_DELIMITER + entry.getValue())
-                .collect(Collectors.joining(COOKIE_VALUES_DELIMITER));
-        return String.format(SET_COOKIE_HEADER, cookies);
+                .map(value -> String.format(
+                        SET_COOKIE_HEADER_FORMAT, HttpHeader.SET_COOKIE.getValue(), value)
+                )
+                .collect(Collectors.joining());
+    }
+
+    public Cookies defensiveCopy() {
+        Cookies newCookies = new Cookies();
+        cookie.forEach(newCookies::set);
+        return newCookies;
     }
 }

tomcat/src/main/java/nextstep/org/apache/catalina/servlet/AbstractServlet.java

@@ -0,0 +1,88 @@
+package nextstep.org.apache.catalina.servlet;
+
+import static nextstep.org.apache.coyote.http11.HttpUtil.selectFirstContentTypeOrDefault;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Objects;
+import java.util.Optional;
+import nextstep.org.apache.coyote.http11.HttpHeader;
+import nextstep.org.apache.coyote.http11.request.Http11Request;
+import nextstep.org.apache.coyote.http11.response.Http11Response;
+import nextstep.org.apache.coyote.http11.Status;
+
+public abstract class AbstractServlet implements Servlet{
+
+    private static final String RESOURCES_PATH_PREFIX = "static";
+    protected static final String NOT_FOUND_DEFAULT_MESSAGE = "404 Not Found";
+    private static final String CHARSET_UTF_8 = ";charset=utf-8";
+    private static final String DEFAULT_EXTENSION = ".html";
+    private static final String NOT_FOUND_PAGE = "/404.html";
+    private static final String HTTP_GET_METHOD = "GET";
+    private static final String HTTP_POST_METHOD = "POST";
+
+    @Override
+    public void service(Http11Request request, Http11Response response) throws Exception {
+        String method = request.getMethod();
+
+        if (method.equals(HTTP_GET_METHOD)) {
+            doGet(request, response);
+        } else if (method.equals(HTTP_POST_METHOD)) {
+            doPost(request, response);
+        } else {
+            response.setStatus(Status.NOT_IMPLEMENTED);
+        }
+    }
+
+    protected abstract void doGet(Http11Request request, Http11Response response) throws  Exception;
+
+    protected abstract void doPost(Http11Request request, Http11Response response) throws Exception;
+
+    protected Optional<String> createResponseBody(String requestPath) throws IOException {
+        if (requestPath.equals("/")) {
+            return Optional.of("Hello world!");
+        }
+
+        String resourceName = RESOURCES_PATH_PREFIX + requestPath;
+        if (!resourceName.contains(".")) {
+            resourceName += DEFAULT_EXTENSION;
+        }
+        URL resource = getClass().getClassLoader().getResource(resourceName);
+
+        if (Objects.isNull(resource)) {
+            return Optional.empty();
+        }
+        return Optional.of(new String(Files.readAllBytes(new File(resource.getFile()).toPath())));
+    }
+
+    protected void responseWithBody(Http11Request request, Http11Response response) throws IOException {
+        Optional<String> responseBody = createResponseBody(request.getPathInfo());
+        String contentType = selectFirstContentTypeOrDefault(request.getHeader(HttpHeader.ACCEPT));
+
+        if (responseBody.isEmpty()) {
+            responseWithNotFound(request, response);
+            return;
+        }
+
+        response.setStatus(Status.OK)
+                .setHeader(HttpHeader.CONTENT_TYPE, contentType + CHARSET_UTF_8)
+                .setHeader(HttpHeader.CONTENT_LENGTH, String.valueOf(
+                        responseBody.get().getBytes(StandardCharsets.UTF_8).length))
+                .setBody(responseBody.get());
+    }
+
+    private void responseWithNotFound(Http11Request request, Http11Response response) throws IOException {
+        String notFoundPageBody = createResponseBody(NOT_FOUND_PAGE)
+                .orElse(NOT_FOUND_DEFAULT_MESSAGE);
+        String contentType = selectFirstContentTypeOrDefault(request.getHeader(HttpHeader.ACCEPT));
+
+        response.setStatus(Status.NOT_FOUND)
+                .setHeader(HttpHeader.CONTENT_TYPE, contentType + CHARSET_UTF_8)
+                .setHeader(HttpHeader.CONTENT_LENGTH, String.valueOf(
+                        notFoundPageBody.getBytes(StandardCharsets.UTF_8).length))
+                .setBody(notFoundPageBody);
+    }
+}