sequel 3.21.0 → 3.39.0

data/spec/core/connection_pool_spec.rb

@@ -84,7 +84,9 @@ describe "A connection pool handling connections" do
   end
 
   specify "#make_new should not make more than max_size connections" do
-    50.times{Thread.new{@cpool.hold{sleep 0.001}}}
+    q = Queue.new
+    50.times{Thread.new{@cpool.hold{q.pop}}}
+    50.times{q.push nil}
     @cpool.created_count.should <= @max_size
   end
 
@@ -96,7 +98,8 @@ describe "A connection pool handling connections" do
 
   specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
     @cpool.created_count.should == 0
-    @cpool.hold{Thread.new{@cpool.hold{}}; sleep 0.03}
+    q, q1 = Queue.new, Queue.new
+    @cpool.hold{Thread.new{@cpool.hold{q1.pop; q.push nil}; q1.pop; q.push nil}; q1.push nil; q.pop; q1.push nil; q.pop}
     @cpool.created_count.should == 2
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
     @cpool.created_count.should == 1
@@ -121,36 +124,30 @@ describe "A connection pool handling connection errors" do
   end
 end
 
-class DummyConnection
-  @@value = 0
-  def initialize
-    @@value += 1
-  end
-  
-  def value
-    @@value
-  end
-end
-
 describe "ConnectionPool#hold" do
   before do
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS) {DummyConnection.new}
+    value = 0
+    @c = Class.new do
+      define_method(:initialize){value += 1}
+      define_method(:value){value}
+    end
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS){@c.new}
   end
   
   specify "should pass the result of the connection maker proc to the supplied block" do
     res = nil
     @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
+    res.should be_a_kind_of(@c)
     res.value.should == 1
     @pool.hold {|c| res = c}
-    res.should be_a_kind_of(DummyConnection)
+    res.should be_a_kind_of(@c)
     res.value.should == 1 # the connection maker is invoked only once
   end
   
   specify "should be re-entrant by the same thread" do
     cc = nil
     @pool.hold {|c| @pool.hold {|c| @pool.hold {|c| cc = c}}}
-    cc.should be_a_kind_of(DummyConnection)
+    cc.should be_a_kind_of(@c)
   end
   
   specify "should catch exceptions and reraise them" do
@@ -166,15 +163,14 @@ describe "A connection pool with a max size of 1" do
   
   specify "should let only one thread access the connection at any time" do
     cc,c1, c2 = nil
-    m = (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx') ? 30 : 1
+    q, q1 = Queue.new, Queue.new
     
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.01;end}}
-    sleep 0.02 * m
+    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; q1.push nil; q.pop}}
+    q1.pop
     cc.should == 'herro'
     c1.should == 'herro'
     
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.01;end}}
-    sleep 0.02 * m
+    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; q1.push nil; q.pop;}}
     
     # connection held by t1
     t1.should be_alive
@@ -186,26 +182,22 @@ describe "A connection pool with a max size of 1" do
     
     @pool.available_connections.should be_empty
     @pool.allocated.should == {t1=>cc}
-    
+
     cc.gsub!('rr', 'll')
-    sleep 0.05 * m
-    
-    # connection held by t2
-    t1.should_not be_alive
-    t2.should be_alive
+    q.push nil
+    q1.pop
 
+    t1.join
+    t2.should be_alive
+    
     c2.should == 'hello'
 
     @pool.available_connections.should be_empty
     @pool.allocated.should == {t2=>cc}
     
-    cc.gsub!('ll', 'rr')
-    sleep 0.05 * m
-    
     #connection released
-    t2.should_not be_alive
-    
-    cc.should == 'herro'
+    q.push nil
+    t2.join
     
     @invoked_count.should == 1
     @pool.size.should == 1
@@ -236,34 +228,81 @@ describe "A connection pool with a max size of 1" do
 end
 
 shared_examples_for "A threaded connection pool" do  
+  specify "should not have all_connections yield connections allocated to other threads" do
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>2, :pool_timeout=>0)) {@invoked_count += 1}
+    q, q1 = Queue.new, Queue.new
+    t = Thread.new do
+      pool.hold do |c1|
+        q1.push nil
+        q.pop
+      end
+    end
+    pool.hold do |c1|
+      q1.pop
+      pool.all_connections{|c| c.should == c1}
+      q.push nil
+    end
+    t.join
+  end
+
+  specify "should not have all_connections yield all available connections" do
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>2, :pool_timeout=>0)){@invoked_count += 1}
+    q, q1 = Queue.new, Queue.new
+    b = []
+    t = Thread.new do
+      pool.hold do |c1|
+        b << c1
+        q1.push nil
+        q.pop
+      end
+    end
+    pool.hold do |c1|
+      q1.pop
+      b << c1
+      q.push nil
+    end
+    t.join
+    a = []
+    pool.all_connections{|c| a << c}
+    a.sort.should == b.sort
+  end
+
+  specify "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
+    x = nil
+    q, q1 = Queue.new, Queue.new
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>1, :pool_timeout=>0)) {@invoked_count += 1}
+    t = Thread.new{pool.hold{|c| q1.push nil; q.pop}}
+    q1.pop
+    proc{pool.hold{|c|}}.should raise_error(Sequel::PoolTimeout)
+    q.push nil
+    t.join
+  end
+  
+  it "should not add a disconnected connection back to the pool if the disconnection_proc raises an error" do
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>1, :pool_timeout=>0, :disconnection_proc=>proc{|c| raise Sequel::Error})) {@invoked_count += 1}
+    proc{pool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::Error)
+    pool.available_connections.length.should == 0
+  end
+
   specify "should let five threads simultaneously access separate connections" do
     cc = {}
     threads = []
