connection_manager 1.0.4 → 1.1.0

data/lib/connection_manager/replication.rb

@@ -1,117 +1,88 @@
-require 'active_support/core_ext/hash/indifferent_access'
 module ConnectionManager
-  module Replication 
+  module Replication
+    attr_accessor :replication_connections
     # Replication methods (replication_method_name, which is the option[:name] for the
     # #replication method) and all their associated connections. The key is the
     # replication_method_name and the value is an array of all the replication_classes
     # the replication_method has access to.
-    # 
+    #
     # EX: replication_methods[:slaves] => ['Slave1Connection',Slave2Connection]
-    def replication_methods
-      @replication_methods ||= HashWithIndifferentAccess.new
+    def replication_connections
+      @replication_connections ||= {:slaves => [], :masters => []}
     end
-       
+
+
     # Is this class replicated
     def replicated?
-      (@replicated == true)
+      (@replication_connections && (!replication_connections[:slaves].empty? || !replication_connections[:masters].empty?))
     end
-    
+
     # Builds a class method that returns an ActiveRecord::Relation for use with
     # in ActiveRecord method chaining.
-    # 
-    # EX: 
+    #
+    # EX:
     # class MyClass < ActiveRecord::Base
-    #   replicated :my_readonly_db, "FooConnection", :method_name => 'slaves'
+    #   replicated :my_readonly_db, "FooConnection",
     #   end
     # end
     #
     # Options:
     # * :name - name of class method to call to access replication, default to slaves
-    # * :readonly - forces all results to readonly
-    # * :type - the type of replication; :slave or :master, defaults to :slave
+    # * :type - the type of replication; :slaves or :masters, defaults to :slaves
     def replicated(*connections)
-        @replicated = true
-        options = {:name => "slaves"}.merge!(connections.extract_options!)
-        options[:type] ||= :slaves
-        options[:build_replicants] = true if (options[:build_replicants].blank? && options[:type] == :masters)
-        use_database(current_database_name, :table_name => table_name) # make sure the base class has current_database_name set
-        connections = connection.replication_keys(options[:type]) if connections.blank?
-        set_replications_to_method(connections,options[:name])
-        build_repliciation_class_method(options)
-        build_query_method_alias_method(options[:name])
-        build_repliciation_instance_method(options[:name])
-        options[:name]
+      options = {:slaves => [], :masters => [], :type => :slaves}.merge(connections.extract_options!.symbolize_keys)
+      options[options[:type]] = connections unless connections.empty?
+      set_replications_connections(options)
     end
-      
-    # Get a connection class name from out replication_methods pool.
-    def fetch_replication_method(method_name)
-      available_connections = @replication_methods[method_name]
+
+    private
+
+    # Fetch a connection class name from out replication_connections pool.
+    # Since any numbers of threads could be attempting to access the replication
+    # connections we use sample to get a random connection instead of blocking
+    # to rotate the pool on every fetch.
+    def fetch_replication_connection(method_name)
+      set_replications_connections(self.replication_connections) unless self.replicated?
+      available_connections = self.replication_connections[method_name] || []
       raise ArgumentError, "No connections found for #{method_name}." if available_connections.blank?
-      available_connections.rotate!
-      available_connections[0]
+      available_connections.sample
     end
-    
-    private
+
+    def fetch_slave_connection
+      fetch_replication_connection(:slaves)
+    end
+
+    def fetch_master_connection
+      fetch_replication_connection(:masters)
+    end
+
     # Builds replication connection classes and methods
-    def set_replications_to_method(connections,replication_method_name='slaves') 
-      raise ArgumentError, "connections could not be found for #{self.name}." if connections.blank?
-      connections.each do |to_use| 
-        connection_class_name = fetch_connection_class_name(to_use) 
-        replication_methods[replication_method_name] ||= []
-        replication_methods[replication_method_name] << connection_class_name
+    def set_replications_connections(options)
+      [:masters,:slaves].each do |type|
+        cons = (options[type].empty? ? connection.replications[type] : options[type])
+        unless cons.empty?
+          self.replication_connections[type] = []
+          cons.each do |to_use|
+            self.replication_connections[type] << fetch_connection_class_name(to_use)
+          end
+        end
       end
