data_objects 0.2.0 → 0.9.2

data/lib/data_objects/reader.rb

@@ -0,0 +1,22 @@
+module DataObjects
+  class Reader
+
+    def fields
+      raise NotImplementedError.new
+    end
+
+    def values
+      raise NotImplementedError.new
+    end
+
+    def close
+      raise NotImplementedError.new
+    end
+
+    # Moves the cursor forward.
+    def next!
+      raise NotImplementedError.new
+    end
+
+  end
+end

data/lib/data_objects/result.rb

@@ -0,0 +1,13 @@
+module DataObjects
+  class Result
+    attr_accessor :insert_id, :affected_rows
+
+    def initialize(command, affected_rows, insert_id = nil)
+      @command, @affected_rows, @insert_id = command, affected_rows, insert_id
+    end
+
+    def to_i
+      @affected_rows
+    end
+  end
+end

data/lib/data_objects/support/pooling.rb

@@ -0,0 +1,236 @@
+require 'set'
+
+class Object
+  # ==== Notes
+  # Provides pooling support to class it got included in.
+  #
+  # Pooling of objects is a faster way of aquiring instances
+  # of objects compared to regular allocation and initialization
+  # because instances are keeped in memory reused.
+  #
+  # Classes that include Pooling module have re-defined new
+  # method that returns instances aquired from pool.
+  #
+  # Term resource is used for any type of poolable objects
+  # and should NOT be thought as DataMapper Resource or
+  # ActiveResource resource and such.
+  #
+  # In Data Objects connections are pooled so that it is
+  # unnecessary to allocate and initialize connection object
+  # each time connection is needed, like per request in a
+  # web application.
+  #
+  # Pool obviously has to be thread safe because state of
+  # object is reset when it is released.
+  module Pooling
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      # ==== Notes
+      # Initializes the pool and returns it.
+      #
+      # ==== Parameters
+      # size_limit<Fixnum>:: maximum size of the pool.
+      #
+      # ==== Returns
+      # <ResourcePool>:: initialized pool
+      def initialize_pool(size_limit, options = {})
+        @__pool.flush! if @__pool
+
+        @__pool = ResourcePool.new(size_limit, self, options)
+      end
+
+      # ==== Notes
+      # Instances of poolable resource are aquired from
+      # pool. This quires a new instance from pool and
+      # returns it.
+      #
+      # ==== Returns
+      # Resource instance aquired from the pool.
+      #
+      # ==== Raises
+      # ArgumentError:: when pool is exhausted and no instance
+      #                 can be aquired.
+      def new
+        pool.aquire
+      end
+
+      # ==== Notes
+      # Returns pool for this resource class.
+      # Initialization is done when necessary.
+      # Default size limit of the pool is 10.
+      #
+      # ==== Returns
+      # <Object::Pooling::ResourcePool>:: pool for this resource class.
+      def pool
+        @__pool ||= ResourcePool.new(10, self)
+      end
+    end
+
+    # ==== Notes
+    # Pool
+    #
+    class ResourcePool
+      attr_reader :size_limit, :class_of_resources, :expiration_period
+
+      # ==== Notes
+      # Initializes resource pool.
+      #
+      # ==== Parameters
+      # size_limit<Fixnum>:: maximum number of resources in the pool.
+      # class_of_resources<Class>:: class of resource.
+      #
+      # ==== Raises
+      # ArgumentError:: when class of resource does not implement
+      #                 dispose instance method or is not a Class.
+      def initialize(size_limit, class_of_resources, options)
+        raise ArgumentError.new("Expected class of resources to be instance of Class, got: #{class_of_resources.class}") unless class_of_resources.is_a?(Class)
+        raise ArgumentError.new("Class #{class_of_resources} must implement dispose instance method to be poolable.") unless class_of_resources.instance_methods.include?("dispose")
+
+        @size_limit         = size_limit
+        @class_of_resources = class_of_resources
+
+        @reserved  = Set.new
+        @available = []
+        @lock      = Mutex.new
+
+        initialization_args  = options.delete(:initialization_args) || []
+
+        @expiration_period   = options.delete(:expiration_period) || 60
+        @initialization_args = [*initialization_args]
+
+        @pool_expiration_thread = Thread.new do
+          while true
+            release_outdated
+
+            sleep (@expiration_period + 1)
+          end
+        end
+      end
+
+      # ==== Notes
+      # Current size of pool: number of already reserved
+      # resources.
+      def size
+        @reserved.size
+      end
+
+      # ==== Notes
+      # Indicates if pool has resources to aquire.
+      #
+      # ==== Returns
+      # <Boolean>:: true if pool has resources can be aquired,
+      #             false otherwise.
+      def available?
+        @reserved.size < size_limit
+      end
+
+      # ==== Notes
+      # Aquires last used available resource and returns it.
+      # If no resources available, current implementation
+      # throws an exception.
+      def aquire
+        @lock.synchronize do
+          if available?
+            instance = prepair_available_resource
+            @reserved << instance
+
+            instance
+          else
+            raise RuntimeError
+          end
+        end
+      end
+
+      # ==== Notes
+      # Releases previously aquired instance.
+      #
+      # ==== Parameters
+      # instance <Anything>:: previosly aquired instance.
+      #
+      # ==== Raises
+      # RuntimeError:: when given not pooled instance.
+      def release(instance)
+        @lock.synchronize do
+          if @reserved.include?(instance)
+            @reserved.delete(instance)
+            instance.dispose
+            @available << instance
+          else
+            raise RuntimeError
+          end
+        end
+      end
+
+      # ==== Notes
+      # Releases all objects in the pool.
+      #
+      # ==== Returns
+      # nil
+      def flush!
+        @reserved.each do |instance|
+          self.release(instance)
+        end
+
+        nil
+      end
+
+      # ==== Notes
+      # Check if instance has been aquired from the pool.
+      #
+      # ==== Returns
+      # <Boolean>:: true if given resource instance has been aquired from pool,
+      #             false otherwise.
+      def aquired?(instance)
+        @reserved.include?(instance)
+      end
+
+      # ==== Notes
+      # Releases instances that haven't been in use and
+      # hit the expiration period.
+      #
+      # ==== Returns
+      # nil
+      def release_outdated
+        @reserved.each do |instance|
+          release(instance) if time_to_release?(instance)
+        end
+
+        nil
+      end
+
+      # ==== Notes
+      # Checks if pooled resource instance is outdated and
+      # should be released.
+      #
+      # ==== Returns
+      # <Boolean>:: true if instance should be released, false otherwise.
+      def time_to_release?(instance)
+        (Time.now - instance.instance_variable_get("@__pool_aquire_timestamp")) > @expiration_period
+      end
+
+      protected
+
+      # ==== Notes
+      # Either allocates new resource,
+      # or takes last used available resource from
+      # the pool.
+      def prepair_available_resource
+        if @available.size > 0
+          res = @available.pop
+          res.instance_variable_set("@__pool_aquire_timestamp", Time.now)
+
+          res
+        else
+          res = @class_of_resources.allocate
+          res.send(:initialize, *@initialization_args)
+          res.instance_variable_set("@__pool_aquire_timestamp", Time.now)
+
+          res
+        end
+      end
+    end # ResourcePool
+  end
+end