-    stop = nil
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.02;end}}; sleep 0.02}
-    sleep 0.04
+    5.times{|i| threads << Thread.new{@pool.hold{|c| q.pop; cc[i] = c; q1.push nil; q2.pop}}; q.push nil; q1.pop}
     threads.each {|t| t.should be_alive}
     cc.size.should == 5
     @invoked_count.should == 5
     @pool.size.should == 5
     @pool.available_connections.should be_empty
-    i = 0
+
     h = {}
+    i = 0
     threads.each{|t| h[t] = (i+=1)}
     @pool.allocated.should == h
-    
-    threads[0].raise "your'e dead"
-    sleep 0.02
-    threads[3].raise "your'e dead too"
-    
-    sleep 0.02
-    
-    @pool.available_connections.should == [1, 4]
-    @pool.allocated.should == {threads[1]=>2, threads[2]=>3, threads[4]=>5}
-    
-    stop = true
-    sleep 0.04
+    @pool.available_connections.should == []
+    5.times{q2.push nil}
+    threads.each{|t| t.join}
     
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
@@ -272,16 +311,15 @@ shared_examples_for "A threaded connection pool" do
   specify "should block threads until a connection becomes available" do
     cc = {}
     threads = []
-    stop = nil
+    q, q1 = Queue.new, Queue.new
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.01;end}}; sleep 0.01}
-    sleep 0.02
+    5.times{|i| threads << Thread.new{@pool.hold{|c| cc[i] = c; q1.push nil; q.pop}}}
+    5.times{q1.pop}
     threads.each {|t| t.should be_alive}
     @pool.available_connections.should be_empty
 
-    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
+    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c; q1.push nil}}}
     
-    sleep 0.02
     threads[5].should be_alive
     threads[6].should be_alive
     threads[7].should be_alive
@@ -290,8 +328,10 @@ shared_examples_for "A threaded connection pool" do
     cc[6].should be_nil
     cc[7].should be_nil
     
-    stop = true
-    sleep 0.1
+    5.times{q.push nil}
+    5.times{|i| threads[i].join}
+    3.times{q1.pop}
+    3.times{|i| threads[i+5].join}
     
     threads.each {|t| t.should_not be_alive}
     
@@ -300,12 +340,60 @@ shared_examples_for "A threaded connection pool" do
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
   end
+
+  specify "should store connections in a stack by default" do
+    c2 = nil
+    c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
+    @pool.size.should == 2
+    @pool.hold{|cc| cc.should == c}
+    @pool.hold{|cc| cc.should == c}
+    @pool.hold do |cc|
+      cc.should == c
+      Thread.new{@pool.hold{|cc2| cc2.should == c2}}
+    end
+  end
+
+  specify "should store connections in a queue if :connection_handling=>:queue" do
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:connection_handling=>:queue)){@invoked_count += 1}
+    c2 = nil
+    c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
+    @pool.size.should == 2
+    @pool.hold{|cc| cc.should == c2}
+    @pool.hold{|cc| cc.should == c}
+    @pool.hold do |cc|
+      cc.should == c2
+      Thread.new{@pool.hold{|cc2| cc2.should == c}}
+    end
+  end
+
+  specify "should not store connections if :connection_handling=>:disconnect" do
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:connection_handling=>:disconnect)){@invoked_count += 1}
+    d = []
+    @pool.disconnection_proc = proc{|c| d << c}
+    c = @pool.hold do |cc|
+      cc.should == 1
+      Thread.new{@pool.hold{|cc2| cc2.should == 2}}.join
+      d.should == [2]
+      @pool.hold{|cc3| cc3.should == 1}
+    end
+    @pool.size.should == 0
+    d.should == [2, 1]
+
+    @pool.hold{|cc| cc.should == 3}
+    @pool.size.should == 0
+    d.should == [2, 1, 3]
+
+    @pool.hold{|cc| cc.should == 4}
+    @pool.size.should == 0
+    d.should == [2, 1, 3, 4]
+  end
 end
 
 describe "Threaded Unsharded Connection Pool" do
   before do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
+    @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts) {@invoked_count += 1}
   end
   
   it_should_behave_like "A threaded connection pool"
@@ -314,7 +402,8 @@ end
 describe "Threaded Sharded Connection Pool" do
   before do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {@invoked_count += 1}
+    @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts) {@invoked_count += 1}
   end
 
   it_should_behave_like "A threaded connection pool"
