public/simple-object-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch to drogon
All checks were successful
Build-Test-Publish / build (linux/amd64) (push) Successful in 56s
Details
Build-Test-Publish / build (linux/arm64) (push) Successful in 1m40s
Details
Build-Test-Publish / create-manifest (push) Successful in 18s
Details

Browse Source
This commit is contained in:
Your Name
2025-06-15 16:19:23 +12:00
parent 69de93c793
commit eedd39a533
10 changed files with 538 additions and 10738 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
src/put_handler.cpp
View File

@@ -3,6 +3,7 @@
#include "compress.hpp"
#include "string_utils.hpp"
#include "utils.hpp"
#include <drogon/MultiPart.h>
#include <random>
#include <chrono>
@@ -25,75 +26,127 @@ namespace simple_object_storage {
PutHandler::PutHandler(Server& server) : server_(server) {}
void PutHandler::handle_put_object(const httplib::Request& req, httplib::Response& res) {
void PutHandler::handle_put_object(const drogon::HttpRequestPtr& req, std::function<void(const drogon::HttpResponsePtr &)>&& callback) {
// Check all request parameters first before processing any data
auto resp = drogon::HttpResponse::newHttpResponse();
std::map<std::string, std::string> params;
if (!server_.validate_write_request(req, res, {}, params)) { // No required params now since token is in header
if (!server_.validate_write_request(req, resp, {}, params)) { // No required params now since token is in header
callback(resp);
return;
}
// 1. Check we're in the /upload path
if (req.path != "/upload") {
res.status = 404;
if (req->getPath() != "/upload") {
resp->setStatusCode(drogon::k404NotFound);
nlohmann::json response = {{"result", "error"}, {"error", "Not found - put requests must be to /upload"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
// Parse the multipart form data
if (!req.has_file("file")) {
res.status = 400;
drogon::MultiPartParser fileParser;
if (fileParser.parse(req) != 0) {
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "Failed to parse multipart data"}};
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
auto &files = fileParser.getFiles();
const drogon::HttpFile* fileData = nullptr;
for (auto& file : files) {
if (file.getItemName() == "file") {
fileData = &file;
break;
}
}
if (!fileData) {
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "No file provided in upload"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
// Get the file data
const auto& file = req.get_file_value("file");
// Parse metadata if provided
nlohmann::json metadata;
if (req.has_file("metadata")) {
// First check if metadata was sent as a form field
auto &parameters = fileParser.getParameters();
auto metadataParam = parameters.find("metadata");
if (metadataParam != parameters.end()) {
try {
const auto& metadata_file = req.get_file_value("metadata");
metadata = nlohmann::json::parse(metadata_file.content);
metadata = nlohmann::json::parse(metadataParam->second);
} catch (const nlohmann::json::parse_error& e) {
res.status = 400;
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "Invalid JSON metadata: " + std::string(e.what())}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
} else {
// If not found as parameter, check if it was sent as a file
for (auto& file : files) {
if (file.getItemName() == "metadata") {
try {
auto fileContent = file.fileContent();
std::string content(fileContent.data(), fileContent.size());
metadata = nlohmann::json::parse(content);
} catch (const nlohmann::json::parse_error& e) {
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "Invalid JSON metadata: " + std::string(e.what())}};
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
break;
}
}
}
// Validate required metadata fields
if (!metadata.contains("labeltags") || !metadata["labeltags"].is_array() || metadata["labeltags"].empty()) {
res.status = 400;
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "Missing or invalid required metadata field: labeltags (must be non-empty array of label:tag pairs)"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
// Validate each label:tag pair format
for (const auto& labeltag : metadata["labeltags"]) {
if (!labeltag.is_string()) {
res.status = 400;
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "Invalid label:tag pair format - must be a string"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
std::string pair = labeltag.get<std::string>();
if (pair.find(':') == std::string::npos) {
res.status = 400;
resp->setStatusCode(drogon::k400BadRequest);
nlohmann::json response = {{"result", "error"}, {"error", "Invalid label:tag pair format - must contain ':' separator"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
}
// Add filename to metadata if not provided
if (!metadata.contains("filename")) {
metadata["filename"] = file.filename;
metadata["filename"] = fileData->getFileName();
}
// Now that all parameters are validated, process the upload
@@ -108,19 +161,24 @@ void PutHandler::handle_put_object(const httplib::Request& req, httplib::Respons
std::filesystem::path temp_path = server_.config_.object_store_path / temp_filename;
std::ofstream temp_file(temp_path, std::ios::binary);
if (!temp_file.is_open()) {
res.status = 500;
resp->setStatusCode(drogon::k500InternalServerError);
nlohmann::json response = {{"result", "error"}, {"error", "Failed to create temporary file"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
// Write file content to temporary file
if (!temp_file.write(file.content.c_str(), file.content.size())) {
res.status = 500;
auto fileContent = fileData->fileContent();
if (!temp_file.write(fileContent.data(), fileContent.size())) {
resp->setStatusCode(drogon::k500InternalServerError);
nlohmann::json response = {{"result", "error"}, {"error", "Failed to write to temporary file"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
temp_file.close();
std::filesystem::remove(temp_path);
callback(resp);
return;
}
@@ -132,9 +190,11 @@ void PutHandler::handle_put_object(const httplib::Request& req, httplib::Respons
// Calculate hash
uint64_t hash = hash_file(temp_path.string());
if (hash == 0) {
res.status = 500;
resp->setStatusCode(drogon::k500InternalServerError);
nlohmann::json response = {{"result", "error"}, {"error", "Failed to calculate hash"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
@@ -155,9 +215,11 @@ void PutHandler::handle_put_object(const httplib::Request& req, httplib::Respons
temp_file_deleter.release();
} catch (const std::filesystem::filesystem_error& e) {
std::cerr << "Error renaming temp file: " << e.what() << std::endl;
res.status = 500;
resp->setStatusCode(drogon::k500InternalServerError);
nlohmann::json response = {{"result", "error"}, {"error", "Failed to store object file"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
return;
}
}
@@ -169,15 +231,19 @@ void PutHandler::handle_put_object(const httplib::Request& req, httplib::Respons
entry.metadata = metadata;
if (!server_.db_->update_or_insert(entry)) {
res.status = 500;
resp->setStatusCode(drogon::k500InternalServerError);
nlohmann::json response = {{"result", "error"}, {"error", "Failed to update database index"}};
res.set_content(response.dump(), "application/json");
resp->setBody(response.dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
// Attempt to clean up the moved file if index fails
try { if (std::filesystem::exists(final_path)) std::filesystem::remove(final_path); } catch(...) {};
callback(resp);
return;
}
res.set_content(nlohmann::json({{"result", "success"}, {"hash", std::to_string(hash)}}).dump(), "application/json");
resp->setBody(nlohmann::json({{"result", "success"}, {"hash", std::to_string(hash)}}).dump());
resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
callback(resp);
}
void PutHandler::add_file_metadata(const std::string& file_path, nlohmann::json& metadata) const {