yam-db-charmer 1.7.4.10 → 1.7.4.13

data/lib/db_charmer/active_record/class_attributes.rb

@@ -20,6 +20,10 @@ module DbCharmer
         @@db_charmer_connection_proxies[self.name]
       end
 
+      def reset_connection_proxies
+        @@db_charmer_connection_proxies = {}
+      end
+
       #-----------------------------------------------------------------------------
       @@db_charmer_default_connections = {}
       def db_charmer_default_connection=(conn)

data/lib/db_charmer/active_record/connection_switching.rb

@@ -36,8 +36,8 @@ module DbCharmer
         class << self
           # Make sure we check our accessors before going to the default connection retrieval method
           def connection_with_magic
-            if db_charmer_allocated_shard_connection 
-              return coerce_to_connection_proxy(db_charmer_allocated_shard_connection, true)
+            if db_charmer_allocated_shard_connection && self.get_shard_strategy == :horizontal
+              return coerce_to_connection_proxy(db_charmer_allocated_shard_connection[:config], true)
             end
             db_charmer_remapped_connection || db_charmer_connection_proxy || connection_without_magic
           end

data/lib/db_charmer/active_record/db_magic.rb

@@ -52,6 +52,17 @@ module DbCharmer
         end
       end
 
+      def exist_pg_database?(server_config, db_name)
+        config_no_db_name = server_config.clone
+        config_no_db_name['database'] = nil
+        establish_connection(config_no_db_name)
+        server_connection = ::ActiveRecord::Base.connection
+        sql = "SELECT datname FROM pg_database WHERE datname='#{db_name}'"
+        existing_dbs = server_connection.execute(sql)
+        server_connection.disconnect!
+        existing_dbs.first ? true : false
+      end
+
     private
 
       def setup_children_magic(opt)

data/lib/db_charmer/active_record/multi_db_proxy.rb

@@ -36,7 +36,7 @@ module DbCharmer
           if self.respond_to? :set_schema_table_name_prefix
             self.set_schema_table_name_prefix(con)
           end
-          
+
           # Chain call
           #Rails.logger.debug "MultiDbProxy#on_db: con=#{con} proxy_target=#{proxy_target}"
           return OnDbProxy.new(proxy_target, con) unless block_given?

data/lib/db_charmer/active_record/reflection.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Reflection
+    class AssociationReflection < MacroReflection
+      def table_name
+        klass.switch_connection_to(klass.db_charmer_allocated_shard_connection[:config]) if sharded_reflection?
+        @table_name = klass.table_name
+      end
+
+      def quoted_table_name
+        klass.switch_connection_to(klass.db_charmer_allocated_shard_connection[:config]) if sharded_reflection?
+        @quoted_table_name = klass.quoted_table_name
+      end
+
+      def sharded_reflection?
+        # TODO: put this logic in WF
+        if klass.db_charmer_allocated_shard_connection && klass.db_charmer_extended
+          return true;
+        end
+        return false
+      end
+    end
+  end
+end

data/lib/db_charmer/active_record/sharding.rb

@@ -15,14 +15,16 @@ module DbCharmer
       # The block passed to this function should return an object responding to key_field
       def create_with_allocated_shard(key_field = :id, &block)
         sharder = sharded_connection.sharder
-        group = sharder.least_loaded_group
-        shard_info = sharder.shard_info_by_group_id(group.id)
-        conn = sharder.shard_connection_config(shard_info, group.id)
+        old_conn = self.db_charmer_allocated_shard_connection
+        self.db_charmer_allocated_shard_connection ||= begin
+            group = sharder.least_loaded_group
+            shard_info = sharder.shard_info_by_group_id(group.id)
+            {:group => group, :shard_info => shard_info, :config => sharder.shard_connection_config(shard_info, group.id)}
+        end
         # Set global shard connection obj
-        self.db_charmer_allocated_shard_connection = conn
-        key_obj = on_db(conn, nil, &block)
-        self.db_charmer_allocated_shard_connection = nil
-        sharder.allocate_new_block_for_key_on_group(key_obj.send(key_field), group)
+        key_obj = on_db(self.db_charmer_allocated_shard_connection[:config], nil, &block)
+        sharder.allocate_new_block_for_key_on_group(key_obj.send(key_field), self.db_charmer_allocated_shard_connection[:group]) if old_conn.nil?
+        self.db_charmer_allocated_shard_connection = old_conn
         key_obj
       end
 

