data_fabric 1.1.0 → 1.2.0

data/example/vendor/plugins/data_fabric/lib/data_fabric/ar22.rb

@@ -0,0 +1,172 @@
+module DataFabric
+  module Extensions
+    def self.included(model)
+      # Wire up ActiveRecord::Base
+      model.extend ClassMethods
+      ConnectionProxy.shard_pools = {}
+    end
+
+    # Class methods injected into ActiveRecord::Base
+    module ClassMethods
+      def data_fabric(options)
+        DataFabric.log { "Creating data_fabric proxy for class #{name}" }
+        @proxy = DataFabric::ConnectionProxy.new(self, options)
+        
+        class << self
+          def connection
+            @proxy
+          end
+
+          def connected?
+            @proxy.connected?
+          end
+
+          def remove_connection(klass)
+            DataFabric.log(Logger::ERROR) { "remove_connection not implemented by data_fabric" }
+          end
+
+          def connection_pool
+            raise "dynamic connection switching means you cannot get direct access to a pool"
+          end
+        end
+      end
+    end
+  end
+
+  class ConnectionProxy
+    cattr_accessor :shard_pools
+    
+    def initialize(model_class, options)
+      @model_class = model_class      
+      @replicated  = options[:replicated]
+      @shard_group = options[:shard_by]
+      @prefix      = options[:prefix]
+      set_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)
+      # Transaction is not re-entrant in SQLite 3 so we
+      # need to track if we've already started an XA to avoid
+      # calling it twice.
+      return yield if in_transaction?
+
+      with_master do
+        connection.transaction(start_db_transaction, &block) 
+      end
+    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 with_master
+      # Allow nesting of with_master.
+      old_role = current_role
+      set_role('master')
+      yield
+    ensure
+      set_role(old_role)
+    end
+    
+  private
+  
+    def in_transaction?
+      current_role == 'master'
+    end
+    
+    def current_pool
+      name = connection_name
+      self.class.shard_pools[name] ||= begin
+        config = ActiveRecord::Base.configurations[name]
+        raise ArgumentError, "Unknown database config: #{name}, have #{ActiveRecord::Base.configurations.inspect}" unless config
+        ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
+      end
+    end
+    
+    def spec_for(config)
+      # XXX This looks pretty fragile.  Will break if AR changes how it initializes connections and adapters.
+      config = config.symbolize_keys
+      adapter_method = "#{config[:adapter]}_connection"
+      initialize_adapter(config[:adapter])
+      ActiveRecord::Base::ConnectionSpecification.new(config, adapter_method)
+    end
+    
+    def initialize_adapter(adapter)
+      begin
+        require 'rubygems'
+        gem "activerecord-#{adapter}-adapter"
+        require "active_record/connection_adapters/#{adapter}_adapter"
+      rescue LoadError
+        begin
+          require "active_record/connection_adapters/#{adapter}_adapter"
+        rescue LoadError
+          raise "Please install the #{adapter} adapter: `gem install activerecord-#{adapter}-adapter` (#{$!})"
+        end
+      end
+    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 { current_role } if @replicated
+        clauses
+      end
+    end
+    
+    def connection
+      current_pool.connection
+    end
+
+    def active?
+      DataFabric.shard_active_for?(@shard_group)
+    end
+
+    def set_role(role)
+      Thread.current[:data_fabric_role] = role
+    end
+    
+    def current_role
+      Thread.current[:data_fabric_role]
+    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

data/example/vendor/plugins/data_fabric/lib/data_fabric/version.rb

@@ -0,0 +1,5 @@
+module DataFabric
+	module Version
+		STRING = "1.2.0"
+	end
+end

data/example22/Rakefile

@@ -0,0 +1,58 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'
+
+require 'fileutils'
+include FileUtils::Verbose
+
+namespace :db do
+    task :migrate do
+      require 'erb'
+      require 'logger'
+      require 'active_record'
+      reference = YAML::load(ERB.new(IO.read("config/database.yml")).result)
+      env = RAILS_ENV = ENV['RAILS_ENV'] || 'development'
+      ActiveRecord::Base.logger = Logger.new(STDOUT)
+      ActiveRecord::Base.logger.level = Logger::WARN
+      ActiveRecord::Base.configurations = reference.dup
+      old_config = reference[env]
+      reference.each_key do |name|
+        next unless name.include? env
+        next if name.include? 'slave' # Replicated databases should not be touched directly
+
+        puts "Migrating #{name}"
+        ActiveRecord::Base.clear_active_connections!
+        ActiveRecord::Base.configurations[env] = reference[name]
+        ActiveRecord::Base.establish_connection RAILS_ENV
+        ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+      end
+    end
+end
+
+namespace :app do
+  task :prepare => [:clean, :copy_plugin, :migrate]
+
+  task :copy_plugin do
+    mkdir_p 'vendor/plugins/data_fabric'
+    cp_r '../lib', 'vendor/plugins/data_fabric'
+    cp '../init.rb', 'vendor/plugins/data_fabric'
+  end
+
+  task :clean do
+    rm_rf 'vendor/plugins/data_fabric'
+    rm_f 'db/*.sqlite3'
+  end
+
+	task :migrate do
+		sh "rake db:migrate"
+		sh "rake RAILS_ENV=test db:migrate"
+	end
+end

