pod4 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f7db5348478c3d4dba39f248760d0f148f14f21866246e95ec3ea8c69505979
-  data.tar.gz: 7cbace08f7fb4151bfb7b9713bed4d5262d4d4bc7b4a0a87e79723e6c990fabf
+  metadata.gz: '059cee54af33433ab352687ba5634d12a30720f913a71f77df04d5121c05c07e'
+  data.tar.gz: a154f4c8bcc9c6cd327124218e5e2ebdaf536d75771704e42c3c5c6bb9d81e45
 SHA512:
-  metadata.gz: 9b0d0707ae21d1060cbc5df5fa0bee569c85a5dc6f9af3db288c4ba4025c047a1cbb3f3390535df81589b1143053bc29337a407b3f345a4bbcfa594ae7051e83
-  data.tar.gz: 983c421cdfca75e40b211d19f9a80ed63bbd14068a539b3861be446803231b361d323e34f91de1675ad1bbc528cd62e9f6dd9601d0b7e252d3985287e8ccbcc8
+  metadata.gz: a3d59bd322a578230457cdee63faa25f47712345bf0738e6043400b529d6bb3ec7650e84c195eb4aa3da7e661998b9c19ab1d9e062a6ca341c7b391c7e62b789
+  data.tar.gz: 7e9dcb3d43858175ad581ef093dbbe39e54cd14f4bd1b887cc3e6976217d270710776bcdd8e2803e980be3e96657ad87efa8037cbd37216bc464d82e0a8bb823

data/README.md

@@ -183,6 +183,9 @@ three.  There is no validation or error control.
 Note that we have to require pg_interface and pg seperately. I won't bother to show this in any
 more model examples.
 
+Note also that we are passing the PG connection string to the interface.  This is not best
+practice.  Ideally, you should set up a connection pool, instead.  See below.
+
 ### Interface ###
 
 Let's start with the interface definition.  Remember, the interface class is only there to
@@ -475,35 +478,34 @@ if you had them, would share the same connection. Note that we are talking in th
 this second wrinkle, because of:
 
 
-### The Connection Object ###
+### The Connection Pool Object ###
 
-The solution to both of these wrinkles is the Pod4::Connection object. 
+The solution to both of these wrinkles is the Pod4::ConnectionPool object. 
 
-By default any interface other than SequelInterface will create a pool of connections and connect
-to the database with one your thread is currently using.  (Sequel uses it's own connection pool, so
-will create one internally. It uses its own thread pool, of course, and we only use the one Sequel
-DB object for the whole of Pod4, so it doesn't need any of that. That's why it uses
-Pod4::Connection, instead.)
+You can pass a database connection parameter to an interface, and it will create a Connection
+object for you and use it internally. 
 
-You can set this up manually, if you wish:
+This will, with the exception of SequelInterface, which just lets Sequel do its own thing, give you
+one connection pool per interface.  This will solve all the above problems, but it is rather
+generous; what you probably want is one connection pool per database for your entire application.
+You can pass this to your interface instead of the DB connection parameters.
 
     #
     # init.rb -- bootup for my project
     #
 
     # Require libraries
-    require "sequel"
+    require "PG""
     require "pod4"
-    require "pod4/sequel_interface"
-    require "pod4/connection"
+    require "pod4/pg_interface"
+    require "pod4/connection_pool"
 
     # require models
-    $conn = Pod4::Connection.new(interface: Pod4::SequelInterface)
+    $conn = Pod4::ConnectionPool.new
     require_relative "models/customer"
 
     # set up database connection
-    hash = get_sequel_params
-    $conn.data_layer_options = Sequel.connect(hash)
+    $conn.data_layer_options = get_pg_param_hash
 
     #############
 
@@ -512,21 +514,17 @@ You can set this up manually, if you wish:
     #
 
     class Foo < Pod4::Model
-      class Interface < Pod4::SequelInterface
+      class FooInterface < Pod4::PgInterface
         set_table    :foo
-        set_id_field :id, autoincrement: true
+        set_id_field :id
       end
 
-      set_interface Interface.new($conn)
+      set_interface FooInterface.new($conn)
 
-TL;DR: the only code that needs to go in the middle of your requires is the line defining a
+TL;DR: the only code that needs to go in the middle of your requires are the lines defining a
 Connection object; you pass that to the interface instead.  You can set up the parameters
 the interface needs and pass them to the connection object afterwards.  
 