data/lib/db_charmer/sharding/method/db_block_group_map_base.rb

@@ -201,7 +201,7 @@ module DbCharmer
             "DbCharmer::Sharding::Method::DbBlockSchemaMap::Shard".classify.constantize
           end
         end
-        
+
         def shard_connections
           # Find all groups
           prepare_shard_models
@@ -238,24 +238,46 @@ module DbCharmer
 
         def create_shard_database(shard)
           conn_config = shard_connection_config_no_dbname(shard)
-          old_proxy = ::ActiveRecord::Base.db_charmer_connection_proxy
-          ::ActiveRecord::Base.switch_connection_to(conn_config)
-          sql = "SELECT datname FROM pg_database WHERE datname='#{shard.db_name}'"
-          existing_dbs = ::ActiveRecord::Base.connection.execute(sql)
-          unless existing_dbs.first
+          unless ::ActiveRecord::Base.exist_pg_database?(conn_config, shard.db_name)
+            old_proxy = ::ActiveRecord::Base.db_charmer_connection_proxy
+            ::ActiveRecord::Base.establish_connection(conn_config)
             ::ActiveRecord::Base.connection.create_database(shard.db_name, conn_config)
+            ::ActiveRecord::Base.connection.disconnect!
+            ::ActiveRecord::Base.switch_connection_to(old_proxy)
           end
-          ::ActiveRecord::Base.switch_connection_to(old_proxy)
         end
-        
+
         def drop_shard_database(shard)
           conn_config = shard_connection_config_no_dbname(shard)
+          conn_config_with_dbname = conn_config.clone.merge(:database => shard.db_name)
+          kill_connections(conn_config_with_dbname, true)
           old_proxy = ::ActiveRecord::Base.db_charmer_connection_proxy
-          ::ActiveRecord::Base.switch_connection_to(conn_config)
+          ::ActiveRecord::Base.establish_connection(conn_config)
+          puts "Dropping shard database: #{shard.inspect}"
           ::ActiveRecord::Base.connection.drop_database(shard.db_name)
+          ::ActiveRecord::Base.connection.disconnect!
           ::ActiveRecord::Base.switch_connection_to(old_proxy)
         end
 
+        # sets environment variables to be used by an exec'd psql process
+        def set_psql_env(config)
+          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]
+          ENV['PGUSER']     = config[:username].to_s if config[:username]
+        end
+
+        # kills all connections to a database
+        def kill_connections(config, verbose = false)
+          set_psql_env(config)
+          proclist_sql = "select pg_terminate_backend(procpid) from pg_stat_activity where datname='#{config[:database]}';"
+          cmd = "psql -U '#{config[:username]}' -c \"#{proclist_sql}\" -t"
+
+          puts "Killing connections to: #{config[:database]}"
+          puts cmd if verbose
+          system(cmd)
+        end
+
         def drop_all_shard_databases
           prepare_shard_models
           shard_class.all.each do |shard|

data/lib/db_charmer/sharding/method/db_block_schema_map.rb

@@ -51,7 +51,7 @@ module DbCharmer
           # They do not expose configs so we hack in and get the instance var
           # FIXME: Find a better way, maybe move config method to our ar extenstions
           slave_host = shard.respond_to?(:db_slave_host) ? shard.db_slave_host : ''
