feat: add UploadHandler

Author: iboukhss

Makefile

@@ -37,6 +37,8 @@ srcs = \
   src/handler/handler.hpp \
   src/handler/static_file_handler.cpp \
   src/handler/static_file_handler.hpp \
+  src/handler/upload_handler.cpp \
+  src/handler/upload_handler.hpp \
   src/http/http_parser.cpp \
   src/http/http_parser.hpp \
   src/http/http_request.cpp \
@@ -62,6 +64,7 @@ deps = $(objs:.o=.d)
 
 # Test sources (keep in alphabetical order)
 test_srcs = \
+  tests/upload_handler_unittest.cpp \
   tests/error_handler_unittest.cpp \
   tests/http_parser_unittest.cpp \
   tests/http_response_unittest.cpp \

src/config/server_config.cpp

@@ -34,6 +34,12 @@ ServerConfig make_site1_config()
     cfg.default_location.path = "";
     cfg.default_location.index = "index.html";
 
+    // ------------------------
+    // Upload location
+    // ------------------------
+    cfg.upload_location.path = "/upload";
+    cfg.upload_location.index = "index.html";
+
     // ------------------------
     // Other locations
     // ------------------------

src/config/server_config.hpp

@@ -25,6 +25,7 @@ struct ServerConfig {
     std::vector<std::string> methods; // allowed methods
 
     Location default_location;
+    Location upload_location;
     std::vector<Location> locations;
 };
 

src/handler/error_handler.cpp

@@ -9,8 +9,9 @@ size_t ErrorHandler::read_data(char* buf, size_t n)
 {
     std::string res = res_.to_string();
     LOG(DEBUG) << res;
-    std::memcpy(buf, &res, n);
-    return (res.size());
+    size_t to_copy = std::min(res.size(), n);
+    std::memcpy(buf, res.data(), to_copy);
+    return (to_copy);
 }
 
 // We never write to this handler (read-only)

src/handler/upload_handler.cpp

@@ -0,0 +1,111 @@
+#include "handler/upload_handler.hpp"
+
+#include "http/http_response.hpp"
+#include "util/log_message.hpp"
+#include "util/syscall_error.hpp"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <iostream>
+#include <sstream>
+
+/*
+ERRORS :
+insufficient space → 507 Insufficient Storage
+
+forbidden directory → 403
+
+invalid request format → 400
+
+If file exists → POST = 409 Conflict
+
+
+Also, the UploadHandler could handle, both POST and PUT requests
+
+*/
+
+UploadHandler::UploadHandler(const std::string& path, size_t content_length)
+    : file_path_(path),
+      fd_(-1),
+      bytes_written_(0),
+      content_length_(content_length),
+      eob_reached_(false),
+      headers_off_(0)
+{
+    struct stat file_stat;
+    if (stat(path.c_str(), &file_stat) == 0 && S_ISREG(file_stat.st_mode)) {
+        // file already exists
+        HttpResponse res;
+        res.code = HttpResponse::kStatusConflict; // 409
+        res.inline_body = "<h1> 409 Conflict — File already exists </h1>";
+        headers_ = res.to_string();
+        return;
+    }
+    fd_ = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    if (fd_ == -1) {
+        HttpResponse res;
+        res.code = HttpResponse::kStatusDiskFull;
+        res.inline_body = "<h1> 507 Disk Full </h1>"; // to display a message during testing
+        headers_ = res.to_string();
+        return;
+    }
+}
+
+UploadHandler::~UploadHandler()
+{
+    if (fd_ != -1)
+        close(fd_);
+}
+
+bool UploadHandler::needs_input() const
+{
+    return bytes_written_ < content_length_;
+}
+
+bool UploadHandler::has_output() const
+{
+    return headers_off_ < headers_.size();
+}
+
+size_t UploadHandler::read_data(char* buf, size_t n)
+{
+    // LOG(DEBUG) << "inside UploadHandler::read_data -> headers_.size == " << headers_.size();
+    size_t to_copy = std::min(headers_.size() - headers_off_, n);
+    std::memcpy(buf, headers_.c_str() + headers_off_, to_copy);
+    headers_off_ += to_copy;
+    return (to_copy);
+}
+
+size_t UploadHandler::write_data(const char* buf, size_t n)
+{
+    ssize_t bytes = write(fd_, buf, n);
+    if (bytes == -1) {
+        // error occured
+        eob_reached_ = true;
+        if (headers_.empty()) {
+            HttpResponse res;
+            res.code = HttpResponse::kStatusDiskFull;
+            res.inline_body = "<h1> 507 Disk Full </h1>"; // to display a message during testing
+            headers_ = res.to_string();
+            bytes_written_ = content_length_; // to ensure needs_input returns false
+        }
+        return 0;
+    }
+    bytes_written_ += bytes;
+    if (bytes_written_ < content_length_) {
+
+        return (bytes);
+    }
+
+    if (headers_.empty()) {
+        eob_reached_ = true;
+        HttpResponse res;
+        res.code = HttpResponse::kStatusCreated;
+        res.inline_body = "<h1> 201 File Created </h1>"; // to display a message during testing
+        headers_ = res.to_string();
+    }
+    return (0);
+}

