data_fabric 1.1.0 → 1.2.0

data/example22/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/example22/script/about

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+$LOAD_PATH.unshift "#{RAILTIES_PATH}/builtin/rails_info"
+require 'commands/about'

data/example22/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/console'

data/example22/script/dbconsole

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/dbconsole'

data/example22/script/destroy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/destroy'

data/example22/script/generate

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/generate'

data/example22/script/performance/benchmarker

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/performance/benchmarker'

data/example22/script/performance/profiler

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/performance/profiler'

data/example22/script/performance/request

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/performance/request'

data/example22/script/plugin

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/plugin'

data/example22/script/process/inspector

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/process/inspector'

data/example22/script/process/reaper

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/process/reaper'

data/example22/script/process/spawner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../config/boot'
+require 'commands/process/spawner'

data/example22/script/runner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/runner'

data/example22/script/server

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/server'

data/example22/test/fixtures/accounts.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+
+<% %w(fiveruns google yahoo microsoft).each_with_index do |name, idx| %>
+<%= name %>:
+  name: <%= name %> 
+  shard: <%= idx % 2 %>
+<% end %>

data/example22/test/functional/accounts_controller_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class AccountsControllerTest < ActionController::TestCase
+  fixtures :accounts
+  
+  def test_index
+    get :index
+    assert_response :success
+    assert assigns(:accounts)
+    assert_equal 4, assigns(:accounts).size
+  end
+end

data/example22/test/integration/account_figments_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class AccountFigmentsTest < ActionController::IntegrationTest
+
+  def test_create_account_and_figments
+    conn0 = db_connection "shard_0_test"
+    conn1 = db_connection "shard_1_test"
+    conn0.clear 'figments'
+    conn1.clear 'figments'
+    assert_equal 0, conn0.count_for('figments')
+    assert_equal 0, conn1.count_for('figments')
+
+    new_session(0) do |user|
+      user.goes_home
+      mike = user.creates_account('mike', '0')
+      user.selects_account(mike)
+      before = mike.figments.size
+      user.creates_figment(14)
+      mike.figments.reload
+      assert_equal before + 1, mike.figments.size
+      assert_equal 14, mike.figments.first.value
+    end
+
+    # Bypass data_fabric and verify the figment went to shard 0.
+    assert_equal 1, conn0.count_for('figments')
+    assert_equal 0, conn1.count_for('figments')
+
+    new_session(1) do |user|
+      user.goes_home
+      bob = user.creates_account('bob', '1')
+      user.selects_account(bob)
+      before = bob.figments.size
+      user.creates_figment(66)
+      bob.figments.reload
+      assert_equal before + 1, bob.figments.size
+      assert_equal 66, bob.figments.first.value
+    end
+
+    # Bypass data_fabric and verify the figment went to shard 1.
+    assert_equal 1, conn0.count_for('figments')
+    assert_equal 1, conn1.count_for('figments')
+  end
+
+  private
+  
+  def db_connection(conf)
+    conn = ActiveRecord::Base.sqlite3_connection(HashWithIndifferentAccess.new(ActiveRecord::Base.configurations[conf]))
+    def conn.count_for(table)
+      Integer(execute("select count(*) as c from #{table}")[0]['c'])
+    end
+    def conn.clear(table)
+      execute("delete from #{table}")
+    end
+    conn
+  end
+
+  def new_session(shard)
+    open_session do |sess|
+      DataFabric.activate_shard :shard => shard do
+        sess.extend(Operations)
+        yield sess if block_given?
+      end
+    end
+  end
+
+  module Operations
+    def goes_home
+      get accounts_path
+      assert_response :success
+    end
+
+    def creates_account(name, shard)
+      post accounts_path, :acct => { :name => name, :shard => shard }
+      assert_response :redirect
+      follow_redirect!
+      assert_response :success
+      assert_template "accounts/index"
+      Account.find_by_name(name)
+    end
+
+    def selects_account(account)
+      get choose_account_path(account)
+      assert_response :redirect
+      follow_redirect!
+      assert_response :success
+      assert_template "accounts/index"
+    end
+    
+    def creates_figment(value)
+      post figments_path, :figment => { :value => value }
+      assert_response :redirect
+      follow_redirect!
+      assert_response :success
+      assert_template "accounts/index"
+    end
+  end
+end

data/example22/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionController::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/example22/test/test_helper.rb

@@ -0,0 +1,38 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/lib/data_fabric.rb

