sbf-dm-transactions 1.3.0.beta

data/lib/dm-transactions/adapters/dm-do-adapter.rb

@@ -0,0 +1,112 @@
+module DataMapper
+  class Transaction
+
+    module DataObjectsAdapter
+      extend Chainable
+
+      # Produces a fresh transaction primitive for this Adapter
+      #
+      # Used by Transaction to perform its various tasks.
+      #
+      # @return [Object]
+      #   a new Object that responds to :close, :begin, :commit,
+      #   and :rollback,
+      #
+      # @api private
+      def transaction_primitive
+        if current_transaction && supports_savepoints?
+          DataObjects::SavePoint.create_for_uri(normalized_uri, current_connection)
+        else
+          DataObjects::Transaction.create_for_uri(normalized_uri)
+        end
+      end
+
+      # Pushes the given Transaction onto the per thread Transaction stack so
+      # that everything done by this Adapter is done within the context of said
+      # Transaction.
+      #
+      # @param [Transaction] transaction
+      #   a Transaction to be the 'current' transaction until popped.
+      #
+      # @return [Array(Transaction)]
+      #   the stack of active transactions for the current thread
+      #
+      # @api private
+      def push_transaction(transaction)
+        transactions << transaction
+      end
+
+      # Pop the 'current' Transaction from the per thread Transaction stack so
+      # that everything done by this Adapter is no longer necessarily within the
+      # context of said Transaction.
+      #
+      # @return [Transaction]
+      #   the former 'current' transaction.
+      #
+      # @api private
+      def pop_transaction
+        transactions.pop
+      end
+
+      # Retrieve the current transaction for this Adapter.
+      #
+      # Everything done by this Adapter is done within the context of this
+      # Transaction.
+      #
+      # @return [Transaction]
+      #   the 'current' transaction for this Adapter.
+      #
+      # @api private
+      def current_transaction
+        transactions.last
+      end
+
+      chainable do
+        protected
+
+        # @api semipublic
+        def open_connection
+          current_connection || super
+        end
+
+        # @api semipublic
+        def close_connection(connection)
+          super unless current_connection.equal?(connection)
+        end
+      end
+
+      private
+
+      # @api private
+      def transactions
+        Thread.current[:dm_transactions]            ||= {}
+        Thread.current[:dm_transactions][object_id] ||= []
+      end
+
+      # Retrieve the current connection for this Adapter.
+      #
+      # @return [Transaction]
+      #   the 'current' connection for this Adapter.
+      #
+      # @api private
+      def current_connection
+        if transaction = current_transaction
+          transaction.primitive_for(self).connection
+        end
+      end
+
+      # Indicate whether adapter supports transactional savepoints.  Not all DO
+      # adapters do, so default to false.
+      #
+      # @return [Boolean]
+      #   whether or not the adapter supports savepoints
+      #
+      # @api private
+      def supports_savepoints?
+        false
+      end
+
+    end # module DataObjectsAdapter
+
+  end # class Transaction
+end # module DataMapper

data/lib/dm-transactions/adapters/dm-mysql-adapter.rb

@@ -0,0 +1,15 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module MysqlAdapter
+      include DataObjectsAdapter
+
+      def supports_savepoints?
+        true
+      end
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-oracle-adapter.rb

@@ -0,0 +1,11 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module OracleAdapter
+      include DataObjectsAdapter
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-postgres-adapter.rb

@@ -0,0 +1,15 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module PostgresAdapter
+      include DataObjectsAdapter
+
+      def supports_savepoints?
+        true
+      end
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-sqlite-adapter.rb

@@ -0,0 +1,11 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module SqliteAdapter
+      include DataObjectsAdapter
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-sqlserver-adapter.rb

@@ -0,0 +1,11 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module SqlserverAdapter
+      include DataObjectsAdapter
+    end
+
+  end
+end

data/lib/dm-transactions/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Transactions
+    VERSION = '1.3.0.beta'
+  end
+end

data/lib/dm-transactions.rb

