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/s3-binary-cache-store.cc

@@ -1,13 +1,20 @@
 #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 {
 
+static constexpr uint64_t AWS_MAX_PART_SIZE = 5ULL * 1024 * 1024 * 1024; // 5GiB
+
 class S3BinaryCacheStore : public virtual HttpBinaryCacheStore
 {
 public:
@@ -28,6 +35,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 +83,45 @@ 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 req = makeRequest(path);
+    auto data = StreamToSourceAdapter(istream).drain();
+    if (contentEncoding) {
+        req.headers.emplace_back("Content-Encoding", *contentEncoding);
+    }
+    req.data = std::move(data);
+    req.mimeType = mimeType;
+    try {
+        getFileTransfer()->upload(req);
+    } catch (FileTransferError & e) {
+        throw Error("while uploading to S3 binary cache at '%s': %s", config->cacheUri.to_string(), e.msg());
+    }
 }
 
 std::string S3BinaryCacheStore::createMultipartUpload(