prebake 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dab6849310807672ec24350dbd6343e3adb1875ffd5a84912d3279fcdf4a455d
-  data.tar.gz: be4d4d24fee4c87d755eaa85175204772a10e2ba0a1c81047b342f6593a4cab2
+  metadata.gz: 9f5c4b69adf22b366fb77141cb413b34df42d095349d8cd87daef343b0651711
+  data.tar.gz: cb0433ad9ed89f37840c4ebce4c1468853f2f16067f2a0f38f84eafc4ec6c04f
 SHA512:
-  metadata.gz: 1cd47249386725f821a1c9e497c1fc5a9c27aa872255a0b745147d96a697f69ca9a648171aa13067c40fe3994882d81cab31cb73a063e7928de88e59c624d4d3
-  data.tar.gz: 7997b12e900e9122114ea31539e4e8a448ca898fe4e559abbb4957baa7634277d50e24aa731021eb73c659e66ff39f84f49180c312bd1dceadf445297bf1ab93
+  metadata.gz: 84df05e82f7ef086192333d326d9441cd0146c1ebcc64f4d56a6c780f34d25fdb00e5a255acdaf55354f132f8a5b070284d55a2aeff824635d1c3ef81129fbed
+  data.tar.gz: 44f1bed2b2af9fc20200253783a01a0d915b9ce5afea9743662c3fba5e6bec2d8d54f1cd9f8d159098830b71cc6194a4215b6925dc6b8e3203e2a956bac6afe4

data/lib/prebake/backends/base.rb

@@ -18,6 +18,14 @@ module Prebake
       def exists?(cache_key)
         raise NotImplementedError, "#{self.class}#exists? not implemented"
       end
+
+      def delete(cache_key)
+        raise NotImplementedError, "#{self.class}#delete not implemented"
+      end
+
+      def checksums_supported?
+        true
+      end
     end
   end
 end

data/lib/prebake/backends/gemstash.rb

@@ -56,6 +56,14 @@ module Prebake
         nil
       end
 
+      def checksums_supported?
+        false
+      end
+
+      def delete(_cache_key)
+        false
+      end
+
       def push(gem_path, cache_key, _checksum)
         uri = URI("#{@url}/private/api/v1/gems")
         gem_content = File.binread(gem_path)

data/lib/prebake/backends/http.rb

@@ -25,8 +25,7 @@ module Prebake
       end
 
       def fetch(cache_key)
-        uri = URI("#{@url}/gems/#{cache_key}")
-        response = http_request(:get, uri)
+        response = http_request(:get, gem_uri(cache_key))
         return nil unless response.is_a?(Net::HTTPSuccess)
 
         path = File.join(Dir.tmpdir, "prebake-#{SecureRandom.hex(16)}.gem")
@@ -38,8 +37,7 @@ module Prebake
       end
 
       def fetch_checksum(cache_key)
-        uri = URI("#{@url}/gems/#{cache_key}.sha256")
-        response = http_request(:get, uri)
+        response = http_request(:get, checksum_uri(cache_key))
         return nil unless response.is_a?(Net::HTTPSuccess)
 
         response.body.strip
@@ -49,21 +47,19 @@ module Prebake
       end
 
       def push(gem_path, cache_key, checksum)
-        gem_uri = URI("#{@url}/gems/#{cache_key}")
-        gem_response = http_request(:put, gem_uri, body: File.binread(gem_path))
+        gem_response = http_request(:put, gem_uri(cache_key), body: File.binread(gem_path))
 
         unless gem_response.is_a?(Net::HTTPSuccess)
           Logger.warn "Failed to push #{cache_key}: #{gem_response.code}"
           return false
         end
 
-        # Checksum is a secondary artifact - log failure but don't fail the push.
-        # The gem itself was pushed successfully; missing checksums can be backfilled.
-        checksum_uri = URI("#{@url}/gems/#{cache_key}.sha256")
-        checksum_response = http_request(:put, checksum_uri, body: checksum)
+        checksum_response = http_request(:put, checksum_uri(cache_key), body: checksum)
 
         unless checksum_response.is_a?(Net::HTTPSuccess)
-          Logger.warn "Checksum push failed for #{cache_key}: #{checksum_response.code}"
+          Logger.warn "Checksum push failed for #{cache_key}: #{checksum_response.code}, removing gem"
+          http_request(:delete, gem_uri(cache_key))
+          return false
         end
 
         Logger.info "Pushed #{cache_key}"
@@ -74,15 +70,32 @@ module Prebake
       end
 
       def exists?(cache_key)
-        uri = URI("#{@url}/gems/#{cache_key}")
-        response = http_request(:head, uri)
+        response = http_request(:head, gem_uri(cache_key))
         response.is_a?(Net::HTTPSuccess)
       rescue StandardError
         false
       end
 
+      def delete(cache_key)
+        gem_response = http_request(:delete, gem_uri(cache_key))
+        http_request(:delete, checksum_uri(cache_key))
+
+        gem_response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        Logger.debug "Delete failed for #{cache_key}: #{e.message}"
+        false
+      end
+
       private
 