-With TdsInterface and PgInterface you can pass the same connection to multiple models and they will
-share it.  These interfaces take a Pod4::ConnectionPool instead, but otherwise the code looks
-exactly the same as the above example. 
-
 
 BasicModel
 ----------

data/lib/pod4/connection.rb

@@ -15,14 +15,20 @@ module Pod4
     #
     # `conn = Pod4::Connection.new(interface: MyInterface)`
     #
-    def initialize(args)
-      raise ArgumentError, "Connection#new needs a Hash" unless args.is_a? Hash
-      raise ArgumentError, "You must pass a Pod4::Interface" \
-        unless args[:interface] \
-            && args[:interface].is_a?(Class) \
-            && args[:interface].ancestors.include?(Interface)
-
-      @interface_class    = args[:interface]
+    def initialize(args=nil)
+      if args
+        raise ArgumentError, "Connection#new argument needs to be a Hash" unless args.is_a? Hash
+
+        if args[:interface]
+          raise ArgumentError, "You must pass a Pod4::Interface" \
+            unless args[:interface] \
+                && args[:interface].is_a?(Class) \
+                && args[:interface].ancestors.include?(Interface)
+        end
+
+        @interface_class = args[:interface]
+      end
+
       @data_layer_options = nil
       @client             = nil
       @options            = nil
@@ -43,7 +49,6 @@ module Pod4
 
     ##
     # Close the connection.  
-    # In the case of a single connection, this is probably not going to get used much. But.
     #
     def close(interface)
       fail_bad_interfaces(interface)
@@ -56,7 +61,7 @@ module Pod4
 
     def fail_bad_interfaces(f)
       raise ArgumentError, "That's not a #@interface_class", caller \
-        unless f.kind_of?(@interface_class)
+        if @interface_class && !f.kind_of?(@interface_class)
 
     end
 

data/lib/pod4/connection_pool.rb

@@ -33,6 +33,10 @@ module Pod4
         get(Thread.current.object_id)
       end
 
+      def get_oldest
+        @items.sort{|a,b| a.stamp <=> b.stamp}.first
+      end
+
       def get_free
         @mutex.synchronize do
           pi = @items.find{|x| x.thread_id.nil? }
@@ -46,16 +50,6 @@ module Pod4
         pi.thread_id = nil if pi
       end
 
-      def release_oldest
-        pi = @items.sort{|a,b| a.stamp <=> b.stamp}.first
-        pi.thread_id = nil if pi
-      end
-
-      def drop(id=nil)
-        id ||= Thread.current.object_id
-        @items.delete_if{|x| x.thread_id == id }
-      end
-
       def size 
         @items.size
       end
@@ -80,6 +74,9 @@ module Pod4
     # * max_wait -- throw a Pod4::PoolTimeout if you wait more than this time in seconds.
     # Pass nil to wait forever. Default is nil, because you would need to handle that timeout.
     #
+    # Note that the :interface parameter is optional here.  You probably want one pool for all your
+    # models and interfaces, so you should leave it out.
+    #
     def initialize(args)
       super(args)
 
@@ -97,22 +94,27 @@ module Pod4
     # Failing that, if we've set a timeout, wait for a client to be freed; if we have not, release
     #   the oldest client and use that.
     #
-    # Note: The interface passes itself in case we want to call it back to get a new client; but
-    # clients are assigned to a _thread_. Every interface in a given thread gets the same pool
-    # item, the same client object.
+    # Note: 'interface' is the instance of the interface class. It passes itself in case we want to
+    # call it back to get a new client or to close a client; but clients are assigned to a
+    # _thread_, not an interface. Every interface in a given thread gets the same pool item, the
+    # same client object.
     #
     def client(interface)
       time = Time.now
       cl   = nil
 
+      Pod4.logger.debug(__FILE__){ "Pool size: #{@pool.size} Thread: #{Thread.current.object_id}" }
+
       # NB: We are constrained to use loop in order for our test to work
       loop do
         if (pi = @pool.get_current)
+          Pod4.logger.debug(__FILE__){ "get current: #{pi.inspect}" }
           cl = pi.client
           break
         end
 
         if (pi = @pool.get_free)
+          Pod4.logger.debug(__FILE__){ "get free: #{pi.inspect}" }
           cl = pi.client
           break
         end
@@ -125,38 +127,42 @@ module Pod4
             next
           else
             Pod4.logger.debug(__FILE__){ "releasing oldest client" }