@@ -45,7 +45,13 @@ module DataFabric
   def self.init
     logger = ActiveRecord::Base.logger unless logger
     log { "Loading data_fabric #{DataFabric::Version::STRING} with ActiveRecord #{ActiveRecord::VERSION::STRING}" }
-    ActiveRecord::Base.send(:include, self)
+
+    if ActiveRecord::VERSION::STRING < '2.2.0'
+      require 'data_fabric/ar20'
+    else
+      require 'data_fabric/ar22'
+    end
+    ActiveRecord::Base.send(:include, DataFabric::Extensions)
   end
   
   def self.activate_shard(shards, &block)
@@ -89,11 +95,6 @@ module DataFabric
     Thread.current[:shards] and Thread.current[:shards][group.to_s]
   end
 
-  def self.included(model)
-    # Wire up ActiveRecord::Base
-    model.extend ClassMethods
-  end
-
   def self.ensure_setup
     Thread.current[:shards] = {} unless Thread.current[:shards]
   end
@@ -102,130 +103,4 @@ module DataFabric
     logger && logger.add(level, &block)
   end
 
-  # Class methods injected into ActiveRecord::Base
-  module ClassMethods
-    def data_fabric(options)
-      proxy = DataFabric::ConnectionProxy.new(self, options)
-      ActiveRecord::Base.active_connections[name] = proxy
-      
-      raise ArgumentError, "data_fabric does not support ActiveRecord's allow_concurrency = true" if allow_concurrency
-      DataFabric.log { "Creating data_fabric proxy for class #{name}" }
-    end
-  end
-  
-  class StringProxy
-    def initialize(&block)
-      @proc = block
-    end
-    def to_s
-      @proc.call
-    end
-  end
-
-  class ConnectionProxy
-    def initialize(model_class, options)
-      @model_class = model_class      
-      @replicated  = options[:replicated]
-      @shard_group = options[:shard_by]
-      @prefix      = options[:prefix]
-      @role        = 'slave' if @replicated
-
-      @model_class.send :include, ActiveRecordConnectionMethods if @replicated
-    end
-    
-    delegate :insert, :update, :delete, :create_table, :rename_table, :drop_table, :add_column, :remove_column, 
-      :change_column, :change_column_default, :rename_column, :add_index, :remove_index, :initialize_schema_information,
-      :dump_schema_information, :execute, :execute_ignore_duplicate, :to => :master
-    
-    def cache(&block)
-      connection.cache(&block)
-    end
-
-    def transaction(start_db_transaction = true, &block)
-      with_master { connection.transaction(start_db_transaction, &block) }
-    end
-
-    def method_missing(method, *args, &block)
-      DataFabric.log(Logger::DEBUG) { "Calling #{method} on #{connection}" }
-      connection.send(method, *args, &block)
-    end
-    
-    def connection_name
-      connection_name_builder.join('_')
-    end
-    
-    def disconnect!
-      if connected?
-        connection.disconnect! 
-        cached_connections[connection_name] = nil
-      end
-    end
-    
-    def verify!(arg)
-      connection.verify!(arg) if connected?
-    end
-    
-    def with_master
-      # Allow nesting of with_master.
-      old_role = @role
-      set_role('master')
-      yield
-    ensure
-      set_role(old_role)
-    end
-
-  private
-
-    def cached_connections
-      @cached_connections ||= {}
-    end
-
-    def connection_name_builder
-      @connection_name_builder ||= begin
-        clauses = []
-        clauses << @prefix if @prefix
-        clauses << @shard_group if @shard_group
-        clauses << StringProxy.new { DataFabric.active_shard(@shard_group) } if @shard_group
-        clauses << RAILS_ENV
-        clauses << StringProxy.new { @role } if @replicated
-        clauses
-      end
-    end
-    
-    def connection
-      name = connection_name
-      if not connected?
-        config = ActiveRecord::Base.configurations[name]
-        raise ArgumentError, "Unknown database config: #{name}, have #{ActiveRecord::Base.configurations.inspect}" unless config
-        DataFabric.log { "Connecting to #{name}" }
-        @model_class.establish_connection(config)
-        cached_connections[name] = @model_class.connection
-        @model_class.active_connections[@model_class.name] = self
-      end
-      cached_connections[name].verify!(3600)
-      cached_connections[name]
-    end
-
-    def connected?
-      DataFabric.shard_active_for?(@shard_group) and cached_connections[connection_name]
-    end
-
-    def set_role(role)
-      @role = role if @replicated
-    end
-    
-    def master
-      with_master { return connection }
-    end
-  end
-
-  module ActiveRecordConnectionMethods
-    def self.included(base)
-      base.alias_method_chain :reload, :master
-    end
-
-    def reload_with_master(*args, &block)
-      connection.with_master { reload_without_master }
-    end
-  end
 end

