Merge pull request #9310 from ngan/fix-stale-cache-after-process-lock

Clear gem specification cache after acquiring process lock

Author: hsbt

bundler/lib/bundler/installer.rb

@@ -63,6 +63,11 @@ def run(options)
       Bundler.create_bundle_path
 
       ProcessLock.lock do
+        # Invalidate any stale gem specification cache from before we acquired the lock.
+        # Another process may have installed gems while we were waiting.
+        Gem::Specification.reset
+        @definition.sources.clear_cache
+
         @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
 
         if @definition.dependencies.empty?

bundler/lib/bundler/source/rubygems.rb

@@ -314,6 +314,13 @@ def dependency_api_available?
         @allow_remote && api_fetchers.any?
       end
 
+      def clear_cache
+        @specs = nil
+        @installed_specs = nil
+        @default_specs = nil
+        @cached_specs = nil
+      end
+
       protected
 
       def remote_names

bundler/lib/bundler/source_list.rb

@@ -136,6 +136,10 @@ def remote!
       all_sources.each(&:remote!)
     end
 
+    def clear_cache
+      rubygems_sources.each(&:clear_cache)
+    end
+
     private
 
     def map_sources(replacement_sources)

spec/bundler/source/rubygems_spec.rb

@@ -45,6 +45,45 @@
     end
   end
 
+  describe "#clear_cache" do
+    it "invalidates memoized indexes so subsequent reads rebuild them" do
+      source = described_class.new
+
+      first_specs = source.specs
+      first_installed = source.send(:installed_specs)
+      first_default = source.send(:default_specs)
+      first_cached = source.send(:cached_specs)
+
+      expect(source.specs).to equal(first_specs)
+      expect(source.send(:installed_specs)).to equal(first_installed)
+      expect(source.send(:default_specs)).to equal(first_default)
+      expect(source.send(:cached_specs)).to equal(first_cached)
+
+      source.clear_cache
+
+      expect(source.specs).not_to equal(first_specs)
+      expect(source.send(:installed_specs)).not_to equal(first_installed)
+      expect(source.send(:default_specs)).not_to equal(first_default)
+      expect(source.send(:cached_specs)).not_to equal(first_cached)
+    end
+
+    it "reflects newly-discovered installed gems after clear_cache" do
+      source = described_class.new
+      foo = Gem::Specification.new("foo", "1.0.0")
+      bar = Gem::Specification.new("bar", "1.0.0")
+
+      allow(Bundler.rubygems).to receive(:installed_specs).and_return([foo])
+      expect(source.send(:installed_specs).search("bar")).to be_empty
+
+      allow(Bundler.rubygems).to receive(:installed_specs).and_return([foo, bar])
+      expect(source.send(:installed_specs).search("bar")).to be_empty
+
+      source.clear_cache
+
+      expect(source.send(:installed_specs).search("bar")).not_to be_empty
+    end
+  end
+
   describe "log debug information" do
     it "log the time spent downloading and installing a gem" do
       build_repo2 do

spec/bundler/source_list_spec.rb

@@ -442,6 +442,16 @@
     end
   end
 
+  describe "#clear_cache" do
+    let(:rubygems_source) { source_list.add_rubygems_source("remotes" => ["https://rubygems.org"]) }
+
+    it "calls #clear_cache on all rubygems sources" do
+      expect(rubygems_source).to receive(:clear_cache)
+      expect(source_list.global_rubygems_source).to receive(:clear_cache)
+      source_list.clear_cache
+    end
+  end
+
   describe "implicit_global_source?" do
     context "when a global rubygem source provided" do
       it "returns a falsy value" do

spec/install/process_lock_spec.rb

@@ -53,5 +53,61 @@
         expect(processed).to eq true
       end
     end
+
+    it "refreshes gem specification cache after waiting for lock" do
+      build_repo2 do
+        build_gem "myrack", "1.0.0"
+      end
+
+      gemfile <<-G
+        source "https://gem.repo2"
+        gem "myrack"
+      G
+
+      # First, install the gem so it's available
+      bundle "install"
+      expect(out).to include("Installing myrack")
+
+      # Queue for thread-safe communication
+      lock_acquired = Queue.new
+      can_release_lock = Queue.new
+      install_output = Queue.new
+
+      # Thread holds lock (simulating another bundle process that just finished installing)
+      thread = Thread.new do
+        Bundler::ProcessLock.lock(default_bundle_path) do
+          # Signal that we have the lock
+          lock_acquired << true
+          # Wait until main thread signals we can release
+          can_release_lock.pop
+        end
+      end
+
+      # Wait for thread to acquire lock
+      lock_acquired.pop
+
+      # Start another install in a thread - it will wait for the lock
+      install_thread = Thread.new do
+        bundle "install", verbose: true
+        install_output << out
+      end
+
+      # Give subprocess time to start and begin waiting for lock
+      sleep 0.5
+
+      # Signal thread to release the lock
+      can_release_lock << true
+
+      # Wait for both threads to complete
+      thread.join
+      install_thread.join
+
+      second_install_out = install_output.pop
+
+      expect(the_bundle).to include_gems "myrack 1.0.0"
+      # The second install should have refreshed its cache after acquiring
+      # the lock and seen that myrack was already installed
+      expect(second_install_out).to include("Using myrack")
+    end
   end
 end