[톰캣 구현하기 - 1,2단계] 오잉(이하늘) 미션 제출합니다.

study/src/test/java/study/FileTest.java

@@ -1,5 +1,9 @@
 package study;
 
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.file.Files;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -27,8 +31,9 @@ class FileTest {
     void resource_디렉터리에_있는_파일의_경로를_찾는다() {
         final String fileName = "nextstep.txt";
 
-        // todo
-        final String actual = "";
+        // TODO
+        URL resource = getClass().getClassLoader().getResource(fileName);
+        String actual = resource.getFile();
 
         assertThat(actual).endsWith(fileName);
     }
@@ -40,14 +45,15 @@ class FileTest {
      * File, Files 클래스를 사용하여 파일의 내용을 읽어보자.
      */
     @Test
-    void 파일의_내용을_읽는다() {
+    void 파일의_내용을_읽는다() throws IOException {
         final String fileName = "nextstep.txt";
 
         // todo
-        final Path path = null;
+        URL resource = getClass().getClassLoader().getResource(fileName);
+        Path path = new File(resource.getPath()).toPath();
 
         // todo
-        final List<String> actual = Collections.emptyList();
+        final List<String> actual = Files.readAllLines(path);
 
         assertThat(actual).containsOnly("nextstep");
     }

study/src/test/java/study/IOStreamTest.java

@@ -7,6 +7,7 @@
 import java.io.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.in;
 import static org.mockito.Mockito.*;
 
 /**
@@ -53,8 +54,9 @@ class OutputStream_학습_테스트 {
              * todo
              * OutputStream 객체의 write 메서드를 사용해서 테스트를 통과시킨다
              */
-
+            outputStream.write(bytes);
             final String actual = outputStream.toString();
+            // byte[] info = actual.getBytes("utf-8"); <- info = bytes
 
             assertThat(actual).isEqualTo("nextstep");
             outputStream.close();
@@ -72,12 +74,12 @@ class OutputStream_학습_테스트 {
         @Test
         void BufferedOutputStream을_사용하면_버퍼링이_가능하다() throws IOException {
             final OutputStream outputStream = mock(BufferedOutputStream.class);
-
             /**
              * todo
              * flush를 사용해서 테스트를 통과시킨다.
              * ByteArrayOutputStream과 어떤 차이가 있을까?
              */
+            outputStream.flush();
 
             verify(outputStream, atLeastOnce()).flush();
             outputStream.close();
@@ -96,7 +98,8 @@ class OutputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
-
+            try(outputStream) {
+            }
             verify(outputStream, atLeastOnce()).close();
         }
     }
@@ -128,7 +131,13 @@ class InputStream_학습_테스트 {
              * todo
              * inputStream에서 바이트로 반환한 값을 문자열로 어떻게 바꿀까?
              */
-            final String actual = "";
+            Reader reader = new InputStreamReader(inputStream);
+            StringBuilder result = new StringBuilder();
+            for (int data = reader.read(); data != -1; data = reader.read()) {
+                result.append((char)data);
+            }
+
+            final String actual = result.toString();
 
             assertThat(actual).isEqualTo("🤩");
             assertThat(inputStream.read()).isEqualTo(-1);
@@ -148,6 +157,8 @@ class InputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
+            try(inputStream) {
+            }
 
             verify(inputStream, atLeastOnce()).close();
         }
@@ -169,12 +180,12 @@ class FilterStream_학습_테스트 {
          * 버퍼 크기를 지정하지 않으면 버퍼의 기본 사이즈는 얼마일까?
          */
         @Test
-        void 필터인_BufferedInputStream를_사용해보자() {
+        void 필터인_BufferedInputStream를_사용해보자() throws IOException {
             final String text = "필터에 연결해보자.";
             final InputStream inputStream = new ByteArrayInputStream(text.getBytes());
-            final InputStream bufferedInputStream = null;
+            final InputStream bufferedInputStream = new BufferedInputStream(inputStream);
 
-            final byte[] actual = new byte[0];
+            final byte[] actual = bufferedInputStream.readAllBytes();
 
             assertThat(bufferedInputStream).isInstanceOf(FilterInputStream.class);
             assertThat(actual).isEqualTo("필터에 연결해보자.".getBytes());
@@ -197,15 +208,19 @@ class InputStreamReader_학습_테스트 {
          * 필터인 BufferedReader를 사용하면 readLine 메서드를 사용해서 문자열(String)을 한 줄 씩 읽어올 수 있다.
          */
         @Test
-        void BufferedReader를_사용하여_문자열을_읽어온다() {
+        void BufferedReader를_사용하여_문자열을_읽어온다() throws IOException {
             final String emoji = String.join("\r\n",
                     "😀😃😄😁😆😅😂🤣🥲☺️😊",
                     "😇🙂🙃😉😌😍🥰😘😗😙😚",
                     "😋😛😝😜🤪🤨🧐🤓😎🥸🤩",
                     "");
             final InputStream inputStream = new ByteArrayInputStream(emoji.getBytes());
+            final InputStreamReader reader = new InputStreamReader(inputStream);
 
-            final StringBuilder actual = new StringBuilder();
+            StringBuilder actual = new StringBuilder();
+            for (int data = reader.read(); data != -1; data = reader.read()) {
+                actual.append((char)data);
+            }
 
             assertThat(actual).hasToString(emoji);
         }

tomcat/src/main/java/nextstep/jwp/model/User.java

@@ -26,6 +26,10 @@ public String getAccount() {
         return account;
     }
 
+    public String getPassword() {
+        return password;
+    }
+
     @Override
     public String toString() {
         return "User{" +

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

@@ -1,18 +1,16 @@
 package org.apache.catalina;
 
-import jakarta.servlet.http.HttpSession;
-
 import java.io.IOException;
+import java.util.Optional;
+import org.apache.coyote.http11.common.Session;
 
 /**
- * A <b>Manager</b> manages the pool of Sessions that are associated with a
- * particular Container.  Different Manager implementations may support
- * value-added features such as the persistent storage of session data,
- * as well as migrating sessions for distributable web applications.
+ * A <b>Manager</b> manages the pool of Sessions that are associated with a particular Container.  Different Manager
+ * implementations may support value-added features such as the persistent storage of session data, as well as migrating
+ * sessions for distributable web applications.
  * <p>
- * In order for a <code>Manager</code> implementation to successfully operate
- * with a <code>Context</code> implementation that implements reloading, it
- * must obey the following constraints:
+ * In order for a <code>Manager</code> implementation to successfully operate with a <code>Context</code> implementation
+ * that implements reloading, it must obey the following constraints:
  * <ul>
  * <li>Must implement <code>Lifecycle</code> so that the Context can indicate
  *     that a restart is required.
@@ -29,28 +27,24 @@ public interface Manager {
      *
      * @param session Session to be added
      */
-    void add(HttpSession session);
+    void add(Session session);
 
     /**
-     * Return the active Session, associated with this Manager, with the
-     * specified session id (if any); otherwise return <code>null</code>.
+     * Return the active Session, associated with this Manager, with the specified session id (if any); otherwise
+     * return
+     * <code>null</code>.
      *
      * @param id The session id for the session to be returned
-     *
-     * @exception IllegalStateException if a new session cannot be
-     *  instantiated for any reason
-     * @exception IOException if an input/output error occurs while
-     *  processing this request
-     *
-     * @return the request session or {@code null} if a session with the
-     *         requested ID could not be found
+     * @return the request session or {@code null} if a session with the requested ID could not be found
+     * @throws IllegalStateException if a new session cannot be instantiated for any reason
+     * @throws IOException           if an input/output error occurs while processing this request
      */
-    HttpSession findSession(String id) throws IOException;
+    Optional<Session> findSession(String id) throws IOException;
 
     /**
      * Remove this Session from the active Sessions for this Manager.
      *
      * @param session Session to be removed
      */
-    void remove(HttpSession session);
+    void remove(Session session);
 }

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

@@ -1,13 +1,18 @@
 package org.apache.coyote.http11;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.Socket;
 import nextstep.jwp.exception.UncheckedServletException;
 import org.apache.coyote.Processor;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.servlet.Servlet;
+import org.apache.coyote.http11.servlet.ServletFinder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.net.Socket;
-
 public class Http11Processor implements Runnable, Processor {
 
     private static final Logger log = LoggerFactory.getLogger(Http11Processor.class);
@@ -28,15 +33,11 @@ public void run() {
     public void process(final Socket connection) {
         try (final var inputStream = connection.getInputStream();
              final var outputStream = connection.getOutputStream()) {
+            final var bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 
-            final var responseBody = "Hello world!";
-
-            final var response = String.join("\r\n",
-                    "HTTP/1.1 200 OK ",
-                    "Content-Type: text/html;charset=utf-8 ",
-                    "Content-Length: " + responseBody.getBytes().length + " ",
-                    "",
-                    responseBody);
+            HttpRequest request = HttpRequest.create(bufferedReader);
+            Servlet servlet = ServletFinder.find(request);
+            HttpResponse response = servlet.handle(request);
 
             outputStream.write(response.getBytes());
             outputStream.flush();

tomcat/src/main/java/org/apache/coyote/http11/common/ContentType.java

@@ -0,0 +1,34 @@
+package org.apache.coyote.http11.common;
+
+import java.util.Arrays;
+
+public enum ContentType {
+    TEXT_PLAIN("", "text/plain;charset=utf-8"),
+    TEXT_HTML(".html", "text/html;charset=utf-8"),
+    TEXT_CSS(".css", "text/css"),
+    APPLICATION_JAVASCRIPT(".js", "application/javascript");
+
+    private String extension;
+    private String detail;
+
+    ContentType(final String extension, final String detail) {
+        this.extension = extension;
+        this.detail = detail;
+    }
+
+    public String getExtension() {
+        return extension;
+    }
+
+    public String getDetail() {
+        return detail;
+    }
+
+    public static String getDetailfromExtension(String extension) {
+        return Arrays.stream(ContentType.values())
+                .filter(it -> it.extension.equals(extension))
+                .findFirst()
+                .map(ContentType::getDetail)
+                .orElseThrow(() -> new IllegalArgumentException("No enum constant with extension: " + extension));
+    }
+}

tomcat/src/main/java/org/apache/coyote/http11/common/Cookies.java

@@ -0,0 +1,28 @@
+package org.apache.coyote.http11.common;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.coyote.http11.util.Parser;
+
+public class Cookies {
+
+    private static final String EMPTY_STRING = "";
+
+    private Map<String, String> values;
+
+    public Cookies(final Map<String, String> values) {
+        this.values = values;
+    }
+
+    public static Cookies create(String line) {
+        return Parser.parseToCookie(line);
+    }
+
+    public static Cookies empty() {
+        return new Cookies(new HashMap<>());
+    }
+
+    public String getCookie(String name) {
+        return values.getOrDefault(name, EMPTY_STRING);
+    }
+}

tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaderName.java

@@ -0,0 +1,19 @@
+package org.apache.coyote.http11.common;
+
+public enum HttpHeaderName {
+    CONTENT_TYPE("Content-Type"),
+    CONTENT_LENGTH("Content-Length"),
+    LOCATION("Location"),
+    SET_COOKIE("Set-Cookie"),
+    ALLOW("Allow");
+
+    private String name;
+
+    HttpHeaderName(final String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaders.java

@@ -0,0 +1,51 @@
+package org.apache.coyote.http11.common;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class HttpHeaders {
+
+    private static final String DELIMITER = ": ";
+    private static final String EMPTY_STRING = "";
+
+    private Map<String, String> headers;
+
+    public HttpHeaders() {
+        headers = new LinkedHashMap<>();
+    }
+
+    private HttpHeaders(final Map<String, String> headers) {
+        this.headers = headers;
+    }
+
+    public static HttpHeaders create(final List<String> lines) {
+        Map<String, String> headers = new LinkedHashMap<>();
+        for (String line : lines) {
+            String[] split = line.split(DELIMITER);
+            headers.put(split[0], split[1]);
+        }
+
+        return new HttpHeaders(headers);
+    }
+
+    public static HttpHeaders create(final Map<String, String> headers) {
+        return new HttpHeaders(new LinkedHashMap<>(headers));
+    }
+
+    public void addHeader(HttpHeaderName header, String value) {
+        headers.put(header.getName(), value);
+    }
+
+    public String getHeader(String name) {
+        return headers.getOrDefault(name, EMPTY_STRING);
+    }
+
+    @Override
+    public String toString() {
+        return headers.entrySet().stream()
+                .map(entry -> entry.getKey() + DELIMITER + entry.getValue() + " ")
+                .collect(Collectors.joining(System.lineSeparator()));
+    }
+}