-          connection.config.clone.merge(
+          connection.instance_variable_get("@config").clone.merge(
             # Name for the connection factory
             :connection_name => connection_name,
             # Connection params
@@ -136,6 +136,7 @@ module DbCharmer
           end
           
           Group.switch_connection_to(old_connection)
+          group
         end
 
         def shard_connections
@@ -159,40 +160,51 @@ module DbCharmer
       # To be mixed in AR#base.
       # Allows a schema name to be set at the same time a db connection is selected.
       module SchemaTableNamePrefix
+
         def set_schema_table_name_prefix(con)
           
           #Rails.logger.debug "set_schema_table_name_prefix: self=#{self} @dbcharmer_table_name_prefix=#{@dbcharmer_table_name_prefix}"
           if con.is_a?(Hash) && con[:schema_name]
             new_prefix = con[:schema_name] + '.'
-            if self.to_s!='ActiveRecord::Base' && @dbcharmer_table_name_prefix.blank?
-              @orig_table_name = table_name if defined?(:original_table_name)
+            if @orig_table_name.blank? && self.to_s != "ActiveRecord::Base"
+              @orig_table_name = orig_table_name
             end
           else
             new_prefix = '' if self.to_s=='ActiveRecord::Base' # this is for migrations
           end
-          
-          # remove the old dbcharmer prefix first
-          if !@dbcharmer_table_name_prefix.blank? && @dbcharmer_table_name_prefix != new_prefix
-            self.table_name_prefix = self.table_name_prefix.gsub(/#{Regexp.escape(@dbcharmer_table_name_prefix)}/, '')
-          end
 
           # Set the new table_name_prefix
           if new_prefix && @dbcharmer_table_name_prefix != new_prefix
+            # remove the old dbcharmer prefix first
+            if !@dbcharmer_table_name_prefix.blank?
+              self.table_name_prefix = self.table_name_prefix.gsub(/#{Regexp.escape(@dbcharmer_table_name_prefix)}/, '')
+            end
+
             @dbcharmer_table_name_prefix = new_prefix
-            self.table_name_prefix = "#{new_prefix}#{self.table_name_prefix}"
+            self.table_name_prefix = new_prefix
 
             # Reset all forms of table_name that were memoized in Rails.
             # Don't do it in the context of migrations where the current class
             # is AR::Base and there is no actual table name.
             unless self.to_s=='ActiveRecord::Base'
               #Rails.logger.debug "set_schema_table_name_prefix: resetting"
-              reset_cached_table_name(@orig_table_name)
+              reset_cached_table_name(orig_table_name)
             end
           end
         end
 
         def orig_table_name
-          @orig_table_name ? @orig_table_name : table_name
+          # Polymorphic active record classes won't have orig_table_name defined and we'll add double prefixes without this logic, because table_name
+          # usees parent class tables
+          if self.superclass && self.superclass.respond_to?(:orig_table_name) && self.superclass.orig_table_name
+            self.superclass.orig_table_name
+          elsif self == ::ActiveRecord::Base
+            nil
+          elsif @orig_table_name
+            @orig_table_name 
+          else
+            self.table_name
+          end
         end
 
         # Rails memoizes table_name and table_name_prefix at the time the models are loaded.

data/lib/db_charmer/sharding.rb

@@ -18,7 +18,7 @@ module DbCharmer
 
     # name is the is the sharded_connection name passed to db_magic in the model
     def self.sharded_connection(name)
-      @@sharded_connections[name] or raise ArgumentError, "Invalid sharded connection name!"
+      @@sharded_connections[name.to_sym] or raise ArgumentError, "Invalid sharded connection name!"
     end
 
     # Return the DbCharmer::Sharding::Connection that matches name
@@ -42,5 +42,9 @@ module DbCharmer
       return unless sharder
       sharder.shard_class.where(:id => connection_config[:shard_id]).first
     end
+
+    def self.reset_connections
+      @@sharded_connections = {}
+    end
   end
 end

data/lib/db_charmer/version.rb

@@ -3,7 +3,7 @@ module DbCharmer
     MAJOR = 1
     MINOR = 7
     PATCH = 4
-    BUILD = 10
+    BUILD = 13
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

data/lib/db_charmer.rb

@@ -129,6 +129,7 @@ ActiveRecord::Base.send(:include, DbCharmer::ActiveRecord::MultiDbProxy::Instanc
 
 # Enable connection proxy for relations
 if DbCharmer.rails3?
+  require 'db_charmer/active_record/reflection'
   require 'db_charmer/rails3/active_record/relation_method'
   require 'db_charmer/rails3/active_record/relation/arel_engine'
   require 'db_charmer/rails3/active_record/relation/connection_routing'

data/lib/tasks/databases.rake

@@ -70,18 +70,21 @@ namespace :db_charmer do
       puts "This task only modifies local databases. #{config['database']} is on a remote host."
     end
   end
+
 end
 
 def drop_core_and_sub_database(config)
   exit unless Rails.env=='test'
+  puts "Dropping #{config['database']}"
   drop_database(config)
   config.each_value do | sub_config |
     next unless sub_config.is_a?(Hash)
     next unless sub_config['database']
     begin
+      puts "Dropping #{config['database']}"
       drop_database(sub_config)
     rescue => e
-      $stderr.puts "#{e.to_s}, #{config['database']} not exists"
+      $stderr.puts "#{e.to_s}, #{config['database']} does not exist"
     end
   end
 end
@@ -89,9 +92,28 @@ end
 # find all schema sharded databases and drop them
 def drop_schema_shard_databases(config)
   exit unless Rails.env=='test'
-
   DbCharmer.env = 'test'
+
+  # remember the sharder config so that we can register it again
+  # after resetting all dbcharmer connections
+  sharding_connection_config = {}
+  config.each do |name, sub_config|
+    next unless sub_config.is_a?(Hash)
+    sharder_name = sub_config['sharder_name']
+    if sharder_name
+      sharding_connection = DbCharmer::Sharding.sharded_connection(sharder_name)
+      sharding_connection_config[sharder_name] = sharding_connection.config if sharding_connection
+      break if sharding_connection_config
+    end
+  end
+  raise 'No sharder found' unless sharding_connection_config.size>0
+  
+  # Reset all DbCharmer connection to make sure to switch to test environment
+  # (connections were initialized for dev env in db:test:prepare)
   DbCharmer::ConnectionFactory.reset!
+  DbCharmer::Sharding.reset_connections
+  ActiveRecord::Base.reset_connection_proxies
+
   
   config.each do |name, sub_config|
     next unless sub_config.is_a?(Hash)
@@ -99,10 +121,21 @@ def drop_schema_shard_databases(config)
 
     # find the database connection for the schema admin db
     next unless sub_config['shard_db_name_prefix']
-    connection = DbCharmer::Sharding.sharded_connection_by_connection_name(name)
+
+    # Register sharder again
+    sharder_name = sub_config['sharder_name']
+    scc = sharding_connection_config[sharder_name]
+    next unless scc
+    scc[:connection] = name
+    DbCharmer::Sharding.register_connection(scc)
+    connection = DbCharmer::Sharding.sharded_connection(sharder_name)
     next unless connection
 
-    # itereate through entries in the shards_info table to find the
+    # Make sure the sharding admin database where we need to find the
+    # config for shards databases exist
+    next unless ::ActiveRecord::Base.exist_pg_database?(sub_config, sub_config['database'])
+    
+    # iterate through entries in the shards_info table to find the
     # databases that will be dropped
     dbgm = DbCharmer::Sharding::Method::DbBlockSchemaMap.new(connection.config)
 

data/lib/tasks/test.rake

@@ -6,6 +6,7 @@ namespace :db_charmer do
     task :prepare => ['db:abort_if_pending_migrations', 'db:load_config'] do |t|
       old_rails_env = Rails.env
       Rails.env = 'test'
+      DbCharmer.env = 'test'
       unless ActiveRecord::Base.schema_format==:sql
         abort "db_charmer can only reset databases using sql, check config.active_record.schema_format"
       end
@@ -20,9 +21,23 @@ namespace :db_charmer do
     end
 
     task :dump_structure do
+      @saved_sharding_config = {}
+      
       ::ActiveRecord::Base.configurations['development'].each_key do |name|
         config = ::ActiveRecord::Base.configurations['development'][name]
         next unless config.is_a?(Hash) && config['database']
+
+        if config['shard_db_name_prefix']
+          # dump schema for first sharded partition
+          @saved_sharding_config[name] = Sharding::ShardDatabaseConfigConverter.new(name, config)
+          cfg = @saved_sharding_config[name].dev_shard_db_config
+          puts "dev_shard_db_config=#{cfg.inspect}"
+          raise 'Cannot find shard configuration' unless cfg
+          dump_database_structure("#{name}_partition", cfg)
+
+          # Save the config for clone_structure
+        end
+
         # Only connect to local databases
         local_database?(config) { dump_database_structure(name, config) }
       end
@@ -33,34 +48,64 @@ namespace :db_charmer do
 
     # desc "Recreate the test databases from the development structure"
     task :clone_structure => [ 'db_charmer:test:dump_structure', 'db_charmer:test:purge' ] do
+      # Databases have just been dropped, old connections are no longer valid
+      DbCharmer::Sharding.reset_connections
+      DbCharmer::ConnectionFactory.reset!
+      ActiveRecord::Base.reset_connection_proxies
+      
+      # keep track of databases that have already been cloned
+      @cloned_db_names = {}
+      
       ::ActiveRecord::Base.configurations['test'].each_key do |name|
         config = ::ActiveRecord::Base.configurations['test'][name]
         next unless config.is_a?(Hash) && config['database']
+
         # Only connect to local databases
-        local_database?(config) { clone_database_structure(name, config) }
+        local_database?(config) { clone_database_structure(name, config, true) }
+
+        if config['shard_db_name_prefix']
+          # Create all partition databases and schemas.
+          # The number of desired databases and scemas is in config.
+          @saved_sharding_config[name].populate_test_shard(config)
+          @saved_sharding_config[name].each_database_shard_group do |partition_config|
+            puts "partition_config=#{partition_config.inspect}"
+            # Only connect to local databases
+            local_database?(partition_config) do
+              clone_database_structure("#{name}_partition", partition_config, false)
+            end
+          end
+          delete_structure_file("#{name}_partition")
+        end
       end
       config = ::ActiveRecord::Base.configurations['test']
-      local_database?(config) { clone_database_structure('main', config) }
+      local_database?(config) { clone_database_structure('main', config, true) }
     end
 
     def dump_database_structure(name, config, origin_env='development')
       return unless config.is_a?(Hash) && config['database']
-      structure_filename = "#{Rails.root}/db/#{origin_env}_#{name}_structure.sql"
+
+      structure_filename = structure_filename(name, origin_env)
       case config["adapter"]
       when /^(jdbc)?mysql/, "oci", "oracle"
         ActiveRecord::Base.establish_connection(config)
         File.open(structure_filename, "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
       when /^(jdbc)?postgresql$/
         ENV['PGHOST']     = config["host"] if config["host"]
-        ENV['PGPORT']     = config["port"].to_s if config["port"]
+        if config["port"]
+          ENV['PGPORT']     = config["port"].to_s
+          port_option = "-p #{config["port"]}"
+        end
         search_path = config["schema_search_path"]
         unless search_path.blank?
           search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
         end
-        cmd ="pg_dump -U #{config["username"]} -s -x -O -f db/#{origin_env}_#{name}_structure.sql #{search_path} #{config['database']}"
+        cmd ="pg_dump -U #{config["username"]} -s -x -O -f #{structure_filename} #{port_option} #{search_path} #{config['database']}"
         puts cmd                                                                                                                         
         `#{cmd}`
         raise "Error dumping database" if $?.exitstatus == 1
+        unless config["schema_search_path"].blank?
+          replace_schema_name_in_file(structure_filename, structure_filename, config["schema_search_path"], 'public')
+        end
       when /^(jdbc)?sqlite/
         dbfile = config["database"] || config["dbfile"]
         `sqlite3 #{dbfile} .schema > #{structure_filename}`
@@ -76,8 +121,18 @@ namespace :db_charmer do
       end
     end
 
-    def clone_database_structure(name, config, origin_env='development')
-      structure_filename = "#{Rails.root}/db/#{origin_env}_#{name}_structure.sql"
+    def clone_database_structure(name, config, delete_structure_file=false, origin_env='development')
+      unless @cloned_db_names[dbkey(config)]
+        @cloned_db_names[dbkey(config)] = true
+      else
+        puts "Skipping #{dbkey(config)} clone (already done)"
+        return
+      end
+
+
+      structure_filename = structure_filename(name, origin_env)
+      puts "clone_database_structure config=#{config.inspect} structure_filename=#{structure_filename}"
+      
       case config["adapter"]
       when /^(jdbc)?mysql/
         ActiveRecord::Base.establish_connection(:test)
@@ -87,11 +142,21 @@ namespace :db_charmer do
         end
       when /^(jdbc)?postgresql$/
         ENV['PGHOST']     = config["host"] if config["host"]
-        ENV['PGPORT']     = config["port"].to_s if config["port"]
+        if config["port"]
+          ENV['PGPORT']     = config["port"].to_s
+          port_option = "-p #{config["port"]}"
+        end
         #ENV['PGPASSWORD'] = config["password"].to_s if config["password"]
-        cmd = "psql -U #{config["username"]} -f #{structure_filename} #{config["database"]}"
+        schema_file = structure_filename
+        unless config["schema_search_path"].blank?
+          tmpfile = Tempfile.new('schema-')
+          replace_schema_name_in_file(structure_filename, tmpfile.path, 'public', config["schema_search_path"])
+          schema_file = tmpfile.path
+        end
+        cmd = "psql -U #{config["username"]} -f #{schema_file} #{port_option} #{config["database"]}"
         puts cmd
         `#{cmd}`
+        tmpfile.delete if tmpfile
       when /^(jdbc)?sqlite/
         dbfile = config["database"] || config["dbfile"]
         `sqlite3 #{dbfile} < #{structure_filename}`
@@ -109,8 +174,158 @@ namespace :db_charmer do
       else
         raise "Task not supported by '#{config["adapter"]}'"
       end
+      delete_structure_file(name) if delete_structure_file
+    end
 
+    def structure_filename(name, origin_env='development')
+      "#{Rails.root}/db/#{origin_env}_#{name}_structure.sql"
+    end
+    
+    def delete_structure_file(name, origin_env='development')
+      structure_filename = structure_filename(name, origin_env)
+      puts "Deleting #{structure_filename}"
       File.delete(structure_filename) if File.exist?(structure_filename)
     end
+    
+    def replace_schema_name_in_file(filename, tmpname, from, to)
+      sql = IO.read(filename)
+      sql = sql.gsub(/CREATE SCHEMA #{from}/, "CREATE SCHEMA #{to}")
+      sql = sql.gsub(/SET search_path = #{from}/, "SET search_path = #{to}")
+      File.open(tmpname, 'w') { |f| f.write(sql)}
+    end
+
+    def dbkey(config)
+      "#{config['database']}|#{config['host']}|#{config['port']}|#{config['schema_search_path']}"
+    end
   end
 end
+
+# Since the sharding database config is not in database.yml but in
+# the xxx_shards_info table, there needs to be a tool to generate
+# a database config hash for the sharding database.
+# This class can generate the hash for the dev sharding database
+# and for the test sharding database, based on the content of the
+# dev shards_info table.
+module Sharding
+  class ShardDatabaseConfigConverter
+
+    attr_reader :dev_shard_db_config
+
+    # dev_sharding_config: db settings of the dev admin database (from database.yml)
+    def initialize(name, dev_sharding_config)
+      @name = name
+      @dev_sharding_config = dev_sharding_config
+      @dev_shard_db_config = generate_dev_shard_db_config # settings of the sharding database
+      @test_shards = []
+      raise "Can't determine shard database configuration." unless @dev_shard_db_config
+    end
+
+    # Inserts  shard and group records in the test admin database.
+    # Saves the db settings hash for the test sharding database.
+    # test_sharding_config: db settings of the test admin database (from database.yml)
+    def populate_test_shard(test_sharding_config)
+      @test_sharding_config = test_sharding_config
+      create_test_shard_and_group
+    end
+
+    def each_database_shard_group
+      @test_shards.each do |shard|
+        shard.groups.each do |group|
+          cfg = { 'host'      => shard.db_host,
+                  'port'      => shard.db_port,
+                  'username'  => shard.db_user,
+                  'database'  => shard.db_name,
+                  'adapter'   => @test_sharding_config['adapter'],
+                  'schema_search_path' => @test_sharder.schema_name(shard.schema_name_prefix, group.id)
+                }
+          yield cfg
+        end
+      end
+    end
+
+    private
+    
+    def generate_dev_shard_db_config
+      if @dev_sharding_config['connection_name']
+        conn = DbCharmer::Sharding.sharded_connection_by_connection_name(@dev_sharding_config['connection_name'])
+      elsif @dev_sharding_config['sharder_name']
+        conn = DbCharmer::Sharding.sharded_connection(@dev_sharding_config['sharder_name'])
+      else
+        puts "Can't find connection_name or sharder_name in database config"
+        return
+      end
+      @sharding_connection_config = conn.config
+      sharder = conn.sharder
+      group = sharder.group_class.first
+      shard = group.shard
+      @schema_name_prefix = shard.schema_name_prefix
+      cfg = { 'host' => shard.db_host,
+              'port' => shard.db_port,
+              'username' => shard.db_user,
+              'database' => shard.db_name,
+              'adapter' => @dev_sharding_config['adapter'],
+              'schema_search_path' => sharder.schema_name(@schema_name_prefix, group.id)
+            }
+    end
+
+    def generate_test_shard_db_config
+      return unless @test_sharding_config && @test_shard && @test_group
+      schema_name_prefix = @test_shard.schema_name_prefix
+      test_group_id = @test_group.id
+      cfg = { 'host' => @test_shard.db_host,
+              'port' => @test_shard.db_port,
+              'username' => @test_shard.db_user,
+              'database' => @test_shard.db_name,
+              'adapter' => @test_sharding_config['adapter'],
+              'schema_search_path' => @test_sharder.schema_name(schema_name_prefix, test_group_id)
+            }
+    end
+
+    def create_test_shard_and_group
+      return unless @test_sharding_config && @sharding_connection_config
+
+      # Reset database connection and sharder in test environment
+      @sharding_connection_config[:connection] = @name
+      DbCharmer::Sharding.register_connection(@sharding_connection_config)
+      conn = DbCharmer::Sharding.sharded_connection(@sharding_connection_config[:name])
+      @test_sharder = conn.sharder
+      @test_sharder.shard_class.establish_connection(@test_sharding_config)
+      @test_sharder.group_class.establish_connection(@test_sharding_config)
+
+      num_shards = @test_sharding_config['num_shard_databases'] || 1
+      num_groups = @test_sharding_config['num_shard_partitions'] || 1
+
+      1.upto num_shards do |ns|
+        test_shard = @test_sharder.shard_class.create do |s|
+          s.db_host = @test_sharding_config['host']
+          s.db_port = @test_sharding_config['port']
+          s.db_user = @test_sharding_config['username']
+          s.db_pass = @test_sharding_config['password'] || ''
+          s.db_name = test_database_name(ns)
+          s.schema_name_prefix  = @schema_name_prefix
+        end
+
+        @test_sharder.create_shard_database(test_shard)
+
+        1.upto num_groups do |np|
+          @test_group = @test_sharder.group_class.create do |group|
+            group.shard_id = test_shard.id
+            group.open     = true
+            group.enabled  = true
+          end
+        end
+
+        @test_shards << test_shard
+      end
+    end
+
+    def test_database_name(ns)
+      dev_db_name_prefix = Regexp.escape(@dev_sharding_config['shard_db_name_prefix'])
+      test_db_name_prefix = @test_sharding_config['shard_db_name_prefix']
+      s = @dev_shard_db_config['database'].gsub(/#{dev_db_name_prefix}/, test_db_name_prefix)
+      s + "_#{ns}"
+    end
+
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: yam-db-charmer
 version: !ruby/object:Gem::Version 
-  hash: 99
+  hash: 109
   prerelease: 
   segments: 
   - 1
   - 7
   - 4
-  - 10
-  version: 1.7.4.10
+  - 13
+  version: 1.7.4.13
 platform: ruby
 authors: 
 - Oleksiy Kovyrin
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-19 00:00:00 -07:00
+date: 2012-10-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -118,6 +118,7 @@ files:
 - lib/db_charmer/active_record/db_magic.rb
 - lib/db_charmer/active_record/migration/multi_db_migrations.rb
 - lib/db_charmer/active_record/multi_db_proxy.rb
+- lib/db_charmer/active_record/reflection.rb
 - lib/db_charmer/active_record/sharding.rb
 - lib/db_charmer/connection_factory.rb
 - lib/db_charmer/connection_proxy.rb