data/lib/data_fabric/ar20.rb

@@ -0,0 +1,133 @@
+module DataFabric
+  module Extensions
+    def self.included(model)
+      # Wire up ActiveRecord::Base
+      model.extend ClassMethods
+    end
+
+    # Class methods injected into ActiveRecord::Base
+    module ClassMethods
+      def data_fabric(options)
+        proxy = DataFabric::ConnectionProxy.new(self, options)
+        ActiveRecord::Base.active_connections[name] = proxy
+
+        raise ArgumentError, "data_fabric does not support ActiveRecord's allow_concurrency = true" if allow_concurrency
+        DataFabric.log { "Creating data_fabric proxy for class #{name}" }
+      end
+    end
+  end
+
+  class ConnectionProxy
+    def initialize(model_class, options)
+      @model_class = model_class      
+      @replicated  = options[:replicated]
+      @shard_group = options[:shard_by]
+      @prefix      = options[:prefix]
+      @role        = 'slave' if @replicated
+
+      @model_class.send :include, ActiveRecordConnectionMethods if @replicated
+    end
+
+    delegate :insert, :update, :delete, :create_table, :rename_table, :drop_table, :add_column, :remove_column, 
+      :change_column, :change_column_default, :rename_column, :add_index, :remove_index, :initialize_schema_information,
+      :dump_schema_information, :execute, :execute_ignore_duplicate, :to => :master
+
+    delegate :insert_many, :to => :master # ar-extensions bulk insert support
+
+    def transaction(start_db_transaction = true, &block)
+      with_master { connection.transaction(start_db_transaction, &block) }
+    end
+
+    def method_missing(method, *args, &block)
+      DataFabric.log(Logger::DEBUG) { "Calling #{method} on #{connection}" }
+      connection.send(method, *args, &block)
+    end
+
+    def connection_name
+      connection_name_builder.join('_')
+    end
+
+    def disconnect!
+      if connected?
+        connection.disconnect! 
+        cached_connections[connection_name] = nil
+      end
+    end
+
+    def verify!(arg)
+      connection.verify!(arg) if connected?
+    end
+
+    def with_master
+      # Allow nesting of with_master.
+      old_role = @role
+      set_role('master')
+      yield
+    ensure
+      set_role(old_role)
+    end
+
+  private
+
+    def cached_connections
+      @cached_connections ||= {}
+    end
+
+    def connection_name_builder
+      @connection_name_builder ||= begin
+        clauses = []
+        clauses << @prefix if @prefix
+        clauses << @shard_group if @shard_group
+        clauses << StringProxy.new { DataFabric.active_shard(@shard_group) } if @shard_group
+        clauses << RAILS_ENV
+        clauses << StringProxy.new { @role } if @replicated
+        clauses
+      end
+    end
+
+    def connection
+      name = connection_name
+      if not connected?
+        config = ActiveRecord::Base.configurations[name]
+        raise ArgumentError, "Unknown database config: #{name}, have #{ActiveRecord::Base.configurations.inspect}" unless config
+        DataFabric.log { "Connecting to #{name}" }
+        @model_class.establish_connection(config)
+        cached_connections[name] = @model_class.connection
+        @model_class.active_connections[@model_class.name] = self
+      end
+      cached_connections[name].verify!(3600)
+      cached_connections[name]
+    end
+
+    def connected?
+      DataFabric.shard_active_for?(@shard_group) and cached_connections[connection_name]
+    end
+
+    def set_role(role)
+      @role = role if @replicated
+    end
+
+    def master
+      with_master { return connection }
+    end
+  end
+
+  module ActiveRecordConnectionMethods
+    def self.included(base)
+      base.alias_method_chain :reload, :master
+    end
+
+    def reload_with_master(*args, &block)
+      connection.with_master { reload_without_master }
+    end
+  end
+
+  class StringProxy
+    def initialize(&block)
+      @proc = block
+    end
+    def to_s
+      @proc.call
+    end
+  end
+end