-      true
+      raise ArgumentError, "Connections could not be found for #{self.name}." if self.replication_connections[:masters].empty? && self.replication_connections[:slaves].empty?
+      self.replication_connections
     end
-    
-    def fetch_connection_class_name(to_use) 
-      connection_class_name = to_use    
-      connection_class_name = fetch_connection_class_name_from_yml_key(connection_class_name) if connection_class_name.to_s.match(/_/)    
-      raise ArgumentError, "For #{self.name}, the class #{connection_class_name} could not be found." if connection_class_name.blank?    
+
+    def fetch_connection_class_name(to_use)
+      connection_class_name = to_use
+      connection_class_name = fetch_connection_class_name_from_yml_key(connection_class_name) if connection_class_name.to_s.match(/_/)
+      raise ArgumentError, "For #{self.name}, the class #{connection_class_name} could not be found." if connection_class_name.blank?
       connection_class_name
     end
 
     def fetch_connection_class_name_from_yml_key(yml_key)
       found = managed_connections[yml_key]
-      connection_class_name = nil
-      if found     
-        connection_class_name = found.first
-      else
-        raise ArgumentError, "For #{self.name}, a connection class for #{yml_key} could not be found." 
-      end
-      connection_class_name
-    end 
-    
-    # Adds a class method, that calls #using with the correct connection class name
-    # by calling fetch_replication_method with the method name. Adds readonly
-    # query method class if replication is specified as readonly.
-    def build_repliciation_class_method(options)
-      class_eval <<-STR
-      class << self
-        def #{options[:name]}
-          using(fetch_replication_method("#{options[:name]}"))#{options[:readonly] ? '.readonly' : ''}
-        end
-      end
-      STR
-    end
-       
-    # Build a query method with the name of our replication method. This method 
-    # uses the relation.klass to fetch the appropriate connection, ensuring the
-    # correct connection is used even if the method is already defined by another class.
-    # We want to make sure we don't override existing methods in ActiveRecord::QueryMethods
-    def build_query_method_alias_method(replication_relation_name)
-      unless ActiveRecord::QueryMethods.instance_methods.include?(replication_relation_name.to_sym)
-        ActiveRecord::QueryMethods.module_eval do
-          define_method replication_relation_name.to_sym do
-            using(self.klass.fetch_replication_method(replication_relation_name))
-          end
-        end
-      end
-    end
-    
-    def build_repliciation_instance_method(replication_relation_name)
-      define_method replication_relation_name.to_sym do
-        using(self.class.fetch_replication_method(replication_relation_name))
-      end 
+      raise ArgumentError, "For #{self.name}, a connection class for #{yml_key} could not be found." unless found
+      found
     end
   end
-end
+end
+ActiveRecord::Base.extend(ConnectionManager::Replication)

data/lib/connection_manager/shards.rb

@@ -22,4 +22,5 @@ module ConnectionManager
       end
     end
   end
-end
+end
+ActiveRecord::Base.extend(ConnectionManager::Shards)

data/lib/connection_manager/using.rb

@@ -1,23 +1,10 @@
-require 'active_support/core_ext/module/delegation'
 module ConnectionManager
   module Using
-    module Relation
-
-      # Specify connection class to used for query.For
-      # example:
-      #
-      # users = User.using(MySlaveConnection).first
-      def using(connection_class_name)
-        @klass = ConnectionManager::Using::Proxy.new(@klass,connection_class_name)
-        self
-      end
-    end
-
     class Proxy
       attr_accessor :klass, :connection_class
-      
+
       def initialize(klass,connection_class)
-        @klass = klass  # the @klass insance from an ActiveRecord::Relation
+        @klass = klass  # the @klass from an ActiveRecord::Relation
         @connection_class = (connection_class.is_a?(String) ? connection_class.constantize : connection_class)
       end
 