data/example22/app/controllers/accounts_controller.rb

@@ -0,0 +1,22 @@
+class AccountsController < ApplicationController
+  layout 'application'
+
+  def index
+    @accounts = Account.find(:all)
+  end
+  
+  def choose
+    @account = Account.find(params[:id])
+    if @account
+      session[:account_id] = @account.id
+      flash[:notice] = "Selected account: #{@account.name}"
+    end
+    redirect_to '/'
+  end
+  
+  def create
+    Account.create!(params[:acct])
+    flash[:notice] = "Account created successfully"
+    redirect_to '/'
+  end
+end

data/example22/app/controllers/application.rb

@@ -0,0 +1,39 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+
+  # See ActionController::RequestForgeryProtection for details
+  # Uncomment the :secret if you're not using the cookie session store
+  protect_from_forgery # :secret => '44f8cf8a0491c23ae99c031a900123cc'
+  
+  # See ActionController::Base for details 
+  # Uncomment this to filter the contents of submitted sensitive data parameters
+  # from your application log (in this case, all fields with names like "password"). 
+  # filter_parameter_logging :password
+	
+	before_filter :find_account
+	around_filter :select_shard
+
+	private
+	def find_account
+		aid = session[:account_id]
+		if aid && aid.to_i != 0
+		  begin
+		    @account = Account.find(Integer(aid))
+	    rescue ActiveRecord::RecordNotFound => e
+	      RAILS_DEFAULT_LOGGER.warn "No such account #{aid}, skipping..."
+	    end
+	  end
+	  session[:account_id] = nil unless @account
+	end
+
+	def select_shard(&block)
+	  if @account
+		  DataFabric.activate_shard(:shard => @account.shard, &block) 
+	  else
+	    yield
+    end
+	end
+end

data/example22/app/controllers/figments_controller.rb

@@ -0,0 +1,8 @@
+class FigmentsController < ApplicationController
+  
+  def create
+    @account.figments.create!(params[:figment])
+    flash[:notice] = "Figment created"
+    redirect_to '/'
+  end
+end

data/example22/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/example22/app/models/account.rb

@@ -0,0 +1,3 @@
+class Account < ActiveRecord::Base
+	has_many :figments
+end

data/example22/app/models/figment.rb

@@ -0,0 +1,4 @@
+class Figment < ActiveRecord::Base
+	data_fabric :shard_by => 'shard', :replicated => false
+	belongs_to :account
+end

data/example22/app/views/accounts/index.html.erb

@@ -0,0 +1,47 @@
+<hr/>
+<h2>Accounts</h2>
+<table>
+	<thead>
+		<tr><th>ID</th><th>Name</th><th>Shard</th><th>&nbsp;</th></tr>
+	</thead>
+	<tbody>
+<% @accounts.each do |account| %>
+	<tr>
+		<td><%= account.id %></td>
+		<td><%= account.name %></td>
+		<td><%= account.shard %></td>
+		<td><%= link_to 'Choose', choose_account_path(account) %></td>
+	</tr>
+<% end %>
+	</tbody>
+</table>
+<hr/>
+<h2>New Account</h2>
+<p>
+<% form_for :acct, :url => accounts_path do |f| %>
+	Name : <%= f.text_field :name %><br/>
+	Shard: <%= select 'acct', 'shard', [[0,0],[1,1]] %><br/>
+	<%= submit_tag 'Save' %>
+<% end %>
+</p>
+<hr/>
+<% if @account %>
+<h2>Current Account: <%= @account.name %></h2>
+	<table>
+		<thead>
+			<tr><th>ID</th><th>Account</th><th>Value</th></tr>
+		</thead>
+		<tbody>
+		<% @account.figments.each do |fig| %>
+		<tr>
+			<td><%= fig.id %></td>
+			<td><%= fig.account.name %></td>
+			<td><%= fig.value %></td>
+		</tr>
+		<% end %>
+		</tbody>
+	</table>
+	Add Fig: <% form_for :figment, :url => figments_path do |f| %><%= f.text_field :value %><%= submit_tag 'Save' %><% end %>
+<% else %>
+	<em>No account selected.</em>
+<% end %>

data/example22/app/views/layouts/application.html.erb

@@ -0,0 +1,8 @@
+<html>
+  <body>
+		<div id='flash' style="background-color: #DDFFDD;">
+			<%= flash[:notice] %>
+		</div>
+		<%= yield %>
+	</body>
+</html>

data/example22/config/boot.rb

@@ -0,0 +1,109 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!