+      def gem_uri(cache_key)
+        URI("#{@url}/gems/#{cache_key}")
+      end
+
+      def checksum_uri(cache_key)
+        URI("#{@url}/gems/#{cache_key}.sha256")
+      end
+
       def apply_auth_header(request)
         request["Authorization"] = "Bearer #{@token}" if @token
       end

data/lib/prebake/backends/http_client.rb

@@ -7,7 +7,8 @@ module Prebake
     module HttpClient
       TIMEOUT = 30
       HTTP_METHODS = { get: Net::HTTP::Get, head: Net::HTTP::Head,
-                       post: Net::HTTP::Post, put: Net::HTTP::Put }.freeze
+                       post: Net::HTTP::Post, put: Net::HTTP::Put,
+                       delete: Net::HTTP::Delete }.freeze
 
       private
 

data/lib/prebake/backends/s3.rb

@@ -29,7 +29,7 @@ module Prebake
       def fetch_checksum(cache_key)
         return nil unless sdk_available?
 
-        response = client.get_object(bucket: @bucket, key: "#{object_key(cache_key)}.sha256")
+        response = client.get_object(bucket: @bucket, key: checksum_key(cache_key))
         response.body.read.strip
       rescue StandardError => e
         Logger.debug "S3 checksum fetch failed for #{cache_key}: #{e.message}"
@@ -39,10 +39,19 @@ module Prebake
       def push(gem_path, cache_key, checksum)
         return false unless sdk_available?
 
+        gem_key = object_key(cache_key)
         File.open(gem_path, "rb") do |file|
-          client.put_object(bucket: @bucket, key: object_key(cache_key), body: file)
+          client.put_object(bucket: @bucket, key: gem_key, body: file)
         end
-        client.put_object(bucket: @bucket, key: "#{object_key(cache_key)}.sha256", body: checksum)
+
+        begin
+          client.put_object(bucket: @bucket, key: checksum_key(cache_key), body: checksum)
+        rescue StandardError => e
+          Logger.warn "S3 checksum push failed for #{cache_key}: #{e.message}, removing gem"
+          client.delete_object(bucket: @bucket, key: gem_key)
+          return false
+        end
+
         Logger.info "Pushed #{cache_key} to S3"
         true
       rescue StandardError => e
@@ -59,12 +68,28 @@ module Prebake
         false
       end
 
+      def delete(cache_key)
+        return false unless sdk_available?
+
+        client.delete_object(bucket: @bucket, key: object_key(cache_key))
+        client.delete_object(bucket: @bucket, key: checksum_key(cache_key))
+        Logger.info "Deleted #{cache_key} from S3"
+        true
+      rescue StandardError => e
+        Logger.debug "S3 delete failed for #{cache_key}: #{e.message}"
+        false
+      end
+
       private
 
       def object_key(cache_key)
         "#{@prefix}/#{cache_key}"
       end
 
+      def checksum_key(cache_key)
+        "#{object_key(cache_key)}.sha256"
+      end
+
       def sdk_available?
         require "aws-sdk-s3"
         true

data/lib/prebake/ext_builder_patch.rb

@@ -18,6 +18,14 @@ module Prebake
       platform = Platform.generalized
       cache_key = CacheKey.for(@spec.name, @spec.version.to_s, platform)
 
+      expected_checksum = Prebake.backend.fetch_checksum(cache_key)
+
+      if expected_checksum.nil? && Prebake.backend.checksums_supported?
+        Logger.warn "No checksum available for #{cache_key}, removing cached gem"
+        Prebake.backend.delete(cache_key)
+        return super
+      end
+
       begin
         cached_gem = Prebake.backend.fetch(cache_key)
       rescue StandardError => e
@@ -30,30 +38,19 @@ module Prebake
         return super
       end
 
-      # Verify checksum if available
-      if verify_checksum(cache_key, cached_gem)
+      if verify_checksum(cache_key, expected_checksum, cached_gem)
         install_from_cache(cached_gem)
       else
-        Logger.warn "Checksum mismatch for #{cache_key}, compiling from source"
         super
       end
     ensure
-      FileUtils.rm_f(cached_gem) if cached_gem && File.exist?(cached_gem.to_s)
+      FileUtils.rm_f(cached_gem) if cached_gem
     end
 
     private
 
-    def verify_checksum(cache_key, gem_path)
-      expected = Prebake.backend.fetch_checksum(cache_key)
-
-      if expected.nil?
-        if ENV.fetch("PREBAKE_REQUIRE_CHECKSUM", "false") == "true"
-          Logger.warn "No checksum available for #{cache_key} and PREBAKE_REQUIRE_CHECKSUM=true, rejecting"
-          return false
-        end
-        Logger.warn "No checksum available for #{cache_key}, skipping verification"
-        return true
-      end
+    def verify_checksum(cache_key, expected, gem_path)
+      return true if expected.nil?
 
       actual = Digest::SHA256.file(gem_path).hexdigest
       if actual == expected

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prebake
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Thejus Paul
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-22 00:00:00.000000000 Z
+date: 2026-03-23 00:00:00.000000000 Z
 dependencies: []
 description: Prebake speeds up bundle install by skipping native gem compilation.
   It fetches precompiled binaries for gems like puma, nokogiri, pg, grpc, and bootsnap