@@ -28,11 +15,38 @@ module ConnectionManager
       end
 
       # Make sure we return the @klass superclass,
-      # which used through the query building code in AR
+      # which used throughout the query building code in AR
       def superclass
         @klass.superclass
       end
 
+      def >= compare
+        return @klass >= compare.klass if compare.is_a?(self.class)
+        @klass >= compare
+      end
+
+      def == compare
+        return @klass == compare.klass if compare.is_a?(self.class)
+        @klass == compare
+      end
+
+      def != compare
+        return @klass != compare.klass if compare.is_a?(self.class)
+        @klass != compare
+      end
+
+      def descendants
+        @klass.descendants
+      end
+
+      def subclasses
+        @klass.subclasses
+      end
+
+      def parent
+        @klass.parent
+      end
+
       # Pass all methods to @klass, this ensures objects
       # build from the query are the correct class and
       # any settings in the model like table_name_prefix
@@ -47,11 +61,3 @@ module ConnectionManager
     end
   end
 end
-ActiveRecord::Relation.send(:include,ConnectionManager::Using::Relation)
-module ActiveRecord
-  class Base
-    class << self
-      delegate :using, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
-    end
-  end
-end

data/lib/connection_manager/version.rb

@@ -1,3 +1,3 @@
 module ConnectionManager
-  VERSION = "1.0.4"
+  VERSION = "1.1.0"
 end

data/lib/connection_manager.rb

@@ -1,29 +1,39 @@
 require "connection_manager/version"
 
 module ConnectionManager
+  require 'thread_safe'
   require 'active_record'
   require 'active_support'
-  require 'connection_manager/helpers/abstract_adapter_helper'
-  require 'connection_manager/connection_builder'
-  require 'connection_manager/helpers/connection_helpers' 
+  require 'connection_manager/connection_adapters/abstract_adapter'
+  require 'connection_manager/core'
+  require 'connection_manager/connection_handling'
+  require 'connection_manager/relation'
+  require 'connection_manager/querying'
+  require 'connection_manager/builder'
   require 'connection_manager/using'
-  require 'connection_manager/shards'  
   require 'connection_manager/replication'
-  require 'connection_manager/patches/cross_schema_patch'
-  require 'connection_manager/connection_manager_railtie' if defined?(Rails)
-    
-  ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include,(ConnectionManager::AbstractAdapterHelper))
-  ActiveRecord::Base.extend(ConnectionManager::ConnectionHelpers) 
-  ActiveRecord::Base.extend(ConnectionManager::ConnectionBuilder)
-  ActiveRecord::Base.extend(ConnectionManager::Replication)
-  ActiveRecord::Base.extend(ConnectionManager::Shards)
-  
-  ActiveSupport.on_load(:active_record) do
-    ActiveRecord::Base.build_connection_classes
+  require 'connection_manager/shards'
+  require 'connection_manager/railtie' if defined?(Rails)
+
+  # Get the current environment if defined
+  # Check for Rails, check for RACK_ENV, default to 'development'
+  def self.env
+    return @env if @env
+    return Rails.env if defined?(Rails)
+    return RACK_ENV if defined?(RACK_ENV)
+    return ENV["AR_ENV"] if ENV["AR_ENV"]
+    "development"
+  end
+
+  def self.env=env
+    @env=env
   end
 
   def self.logger
     @logger ||= ActiveRecord::Base.logger
   end
+  
+  def self.logger=logger
+    @logger = logger
+  end
 end
-

data/spec/{mysql2_database.yml → database.yml}

@@ -2,49 +2,53 @@
 # re-generated from your development database when you run "rake".
 # Do not set this db to the same as development or production.
 common: &common
-  adapter: mysql2
-  username: root
-  password: omegared
   pool: 100
   timeout: 5000
   build_connection_class: true
-  
+
 master: &master
   username: root
   password: omegared
-  
+
 readonly: &readonly
   username: root
   password: omegared
