acts_as_partitionable 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Revolution Health Group LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,102 @@
+== Introduction
+
+ActsAsPartitionable provides support for using multiple databases to support 
+data partitioning schemes for existing models. 
+This plugin allows models marked as acts_as_partitionable to specify database 
+partitions to and explicit names to reference those partitions using existing 
+models.  As part of this plugin connection pooling is provided so that many 
+different models may share the same database for partitions without forcing each 
+partition model object to inherit from a common base class.
+
+== Disclaimer
+
+As part of our strategy to address data partitioning as stated in our blog 
+entry: 
+http://revolutiononrails.blogspot.com/2007/04/ActsAsReadonlyable-to-support-
+read-only.html
+
+We wrote this plugin in preparation to using slave DBs but we are not going to 
+have those until May 2007.  
+So even though the code is covered with tests (see 
+svn://rubyforge.org/var/svn/actsaspartition/trunk/test/unit/partitionable_test.r
+b), it has not yet been used in a production environment.
+
+We will have a discovery period in May when the code is likely to be improved so 
+for now you can use is at your own risk. 
+Meanwhile, we would be happy to fix any issue revealed. Drop us a line at rails-
+trunk [ at ] revolution DOT com.
+
+Using this plugin should not be your first step in application 
+optimization/scaling or even the second one. 
+Before installing it make sure you understand the implication of leveraging 
+multiple DBs (for example, the potential for cross DB joins).
+
+== Example
+
+=== Sample Model
+
+class SomeModel < ActiveRecord::Base
+# use the read_only database from the database.yml
+    acts_as_partitionable :name => "partition_1", :access => :readonly, 
+:db_config => :read_only
+
+# use the default database for partition_2
+    acts_as_partitionable :name => "partition_2"
+
+# use the a specific w/r database for partition_3
+    acts_as_partitionable :name => "partition_3", :db_config => 
+:some_model_partition
+
+# Specify the database configuration from a hash
+    acts_as_partitionable :access => :readonly, :db_config => {:adapter => 
+"mysql", :database => "partionable_db_test", :username => "root", :password => 
+"", :host => "localhost"} 
+end
+
+=== Sample DB Config
+
+dbs:
+
+  database: master_db
+  host: master-host
+
+read_only:
+  database: slave_db
+  host: slave-host
+
+
+some_model_partition:
+  database: slave_db_2
+  host: slave-host
+
+=== Usage
+
+r = SomeModel.readonly.find(:first)  # executes against the read_only db - 
+slave_db
+r.field = 'value'
+r.save!  # raises ActiveRecord::ReadOnlyRecord 
+r.readonly? # true
+
+t = SomeModel.partition_3.find(:first) # executes against slave_db_2
+t.field = 'some value'
+t.save! # success to partition_3
+
+
+== Installation
+
+As plugin: 
+script/plugin install 
+svn://rubyforge.org/var/svn/actsaspartition/trunk/vendor/plugins/acts_as_partiti
+onable
+
+
+== License
+
+ActsAsPartitionable is released under the MIT license.
+
+
+== Support
+
+The plugin RubyForge page is http://rubyforge.org/projects/actsaspartition
+
+

data/lib/acts_as_partitionable.rb