data/lib/data_objects/transaction.rb

@@ -0,0 +1,42 @@
+module DataObjects
+
+  class Transaction
+
+    HOST = "#{Socket::gethostbyname(Socket::gethostname)[0]}" rescue "localhost"
+    @@counter = 0
+
+    attr_reader :connection
+    attr_reader :id
+
+    def self.create_for_uri(uri)
+      uri = uri.is_a?(String) ? URI::parse(uri) : uri
+      DataObjects.const_get(uri.scheme.capitalize)::Transaction.new(uri)
+    end
+
+    #
+    # Creates a Transaction bound to the given connection
+    #
+    # ==== Parameters
+    # conn<DataObjects::Connection>:: The Connection to bind the new Transaction to
+    #
+    def initialize(uri)
+      @connection = DataObjects::Connection.new(uri)
+      @id = "#{HOST}:#{$$}:#{Time.now.to_f}:#{@@counter += 1}"
+    end
+
+    def close
+      @connection.close
+    end
+
+    [:begin, :commit, :rollback, :rollback_prepared, :prepare].each do |method_name|
+
+      eval <<EOF
+def #{method_name}
+  raise NotImplementedError
+end
+EOF
+
+    end
+
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Command do
+  before do
+    @connection = DataObjects::Connection.new('mock://localhost')
+    @command = DataObjects::Command.new(@connection, 'SQL STRING')
+  end
+
+  it "should assign the connection object to @connection" do
+    @command.instance_variable_get("@connection").should == @connection
+  end
+
+  it "should assign the sql text to @text" do
+    @command.instance_variable_get("@text").should == 'SQL STRING'
+  end
+
+  %w{connection execute_non_query execute_reader set_types to_s}.each do |meth|
+    it "should respond to ##{meth}" do
+      @command.should respond_to(meth.intern)
+    end
+  end
+
+  %w{execute_non_query execute_reader set_types}.each do |meth|
+    it "should raise NotImplementedError on ##{meth}" do
+      lambda { @command.send(meth.intern, nil) }.should raise_error(NotImplementedError)
+    end
+  end
+
+  it "should make the connection object available in #connection" do
+    @command.connection.should == @command.instance_variable_get("@connection")
+  end
+
+  it "should make the SQL text available in #to_s" do
+    @command.to_s.should == @command.instance_variable_get("@text")
+  end
+
+end