-  
-test:
+
+mysql_without_db:
   <<: *common
   <<: *master
-  database: cm_test
-  slaves: [slave_1_cm_test, slave_2_cm_test]
-  
-cm_user_test:
+
+test:
   <<: *common
   <<: *master
-  database: cm_user_test
-  slaves: [slave_1_cm_user_test]
-  
-slave_1_cm_test:
-  <<: *common 
-  <<: *readonly
+  adapter: mysql2
   database: cm_test
-  
-slave_2_cm_test:
+  slaves: [slave_test]
+
+slave_test:
   <<: *common
-  <<: *readonly
+  <<: *master
+  adapter: mysql2
   database: cm_test
+  masters: [test]
 
-shard_1_cm_test:  
-   <<: *common
-   <<: *master
-   database: legacy_cm_test
+mysql_without_db:
+  <<: *common
+  <<: *master
+  adapter: mysql2
 
-slave_1_cm_user_test:
+cm_user_test:
   <<: *common
-  <<: *readonly
+  <<: *master
+  adapter: mysql2
   database: cm_user_test
+
+postgres_without_db:
+  <<: *common
+  adapter: postgresql
+  database: postgres
+
+test_other:
+  <<: *common
+  adapter: postgresql
+  database: cm_test

data/spec/factories.rb

@@ -13,7 +13,7 @@ FactoryGirl.define do
   end
 
   factory :fruit do
-    name "MyString"
+    name {FactoryGirl.generate(:rand_name)}
     region
   end
 

data/spec/helpers/database_spec_helper.rb

@@ -1,11 +1,11 @@
 class TestDB
-  def self.yml(driver='sqlite')
-    YAML::load(File.open(File.join(File.dirname(__FILE__),'..',"#{driver}_database.yml")))
+  def self.yml
+    YAML::load(File.open(File.join(File.dirname(__FILE__),'..',"database.yml")))
   end
 
-  def self.connect(driver='sqlite',logging=false)
-    ActiveRecord::Base.configurations = yml(driver)
-    ActiveRecord::Base.establish_connection('test')
+  def self.connect(logging=false)
+    ActiveRecord::Base.configurations = yml
+    ActiveRecord::Base.establish_connection(:test)
     ActiveRecord::Base.logger = Logger.new(STDOUT) if logging
   end
 
@@ -23,62 +23,90 @@ end
 class TestMigrations < ActiveRecord::Migration
   # all the ups
   def self.up
-    ActiveRecord::Base.establish_connection(:test)
-    begin
-      create_table "#{ActiveRecord::Base.schema_name}.foos" do |t|
-        t.string :name
-        t.integer :cm_user_id
+    {:mysql_without_db => :test,:postgres_without_db => :test_other}.each do |build,key|
+      ActiveRecord::Base.establish_connection(build)
+
+      if build == :mysql_without_db
+        begin
+          ActiveRecord::Base.connection.execute("CREATE DATABASE IF NOT EXISTS cm_test;")
+        rescue => e
+          puts "Error creating database: #{e}"
+        end
+        begin
+          ActiveRecord::Base.connection.execute("CREATE DATABASE IF NOT EXISTS cm_user_test;")
+        rescue => e
+          puts "Error creating database: #{e}"
+        end
+        ActiveRecord::Base.establish_connection(key)
+      else
+        begin
+          ActiveRecord::Base.connection.execute("CREATE DATABASE cm_test;")
+        rescue => e
+          puts "Error creating database: #{e}"
+        end
+        ActiveRecord::Base.establish_connection(key)
+        begin
+          ActiveRecord::Base.connection.execute("CREATE SCHEMA cm_test;")
+        rescue => e
+          puts "Error creating schema: #{e}"
+        end
       end