src/handler/upload_handler.hpp

@@ -0,0 +1,40 @@
+#ifndef HANDLER_UPLOAD_HANDLER_HPP_
+#define HANDLER_UPLOAD_HANDLER_HPP_
+
+#include "handler/handler.hpp"
+
+#include <sys/stat.h>
+
+#include <string>
+
+class UploadHandler : public Handler {
+public:
+    explicit UploadHandler(const std::string& path, size_t content_lenght);
+    virtual ~UploadHandler();
+
+    virtual size_t read_data(char* buf, size_t n); // we should not read from this handler
+    virtual size_t write_data(const char* buf, size_t n);
+
+    virtual bool has_output() const;
+    virtual bool needs_input() const;
+    virtual bool is_done() const { return headers_sent(); }
+    const std::string& path() const { return file_path_; }
+
+private:
+    UploadHandler(const UploadHandler&);
+    UploadHandler& operator=(const UploadHandler&);
+
+    bool headers_sent() const { return headers_off_ == headers_.size(); }
+    bool body_written() const { return eob_reached_; }
+
+    const std::string file_path_;
+
+    int fd_;
+    size_t bytes_written_;
+    size_t content_length_;
+    bool eob_reached_;
+    std::string headers_;
+    size_t headers_off_;
+};
+
+#endif

src/http/http_response.cpp

@@ -45,11 +45,14 @@ const char* HttpResponse::reason_phrase(HttpResponse::Status code) const
 {
     switch (code) {
     case kStatusOk:                  return "OK";
+    case kStatusCreated:             return "File Created";
     case kStatusBadRequest:          return "Bad Request";
     case kStatusForbidden:           return "Forbidden";
     case kStatusNotFound:            return "Not Found";
     case kStatusMethodNotAllowed:    return "Method Not Allowed";
+    case kStatusConflict:            return "Conflict";
     case kStatusInternalServerError: return "Internal Server Error";
     case kStatusNotImplemented:      return "Not Implemented";
+    case kStatusDiskFull:            return "Disk Full";
     }
 }

src/http/http_response.hpp

@@ -7,12 +7,15 @@ struct HttpResponse {
 public:
     enum Status {
         kStatusOk = 200,
+        kStatusCreated = 201,
         kStatusBadRequest = 400,
         kStatusForbidden = 403,
         kStatusNotFound = 404,
         kStatusMethodNotAllowed = 405,
+        kStatusConflict = 409,
         kStatusInternalServerError = 500,
-        kStatusNotImplemented = 501
+        kStatusNotImplemented = 501,
+        kStatusDiskFull = 507
     };
 
     HttpResponse();

src/router/router.cpp

@@ -3,6 +3,7 @@
 #include "config/server_config.hpp"
 #include "handler/error_handler.hpp"
 #include "handler/static_file_handler.hpp"
+#include "handler/upload_handler.hpp"
 #include "http/http_request.hpp"
 #include "http/http_response.hpp"
 #include "util/log_message.hpp"
@@ -122,7 +123,13 @@ Handler* Router::handle_request(const HttpRequest& request)
     if (request.method == "GET") {
         return new StaticFileHandler(full_path);
     }
+    if (request.method == "POST") {
+        return new UploadHandler(full_path, request.content_length);
+    }
+    /*  if (request.method == "DELETE") {
+            return new DeleteHandler(full_path);*/
 
-    NOTREACHED();
+    // Fallback, should never happen in theory
+    std::cerr << "Something terrible happened in the router" << std::endl;
     return new ErrorHandler(HttpResponse::kStatusInternalServerError); // 500
 }

