[톰캣 구현하기 - 3, 4단계] 민트(유재민) 미션 제출합니다.

study/src/main/resources/application.yml

@@ -4,6 +4,6 @@ handlebars:
 server:
   tomcat:
     accept-count: 1
-    max-connections: 1
+    max-connections: 2
     threads:
       max: 2

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

@@ -29,24 +29,26 @@ void testNewFixedThreadPool() {
         executor.submit(logWithSleep("hello fixed thread pools"));
         executor.submit(logWithSleep("hello fixed thread pools"));
         executor.submit(logWithSleep("hello fixed thread pools"));
+        executor.submit(logWithSleep("hello fixed thread pools"));
+        executor.submit(logWithSleep("hello fixed thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
-        final int expectedQueueSize = 0;
+        final int expectedPoolSize = 2;
+        final int expectedQueueSize = 3;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());
         assertThat(expectedQueueSize).isEqualTo(executor.getQueue().size());
     }
 
     @Test
-    void testNewCachedThreadPool() {
+    void testNewCachedThreadPool() throws InterruptedException {
         final var executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
         executor.submit(logWithSleep("hello cached thread pools"));
         executor.submit(logWithSleep("hello cached thread pools"));
         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,5 +1,6 @@
 package thread.stage1;
 
+import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -17,7 +18,8 @@
  */
 class ConcurrencyTest {
 
-    @Test
+//    @Test
+    @RepeatedTest(2000)
     void test() throws InterruptedException {
         final var userServlet = new UserServlet();
 

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);
         }

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

@@ -8,22 +8,27 @@
 import java.io.UncheckedIOException;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 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 DEFAULT_MAX_THREADS = 200;
 
     private final ServerSocket serverSocket;
+    private final ExecutorService executorService;
     private boolean stopped;
 
     public Connector() {
-        this(DEFAULT_PORT, DEFAULT_ACCEPT_COUNT);
+        this(DEFAULT_PORT, DEFAULT_ACCEPT_COUNT, DEFAULT_MAX_THREADS);
     }
 
-    public Connector(final int port, final int acceptCount) {
+    public Connector(final int port, final int acceptCount, final int maxThreads) {
+        executorService = Executors.newFixedThreadPool(maxThreads);
         this.serverSocket = createServerSocket(port, acceptCount);
         this.stopped = false;
     }
@@ -67,7 +72,7 @@ private void process(final Socket connection) {
             return;
         }
         var processor = new Http11Processor(connection);
-        new Thread(processor).start();
+        executorService.execute(processor);
     }
 
     public void stop() {

tomcat/src/main/java/org/apache/coyote/http11/Http11Processor.java

@@ -1,9 +1,13 @@
 package org.apache.coyote.http11;
 
-import nextstep.jwp.db.InMemoryUserRepository;
-import nextstep.jwp.exception.UncheckedServletException;
-import nextstep.jwp.model.User;
 import org.apache.coyote.Processor;
+import org.apache.coyote.http11.controller.AuthController;
+import org.apache.coyote.http11.controller.RegisterController;
+import org.apache.coyote.http11.request.HttpHeaders;
+import org.apache.coyote.http11.request.HttpRequest;
+import org.apache.coyote.http11.request.RequestLine;
+import org.apache.coyote.http11.response.HttpResponse;
+import org.apache.coyote.http11.response.HttpStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -16,22 +20,18 @@
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.UUID;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class Http11Processor implements Runnable, Processor {
 
     private static final Logger log = LoggerFactory.getLogger(Http11Processor.class);
-    private static final String SAFARI_CHROME_ACCEPT_HEADER_DEFAULT_VALUE = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8";
 
     private final Socket connection;
-    private final SessionManager sessionManager = new SessionManager();
+
+    private final AuthController authController = new AuthController();
+    private final RegisterController registerController = new RegisterController();
 
     public Http11Processor(final Socket connection) {
         this.connection = connection;
@@ -51,182 +51,65 @@ public void process(final Socket connection) {
             InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
             BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
 
-            List<String> headers = new ArrayList<>();
+            HttpRequest httpRequest = readHttpRequest(bufferedReader);
+            HttpResponse httpResponse = new HttpResponse(httpRequest.httpVersion());
 
-            String header = "";
-            while (!(header = bufferedReader.readLine()).equals("")) {
-                headers.add(header);
-            }
-            String[] splitStatusLine = Objects.requireNonNull(headers.get(0)).split(" ");
-            String requestMethod = splitStatusLine[0];
-            String requestUri = splitStatusLine[1];
-
-            String requestAcceptHeader = findHeader("Accept", headers);
-            String contentTypeHeader = getContentTypeHeaderFrom(requestAcceptHeader);
-
-            RequestHandler requestHandler;
-            if (requestMethod.equalsIgnoreCase("POST")) {
-                int contentLength = getContentLength(headers);
-                String requestBody = readRequestBody(bufferedReader, contentLength);
-                requestHandler = handlePostRequest(requestUri, requestBody);
+            if (httpRequest.path().equals("/login") || httpRequest.path().equals("/login.html")) {
+                authController.service(httpRequest, httpResponse);
+            } else if (httpRequest.path().equals("/register") || httpRequest.path().equals("/register.html")) {
+                registerController.service(httpRequest, httpResponse);
             } else {
-                String cookieHeader = findHeader("Cookie", headers);
-                requestHandler = handleGetRequest(requestMethod, requestUri, cookieHeader);
+                httpResponse.setHttpStatus(HttpStatus.OK).setResponseFileName(httpRequest.path());
             }
 
-            String responseBody = readFile(requestHandler.getResponseFilePath());
-
-            List<String> responseHeaders = new ArrayList<>();
-            responseHeaders.add("HTTP/1.1 " + requestHandler.getHttpStatus() + " ");
-            responseHeaders.add(contentTypeHeader);
-            responseHeaders.add("Content-Length: " + responseBody.getBytes().length + " ");
-            for (Entry<String, String> headerEntry : requestHandler.getHeaders().entrySet()) {
-                responseHeaders.add(headerEntry.getKey() + ": " + headerEntry.getValue());
-            }
-            String responseHeader = String.join("\r\n", responseHeaders);
+            httpResponse.setBody(readFile(httpResponse.getResponseFileName()));
+            httpResponse.addHeader("Content-Length", String.valueOf(httpResponse.getBody().getBytes().length));
+            httpResponse.addHeader("Content-Type", getContentTypeHeaderFrom(httpRequest));
 
             BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
-
-            var response = String.join("\r\n", responseHeader, "", responseBody);
-
-            bufferedOutputStream.write(response.getBytes());
+            bufferedOutputStream.write(httpResponse.format().getBytes());
             bufferedOutputStream.flush();
-        } catch (IOException | UncheckedServletException e) {
+        } catch (Exception e) {
             log.error(e.getMessage(), e);
         }
     }
 
-    private static String findHeader(String key, List<String> headers) {
-        return headers.stream()
-                      .filter(it -> it.startsWith(key + ": "))
-                      .findFirst()
-                      .orElse("Accept: " + SAFARI_CHROME_ACCEPT_HEADER_DEFAULT_VALUE);
+    private HttpRequest readHttpRequest(BufferedReader bufferedReader) throws IOException {
+        List<String> lines = readRequesteHeaders(bufferedReader);
+        RequestLine requestLine = RequestLine.from(lines.get(0));
+        HttpHeaders httpHeaders = HttpHeaders.from(lines.subList(1, lines.size()));
+        String requestBody = readRequestBody(bufferedReader, httpHeaders.contentLength());
+        return new HttpRequest(requestLine, httpHeaders, requestBody);
     }
 
-    private static String getContentTypeHeaderFrom(String requestAcceptHeader) {
-        String[] splitAcceptHeader = requestAcceptHeader.split(" ");
-        String headerValue = splitAcceptHeader[1];
-        String[] acceptTypes = headerValue.split(";");
-        String[] splitAcceptTypes = acceptTypes[0].split(",");
-
-        if (Arrays.asList(splitAcceptTypes).contains("text/css")) {
-            return "Content-Type: text/css;charset=utf-8 ";
+    private List<String> readRequesteHeaders(BufferedReader bufferedReader) throws IOException {
+        List<String> lines = new ArrayList<>();
+        String line = "";
+        while (!(line = bufferedReader.readLine()).equals("")) {
+            lines.add(line);
         }
-        return "Content-Type: text/html;charset=utf-8 ";
+        return lines;
     }
 
-    private int getContentLength(List<String> headers) {
-        Optional<String> contentLengthHeader = headers.stream()
-                                                      .filter(it -> it.startsWith("Content-Length"))
-                                                      .findFirst();
-
-        if (contentLengthHeader.isEmpty()) {
-            return -1;
+    private static String getContentTypeHeaderFrom(HttpRequest httpRequest) {
+        List<String> acceptHeaderValues = httpRequest.header("Accept");
+        if (acceptHeaderValues != null && acceptHeaderValues.contains("text/css")) {
+            return "text/css;charset=utf-8";
         }
-        int index = contentLengthHeader.get().indexOf(" ");
-        return Integer.parseInt(contentLengthHeader.get().substring(index + 1));
+        return "text/html;charset=utf-8";
     }
 
     private static String readRequestBody(BufferedReader bufferedReader, int contentLength) throws IOException {
+        if (contentLength <= 0) {
+            return "";
+        }
         char[] buffer = new char[contentLength];
         bufferedReader.read(buffer, 0, contentLength);
         return new String(buffer);
     }
 
-    private RequestHandler handlePostRequest(String requestUri, String requestBody) {
-        String[] splitRequestBody = requestBody.split("&");
-        if (requestUri.equals("/login")) {
-            return handleLoginRequest(splitRequestBody);
-        }
-        if (requestUri.equals("/register")) {
-            return handleRegisterRequest(splitRequestBody);
-        }
-        return RequestHandler.of("GET", "404 Not Found", "static/404.html");
-    }
-
-    private RequestHandler handleLoginRequest(String[] splitQueryString) {
-        Optional<String> account = getValueOf("account", splitQueryString);
-        Optional<String> password = getValueOf("password", splitQueryString);
-
-        if (account.isEmpty() || password.isEmpty()) {
-            return RequestHandler.of("GET", "400 Bad Request", "static/401.html");
-        }
-
-        Optional<User> findUser = InMemoryUserRepository.findByAccount(account.get());
-        if (findUser.isPresent() && findUser.get().checkPassword(password.get())) {
-            User user = findUser.get();
-            log.info(user.toString());
-            Session session = new Session(UUID.randomUUID().toString());
-            session.setAttribute("user", user);
-            sessionManager.add(session);
-            RequestHandler requestHandler = RequestHandler.of("GET", "302 Found", "static/index.html");
-            requestHandler.addHeader("Set-Cookie", "JSESSIONID=" + session.getId());
-            return requestHandler;
-        }
-        return RequestHandler.of("GET", "401 Unauthorized", "static/401.html");
-    }
-
-    private Optional<String> getValueOf(String key, String[] splitQueryString) {
-        return Arrays.stream(splitQueryString)
-                     .filter(it -> equalsKey(key, it))
-                     .map(it -> it.substring(it.indexOf("=") + 1))
-                     .findFirst();
-    }
-
-    private boolean equalsKey(String expected, String actual) {
-        String[] splitActual = actual.split("=");
-        return splitActual[0].equals(expected);
-    }
-
-    private RequestHandler handleRegisterRequest(String[] splitQueryString) {
-        Optional<String> account = getValueOf("account", splitQueryString);
-        Optional<String> email = getValueOf("email", splitQueryString);
-        Optional<String> password = getValueOf("password", splitQueryString);
-
-        if (account.isEmpty() || email.isEmpty() || password.isEmpty()) {
-            return RequestHandler.of("GET", "400 Bad Request", "static/register.html");
-        }
-
-        InMemoryUserRepository.save(new User(account.get(), password.get(), email.get()));
-        return RequestHandler.of("GET", "302 Found", "static/index.html");
-    }
-
-    private RequestHandler handleGetRequest(String requestMethod, String requestUri, String cookie) throws IOException {
-        if (!requestMethod.equalsIgnoreCase("GET")) {
-            throw new IllegalArgumentException("GET 요청만 처리 가능합니다.");
-        }
-
-        if (requestUri.equals("/login.html") || requestUri.equals("/login")) {
-            return handleLoginPageRequest(cookie);
-        }
-
-        String fileName = "static" + requestUri;
-        return RequestHandler.of("GET", "200 OK", fileName);
-    }
-
-    private RequestHandler handleLoginPageRequest(String cookie) throws IOException {
-        Optional<String> sessionId = getSessionId(cookie);
-        if (sessionId.isEmpty()) {
-            return RequestHandler.of("GET", "200 OK", "static/login.html");
-        }
-        Session session = sessionManager.findSession(sessionId.get());
-        User user = getUser(session);
-        if (InMemoryUserRepository.existsByAccount(user.getAccount())) {
-            return RequestHandler.of("GET", "302 Found", "static/index.html");
-        }
-        return RequestHandler.of("GET", "200 OK", "static/login.html");
-    }
-
-    private Optional<String> getSessionId(String cookieHeader) {
-        String[] splitCookie = cookieHeader.split(" ");
-        return getValueOf("JSESSIONID", splitCookie);
-    }
-
-    private User getUser(Session session) {
-        return (User) session.getAttribute("user");
-    }
-
-    private String readFile(String filePath) {
+    private String readFile(String fileName) {
+        String filePath = this.getClass().getClassLoader().getResource("static" + fileName).getPath();
         try (Stream<String> lines = Files.lines(Paths.get(filePath))) {
             return lines.collect(Collectors.joining("\n", "", "\n"));
         } catch (IOException | UncheckedIOException e) {