activerecord-turntable 1.0.0

data/lib/active_record/turntable/mixer/fader/update_shards_merge_result.rb

@@ -0,0 +1,17 @@
+module ActiveRecord::Turntable
+  class Mixer
+    class Fader
+      class UpdateShardsMergeResult < Fader
+        def execute
+          @proxy.shards_transaction(@shards_query_hash.keys) do
+            @shards_query_hash.map do |shard, query|
+              args = @args.dup
+              args[1] = args[1].dup if args[1].present?
+              shard.connection.send(@called_method, query, *@args, &@block)
+            end.inject(&:+)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/turntable/pool_proxy.rb

@@ -0,0 +1,56 @@
+module ActiveRecord::Turntable
+  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 PoolProxy
+    def initialize(proxy)
+      @proxy = proxy
+    end
+
+    def connection
+      @proxy
+    end
+
+    def spec
+      @proxy.spec
+    end
+
+
+    def with_connection
+      yield @proxy
+    end
+
+    def connected?
+      @proxy.connected?
+    end
+
+    if ActiveRecord::VERSION::STRING > '3.1'
+      %w(columns_hash column_defaults primary_keys).each do |name|
+        define_method(name.to_sym) do
+          @proxy.send(name.to_sym)
+        end
+      end
+
+      %w(table_exists? columns).each do |name|
+        define_method(name.to_sym) do |*args|
+          @proxy.send(name.to_sym, *args)
+        end
+      end
+    end
+
+    %w(disconnect! release_connection clear_all_connections! clear_reloadable_connections! clear_stale_cached_connections! verify_active_connections!).each do |name|
+      define_method(name.to_sym) do
+        @proxy.shards.values.each do |pool|
+          pool.connection_pool.send(name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/turntable/rack.rb

@@ -0,0 +1,5 @@
+module ActiveRecord::Turntable
+  module Rack
+    autoload :ConnectionManagement, 'active_record/turntable/rack/connection_management'
+  end
+end

data/lib/active_record/turntable/rack/connection_management.rb

@@ -0,0 +1,18 @@
+module ActiveRecord::Turntable
+  module Rack
+    class ConnectionManagement
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        unless env.key?("rack.test")
+          ActiveRecord::Base.connection_handler.clear_all_connections!
+          ActiveRecord::Base.clear_all_connections!
+        end
+      end
+    end
+  end
+end

data/lib/active_record/turntable/railtie.rb

@@ -0,0 +1,14 @@
+module ActiveRecord::Turntable
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "active_record/turntable/railties/databases.rake"
+    end
+
+    # rails loading hook
+    ActiveSupport.on_load(:before_initialize) do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.send(:include, ActiveRecord::Turntable)
+      end
+    end
+  end
+end

data/lib/active_record/turntable/railties/databases.rake

@@ -0,0 +1,205 @@
+require 'active_record/turntable'
+ActiveRecord::SchemaDumper.send(:include, ActiveRecord::Turntable::ActiveRecordExt::SchemaDumper)
+
+db_namespace = namespace :db do
+  task :create do
+    if Rails.env.development? && ActiveRecord::Base.configurations['test'] && ActiveRecord::Base.configurations["test"]["shards"]
+      dbs = ActiveRecord::Base.configurations["test"]["shards"].values
+      dbs += ActiveRecord::Base.configurations["test"]["seq"].values if ActiveRecord::Base.configurations["test"]["seq"]
+      dbs.each do |shard_config|
+        create_database(shard_config)
+      end
+    end
+    if shard_configs = ActiveRecord::Base.configurations[Rails.env || 'development']["shards"]
+      dbs = shard_configs.values
+      dbs += ActiveRecord::Base.configurations[Rails.env || 'development']["seq"].values if ActiveRecord::Base.configurations[Rails.env || 'development']["seq"]
+      dbs.each do |shard_config|
+        create_database(shard_config)
+      end
+    end
+    config = ActiveRecord::Base.configurations[Rails.env || 'development']
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  task :drop do
+    config = ActiveRecord::Base.configurations[Rails.env || 'development']
+    shard_configs = config["shards"]
+    if shard_configs
+      dbs = shard_configs.values
+      dbs += ActiveRecord::Base.configurations[Rails.env || 'development']["seq"].values if ActiveRecord::Base.configurations[Rails.env || 'development']["seq"]
+      dbs.each do |shard_config|
+        begin
+          drop_database(shard_config)
+        rescue Exception => e
+          $stderr.puts "Couldn't drop #{ config['database']} : #{e.inspect}"
+        end
+      end
+    end
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  namespace :schema do
+    task :dump do
+      require 'active_record/schema_dumper'
+      config = ActiveRecord::Base.configurations[Rails.env]
+      shard_configs = config["shards"]
+      shard_configs.merge!(config["seq"]) if config["seq"]
+      if shard_configs
+        shard_configs.each do |name, config|
+          filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema-#{name}.rb"
+          File.open(filename, "w:utf-8") do |file|
+            ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+          end
+        end
+      end
+      ActiveRecord::Base.establish_connection(config)
+      db_namespace['schema:dump'].reenable
+    end
+
+    desc 'Load a schema.rb file into the database'
+    task :load => :environment do
+      config = ActiveRecord::Base.configurations[Rails.env]
+      shard_configs = config["shards"]
+      shard_configs.merge!(config["seq"]) if config["seq"]
+      if shard_configs
+        shard_configs.each do |name, config|
+          ActiveRecord::Base.establish_connection(config)
+          file = ENV['SCHEMA'] || "#{Rails.root}/db/schema-#{name}.rb"
+          if File.exists?(file)
+            load(file)
+          else
+            abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded'}
+          end
+        end
+      end
+      ActiveRecord::Base.establish_connection(config)
+    end
+  end
+
+  namespace :structure do
+    desc 'Dump the database structure to an SQL file'
+    task :dump => :environment do
+      config = ActiveRecord::Base.configurations[Rails.env]
+      shard_configs = config["shards"]
+      shard_configs.merge!(config["seq"]) if config["seq"]
+      if shard_configs
+        shard_configs.each do |name, config|
+          case config['adapter']
+          when /mysql/, 'oci', 'oracle'
+            ActiveRecord::Base.establish_connection(config)
+            File.open("#{Rails.root}/db/#{Rails.env}_#{name}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+          when /postgresql/
+            ENV['PGHOST']     = config['host'] if config['host']
+            ENV['PGPORT']     = config["port"].to_s if config['port']
+            ENV['PGPASSWORD'] = config['password'].to_s if config['password']
+            search_path = config['schema_search_path']
+            unless search_path.blank?
+              search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
+            end
+            `pg_dump -i -U "#{config['username']}" -s -x -O -f db/#{Rails.env}_#{name}_structure.sql #{search_path} #{config['database']}`
+            raise 'Error dumping database' if $?.exitstatus == 1
+          when /sqlite/
+            dbfile = config['database'] || config['dbfile']
+            `sqlite3 #{dbfile} .schema > db/#{Rails.env}_#{name}_structure.sql`
+          when 'sqlserver'
+            `smoscript -s #{config['host']} -d #{config['database']} -u #{config['username']} -p #{config['password']} -f db\\#{Rails.env}_#{name}_structure.sql -A -U`
+          when "firebird"
+            set_firebird_env(config)
+            db_string = firebird_db_string(config)
+            sh "isql -a #{db_string} > #{Rails.root}/db/#{Rails.env}_#{name}_structure.sql"
+          else
+            raise "Task not supported by '#{config["adapter"]}'"
+          end
+
+          if ActiveRecord::Base.connection.supports_migrations?
+            File.open("#{Rails.root}/db/#{Rails.env}_#{name}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+          end
+        end
+      end
+      ActiveRecord::Base.establish_connection(config)
+    end
+  end
+
+
+  namespace :test do
+    # desc "Recreate the test databases from the development structure"
+    task :clone_structure do
+      config = ActiveRecord::Base.configurations[Rails.env]
+      shard_configs = config["shards"]
+      shard_configs.merge!(config["seq"]) if config["seq"]
+      if shard_configs
+        shard_configs.each do |name, config|
+          case config['adapter']
+          when /mysql/
+            ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+            IO.readlines("#{Rails.root}/db/#{Rails.env}_#{name}_structure.sql").join.split("\n\n").each do |table|
+              ActiveRecord::Base.connection.execute(table)
+            end
+          when /postgresql/
+            ENV['PGHOST']     = config['host'] if config['host']
+            ENV['PGPORT']     = config['port'].to_s if config['port']
+            ENV['PGPASSWORD'] = config['password'].to_s if config['password']
+            `psql -U "#{config['username']}" -f "#{Rails.root}/db/#{Rails.env}#{name}_structure.sql" #{config['database']} #{config['template']}`
+          when /sqlite/
+            dbfile = config['database'] || config['dbfile']
+            `sqlite3 #{dbfile} < "#{Rails.root}/db/#{Rails.env}#{name}_structure.sql"`
+          when 'sqlserver'
+            `sqlcmd -S #{config['host']} -d #{config['database']} -U #{config['username']} -P #{config['password']} -i db\\#{Rails.env}#{name}_structure.sql`
+          when 'oci', 'oracle'
+            ActiveRecord::Base.establish_connection(config)
+            IO.readlines("#{Rails.root}/db/#{Rails.env}#{name}_structure.sql").join.split(";\n\n").each do |ddl|
+              ActiveRecord::Base.connection.execute(ddl)
+            end
+          when 'firebird'
+            set_firebird_env(config)
+            db_string = firebird_db_string(config)
+            sh "isql -i #{Rails.root}/db/#{Rails.env}#{name}_structure.sql #{db_string}"
+          else
+            raise "Task not supported by '#{config['adapter']}'"
+          end
+        end
+      end
+      ActiveRecord::Base.establish_connection(config)
+    end
+
+    # desc "Empty the test database"
+    task :purge => :environment do
+      config = ActiveRecord::Base.configurations[Rails.env]
+      shard_configs = config["shards"]
+      shard_configs.merge!(config["seq"]) if config["seq"]
+      if shard_configs
+        shard_configs.each do |name, config|
+          case config['adapter']
+          when /mysql/
+            ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::Base.connection.recreate_database(config['database'], mysql_creation_options(config))
+          when /postgresql/
+            ActiveRecord::Base.clear_active_connections!
+            drop_database(config)
+            create_database(config)
+          when /sqlite/
+            dbfile = config['database'] || config['dbfile']
+            File.delete(dbfile) if File.exist?(dbfile)
+          when 'sqlserver'
+            # TODO
+          when "oci", "oracle"
+            ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+              ActiveRecord::Base.connection.execute(ddl)
+            end
+          when 'firebird'
+            ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::Base.connection.recreate_database!
+          else
+            raise "Task not supported by '#{config['adapter']}'"
+          end
+        end
+      end
+      ActiveRecord::Base.establish_connection(config)
+    end
+  end
+
+end
+

data/lib/active_record/turntable/seq_shard.rb

@@ -0,0 +1,14 @@
+module ActiveRecord::Turntable
+  class SeqShard < Shard
+    private
+    def retrieve_connection_pool
+      ActiveRecord::Base.turntable_connections[name] ||=
+        begin
+          config = ActiveRecord::Base.configurations[Rails.env]["seq"][name]
+          raise ArgumentError, "Unknown database config: #{name}, have #{ActiveRecord::Base.configurations.inspect}" unless config
+          ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec_for(config))
+        end
+    end
+  end
+end
+

data/lib/active_record/turntable/sequencer.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# 採番
+#
+
+module ActiveRecord::Turntable
+  class Sequencer
+    autoload :Api, "active_record/turntable/sequencer/api"
+    autoload :Mysql, "active_record/turntable/sequencer/mysql"
+    @@sequence_types = {
+      :api => Api,
+      :mysql => Mysql
+    }
+
+    @@sequences = {}
+    @@tables = {}
+    cattr_reader :sequences, :tables
+
+    def self.build(klass)
+      seq_config_name = ActiveRecord::Base.turntable_config["clusters"][klass.turntable_cluster_name.to_s]["seq"]["connection"]
+      seq_config = ActiveRecord::Base.configurations[Rails.env]["seq"][seq_config_name]
+      seq_type = (seq_config["seq_type"] ? seq_config["seq_type"].to_sym : :mysql)
+      @@tables[klass.table_name] ||= (@@sequences[sequence_name(klass.table_name, klass.primary_key)] ||= @@sequence_types[seq_type].new(klass, seq_config))
+    end
+
+    def self.has_sequencer?(table_name)
+      !!@@tables[table_name]
+    end
+
+    def self.sequence_name(table_name, pk)
+      "#{ table_name}_#{pk || 'id'}_seq"
+    end
+
+    def self.table_name(seq_name)
+      seq_name.split('_').first
+    end
+
+    def next_sequence_value
+      raise ActiveRecord::Turntable::NotImplementedError
+    end
+
+    def current_sequence_value
+      raise ActiveRecord::Turntable::NotImplementedError
+    end
+  end
+end

data/lib/active_record/turntable/sequencer/api.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# APIサーバを利用しての採番
+#
+require 'httpclient'
+
+module ActiveRecord::Turntable
+  class Sequencer
+    class Api < Sequencer
+      API_ENDPOINT = '/sequences/'
+      NEXT_VALUE_ENDPOINT = '/new'
+
+      def initialize(klass, options = {})
+        @klass = klass
+        @options = options
+        @host = @options["api_host"]
+        @port = @options["api_port"]
+        @client = HTTPClient.new
+      end
+
+      def next_sequence_value(sequence_name)
+        res = @client.get_content("http://#{@host}:#{@port}#{API_ENDPOINT}#{sequence_name}#{NEXT_VALUE_ENDPOINT}")
+        new_id = res.to_i
+        raise SequenceNotFoundError if new_id.zero?
+        return new_id
+      end
+
+      def current_sequence_value(sequence_name)
+        res = @client.get_content("http://#{@host}:#{@port}#{API_ENDPOINT}#{sequence_name}")
+        current_id = res.to_i
+        raise SequenceNotFoundError if current_id.zero?
+        return current_id
+      end
+    end
+  end
+end

data/lib/active_record/turntable/sequencer/mysql.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+#
+# 採番
+#
+
+module ActiveRecord::Turntable
+  class Sequencer
+    class Mysql < Sequencer
+      def initialize(klass, options = {})
+        @klass = klass
+        @options = options
+      end
+
+      def next_sequence_value(sequence_name)
+        conn = @klass.connection.seq.connection
+        conn.execute "BEGIN"
+        conn.execute "UPDATE #{@klass.connection.quote_table_name(sequence_name)} SET id=LAST_INSERT_ID(id+1)"
+        conn.execute "COMMIT"
+        res = conn.execute("SELECT LAST_INSERT_ID()")
+        new_id = res.first.first.to_i
+        raise SequenceNotFoundError if new_id.zero?
+        return new_id
+      end
+
+      def current_sequence_value(sequence_name)
+        res = @klass.connection.seq.connection.execute("SELECT id FROM #{@klass.connection.quote_table_name(sequence_name)} LIMIT 1")
+        current_id = res.first.first.to_i
+        return current_id
+      end
+    end
+  end
+end