@@ -324,19 +413,15 @@ describe "ConnectionPool#disconnect" do
   before do
     @count = 0
     @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {{:id => @count += 1}}
+    threads = []
+    q, q1 = Queue.new, Queue.new
+    5.times {|i| threads << Thread.new {@pool.hold {|c| q1.push nil; q.pop}}}
+    5.times{q1.pop}
+    5.times{q.push nil}
+    threads.each {|t| t.join}
   end
   
   specify "should invoke the given block for each available connection" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
-    while @pool.size < 5
-      sleep 0.02
-    end
-    stop = true
-    sleep 0.1
-    threads.each {|t| t.join}
-    
     @pool.size.should == 5
     @pool.available_connections.size.should == 5
     @pool.available_connections.each {|c| c[:id].should_not be_nil}
@@ -346,34 +431,13 @@ describe "ConnectionPool#disconnect" do
   end
   
   specify "should remove all available connections" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
-    while @pool.size < 5
-      sleep 0.02
-    end
-    stop = true
-    sleep 0.1
-    threads.each {|t| t.join}
-    
     @pool.size.should == 5
     @pool.disconnect
     @pool.size.should == 0
   end
 
   specify "should disconnect connections in use as soon as they are no longer in use" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
-    while @pool.size < 5
-      sleep 0.02
-    end
-    stop = true
-    sleep 0.1
-    threads.each {|t| t.join}
-    
     @pool.size.should == 5
-    
     @pool.hold do |conn|
       @pool.available_connections.size.should == 4
       @pool.available_connections.each {|c| c.should_not be(conn)}
@@ -392,6 +456,16 @@ describe "A connection pool with multiple servers" do
     @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
   end
   
+  specify "#all_connections should return connections for all servers" do
+    @pool.hold{}
+    @pool.all_connections{|c1| c1.should == "default1"}
+    a = []
+    @pool.hold(:read_only) do |c|
+      @pool.all_connections{|c1| a << c1}
+    end
+    a.sort_by{|c| c.to_s}.should == ["default1", "read_only1"]
+  end
+  
   specify "#servers should return symbols for all servers" do
     @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
   end
@@ -556,9 +630,10 @@ describe "A connection pool with multiple servers" do
   specify "#remove_servers should disconnect available connections immediately" do
     pool = Sequel::ConnectionPool.get_pool(:max_connections=>5, :servers=>{:server1=>{}}){|s| s}
     threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new{pool.hold(:server1){|c| sleep 0.05}}}
-    sleep 0.1
+    q, q1 = Queue.new, Queue.new
+    5.times {|i| threads << Thread.new {pool.hold(:server1){|c| q1.push nil; q.pop}}}
+    5.times{q1.pop}
+    5.times{q.push nil}
     threads.each {|t| t.join}
     
     pool.size(:server1).should == 5
@@ -645,6 +720,16 @@ describe "A single threaded pool with multiple servers" do
     @pool = Sequel::ConnectionPool.get_pool(ST_CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
   end
   
+  specify "#all_connections should return connections for all servers" do
+    @pool.hold{}
+    @pool.all_connections{|c1| c1.should == :default}
+    a = []
+    @pool.hold(:read_only) do
+      @pool.all_connections{|c1| a << c1}
+    end
+    a.sort_by{|c| c.to_s}.should == [:default, :read_only]
+  end
+  
   specify "#servers should return symbols for all servers" do
     @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
   end
@@ -751,6 +836,32 @@ describe "A single threaded pool with multiple servers" do
 end
 
 shared_examples_for "All connection pools classes" do
+  specify "should have all_connections yield current and available connections" do
+    p = @class.new({}){123}
+    p.hold{|c| p.all_connections{|c1| c.should == c1}}
+  end
+
+  specify "should be able to modify after_connect proc after the pool is created" do
+    a = []
+    p = @class.new({}){123}
+    p.after_connect = pr = proc{|c| a << c}
+    p.after_connect.should == pr
+    a.should == []
+    p.hold{}
+    a.should == [123]
+  end
+
+  specify "should be able to modify disconnection_proc after the pool is created" do
+    a = []
+    p = @class.new({}){123}
+    p.disconnection_proc = pr = proc{|c| a << c}
+    p.disconnection_proc.should == pr
+    p.hold{}
+    a.should == []
+    p.disconnect
+    a.should == [123]
+  end
+
   specify "should not raise an error when disconnecting twice" do
     c = @class.new({}){123}
     proc{c.disconnect}.should_not raise_error
@@ -808,6 +919,20 @@ shared_examples_for "All connection pools classes" do
     y.should == 123
   end
   
+  specify "should have a reentrent hold method" do
+    o = Object.new
+    c = @class.new({}){o}
+    c.hold do |x|
+      x.should == o
+      c.hold do |x1|
+        x1.should == o
+        c.hold do |x2|
+          x2.should == o
+        end
+      end
+    end
+  end
+  
   specify "should have a servers method that returns an array of shard/server symbols" do
     @class.new({}){123}.servers.should == [:default]
   end