refactor(libstore/s3-binary-cache-store): implement upload()

This stops us from just delegating to
`HttpBinaryCacheStore::upsertFile`, handling compression in our
`upsertFile` override, which will be necessary for multipart uploads.

Author: lovesegfault

src/libstore/http-binary-cache-store.cc

@@ -134,28 +134,38 @@ bool HttpBinaryCacheStore::fileExists(const std::string & path)
     }
 }
 
+void HttpBinaryCacheStore::uploadData(
+    std::string_view path, std::string data, std::string_view mimeType, std::optional<std::string_view> contentEncoding)
+{
+    auto req = makeRequest(path);
+    req.method = HttpMethod::PUT;
+
+    if (contentEncoding) {
+        req.headers.emplace_back("Content-Encoding", *contentEncoding);
+    }
+
+    req.data = std::move(data);
+    req.mimeType = mimeType;
+
+    getFileTransfer()->upload(req);
+}
+
 void HttpBinaryCacheStore::upsertFile(
     const std::string & path,
     std::shared_ptr<std::basic_iostream<char>> istream,
     const std::string & mimeType,
     uint64_t sizeHint)
 {
-    auto req = makeRequest(path);
-    req.method = HttpMethod::PUT;
     auto data = StreamToSourceAdapter(istream).drain();
 
     auto compressionMethod = getCompressionMethod(path);
 
     if (compressionMethod) {
         data = compress(*compressionMethod, data);
-        req.headers.emplace_back("Content-Encoding", *compressionMethod);
     }
 
-    req.data = std::move(data);
-    req.mimeType = mimeType;
-
     try {
-        getFileTransfer()->upload(req);
+        uploadData(path, std::move(data), mimeType, compressionMethod);
     } catch (FileTransferError & e) {
         UploadToHTTP err(e.message());
         err.addTrace({}, "while uploading to HTTP binary cache at '%s'", config->cacheUri.to_string());

src/libstore/include/nix/store/http-binary-cache-store.hh

@@ -88,6 +88,20 @@ protected:
 
     FileTransferRequest makeRequest(std::string_view path);
 
+    /**
+     * Uploads data to the binary cache.
+     *
+     * @param path The path in the binary cache to upload to
+     * @param data The data to upload (should already be compressed if needed)
+     * @param mimeType The MIME type of the content
+     * @param contentEncoding Optional Content-Encoding header value (e.g., "xz", "br")
+     */
+    void uploadData(
+        std::string_view path,
+        std::string data,
+        std::string_view mimeType,
+        std::optional<std::string_view> contentEncoding);
+
     void getFile(const std::string & path, Sink & sink) override;
 
     void getFile(const std::string & path, Callback<std::optional<std::string>> callback) noexcept override;

src/libstore/s3-binary-cache-store.cc

@@ -1,13 +1,22 @@
 #include "nix/store/s3-binary-cache-store.hh"
 #include "nix/store/http-binary-cache-store.hh"
 #include "nix/store/store-registration.hh"
+#include "nix/util/error.hh"
+#include "nix/util/logging.hh"
+#include "nix/util/compression.hh"
+#include "nix/util/serialise.hh"
+#include "nix/util/util.hh"
 
 #include <cassert>
 #include <ranges>
 #include <regex>
 
 namespace nix {
 
+MakeError(UploadToS3, Error);
+
+static constexpr uint64_t AWS_MAX_PART_SIZE = 5ULL * 1024 * 1024 * 1024; // 5GiB
+
 class S3BinaryCacheStore : public virtual HttpBinaryCacheStore
 {
 public:
@@ -28,6 +37,21 @@ class S3BinaryCacheStore : public virtual HttpBinaryCacheStore
 private:
     ref<S3BinaryCacheStoreConfig> s3Config;
 
+    /**
+     * Uploads a file to S3 using a regular (non-multipart) upload.
+     *
+     * This method is suitable for files up to 5GiB in size. For larger files,
+     * multipart upload should be used instead.
+     *
+     * @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
+     */
+    void upload(
+        std::string_view path,
+        std::shared_ptr<std::basic_iostream<char>> istream,
+        const uint64_t sizeHint,
+        std::string_view mimeType,
+        std::optional<std::string_view> contentEncoding);
+
     /**
      * Creates a multipart upload for large objects to S3.
      *
@@ -61,7 +85,42 @@ void S3BinaryCacheStore::upsertFile(
     const std::string & mimeType,
     uint64_t sizeHint)
 {
-    HttpBinaryCacheStore::upsertFile(path, istream, mimeType, sizeHint);
+    auto compressionMethod = getCompressionMethod(path);
+    std::optional<std::string> contentEncoding = std::nullopt;
+
+    if (compressionMethod) {
+        auto compressedData = compress(*compressionMethod, StreamToSourceAdapter(istream).drain());
+        sizeHint = compressedData.size();
+        istream = std::make_shared<std::stringstream>(std::move(compressedData));
+        contentEncoding = compressionMethod;
+    }
+
+    upload(path, istream, sizeHint, mimeType, contentEncoding);
+}
+
+void S3BinaryCacheStore::upload(
+    std::string_view path,
+    std::shared_ptr<std::basic_iostream<char>> istream,
+    const uint64_t sizeHint,
+    std::string_view mimeType,
+    std::optional<std::string_view> contentEncoding)
+{
+    debug("using S3 regular upload for '%s' (%d bytes)", path, sizeHint);
+    if (sizeHint > AWS_MAX_PART_SIZE)
+        throw Error(
+            "file too large for S3 upload without multipart: %s would exceed maximum size of %s. Consider enabling multipart-upload.",
+            renderSize(sizeHint),
+            renderSize(AWS_MAX_PART_SIZE));
+
+    auto data = StreamToSourceAdapter(istream).drain();
+
+    try {
+        uploadData(path, std::move(data), mimeType, contentEncoding);
+    } catch (FileTransferError & e) {
+        UploadToS3 err(e.message());
+        err.addTrace({}, "while uploading to S3 binary cache at '%s'", config->cacheUri.to_string());
+        throw err;
+    }
 }
 
 std::string S3BinaryCacheStore::createMultipartUpload(