remove useless code

Shfdis · Shfdis · commit c15595cc4606 · 2026-06-02T23:32:04.000+03:00
diff --git a/.gitignore b/.gitignore
@@ -21,6 +21,8 @@ echo_server
 .cache/
 .vscode/
 .idea/
+.agents/
+.codex/
 *.swp
 *.swo
 *~
diff --git a/server/include/io_uring.h b/server/include/io_uring.h
@@ -9,6 +9,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <string_view>
 #define QUEUE_DEPTH 1024
 namespace HTTP {
 class IOUring;
@@ -22,13 +23,13 @@ class IOUring {
     int fd;
     std::optional<char *> toRead;
     std::function<void(int)> complete;
-    std::shared_ptr<std::string> writeData;
+    std::string_view writeData;
     size_t writeOffset{0};
     size_t writeLen{0};
   };
   struct SqeData {
     std::function<void(int)> complete;
-    std::shared_ptr<std::string> writeData;
+    std::string_view writeData;
     size_t writeOffset{0};
     size_t writeLen{0};
   };
@@ -44,10 +45,10 @@ class IOUring {
   IOUring();
   IOUring &operator=(IOUring &&rhs);
   void Read(int fileDescriptor, std::array<char, 256> &buffer, std::function<void(int)> complete);
-  CoFuture<size_t> ReadAsync(int fileDescriptor, std::array<char, 256> &buffer);
-  void Write(int fileDescriptor, std::shared_ptr<std::string> data, size_t offset, size_t len,
+  CoFuture<int> ReadAsync(int fileDescriptor, std::array<char, 256> &buffer);
+  void Write(int fileDescriptor, std::string_view data, size_t offset, size_t len,
              std::function<void(int)> complete);
-  CoFuture<size_t> WriteAsync(int fileDescriptor, std::shared_ptr<std::string> data, size_t offset,
+  CoFuture<int> WriteAsync(int fileDescriptor, std::string_view data, size_t offset,
                               size_t len);
   void Accept(int fileDescriptor, std::function<void(int)> complete);
   CoFuture<int> AcceptAsync(int fileDescriptor);
diff --git a/server/src/io_uring.cpp b/server/src/io_uring.cpp
@@ -38,8 +38,8 @@ void IOUring::AddEntries() {
       io_uring_prep_read(sqEntry, entry.fd, entry.toRead.value(), 256, 0);
     } else if (entry.type == IOUring::ACCEPT) {
       io_uring_prep_accept(sqEntry, entry.fd, nullptr, nullptr, 0);
-    } else {
-      const char *ptr = sqeData->writeData->data() + sqeData->writeOffset;
+    } else [[likely]] {
+      const char *ptr = sqeData->writeData.data() + sqeData->writeOffset;
       io_uring_prep_write(sqEntry, entry.fd, ptr, sqeData->writeLen, 0);
     }
     io_uring_sqe_set_data(sqEntry, sqeData);
@@ -73,15 +73,15 @@ void IOUring::Poll() {
   }
 }
 
-void IOUring::Write(int fileDescriptor, std::shared_ptr<std::string> data, size_t offset,
+void IOUring::Write(int fileDescriptor, std::string_view data, size_t offset,
                     size_t len, std::function<void(int)> complete) {
   if (fileDescriptor < 0) {
     throw std::runtime_error("Invalid file descriptor");
   }
   Entry entry;
   entry.type = IOUring::WRITE;
   entry.fd = fileDescriptor;
-  entry.writeData = std::move(data);
+  entry.writeData = data;
   entry.writeOffset = offset;
   entry.writeLen = len;
   entry.complete = std::move(complete);
@@ -102,11 +102,11 @@ void IOUring::Read(int fileDescriptor, std::array<char, 256> &buffer,
   queue_.push_back(entry);
 }
 
-CoFuture<size_t> IOUring::ReadAsync(int fileDescriptor, std::array<char, 256> &buffer) {
-  auto promise = std::make_shared<CoPromise<size_t>>();
+CoFuture<int> IOUring::ReadAsync(int fileDescriptor, std::array<char, 256> &buffer) {
+  auto promise = std::make_shared<CoPromise<int>>();
   auto future = promise->GetFuture();
   Read(fileDescriptor, buffer, [promise](int result) {
-    promise->Set(result < 0 ? 0 : static_cast<size_t>(result));
+    promise->Set(result);
   });
   return future;
 }
@@ -132,12 +132,12 @@ CoFuture<int> IOUring::AcceptAsync(int fileDescriptor) {
   return future;
 }
 
-CoFuture<size_t> IOUring::WriteAsync(int fileDescriptor, std::shared_ptr<std::string> data,
+CoFuture<int> IOUring::WriteAsync(int fileDescriptor, std::string_view data,
                                      size_t offset, size_t len) {
-  auto promise = std::make_shared<CoPromise<size_t>>();
+  auto promise = std::make_shared<CoPromise<int>>();
   auto future = promise->GetFuture();
-  Write(fileDescriptor, std::move(data), offset, len, [promise](int result) {
-    promise->Set(result < 0 ? 0 : static_cast<size_t>(result));
+  Write(fileDescriptor, data, offset, len, [promise](int result) {
+    promise->Set(result);
   });
   return future;
 }
diff --git a/server/src/read_iterator.cpp b/server/src/read_iterator.cpp
@@ -1,14 +1,41 @@
 #include "read_iterator.h"
 #include "http_error.h"
 #include <algorithm>
+#include <cerrno>
+#include <stdexcept>
 #include <string>
+#include <system_error>
 namespace HTTP {
+
+namespace {
+constexpr int kMaxIoAttempts = 3;
+
+bool IsRetryableIoError(int result) {
+  return result == -EINTR || result == -EAGAIN || result == -EWOULDBLOCK;
+}
+} // namespace
+
 ReadIterator::ReadIterator(IOUring &ring, int fd_) : ring_(ring), fd_(fd_), length_(0), position_(0) {
 }
 
 CoFuture<void> ReadIterator::Ensure() {
   if (position_ >= length_) {
-    length_ = co_await ring_.ReadAsync(fd_, buffer_);
+    for (int attempt = 1; attempt <= kMaxIoAttempts; ++attempt) {
+      int result = co_await ring_.ReadAsync(fd_, buffer_);
+      if (result > 0) {
+        length_ = static_cast<size_t>(result);
+        position_ = 0;
+        co_return;
+      }
+      if (result == 0) {
+        length_ = 0;
+        position_ = 0;
+        co_return;
+      }
+      if (!IsRetryableIoError(result) || attempt == kMaxIoAttempts) {
+        throw std::system_error(-result, std::generic_category(), "read failed");
+      }
+    }
     position_ = 0;
   }
   co_return;
@@ -187,30 +214,34 @@ CoFuture<void> ReadIterator::ParseHeaders(RequestData &data) {
 CoFuture<void> ReadIterator::ParseBody(RequestData &data) {
   auto it = data.headers.find("Content-Length");
   if (it != data.headers.end()) {
+    size_t length;
     try {
-      size_t length = std::stoul(it->second);
-      data.body.clear();
-      data.body.reserve(length);
+      length = std::stoul(it->second);
+    } catch (const std::invalid_argument &) {
+      co_return;
+    } catch (const std::out_of_range &) {
+      co_return;
+    }
+    data.body.clear();
+    data.body.reserve(length);
+    co_await Ensure();
+    if (*this && (**this == '\n' || **this == '\r')) {
+      co_await ++*this;
       co_await Ensure();
       if (*this && (**this == '\n' || **this == '\r')) {
         co_await ++*this;
-        co_await Ensure();
-        if (*this && (**this == '\n' || **this == '\r')) {
-          co_await ++*this;
-        }
-      }
-      size_t remaining = length;
-      while (remaining > 0) {
-        co_await Ensure();
-        if (!*this) break;
-        size_t avail = Available();
-        if (avail == 0) continue;
-        size_t take = std::min(avail, remaining);
-        data.body.append(CurrentPtr(), take);
-        Advance(take);
-        remaining -= take;
       }
-    } catch (...) {
+    }
+    size_t remaining = length;
+    while (remaining > 0) {
+      co_await Ensure();
+      if (!*this) break;
+      size_t avail = Available();
+      if (avail == 0) continue;
+      size_t take = std::min(avail, remaining);
+      data.body.append(CurrentPtr(), take);
+      Advance(take);
+      remaining -= take;
     }
     co_return;
   }
diff --git a/server/src/server.cpp b/server/src/server.cpp
@@ -3,6 +3,7 @@
 #include "read_iterator.h"
 #include "request_data.h"
 #include "trie.h"
+#include <cerrno>
 #include <cctype>
 #include <csignal>
 #include <iostream>
@@ -11,6 +12,7 @@
 #include <optional>
 #include <sstream>
 #include <stdexcept>
+#include <system_error>
 #include <sys/socket.h>
 #include <thread>
 #include <unistd.h>
@@ -62,6 +64,12 @@ static bool wants_close(const RequestData &request) {
     ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
   return value.find("close") != std::string::npos;
 }
+
+constexpr int kMaxIoAttempts = 3;
+
+bool IsRetryableIoError(int result) {
+  return result == -EINTR || result == -EAGAIN || result == -EWOULDBLOCK;
+}
 } // namespace
 
 Server::Server(Server &&rhs) {
@@ -136,15 +144,24 @@ CoFuture<void> Server::WriteResponse(IOUring &ring, int connectionFD, const Resp
   }
   text << "\r\n";
   text << data.body;
-  auto final = std::make_shared<std::string>(text.str());
+  std::string final = text.str();
   size_t sent = 0;
-  while (sent < final->size()) {
-    size_t wrote = co_await ring.WriteAsync(connectionFD, final, sent,
-                                            final->size() - sent);
-    if (wrote == 0) {
+  int attempts = 0;
+  while (sent < final.size()) {
+    int result = co_await ring.WriteAsync(connectionFD, final, sent,
+                                          final.size() - sent);
+    if (result > 0) {
+      sent += static_cast<size_t>(result);
+      attempts = 0;
+      continue;
+    }
+    if (result == 0) {
       break;
     }
-    sent += wrote;
+    ++attempts;
+    if (!IsRetryableIoError(result) || attempts >= kMaxIoAttempts) {
+      throw std::system_error(-result, std::generic_category(), "write failed");
+    }
   }
   co_return;
 }
@@ -198,6 +215,11 @@ CoFuture<void> Server::Process(IOUring &ring, int connectionFD) {
       response.body = error.message;
       mustClose = true;
       keepAlive = false;
+    } catch (const std::system_error &) {
+      response.status = 500;
+      response.body = "Internal server error";
+      mustClose = true;
+      keepAlive = false;
     } catch (std::runtime_error &error) {
       response.status = 500;
       response.body = error.what();
@@ -211,7 +233,12 @@ CoFuture<void> Server::Process(IOUring &ring, int connectionFD) {
     }
 
     if (!mustClose || response.status != 400 || !response.body.empty()) {
-      co_await WriteResponse(ring, connectionFD, response, keepAlive);
+      try {
+        co_await WriteResponse(ring, connectionFD, response, keepAlive);
+      } catch (const std::system_error &) {
+        mustClose = true;
+        keepAlive = false;
+      }
     }
     if (!keepAlive || mustClose) {
       (void)shutdown(connectionFD, SHUT_WR);