tests/upload_handler_unittest.cpp

@@ -0,0 +1,126 @@
+
+#include "handler/upload_handler.hpp"
+#include "http/http_response.hpp"
+#include "stdio.h"
+#include "utest/utest.h"
+
+#include <iostream>
+
+static void write_all(Handler* handler, const std::string& content)
+{
+    size_t written = 0;
+
+    while (handler->needs_input()) {
+        size_t n = handler->write_data(content.c_str() + written, content.size() - written);
+        written += n;
+
+        if ((n == 0 && handler->needs_input()))
+            break;
+    }
+}
+
+UTEST(UploadHandlerTest, needs_input_upload_ongoing)
+{
+    std::string upload_path = "www/example/needs_input_upload_ongoing.txt";
+    std::string content = "some content to be written to the file";
+    Handler* handler = new UploadHandler(upload_path, content.size());
+    ASSERT_TRUE(handler->needs_input());
+    delete (handler);
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, has_output_upload_ongoing)
+{
+    std::string upload_path = "www/example/has_output_upload_ongoing.txt";
+    std::string content = "some content to be written to the file";
+    Handler* handler = new UploadHandler(upload_path, content.size());
+    ASSERT_FALSE(handler->has_output());
+    delete (handler);
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, needs_input_upload_done)
+{
+    std::string upload_path = "www/example/needs_input_upload_done.txt";
+    std::string content = "some content to be written to the file";
+    Handler* handler = new UploadHandler(upload_path, content.size());
+    write_all(handler, content);
+    ASSERT_TRUE(handler->has_output());
+    delete (handler);
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, has_output_upload_done)
+{
+    std::string upload_path = "www/example/has_output_upload_done.txt";
+    std::string content = "some content to be written to the file";
+    Handler* handler = new UploadHandler(upload_path, content.size());
+    write_all(handler, content);
+    ASSERT_TRUE(handler->has_output());
+    delete (handler);
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, check_content_uploaded)
+{
+    std::string upload_path = "www/example/check_content_uploaded.txt";
+    std::string content = "some content to be written to the file";
+    Handler* handler = new UploadHandler(upload_path, content.size());
+    write_all(handler, content);
+    ASSERT_FALSE(handler->needs_input());
+    ASSERT_TRUE(handler->has_output());
+    delete (handler);
+
+    // validating content
+    FILE* f = fopen(upload_path.c_str(), "r");
+    std::cout << "opening the file" << std::endl;
+    ASSERT_TRUE(f != NULL);
+    char buffer[1028];
+    size_t n = fread(buffer, 1, sizeof(buffer), f);
+    fclose(f);
+    std::string file_content(buffer, n);
+    std::cout << "file_content = " << file_content << std::endl;
+    ASSERT_STREQ(content.c_str(), file_content.c_str());
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, ReturnsUploadSuccess)
+{
+    std::string upload_path = "www/example/return_201.txt";
+    std::string content = "some content to be written to the file";
+    Handler* handler = new UploadHandler(upload_path, content.size());
+    ASSERT_FALSE(handler->has_output());
+    write_all(handler, content);
+    ASSERT_TRUE(handler->has_output());
+    char buffer[1028];
+    size_t n = handler->read_data(buffer, sizeof(buffer));
+    std::string http_res(buffer, n);
+    ASSERT_TRUE(http_res.find("201") != std::string::npos);
+    delete (handler);
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, ReturnsFileAlreadyExists)
+{
+    std::string upload_path = "www/example/return_409.txt";
+    std::string content = "some content to be written to the file";
+    {
+        Handler* handler1 = new UploadHandler(upload_path, content.size());
+        write_all(handler1, content);
+        ASSERT_TRUE(handler1->has_output());
+        delete handler1;
+    }
+    Handler* handler2 = new UploadHandler(upload_path, content.size());
+    ASSERT_TRUE(handler2->has_output());
+    char buffer[1028];
+    size_t n = handler2->read_data(buffer, sizeof(buffer));
+    std::string http_res(buffer, n);
+    ASSERT_TRUE(http_res.find("409") != std::string::npos);
+    delete (handler2);
+    remove(upload_path.c_str());
+}
+
+UTEST(UploadHandlerTest, return_507)
+{
+    UTEST_SKIP("TODO: Test Disk full without making your machine explode");
+}