-            @pool.release_oldest
+            oldest = @pool.get_oldest
+            interface.close_connection oldest.client
+            @pool.release(oldest.thread_id)
             next
           end
         end
 
+        Pod4.logger.debug(__FILE__){ "new connection" }
         cl = interface.new_connection(@data_layer_options)
         @pool << cl
         break
       end # of loop
 
+      Pod4.logger.debug(__FILE__){ "Got client: #{cl.inspect}" }
       cl
     end
 
     ##
     # De-assign the client for the current thread from that thread.
     #
-    # We never ask the interface to close the connection to the database.  There is no advantage in
-    # doing that for us.
-    #
-    # Note: The interface passes itself in case we want to call it back to actually close the
-    # client; but clients are assigned to a _thread_.
+    # Note: 'interface' is the instance of the interface class.  This is so we can call it
+    # and get it to close the client; we don't know how to do that.
     #
     def close(interface)
-      @pool.release
+      current = @pool.get_current
+      interface.close_connection current.client
+      @pool.release current.thread_id
     end
 
-    ##
-    # Remove the client object entirely -- for example, because the connection to the database has
-    # expired.
+    ## 
+    # Remove the client from the pool but don't try to close it.
+    # we provide this for if the Interface finds that a connection is no longer open; TdsInterface
+    # uses it.
     #
     def drop(interface)
-      @pool.drop
+      @pool.release
     end
 
     ##

data/lib/pod4/pg_interface.rb

@@ -1,4 +1,4 @@
-require "octothorpe"
+require "octothorpe" #bamf
 require "date"
 require "time"
 require "bigdecimal"
@@ -319,7 +319,7 @@ module Pod4
     ##
     # Close the connection to the database.
     #
-    # Pod4 itself doesn't use this(?)
+    # This is called from a Connection Object.
     #
     def close_connection(conn)
       Pod4.logger.info(__FILE__){ "Closing connection to DB" }
@@ -360,11 +360,7 @@ module Pod4
     def ensure_connection
       client = @connection.client(self)
 
-      if client.nil?
-        open
-      elsif ! connected?(client)
-        client.reset
-      end
+      client.reset unless connected?(client)
 
       client
     end

data/lib/pod4/tds_interface.rb

@@ -320,8 +320,7 @@ module Pod4
     ##
     # Close the connection to the database.
     #
-    # We don't actually use this.  Theoretically it would be called by ConnectionPool, but we
-    # don't.  I've left it in for completeness.
+    # This is called by ConnectionPool.
     #
     def close_connection(conn)
       Pod4.logger.info(__FILE__){ "Closing connection to DB" }

data/lib/pod4/version.rb

@@ -1,3 +1,3 @@
 module Pod4 
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
 end

data/spec/common/connection_pool_parallelism_spec.rb

@@ -60,7 +60,7 @@ describe Pod4::ConnectionPool do
   let(:ifce_class) do
     Class.new Pod4::Interface do
       def initialize;                  end
-      def close_connection;            end
+      def close_connection(int);       end
       def new_connection(opts); @conn; end
 
       def set_conn(c); @conn = c; end

data/spec/common/connection_pool_spec.rb

@@ -6,7 +6,7 @@ describe Pod4::ConnectionPool do
   let(:ifce_class) do
     Class.new Pod4::Interface do
       def initialize;                  end
-      def close_connection;            end
+      def close_connection(int);       end
       def new_connection(opts); @conn; end
 
       def set_conn(c); @conn = c; end
@@ -228,6 +228,13 @@ describe Pod4::ConnectionPool do
           expect( conn.thread_id ).to eq Thread.current.object_id
         end
 
+        it "calls close_connection on the interface with the oldest client ID" do
+          oldest = @connection._pool.sort_by{|x| x.stamp}.first
+          expect( @interface ).to receive(:close_connection).with(oldest.client)
+
+          @connection.client(@interface)
+        end
+
       end # of when we reach the maximum and no max_wait is set
 
     end # of when max_clients != nil, there is no client for this thread and none free
@@ -253,6 +260,11 @@ describe Pod4::ConnectionPool do
       expect( @connection._pool.first.thread_id ).to be_nil
     end
 
+    it "calls #close_connection on the interface" do
+      expect( @interface).to receive(:close_connection)
+      @connection.close(@interface)
+    end
+
   end # of #close
 
 
@@ -267,16 +279,19 @@ describe Pod4::ConnectionPool do
       expect( @connection._pool.size ).to eq 1
       expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
     end