@@ -0,0 +1,94 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+# This source code may not be disclosed to others, used or reproduced without the written permission of Revolution Health Group.
+module Acts
+  module Partitionable
+  
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_partitionable?
+        true
+      end
+      
+      # Readonly Simple Sample:
+      # class User
+      # acts_as_partitionable :access => :readonly, :db_config => ... 
+      # end
+      # User.readonly do
+      #   me = find(1)   # DB hit
+      # end
+      # - or -
+      # User.readonly.find(:all)
+      #
+      #
+      # :access => [:readonly, :readwrite (default), :writeonly]
+      #
+      def acts_as_partitionable(options = {})
+        # default options
+        default_partition_name = "partition"
+        options = {:access => :readwrite, :name => default_partition_name}.merge(options)
+        
+        partition_name = options[:name]
+        
+        partition_db_klass_readonly = false
+        if options[:access] == :readonly
+          partition_db_klass_readonly = true
+          include ReadonlyInstanceMethods if partition_name == default_partition_name
+        end
+
+        if options[:db_config].is_a?(Hash)
+          db_config = options[:db_config]
+        elsif options[:db_config].is_a?(Symbol) or options[:db_config].is_a?(String)
+          begin
+            db_config = configurations[RAILS_ENV].merge(configurations[RAILS_ENV][options[:db_config].to_s])
+          rescue
+            raise ::ActiveRecord::ConfigurationError.new
+          end
+        end
+
+        partition_db_klass ||= eval <<-TOS
+          class #{self.name}Partitionable#{partition_name} < #{self.name}
+            # setting abstract_class to true so that ActiveRecord doesn't look
+            # for a db table for this base model class
+            self.abstract_class = true
+            def self.find_every(options)
+              (options ||= {})[:readonly] = true if #{partition_db_klass_readonly}
+              super(options)
+            end
+            def self.readonly?; #{partition_db_klass_readonly}; end
+          end 
+          #{self.name}Partitionable#{partition_name}
+        TOS
+        partition_db_klass.establish_connection(db_config)
+        
+        class_eval <<-PART_PROC_END    
+        def self.#{partition_name}(&block)
+          return #{partition_db_klass}.module_eval(&block) if block_given?
+          #{partition_db_klass}
+        end
+        PART_PROC_END
+      end # acts_as_partitionable
+      
+      
+      module ReadonlyInstanceMethods #:nodoc:
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+        
+        module ClassMethods
+          
+          def readonly(&block)
+            self.partition(&block)
+          end
+          
+        end # ClassMethods
+      end # ReadonlyInstanceMethods
+      
+	  end # ClassMethods
+	  
+  end # Partitionable
+end # Acts
+
+ActiveRecord::Base.send :include, Acts::Partitionable

data/lib/connection_pool.rb

@@ -0,0 +1,64 @@
+# CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+# This source code may not be disclosed to others, used or reproduced without the written permission of Revolution Health Group.
+module ActiveRecord
+  class Base
+    class << self
+      alias_method :no_cp_remove_connection, :remove_connection
+      alias_method :no_cp_establish_connection, :establish_connection
+            
+      @@pooled_connections ||= {}
+      def pooled_connections
+        @@pooled_connections[Thread.current.object_id] ||= {}
+      end
+      
+      def close_all_connections
+        pooled_connections.each do | key, value | 
+          pooled_connections.delete(key)
+          active_connections.select { |klass, konn| no_cp_remove_connection(klass.constantize) if konn == value[:connection] } 
+        end
+      end
+      
+      def remove_connection(klass=self)
+        konn = active_connections[klass.name]
+        conn_key = nil
+        pooled_connections.each { |key, value| conn_key = key if value != nil && value[:connection] == konn }
+        if conn_key != nil
+          pooled_connections[conn_key][:count] -= 1
+          if pooled_connections[conn_key][:count] > 0
+            # remove it from the active list so that AR wont disconnect until 0 references
+            active_connections.delete(klass.name)
+          else
+            # must be time to clean up.
+            pooled_connections.delete(conn_key)
+          end
+        end
+        no_cp_remove_connection(klass)
+      end # remove_connection
+      
+      def establish_connection(spec = nil)
+        if spec != nil and spec.kind_of?(ActiveRecord::Base::ConnectionSpecification)
+          @partitionable_adapter_methods ||= []
+          if not @partitionable_adapter_methods.include?(spec.adapter_method.to_s)
+            @partitionable_adapter_methods << (spec.adapter_method.to_s)
+            self.class_eval <<-REUSE_END
+              def self.#{spec.adapter_method}(config)
+                conn_key = config.to_s
+                if not pooled_connections.key?(conn_key)
+                  pooled_connections[conn_key] = { :connection => super(config), :count => 1 }
+                elsif pooled_connections[conn_key] != nil
+                  pooled_connections[conn_key][:count] += 1
+                end
+                pooled_connections[conn_key][:connection] rescue nil
+              end
+            REUSE_END
+          end
+        end
+        no_cp_establish_connection(spec)
+      end # establish_connection
+	  end
+  end # Pool
+end # Connection
+
+#ActiveRecord::Base.send :include, Connection::Pool
+#ActiveRecord::Base.extend Connection::Pool::ConnectionReuseMethods
+

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: acts_as_partitionable
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-04-17 00:00:00 -04:00
+summary: acts_as_partitionable allows one to use multiple DBs to partition data for models
+require_paths: 
+- lib
+email: rails-trunk@revolution.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- RHG Team
+files: 
+- lib/acts_as_partitionable.rb
+- lib/connection_pool.rb
+- README
+- MIT-LICENSE
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+