@@ -0,0 +1,443 @@
+require 'dm-core'
+
+module DataMapper
+  class Transaction
+    extend Chainable
+
+    # @api private
+    attr_accessor :state
+
+    # @api private
+    def none?
+      state == :none
+    end
+
+    # @api private
+    def begin?
+      state == :begin
+    end
+
+    # @api private
+    def rollback?
+      state == :rollback
+    end
+
+    # @api private
+    def commit?
+      state == :commit
+    end
+
+    # Create a new Transaction
+    #
+    # @see Transaction#link
+    #
+    # In fact, it just calls #link with the given arguments at the end of the
+    # constructor.
+    #
+    # @api public
+    def initialize(*things)
+      @transaction_primitives = {}
+      self.state = :none
+      @adapters = {}
+      link(*things)
+      if block_given?
+        warn "Passing block to #{self.class.name}.new is deprecated (#{caller[0]})"
+        commit { |*block_args| yield(*block_args) }
+      end
+    end
+
+    # Associate this Transaction with some things.
+    #
+    # @param [Object] things
+    #   the things you want this Transaction associated with:
+    #
+    #   Adapters::AbstractAdapter subclasses will be added as
+    #     adapters as is.
+    #   Arrays will have their elements added.
+    #   Repository will have it's own @adapters added.
+    #   Resource subclasses will have all the repositories of all
+    #     their properties added.
+    #   Resource instances will have all repositories of all their
+    #     properties added.
+    #
+    # @param [Proc] block
+    #   a block (taking one argument, the Transaction) to execute within
+    #   this transaction. The transaction will begin and commit around
+    #   the block, and rollback if an exception is raised.
+    #
+    # @api private
+    def link(*things)
+      unless none?
+        raise "Illegal state for link: #{state}"
+      end
+
+      things.each do |thing|
+        case thing
+          when DataMapper::Adapters::AbstractAdapter
+            @adapters[thing] = :none
+          when DataMapper::Repository
+            link(thing.adapter)
+          when DataMapper::Model
+            link(*thing.repositories)
+          when DataMapper::Resource
+            link(thing.model)
+          when Array
+            link(*thing)
+          else
+            raise "Unknown argument to #{self.class}#link: #{thing.inspect} (#{thing.class})"
+        end
+      end
+
+      if block_given?
+        commit { |*block_args| yield(*block_args) }
+      else
+        self
+      end
+    end
+
+    # Begin the transaction
+    #
+    # Before #begin is called, the transaction is not valid and can not be used.
+    #
+    # @api private
+    def begin
+      unless none?
+        raise "Illegal state for begin: #{state}"
+      end
+
+      each_adapter(:connect_adapter, [:log_fatal_transaction_breakage])
+      each_adapter(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
+      self.state = :begin
+    end
+
+    # Commit the transaction
+    #
+    #   If no block is given, it will simply commit any changes made since the
+    #   Transaction did #begin.
+    #
+    # @param block<Block>   a block (taking the one argument, the Transaction) to
+    #   execute within this transaction. The transaction will begin and commit
+    #   around the block, and roll back if an exception is raised.
+    #
+    # @api private
+    def commit
+      if block_given?
+        unless none?
+          raise "Illegal state for commit with block: #{state}"
+        end
+
+        begin
+          self.begin
+          rval = within { |*block_args| yield(*block_args) }
+        rescue Exception => exception
+          if begin?
+            rollback
+          end
+          raise exception
+        ensure
+          unless exception
+            if begin?
+              commit
+            end
+            return rval
+          end
+        end
+      else
+        unless begin?
+          raise "Illegal state for commit without block: #{state}"
+        end
+        each_adapter(:commit_adapter, [:log_fatal_transaction_breakage])
+        each_adapter(:close_adapter, [:log_fatal_transaction_breakage])
+        self.state = :commit
+      end
+    end
+
+    # Rollback the transaction
+    #
+    # Will undo all changes made during the transaction.
+    #
+    # @api private
+    def rollback
+      unless begin?
+        raise "Illegal state for rollback: #{state}"
+      end
+      each_adapter(:rollback_adapter_if_begin, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
+      each_adapter(:close_adapter_if_open, [:log_fatal_transaction_breakage])
+      self.state = :rollback
+    end
+
+    # Execute a block within this Transaction.
+    #
+    # No #begin, #commit or #rollback is performed in #within, but this
+    # Transaction will pushed on the per thread stack of transactions for each
+    # adapter it is associated with, and it will ensures that it will pop the
+    # Transaction away again after the block is finished.
+    #
+    # @param block<Block> the block of code to execute.
+    #
+    # @api private
+    def within
+      unless block_given?
+        raise 'No block provided'
+      end
+
+      unless begin?
+        raise "Illegal state for within: #{state}"
+      end
+
+      adapters = @adapters
+
+      adapters.each_key do |adapter|
+        adapter.push_transaction(self)
+      end
+
+      begin
+        yield self
+      ensure
+        adapters.each_key do |adapter|
+          adapter.pop_transaction
+        end
+      end
+    end
+
+    # @api private
+    def method_missing(method, *args, &block)
+      first_arg = args.first
+
+      return super unless args.size == 1 && first_arg.kind_of?(Adapters::AbstractAdapter)
+      return super unless match = method.to_s.match(/\A(.*)_(if|unless)_(none|begin|rollback|commit)\z/)
+
+      action, condition, expected_state = match.captures
+      return super unless respond_to?(action, true)
+
+      state   = state_for(first_arg).to_s
+      execute = (condition == 'if') == (state == expected_state)
+
+      send(action, first_arg) if execute
+    end
+
+    # @api private
+    def primitive_for(adapter)
+      unless @adapters.include?(adapter)
+        raise "Unknown adapter #{adapter}"
+      end
+
+      unless @transaction_primitives.include?(adapter)
+        raise "No primitive for #{adapter}"
+      end
+
+      @transaction_primitives[adapter]
+    end
+
+    private
+
+    # @api private
+    def validate_primitive(primitive)
+      [:close, :begin, :rollback, :commit].each do |meth|
+        unless primitive.respond_to?(meth)
+          raise "Invalid primitive #{primitive}: doesnt respond_to?(#{meth.inspect})"
+        end
+      end
+
+      primitive
+    end
+
+    # @api private
+    def each_adapter(method, on_fail)
+      adapters = @adapters
+      begin
+        adapters.each_key do |adapter|
+          send(method, adapter)
+        end
+      rescue Exception => exception
+        adapters.each_key do |adapter|
+          on_fail.each do |fail_handler|
+            begin
+              send(fail_handler, adapter)
+            rescue Exception => inner_exception
+              DataMapper.logger.fatal("#{self}#each_adapter(#{method.inspect}, #{on_fail.inspect}) failed with #{exception.inspect}: #{exception.backtrace.join("\n")} - and when sending #{fail_handler} to #{adapter} we failed again with #{inner_exception.inspect}: #{inner_exception.backtrace.join("\n")}")
+            end
+          end
+        end
+        raise exception
+      end
+    end
+
+    # @api private
+    def state_for(adapter)
+      unless @adapters.include?(adapter)
+        raise "Unknown adapter #{adapter}"
+      end
+
+      @adapters[adapter]
+    end
+
+    # @api private
+    def do_adapter(adapter, what, prerequisite)
+      unless @transaction_primitives.include?(adapter)
+        raise "No primitive for #{adapter}"
+      end
+
+      state = state_for(adapter)
+
+      unless state == prerequisite
+        raise "Illegal state for #{what}: #{state}"
+      end
+
+      DataMapper.logger.debug("#{adapter.name}: #{what}")
+      @transaction_primitives[adapter].send(what)
+      @adapters[adapter] = what
+    end
+
+    # @api private
+    def log_fatal_transaction_breakage(adapter)
+      DataMapper.logger.fatal("#{self} experienced a totally broken transaction execution. Presenting member #{adapter.inspect}.")
+    end
+
+    # @api private
+    def connect_adapter(adapter)
+      if @transaction_primitives.key?(adapter)
+        raise "Already a primitive for adapter #{adapter}"
+      end
+
+      @transaction_primitives[adapter] = validate_primitive(adapter.transaction_primitive)
+    end
+
+    # @api private
+    def close_adapter_if_open(adapter)
+      if @transaction_primitives.include?(adapter)
+        close_adapter(adapter)
+      end
+    end
+
+    # @api private
+    def close_adapter(adapter)
+      unless @transaction_primitives.include?(adapter)
+        raise 'No primitive for adapter'
+      end
+
+      @transaction_primitives[adapter].close
+      @transaction_primitives.delete(adapter)
+    end
+
+    # @api private
+    def begin_adapter(adapter)
+      do_adapter(adapter, :begin, :none)
+    end
+
+    # @api private
+    def commit_adapter(adapter)
+      do_adapter(adapter, :commit, :begin)
+    end
+
+    # @api private
+    def rollback_adapter(adapter)
+      do_adapter(adapter, :rollback, :begin)
+    end
+
+    # @api private
+    def rollback_and_close_adapter(adapter)
+      rollback_adapter(adapter)
+      close_adapter(adapter)
+    end
+
+    module Repository
+
+      # Produce a new Transaction for this Repository
+      #
+      # @return [Adapters::Transaction]
+      #   a new Transaction (in state :none) that can be used
+      #   to execute code #with_transaction
+      #
+      # @api public
+      def transaction
+        Transaction.new(self)
+      end
+    end # module Repository
+
+    module Model
+      # @api private
+      def self.included(mod)
+        mod.descendants.each { |model| model.extend self }
+      end
+
+      # Produce a new Transaction for this Resource class
+      #
+      # @return <Adapters::Transaction
+      #   a new Adapters::Transaction with all Repositories
+      #   of the class of this Resource added.
+      #
+      # @api public
+      def transaction
+        transaction = Transaction.new(self)
+        transaction.commit { |block_args| yield(*block_args) }
+      end
+    end # module Model
+
+    module Resource
+
+      # Produce a new Transaction for the class of this Resource
+      #
+      # @return [Adapters::Transaction]
+      #   a new Adapters::Transaction for the Repository
+      #   of the class of this Resource added.
+      #
+      # @api public
+      def transaction
+        model.transaction { |*block_args| yield(*block_args) }
+      end
+    end # module Resource
+
+    def self.include_transaction_api
+      [ :Repository, :Model, :Resource ].each do |name|
+        DataMapper.const_get(name).send(:include, const_get(name))
+      end
+      Adapters::AbstractAdapter.descendants.each do |adapter_class|
+        Adapters.include_transaction_api(DataMapper::Inflector.demodulize(adapter_class.name))
+      end
+    end
+
+  end # class Transaction
+
+  module Adapters
+
+    def self.include_transaction_api(const_name)
+      require transaction_extensions(const_name)
+      if Transaction.const_defined?(const_name)
+        adapter = const_get(const_name)
+        adapter.send(:include, transaction_module(const_name))
+      end
+    rescue LoadError
+      # Silently ignore the fact that no adapter extensions could be required
+      # This means that the adapter in use doesn't support transactions
+    end
+
+    def self.transaction_module(const_name)
+      Transaction.const_get(const_name)
+    end
+
+    class << self
+    private
+
+      # @api private
+      def transaction_extensions(const_name)
+        name = adapter_name(const_name)
+        name = 'do' if name == 'dataobjects'
+        "dm-transactions/adapters/dm-#{name}-adapter"
+      end
+
+    end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+        include_transaction_api(const_name)
+        super
+      end
+    end
+
+  end # module Adapters
+
+  Transaction.include_transaction_api
+
+end # module DataMapper

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,17 @@
+require 'rspec'
+require_relative 'require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+
+if %w(postgres mysql sqlite oracle sqlserver).include?(ENV['ADAPTER'])
+  describe "require 'dm-transactions after calling DataMapper.setup" do
+    before(:all) do
+      @adapter = DataMapper::Spec.adapter
+      require 'dm-transactions'
+    end
+
+    it_behaves_like "require 'dm-transactions'"
+  end
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,17 @@
+require 'rspec'
+require_relative 'require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+
+if %w(postgres mysql sqlite oracle sqlserver).include?(ENV['ADAPTER'])
+  describe "require 'dm-transactions' before calling DataMapper.setup" do
+    before(:all) do
+      require 'dm-transactions'
+      @adapter = DataMapper::Spec.adapter
+    end
+
+    it_behaves_like "require 'dm-transactions'"
+  end
+end

data/spec/isolated/require_spec.rb

@@ -0,0 +1,13 @@
+shared_examples "require 'dm-transactions'" do
+  %w[ Repository Model Resource ].each do |name|
+    it "includes the transaction api in DataMapper::#{name}" do
+      expect((DataMapper.const_get(name) < DataMapper::Transaction.const_get(name))).to be(true)
+    end
+  end
+
+  it "includes the transaction api into the adapter" do
+    expect(@adapter.respond_to?(:push_transaction)).to be(true)
+    expect(@adapter.respond_to?(:pop_transaction)).to be(true)
+    expect(@adapter.respond_to?(:current_transaction)).to be(true)
+  end
+end