-     
-    it "removes the client object from the pool entirely" do
+
+    it "removes the client object from the pool" do
       @connection.drop(@interface)
-      expect( @connection._pool.size ).to eq 0
+      expect( @connection._pool.size ).to eq 1
+      expect( @connection._pool.first.thread_id ).to be_nil
     end
     
   end # of #drop
   
   
-
+  
+  
+  
 
 end
 

data/spec/common/connection_spec.rb

@@ -28,12 +28,13 @@ describe Pod4::Connection do
 
   describe "#new" do
 
-    it "takes a hash" do
-      expect{ Pod4::Connection.new       }.to raise_error ArgumentError
-      expect{ Pod4::Connection.new(:foo) }.to raise_error ArgumentError
+    it "takes an optional hash" do
+      expect{ Pod4::Connection.new         }.not_to raise_error
+      expect{ Pod4::Connection.new(foo: 4) }.not_to raise_error
+      expect{ Pod4::Connection.new(:foo)   }.to raise_error ArgumentError
     end
 
-    it "needs :interface, a Pod4::Interface class" do
+    it "the :interface parameter must be a Pod4::Interface class" do
       expect{ Pod4::Connection.new(interface: "foo") }.to raise_error ArgumentError
       expect{ Pod4::Connection.new(interface: Array) }.to raise_error ArgumentError
       expect{ Pod4::Connection.new(interface: ConnectionTestingI) }.not_to raise_error

data/spec/mri/connection_pool_spec.rb

@@ -0,0 +1,81 @@
+require "pod4/pg_interface"
+require "pg"
+
+require_relative "../fixtures/database"
+
+
+describe "PgInterface" do
+
+  def db_setup(connect)
+    client = PG.connect(connect)
+
+    client.exec(%Q|
+      drop table if exists flobert;
+
+      create table flobert (
+        id   serial primary key,
+        code text,
+        name text );
+
+      insert into flobert (code, name) 
+        values ( 'one', 'first code');| )
+
+  ensure
+    client.finish if client
+  end
+
+  # we can't use Pod4 to get the connections because it will reuse the current connection!
+  def get_connections(connect)
+    client = PG.connect(connect)
+    result = client.exec %Q|select * from pg_stat_activity   
+                              where datname = 'pod4_test'
+                                and query like '%flobert%'
+                                and not (query like '%pg_stat_activity%');|
+
+    rows = result.map{it}
+    client.finish
+    rows
+  end
+
+  let(:pg_interface_class) do
+    Class.new PgInterface do
+      set_table :flobert
+      set_id_fld :id
+    end
+  end
+
+  let(:interface) do
+    pg_interface_class.new(@pool)
+  end
+
+  before(:all) do
+    @connect_hash = DB[:pg]
+    db_setup(@connect_hash)
+
+    @pool = ConnectionPool.new(interface: PgInterface)
+    @pool.data_layer_options = @connect_hash
+  end
+
+
+  describe "#close" do
+    # we're specifically and only testing here that the connection goes away after manually calling
+    # close.  In the common unit tests we test that #client calls #close_connection on the
+    # interface when it needs to release a connection.
+
+    it "drops the database connection" do
+      list = interface.list
+
+      rows = get_connections(@connect_hash)
+      expect( rows.count ).to eq 1
+
+      @pool.close interface
+
+      rows = get_connections(@connect_hash)
+      expect( rows.count ).to eq 0
+    end
+
+  end # of #close
+
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pod4
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Andy Jones
@@ -104,6 +104,7 @@ files:
 - spec/jruby/sequel_encrypting_jdbc_pg_spec.rb
 - spec/jruby/sequel_interface_jdbc_ms_spec.rb
 - spec/jruby/sequel_interface_jdbc_pg_spec.rb
+- spec/mri/connection_pool_spec.rb
 - spec/mri/pg_encrypting_spec.rb
 - spec/mri/pg_interface_spec.rb
 - spec/mri/sequel_encrypting_spec.rb
@@ -158,6 +159,7 @@ test_files:
 - spec/jruby/sequel_encrypting_jdbc_pg_spec.rb
 - spec/jruby/sequel_interface_jdbc_ms_spec.rb
 - spec/jruby/sequel_interface_jdbc_pg_spec.rb
+- spec/mri/connection_pool_spec.rb
 - spec/mri/pg_encrypting_spec.rb
 - spec/mri/pg_interface_spec.rb
 - spec/mri/sequel_encrypting_spec.rb