-    rescue => e
-      puts "tables failed to create: #{e}"
-    end
-    begin
-      create_table "#{ActiveRecord::Base.schema_name}.fruits" do |t|
-        t.string :name
-        t.integer :region_id
-        t.timestamps
+
+      begin
+        create_table "cm_test.foos" do |t|
+          t.string :name
+          t.integer :cm_user_id
+        end
+      rescue => e
+        puts "tables failed to create: #{e}"
       end
-    rescue => e
-      puts "tables failed to create: #{e}"
-    end
-    begin
-      create_table "#{ActiveRecord::Base.schema_name}.baskets" do |t|
-        t.string :name
-        t.timestamps
+      begin
+        create_table "cm_test.fruits" do |t|
+          t.string :name
+          t.integer :region_id
+          t.timestamps
+        end
+      rescue => e
+        puts "tables failed to create: #{e}"
       end
-    rescue => e
-      puts "tables failed to create: #{e}"
-    end
-    begin
-      create_table "#{ActiveRecord::Base.schema_name}.fruit_baskets" do |t|
-        t.integer :fruit_id
-        t.integer :basket_id
-        t.timestamps
+      begin
+        create_table "cm_test.baskets" do |t|
+          t.string :name
+          t.timestamps
+        end
+      rescue => e
+        puts "tables failed to create: #{e}"
       end
-    rescue => e
-      puts "tables failed to create: #{e}"
-    end
-    begin
-      create_table "#{ActiveRecord::Base.schema_name}.regions" do |t|
-        t.string :name
-        t.integer :type_id
-        t.timestamps
+      begin
+        create_table "cm_test.fruit_baskets" do |t|
+          t.integer :fruit_id
+          t.integer :basket_id
+          t.timestamps
+        end
+      rescue => e
+        puts "tables failed to create: #{e}"
       end
-    rescue => e
-      puts "tables failed to create: #{e}"
-    end
-    begin
-      create_table "#{ActiveRecord::Base.schema_name}.types" do |t|
-        t.string :name
-        t.timestamps
+      begin
+        create_table "cm_test.regions" do |t|
+          t.string :name
+          t.integer :type_id
+          t.timestamps
+        end
+      rescue => e
+        puts "tables failed to create: #{e}"
+      end
+      begin
+        create_table "cm_test.types" do |t|
+          t.string :name
+          t.timestamps
+        end
+      rescue => e
+        puts "tables failed to create: #{e}"
       end
-    rescue => e
-      puts "tables failed to create: #{e}"
     end
-
     ActiveRecord::Base.establish_connection(:cm_user_test)
     begin
-      create_table :cm_users do |t|
+      create_table 'cm_user_test.cm_users' do |t|
         t.string :name
       end
     rescue => e
@@ -87,31 +115,32 @@ class TestMigrations < ActiveRecord::Migration
 
     # Table is in more than 1 schema
     begin
-      create_table "#{ActiveRecord::Base.schema_name}.types" do |t|
+      create_table "cm_user_test.types" do |t|
         t.string :name
         t.timestamps
       end
     rescue => e
       puts "tables failed to create: #{e}"
     end
-
     ActiveRecord::Base.establish_connection(:test)
   end
 
   # all the downs
-  def self.down(connection_name='test',user_connection_name='cm_user_test')
-    ActiveRecord::Base.establish_connection(:test)
-    [:foos,:fruits,:baskets,:fruit_baskets,:regions,:types].each do |t|
-      begin
-        drop_table t
-      rescue => e
-        puts "tables were not dropped: #{e}"
+  def self.down
+    [:test, :test_other].each do |key|
+      ActiveRecord::Base.establish_connection(key)
+      [:foos,:fruits,:baskets,:fruit_baskets,:regions,:types].each do |t|
+        begin
+          drop_table "cm_test.#{t.to_s}"
+        rescue => e
+          puts "tables were not dropped: #{e}"
+        end
       end
     end
     ActiveRecord::Base.establish_connection(:cm_user_test)
     [ :cm_users, :types].each do |t|
       begin
-        drop_table t
+        puts drop_table "cm_user_test.#{t.to_s}"
       rescue => e
         puts "tables were not dropped: #{e}"
       end