data/spec/connection_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Connection do
+  before do
+    @connection = DataObjects::Connection.new('mock://localhost')
+  end
+
+  %w{dispose create_command}.each do |meth|
+    it "should respond to ##{meth}" do
+      @connection.should respond_to(meth.intern)
+    end
+  end
+
+  it "should have #to_s that returns the connection uri string" do
+    @connection.to_s.should == 'mock://localhost'
+  end
+
+  describe "getting inherited" do
+    # HACK: Connections needs to exist under the DataObjects namespace?
+    module DataObjects
+      class MyConnection < DataObjects::Connection; end
+    end
+
+    it "should set the @connection_lock ivar to a Mutex" do
+      DataObjects::MyConnection.instance_variable_get("@connection_lock").should_not be_nil
+      DataObjects::MyConnection.instance_variable_get("@connection_lock").should be_kind_of(Mutex)
+    end
+
+    it "should set the @available_connections ivar to a Hash" do
+      DataObjects::MyConnection.instance_variable_get("@available_connections").should_not be_nil
+      DataObjects::MyConnection.instance_variable_get("@available_connections").should be_kind_of(Hash)
+    end
+
+    it "should set the @reserved_connections ivar to a Set" do
+      DataObjects::MyConnection.instance_variable_get("@reserved_connections").should_not be_nil
+      DataObjects::MyConnection.instance_variable_get("@reserved_connections").should be_kind_of(Set)
+    end
+  end
+
+  describe "initialization" do
+    it "should accept a regular connection uri as a String" do
+      c = DataObjects::Connection.new('mock://localhost/database')
+      # relying on the fact that mock connection sets @uri
+      uri = c.instance_variable_get("@uri")
+
+      uri.should be_kind_of(Addressable::URI)
+      uri.scheme.should == 'mock'
+      uri.host.should == 'localhost'
+      uri.path.should == '/database'
+    end
+
+    it "should accept a conneciton uri as a Addressable::URI" do
+      c = DataObjects::Connection.new(Addressable::URI::parse('mock://localhost/database'))
+      # relying on the fact that mock connection sets @uri
+      uri = c.instance_variable_get("@uri")
+
+      uri.should be_kind_of(Addressable::URI)
+      uri.to_s.should == 'mock://localhost/database'
+    end
+
+    it "should determine which DataObject adapter from the uri scheme" do
+      DataObjects::Mock::Connection.should_receive(:__new)
+      DataObjects::Connection.new('mock://localhost/database')
+    end
+
+    it "should determine which DataObject adapter from a JDBC URL scheme" do
+      DataObjects::Mock::Connection.should_receive(:__new)
+      DataObjects::Connection.new('jdbc:mock://localhost/database')
+    end
+
+    it "should aquire a connection" do
+      uri = Addressable::URI.parse('mock://localhost/database')
+      DataObjects::Mock::Connection.should_receive(:__new).with(uri)
+
+      DataObjects::Connection.new(uri)
+    end
+
+    it "should return the Connection specified by the scheme" do
+      c = DataObjects::Connection.new(Addressable::URI.parse('mock://localhost/database'))
+      c.should be_kind_of(DataObjects::Mock::Connection)
+    end
+  end
+end

data/spec/dataobjects_spec.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))

data/spec/do_mock.rb

@@ -0,0 +1,31 @@
+module DataObjects
+
+  module Mock
+    class Connection < DataObjects::Connection
+      def initialize(uri)
+        @uri = uri
+      end
+
+      def dispose
+        nil
+      end
+    end
+
+    class Command < DataObjects::Command
+      def execute_non_query(*args)
+        Result.new(self, 0, nil)
+      end
+
+      def execute_reader(*args)
+        Reader.new
+      end
+    end
+
+    class Result < DataObjects::Result
+    end
+
+    class Reader < DataObjects::Reader
+    end
+  end
+
+end