octoshark 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e36f799c08e10ce190cd98d93fbc9133388f85cc
-  data.tar.gz: 4d3b95a2b17155770a2f22c6d0fb7598bb192eda
+  metadata.gz: 055693668b801861b20b03a2b5d59cbe98a01184
+  data.tar.gz: 0b23a9ce02c5c88ec3c3abfae20ab9433e934221
 SHA512:
-  metadata.gz: 62ae7717fe0960b31426328514a7bd59ec3084e409dd19cbdcf8f8b10b74348c030b36c3b3afe01c218ad5ee1790842073981f5d662f236b507ec34c7b3b5c1b
-  data.tar.gz: 8f639d0260942633132b479193ba1c4105bf1b965929bf57a804e0a3c1ce2aaf7caa190c947ad08d749ac788a1f6fa398ec4c133481c8146b2b78d7e495fefda
+  metadata.gz: d2301c93076eb07afa01dead10f23c17524a5772089df8ecf5ddffca1902ff2fe3ad4022ca38db4b70a8fe6c7f8387335b6e2e2750c11cfb830a07fc14c5b9ce
+  data.tar.gz: 64f37f5fde130bc56398cbfc40e397f16cbd8c8a294db6638c44f0bcec799c9a7f9459ab34dbdff5d49a32f699a96e7bf13d3ae250cefd7a05dd333c2e066987

data/.travis.yml

@@ -11,4 +11,5 @@ gemfile:
   - gemfiles/rails3.2.gemfile
   - gemfiles/rails4.gemfile
   - gemfiles/rails4.1.gemfile
+  - gemfiles/rails4.2.gemfile
 script: bundle exec rspec spec

data/Appraisals

@@ -17,3 +17,7 @@ end
 appraise "rails4.1" do
   gem "activerecord", "~> 4.1.0"
 end
+
+appraise "rails4.2" do
+  gem "activerecord", "~> 4.2.0"
+end

data/README.md

@@ -2,7 +2,7 @@
 
 ![Travis status](https://travis-ci.org/dalibor/octoshark.png)
 
-Octoshark is a simple ActiveRecord connection switcher. It provides a general purpose connection switching mechanism that can be used in sharding and master-slave multi-database environments. It's up to you to specify how ActiveRecord models will use the Octoshark connections, see below for example scenarios.
+Octoshark is a simple ActiveRecord connection manager. It provides a connection switching mechanism that can be used in various scenarios like: sharding, master-slave, multi-tenancy, etc. You have control over how connections are configured and used, see below for examples.
 
 
 ## Installation
@@ -28,97 +28,122 @@ $ gem install octoshark
 
 ## Usage
 
-Specify the connections for Octoshark to manage. This is usually done in an app initializer.
+Create a new connection manager with connection 2 pools for Octoshark to manage. This usually goes in the app initializer.
 
 ```ruby
-Octoshark.configure({
+CONN_MANAGER = Octoshark::ConnectionManager.new({
   db1: { adapter: "sqlite3", database: "db/db1.sqlite" },
   db2: { adapter: "sqlite3", database: "db/db2.sqlite" }
 })
 ```
 
-Configure which ActiveRecord models will use the Octoshark connection by overriding the Model.connection method. If there are many models, extract it in a module and include it.
+Configure which ActiveRecord model will use the Octoshark connection by overriding the `Model.connection` method.
 
 ```ruby
 class Post < ActiveRecord::Base
   def self.connection
-    Octoshark.current_connection
+    CONN_MANAGER.current_connection
   end
 end
 ```
 
-To use a specific database connection, do:
+Alternatively, extract it as a module and include in models.
 
 ```ruby
-Octoshark.with_connection(:db1) do
-  # work with db1
-  Post.first
+module ShardingModel
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def connection
+      OCTOSHARK.current_connection
+    end
+  end
 end
 ```
 
-Octoshark connection is changed for the duration of the block and then reversed back to the previous connection.
+To use a specific database connection:
 
-`Octoshark.current_connection` returns the active connection while in `with_connection` block, and outside it raises `Octoshark::NoCurrentConnectionError` error.
+```ruby
+CONN_MANAGER.with_connection(:db1) do
+  # run queries on db1
+  Post.first
+end
+```
 
-Multiple connection switch blocks can be nested:
+Multiple `with_connection` blocks can be nested:
 
 ```ruby
-Octoshark.with_connection(:db1) do
-  # work with db1
+CONN_MANAGER.with_connection(:db1) do
+  # run queries on db1
 
-  Octoshark.with_connection(:db2) do
-    # work with db2
+  CONN_MANAGER.with_connection(:db2) do
+    # run queries on db2
   end
 
-  # work with db1
+  # run queries on db1
 end
 ```
 
+`CONN_MANAGER.current_connection` returns the active connection while in the `with_connection` block or raises `Octoshark::Error::NoCurrentConnection` otherwise.
+
 
-## Sharding Example
+## Sharding example
 
-For example, let's say we have few models that are in the default Rails database (User, Account, etc) and few models that we want to shard (Blog, Post, Comment, etc). For all models in the default database, we can use the default ActiveRecord connection, and for all sharded models we need to the Octoshark connection.
+Some models are in the core DB, and others in shard DBs. Shard is selected based on a user attribute. For core models use the default ActiveRecord connection and for sharded models define and use Octoshark connections.
 
-We specify the connection for the sharded models based on the shard key (User) in a controller with an around filter:
+Switch the connection in a controller with an around filter:
 
 ```ruby
-# before_filter :find_user
 around_filter :select_shard
 
 def select_shard(&block)
-  Octoshark.with_connection(current_user.shard, &block)
+  CONN_MANAGER.with_connection(current_user.shard, &block)
 end
 ```
 
-Similarly, in all other application entry-points that start with the default ActiveRecord connection (background jobs for an example), we need to switch the shard connection and then proceed.
+Similar approach applies to other application entry-points like background jobs.
 
 
-## Master-Slave Example
+## Master-Slave example
 
-When we want to do something in the slave database with all ActiveRecord models, then we need to add Octoshark's current or default connection to all models, either by overriding `ActiveRecord:Base.connection` or using a module that we include in all models.
+All models are in master and slave databases. For master models use the default ActiveRecord connection and for slave models define and use Octoshark connections.
 
 ```ruby
 class ActiveRecord::Base
   def self.connection
-    # Some rake tasks like `rake db:create` does not load initializers,
-    # and because we're overriding ActiveRecord::Base.connection,
-    # we need to make sure Octoshark is configured before using it.
-    Octoshark.configure(configs) unless Octoshark.configured?
-
     # Return the current connection (from with_connection block) or default one
-    Octoshark.current_or_default_connection
+    CONN_MANAGER.current_or_default_connection
   end
 end
 ```
 
-Here we use `Octoshark.current_or_default_connection` method which returns the current connection while in `with_connection` block and fallback to the default connection when outside.
+`CONN_MANAGER.current_or_default_connection` method returns the current connection while in `with_connection` block or the default ActiveRecord connection when outside.
 
 
-## Octoshark.reload!
+## Multi-tenant example
 
-Whenever ActiveRecord::Base establishes a new database connection, `Octoshark.reload!` is called. This is necessary for Octoshark to disconnect old connection pools and set new ones, otherwise `ActiveRecord::ConnectionNotEstablished` will be raised.
+Some models are in the core DB, and others in user's own dedicated database. For core models use the default ActiveRecord connection and for tenant models can use Octoshark's mechanism to create new temporary connection.
 
-Few examples where database connections are re-established:
+Switch the connection in a controller with an around filter:
+
+```ruby
+# in initializer
+CONN_MANAGER = Octoshark::ConnectionManager.new
+
+# in controller
+around_filter :select_shard
+
+def select_shard(&block)
+  CONN_MANAGER.with_new_connection(name, config, reusable: false, &block)
+end
+```
+
+`CONN_MANAGER.with_new_connection` method creates a temporary connection that will automatically disconnect. If you want to reuse it in subsequent connection switches, set `reusable: true` and it will be added to the connection manager and reused with the next calls. Depends on the use-case and what's preferable. In test environment usually you would want to set it to `reusable` so that database cleaner can clean data with transaction strategy.
+
+
+## Octoshark.reset_connection_managers!
+
+Whenever ActiveRecord::Base calls `establish_connection` (usually by an ancestor process that must have subsequently forked), `Octoshark.reset_connection_managers!` is automatically called to re-establish the Octoshark connections. It prevents `ActiveRecord::ConnectionNotEstablished` in the scenarios like:
 
 * Unicorn before/after fork
 * Spring prefork/serve
@@ -127,7 +152,7 @@ Few examples where database connections are re-established:
 
 ## Database Cleaner
 
-Here's an example how to clean default and shard databases using both default connection and Octoshark connections:
+RSpec example on how to clean default and Octoshark data with Database Cleaner:
 
 ```ruby
 config.before(:suite) do
@@ -146,16 +171,21 @@ config.after(:each) do
 end
 
 def setup_database_cleaner
-  Octoshark.connection_pools.each_pair do |connection_name, connection_pool|
-    DatabaseCleaner[:active_record, {connection: connection_pool}]
+  DatabaseCleaner[:active_record, {connection: ActiveRecord::Base.connection_pool}]
+  Octoshark.connection_managers.each do |manager|
+    manager.connection_pools.each_pair do |connection_name, connection_pool|
+      DatabaseCleaner[:active_record, {connection: connection_pool}]
+    end
   end
 end
 ```
 
+
 ## Logo
 
 Thanks to [@saschamt](https://github.com/saschamt) for Octoshark logo design. :)
 
+
 ## Contributing
 
 1. Fork it ( http://github.com/dalibor/octoshark/fork )

data/gemfiles/rails4.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.2.0"
+
+gemspec :path => "../"

data/lib/octoshark.rb

@@ -3,55 +3,23 @@ require 'active_record'
 require 'octoshark/active_record_extensions'
 
 module Octoshark
-  autoload :ConnectionSwitcher, 'octoshark/connection_switcher'
+  autoload :ConnectionManager, 'octoshark/connection_manager'
+  autoload :Error,             'octoshark/error'
 
-  class NotConfiguredError < RuntimeError; end
-  class NoConnectionError < StandardError; end;
-  class NoCurrentConnectionError < StandardError; end;
+  # Octoshark needs to keep track of all connection managers in order to
+  # automatically reconnect on connection establish.
+  @@connection_managers = []
 
-  OCTOSHARK = :octoshark
-
-  class << self
-    delegate :connection_pools,
-      :current_or_default_connection,
-      :disconnect!,
-      :find_connection_pool,
-      :with_connection,
-      :without_connection,
-      :current_connection,
-      :current_connection?,
-      to: :switcher
-
-    def configure(configs)
-      @configs = configs
-      @switcher = ConnectionSwitcher.new(configs)
-    end
-
-    def reset!
-      return unless configured?
-      disconnect!
-      @confings = nil
-      @switcher = nil
-      Thread.current[OCTOSHARK] = nil
-    end
-
-    def reload!
-      raise_not_configured_error unless @configs
-      disconnect!
-      @switcher = ConnectionSwitcher.new(@configs)
-    end
-
-    def configured?
-      !@switcher.nil?
-    end
+  def self.connection_managers
+    @@connection_managers
+  end
 
-    def switcher
-      @switcher || raise_not_configured_error
-    end
+  def self.reset_connection_managers!
+    connection_managers.map(&:reset!)
+  end
 
-    private
-    def raise_not_configured_error
-      raise NotConfiguredError, "Octoshark is not configured, use Octoshark.configure"
-    end
+  def self.disconnect!
+    connection_managers.map(&:disconnect!)
+    @@connection_managers = []
   end
 end

data/lib/octoshark/active_record_extensions.rb

@@ -9,9 +9,13 @@ module Octoshark
     end
 
     module ClassMethods
+      # When a connection is established in an ancestor process that must have
+      # subsequently forked, ActiveRecord establishes a new connection because
+      # it can't reuse the existing one. When that happens, we need to reconnect
+      # Octoshark connection managers.
       def establish_connection_with_octoshark(*args)
         establish_connection_without_octoshark(*args)
-        Octoshark.reload! if Octoshark.configured?
+        Octoshark.reset_connection_managers!
       end
     end
   end

data/lib/octoshark/connection_manager.rb

@@ -0,0 +1,110 @@
+module Octoshark
+  class ConnectionManager
+
+    attr_reader :connection_pools
+
+    def initialize(configs = {})
+      @configs = configs.with_indifferent_access
+      setup_connection_pools
+
+      Octoshark.connection_managers << self
+    end
+
+    def reset!
+      disconnect!
+      setup_connection_pools
+    end
+
+    def current_connection
+      Thread.current[identifier] || raise(Octoshark::Error::NoCurrentConnection, "No current connection")
+    end
+
+    def current_connection?
+      !Thread.current[identifier].nil?
+    end
+
+    def current_or_default_connection
+      Thread.current[identifier] || ActiveRecord::Base.connection_pool.connection
+    end
+
+    def with_connection(name, &block)
+      connection_pool = find_connection_pool(name)
+      with_connection_pool(name, connection_pool, &block)
+    end
+
+    def with_new_connection(name, config, reusable: false, &block)
+      if reusable
+        connection_pool = @connection_pools[name] ||= create_connection_pool(config)
+        with_connection_pool(name, connection_pool, &block)
+      else
+        connection_pool = create_connection_pool(config)
+        with_connection_pool(name, connection_pool, &block).tap do
+          connection_pool.disconnect!
+        end
+      end
+    end
+
+    def without_connection(&block)
+      change_connection_reference(nil) do
+        yield
+      end
+    end
+
+    def find_connection_pool(name)
+      @connection_pools[name] || raise(Octoshark::Error::NoConnection, "No such database connection '#{name}'")
+    end
+
+    def disconnect!
+      @connection_pools.values.each do |connection_pool|
+        connection_pool.disconnect!
+      end
+    end
+
+    def identifier
+      @identifier ||= "octoshark_#{Process.pid}"
+    end
+
+    private
+    def spec_class
+      if defined?(ActiveRecord::ConnectionAdapters::ConnectionSpecification)
+        spec_class = ActiveRecord::ConnectionAdapters::ConnectionSpecification
+      else
+        spec_class = ActiveRecord::Base::ConnectionSpecification
+      end
+    end
+
+    def change_connection_reference(connection, &block)
+      previous_connection = Thread.current[identifier]
+      Thread.current[identifier] = connection
+
+      begin
+        yield
+      ensure
+        Thread.current[identifier] = previous_connection
+      end
+    end
+
+    def setup_connection_pools
+      @connection_pools = HashWithIndifferentAccess.new
+
+      @configs.each_pair do |name, config|
+        @connection_pools[name] = create_connection_pool(config)
+      end
+    end
+
+    def create_connection_pool(config)
+      spec = spec_class.new(config, "#{config[:adapter]}_connection")
+      ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec)
+    end
+
+    def with_connection_pool(name, connection_pool, &block)
+      connection_pool.with_connection do |connection|
+        connection.connection_name = name
+
+        change_connection_reference(connection) do
+          yield(connection)
+        end
+      end
+    end
+  end
+end

data/lib/octoshark/error.rb

@@ -0,0 +1,6 @@
+module Octoshark
+  class Error < StandardError
+    class NoConnection < Error; end;
+    class NoCurrentConnection < Error; end;
+  end
+end

data/lib/octoshark/version.rb

@@ -1,3 +1,3 @@
 module Octoshark
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/spec/octoshark/active_record_extensions_spec.rb

@@ -2,23 +2,14 @@ require 'spec_helper'
 require 'logger'
 
 describe "ActiveRecord Extensions" do
-  it "reloads connection pools when establishing a new connection" do
-    Octoshark.configure(configs)
-
-    spec = ActiveRecord::Base.remove_connection
-    ActiveRecord::Base.establish_connection(spec)
-
-    expect(Octoshark.find_connection_pool(:default)).to eq(ActiveRecord::Base.connection_pool)
-  end
-
   it "logs current connection name" do
     io = StringIO.new
     logger = Logger.new(io)
 
     ActiveRecord::Base.logger = logger
 
-    Octoshark.configure(configs)
-    Octoshark.with_connection(:db1) do |connection|
+    manager = Octoshark::ConnectionManager.new(configs)
+    manager.with_connection(:db1) do |connection|
       connection.execute("SELECT 1")
     end
 
@@ -33,8 +24,8 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    Octoshark.configure(configs)
-    Octoshark.with_connection(:db1) do |connection|
+    manager = Octoshark::ConnectionManager.new(configs)
+    manager.with_connection(:db1) do |connection|
       ActiveRecord::Base.connection.execute("SELECT 1")
     end
 

data/spec/octoshark/connection_manager_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+describe Octoshark::ConnectionManager do
+  describe "#initialize" do
+    it "initializes connection manager with default connection" do
+      manager = Octoshark::ConnectionManager.new
+
+      expect(manager.connection_pools.length).to eq(0)
+      expect(manager.connection_pools[:default]).to be_nil
+    end
+
+    it "initializes connection manager with custom connections" do
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      expect(manager.connection_pools.length).to eq(2)
+      expect(manager.connection_pools[:db1]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
+      expect(manager.connection_pools[:db2]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
+    end
+
+    it "accepts configs with string keys" do
+      configs = { 'db1' => { 'adapter' => "sqlite3", 'database' => "tmp/db1.sqlite" } }
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      expect { manager.connection_pools[:db1].connection }.not_to raise_error
+    end
+  end
+
+  describe "#current_connection" do
+    it "returns last used connection as current one" do
+      manager = Octoshark::ConnectionManager.new(configs)
+      manager.with_connection(:db1) do |connection|
+        expect(manager.current_connection).to eq(connection)
+      end
+    end
+
+    it "raises error when no current connection" do
+      manager = Octoshark::ConnectionManager.new
+
+      expect { manager.current_connection }.to raise_error(Octoshark::Error::NoCurrentConnection)
+    end
+  end
+
+  describe "#current_connection?" do
+    it "returns true if current one" do
+      manager = Octoshark::ConnectionManager.new(configs)
+      manager.with_connection(:db1) do
+        expect(manager.current_connection?).to be_truthy
+      end
+    end
+
+    it "returns false if no current one" do
+      manager = Octoshark::ConnectionManager.new
+
+      expect(manager.current_connection?).to be_falsey
+    end
+  end
+
+  describe "#current_or_default_connection" do
+    it "returns current connection" do
+      manager = Octoshark::ConnectionManager.new(configs)
+      manager.with_connection(:db1) do |db1|
+        expect(manager.current_or_default_connection).to eq(db1)
+      end
+    end
+
+    it "returns default connection when no current connection" do
+      manager = Octoshark::ConnectionManager.new
+
+      expect(manager.current_or_default_connection).to eq(ActiveRecord::Base.connection_pool.connection)
+    end
+  end
+
+  describe '#find_connection_pool' do
+    it "can find connection pool by name" do
+      manager = Octoshark::ConnectionManager.new(configs)
+      expect(manager.find_connection_pool(:db1)).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
+    end
+
+    it "raises Octoshark::Error::NoConnection when no pool with that name" do
+      manager = Octoshark::ConnectionManager.new({})
+      expect { manager.find_connection_pool(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
+    end
+  end
+
+  describe '#with_connection' do
+    it "can use multiple connections" do
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      manager.with_connection(:db1) do
+        expect(db(manager.current_connection)).to eq("db1")
+      end
+
+      manager.with_connection(:db2) do
+        expect(db(manager.current_connection)).to eq("db2")
+      end
+    end
+
+    it "can nest connection" do
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      manager.with_connection(:db1) do
+        expect(db(manager.current_connection)).to eq("db1")
+
+        manager.with_connection(:db2) do
+          expect(db(manager.current_connection)).to eq("db2")
+        end
+
+        expect(db(manager.current_connection)).to eq("db1")
+      end
+    end
+
+    it "returns value from execution" do
+      manager = Octoshark::ConnectionManager.new(configs)
+      result = manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(result).to eq([{"1"=>1, 0=>1}])
+    end
+
+    it "raises Octoshark::Error::NoConnection" do
+      manager = Octoshark::ConnectionManager.new({})
+
+      expect { manager.with_connection(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
+    end
+  end
+
+  describe "#with_new_connection" do
+    it "creates temporary connection" do
+      manager = Octoshark::ConnectionManager.new
+      result = manager.with_new_connection(:db1, configs[:db1]) { |connection| connection.execute("SELECT 1") }
+
+      expect(manager.connection_pools).to be_blank
+    end
+
+    it "returns query results with temporary connection" do
+      manager = Octoshark::ConnectionManager.new
+      result = manager.with_new_connection(:db1, configs[:db1]) { |connection| connection.execute("SELECT 1") }
+
+      expect(result).to eq([{"1"=>1, 0=>1}])
+    end
+
+    it "creates persistent connection" do
+      connection_id = nil
+      manager = Octoshark::ConnectionManager.new
+      expect(manager.connection_pools.length).to eq(0)
+
+      manager.with_new_connection(:db1, configs[:db1], reusable: true) do |connection|
+        connection_id = connection.object_id
+      end
+      expect(manager.connection_pools.length).to eq(1)
+
+      manager.with_new_connection(:db1, configs[:db1], reusable: true) do |connection|
+        expect(connection.object_id).to eq(connection_id)
+      end
+      expect(manager.connection_pools.length).to eq(1)
+    end
+
+    it "returns query results with persistent connection" do
+      manager = Octoshark::ConnectionManager.new
+
+      result = manager.with_new_connection(:db1, configs[:db1], reusable: true) { |connection| connection.execute("SELECT 1") }
+      expect(result).to eq([{"1"=>1, 0=>1}])
+
+      result = manager.with_new_connection(:db1, configs[:db1], reusable: true) { |connection| connection.execute("SELECT 1") }
+      expect(result).to eq([{"1"=>1, 0=>1}])
+    end
+  end
+
+  describe '#without_connection' do
+    it "can reset current connection temporarily inside nested connection block" do
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      manager.with_connection(:db1) do
+        expect(db(manager.current_connection)).to eq("db1")
+
+        manager.without_connection do
+          expect { manager.current_connection }.to raise_error(Octoshark::Error::NoCurrentConnection)
+        end
+
+        expect(db(manager.current_connection)).to eq("db1")
+      end
+    end
+  end
+
+  describe "#disconnect!" do
+    it "removes all connections from connection pools" do
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(manager.find_connection_pool(:db1)).to be_connected
+
+      manager.disconnect!
+
+      expect(manager.find_connection_pool(:db1)).to_not be_connected
+    end
+  end
+
+  describe ".reset!" do
+    it "gets new connection pools ready to rock" do
+      manager = Octoshark::ConnectionManager.new(configs)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+
+      manager.reset!
+
+      expect(manager.connection_pools[:db1].connections.count).to eq(0)
+
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+    end
+  end
+end

data/spec/octoshark_spec.rb

@@ -2,92 +2,39 @@ require 'spec_helper'
 
 describe Octoshark do
 
-  describe ".configure" do
-    it "creates connection switcher" do
-      Octoshark.configure({})
+  describe ".reset_connection_managers!" do
+    it "resets connection managers" do
+      manager = Octoshark::ConnectionManager.new(configs)
+      old_pools = manager.connection_pools.map(&:object_id)
 
-      expect(Octoshark.switcher).to_not be_nil
-    end
-  end
-
-  describe ".reset!" do
-    it "removes connection switcher" do
-      Octoshark.configure({})
-      Octoshark.reset!
-
-      expect { Octoshark.switcher }.to raise_error(Octoshark::NotConfiguredError)
-    end
-
-    it "cleans octoshark thread key" do
-      Octoshark.configure({})
-      Octoshark.reset!
+      Octoshark.reset_connection_managers!
 
-      expect(Thread.current[Octoshark::OCTOSHARK]).to be_nil
-    end
-
-    it "cleans old connections" do
-      check_connections_clean_up { Octoshark.reset! }
+      new_pools = manager.connection_pools.map(&:object_id)
+      expect(new_pools).to_not eq(old_pools)
     end
   end
 
-  describe ".reload!" do
-    it "replaces connection switcher" do
-      Octoshark.configure({})
-      switcher = Octoshark.switcher
+  describe ".disconnect!" do
+    it "disconnects connection managers" do
+      manager = Octoshark::ConnectionManager.new(configs)
 
-      Octoshark.reload!
+      Octoshark.disconnect!
 
-      expect(Octoshark.switcher).to_not be_nil
-      expect(Octoshark.switcher).to_not eq(switcher)
+      expect(Octoshark.connection_managers).to be_blank
     end
 
-    it "clears old switcher connections" do
-      check_connections_clean_up { Octoshark.reload! }
-    end
-  end
-
-  describe ".configured?" do
-    it "is not configured by default" do
-      expect(Octoshark.configured?).to be_falsey
-    end
-
-    it "is configured is switcher is configured" do
-      Octoshark.configure({})
-
-      expect(Octoshark.configured?).to be_truthy
-    end
-  end
-
-  describe ".switcher" do
-    it "returns connection switcher" do
-      Octoshark.configure({})
-
-      expect(Octoshark.switcher).to be_an_instance_of(Octoshark::ConnectionSwitcher)
-    end
+    it "cleans old connections" do
+      manager = Octoshark::ConnectionManager.new(configs)
 
-    it "raises 'NotConfiguredError' error if not configured" do
-      expect { Octoshark.switcher }.to raise_error(Octoshark::NotConfiguredError)
-    end
-  end
+      manager.with_connection(:db1) { |connection| connection.execute("SELECT 1") }
+      manager.with_connection(:db2) { |connection| connection.execute("SELECT 1") }
+      expect(manager.connection_pools[:db1].connections.count).to eq(1)
+      expect(manager.connection_pools[:db2].connections.count).to eq(1)
 
-  [
-    :connection_pools,
-    :current_connection,
-    :current_connection?,
-    :current_or_default_connection,
-    :disconnect!,
-    :find_connection_pool,
-    :with_connection,
-    :without_connection,
-  ].each do |method_name|
-    describe ".#{method_name}" do
-      it "delegates #{method_name} to connection switcher" do
-        Octoshark.configure({})
-        expect(Octoshark.switcher).to respond_to(method_name)
-        expect(Octoshark.switcher).to receive(method_name)
+      Octoshark.disconnect!
 
-        Octoshark.send(method_name)
-      end
+      expect(manager.connection_pools[:db1].connections.count).to eq(0)
+      expect(manager.connection_pools[:db2].connections.count).to eq(0)
     end
   end
 end

data/spec/spec_helper.rb

@@ -17,7 +17,6 @@ RSpec.configure do |config|
 
   config.before :each do
     ActiveRecord::Base.establish_connection({adapter: 'sqlite3', database: 'tmp/default.sqlite'})
-    Octoshark.reset!
   end
 
   config.after :suite do

data/spec/support/helpers.rb

@@ -13,16 +13,4 @@ module Helpers
       split('/').last.
       split('.').first
   end
-
-  def check_connections_clean_up
-    Octoshark.configure({})
-    switcher = Octoshark.switcher
-
-    Octoshark.with_connection(:default) { |connection| connection.execute("SELECT 1") }
-    expect(switcher.connection_pools.map { |_, c| c.connections.count }.sum).to eq(1)
-
-    yield
-
-    expect(switcher.connection_pools.map { |_, c| c.connections.count }.sum).to eq(0)
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: octoshark
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Dalibor Nasevic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-25 00:00:00.000000000 Z
+date: 2015-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -114,14 +114,16 @@ files:
 - gemfiles/rails3.2.gemfile
 - gemfiles/rails3.gemfile
 - gemfiles/rails4.1.gemfile
+- gemfiles/rails4.2.gemfile
 - gemfiles/rails4.gemfile
 - lib/octoshark.rb
 - lib/octoshark/active_record_extensions.rb
-- lib/octoshark/connection_switcher.rb
+- lib/octoshark/connection_manager.rb
+- lib/octoshark/error.rb
 - lib/octoshark/version.rb
 - octoshark.gemspec
 - spec/octoshark/active_record_extensions_spec.rb
-- spec/octoshark/connection_switcher_spec.rb
+- spec/octoshark/connection_manager_spec.rb
 - spec/octoshark_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb
@@ -151,7 +153,7 @@ specification_version: 4
 summary: Octoshark is an ActiveRecord connection switcher
 test_files:
 - spec/octoshark/active_record_extensions_spec.rb
-- spec/octoshark/connection_switcher_spec.rb
+- spec/octoshark/connection_manager_spec.rb
 - spec/octoshark_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb

data/lib/octoshark/connection_switcher.rb

@@ -1,77 +0,0 @@
-module Octoshark
-  class ConnectionSwitcher
-
-    attr_reader :connection_pools
-
-    def initialize(configs = {})
-      configs           = configs.with_indifferent_access
-      @default_pool     = ActiveRecord::Base.connection_pool
-      @connection_pools = { default: @default_pool }.with_indifferent_access
-
-      configs.each_pair do |name, config|
-        spec = spec_class.new(config, "#{config[:adapter]}_connection")
-        @connection_pools[name] = ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec)
-      end
-    end
-
-    def current_connection
-      Thread.current[OCTOSHARK] || raise(NoCurrentConnectionError, "No current connection, use Octoshark.with_connection")
-    end
-
-    def current_connection?
-      !Thread.current[OCTOSHARK].nil?
-    end
-
-    def current_or_default_connection
-      Thread.current[OCTOSHARK] || @default_pool.connection
-    end
-
-    def with_connection(name, &block)
-      find_connection_pool(name).with_connection do |connection|
-        connection.connection_name = name
-
-        change_connection_reference(connection) do
-          yield(connection)
-        end
-      end
-    end
-
-    def without_connection(&block)
-      connection = nil
-
-      change_connection_reference(connection) do
-        yield(connection)
-      end
-    end
-
-    def find_connection_pool(name)
-      @connection_pools[name] || raise(NoConnectionError, "No such database connection '#{name}'")
-    end
-
-    def disconnect!
-      @connection_pools.values.each do |connection_pool|
-        connection_pool.disconnect!
-      end
-    end
-
-    private
-    def spec_class
-      if defined?(ActiveRecord::ConnectionAdapters::ConnectionSpecification)
-        spec_class = ActiveRecord::ConnectionAdapters::ConnectionSpecification
-      else
-        spec_class = ActiveRecord::Base::ConnectionSpecification
-      end
-    end
-
-    def change_connection_reference(connection)
-      previous_connection = Thread.current[OCTOSHARK]
-      Thread.current[OCTOSHARK] = connection
-
-      begin
-        yield
-      ensure
-        Thread.current[OCTOSHARK] = previous_connection
-      end
-    end
-  end
-end

data/spec/octoshark/connection_switcher_spec.rb

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-describe Octoshark::ConnectionSwitcher do
-  describe "#initialize" do
-    it "initializes connection switcher with default connection" do
-      switcher = Octoshark::ConnectionSwitcher.new
-      conn = ActiveRecord::Base.connection
-
-      expect(switcher.connection_pools.length).to eq(1)
-      expect(switcher.connection_pools[:default]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-    end
-
-    it "initializes connection switcher with custom connections" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-
-      expect(switcher.connection_pools.length).to eq(3)
-      expect(switcher.connection_pools[:default]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-      expect(switcher.connection_pools[:db1]).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-    end
-
-    it "accepts configs with string keys" do
-      configs = { 'db1' => { 'adapter' => "sqlite3", 'database' => "tmp/db1.sqlite" } }
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-
-      expect { switcher.connection_pools[:db1].connection }.not_to raise_error
-    end
-  end
-
-  describe "#current_connection" do
-    it "returns last used connection as current one" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-      switcher.with_connection(:db1) do |connection|
-        expect(switcher.current_connection).to eq(connection)
-      end
-    end
-
-    it "raises error when no current connection" do
-      switcher = Octoshark::ConnectionSwitcher.new
-
-      expect { switcher.current_connection }.to raise_error(Octoshark::NoCurrentConnectionError)
-    end
-  end
-
-  describe "#current_connection?" do
-    it "returns true if current one" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-      switcher.with_connection(:db1) do |connection|
-        expect(switcher.current_connection?).to be_truthy
-      end
-    end
-
-    it "returns false if no current one" do
-      switcher = Octoshark::ConnectionSwitcher.new
-
-      expect(switcher.current_connection?).to be_falsey
-    end
-  end
-
-  describe "#current_or_default_connection" do
-    it "returns current connection" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-      switcher.with_connection(:db1) do |connection|
-        expect(switcher.current_or_default_connection).to eq(connection)
-      end
-    end
-
-    it "returns default connection when no current connection" do
-      switcher = Octoshark::ConnectionSwitcher.new
-      connection = switcher.find_connection_pool(:default).connection
-
-      expect(switcher.current_or_default_connection).to eq(connection)
-    end
-  end
-
-  describe '#find_connection_pool' do
-    it "can find connection pool by name" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-      expect(switcher.find_connection_pool(:db1)).to be_an_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool)
-    end
-
-    it "raises Octoshark::NoConnectionError when no pool with that name" do
-      switcher = Octoshark::ConnectionSwitcher.new({})
-      expect { switcher.find_connection_pool(:invalid) }.to raise_error(Octoshark::NoConnectionError)
-    end
-  end
-
-  describe '#with_connection' do
-    it "can select default connection" do
-      switcher = Octoshark::ConnectionSwitcher.new({})
-
-      switcher.with_connection(:default) do |connection|
-        expect(db(switcher.current_connection)).to eq("default")
-      end
-    end
-
-    it "can use multiple connections" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-
-      switcher.with_connection(:default) do |connection|
-        expect(db(switcher.current_connection)).to eq("default")
-      end
-
-      switcher.with_connection(:db1) do |connection|
-        expect(db(switcher.current_connection)).to eq("db1")
-      end
-
-      switcher.with_connection(:db2) do |connection|
-        expect(db(switcher.current_connection)).to eq("db2")
-      end
-    end
-
-    it "can nest connection" do
-      switcher = Octoshark::ConnectionSwitcher.new(configs)
-
-      switcher.with_connection(:db1) do |connection|
-        expect(db(switcher.current_connection)).to eq("db1")
-
-        switcher.with_connection(:db2) do |connection|
-          expect(db(switcher.current_connection)).to eq("db2")
-        end
-
-        expect(db(switcher.current_connection)).to eq("db1")
-      end
-    end
-
-    it "returns value from execution" do
-      switcher = Octoshark::ConnectionSwitcher.new({})
-      result = switcher.with_connection(:default) { |connection| connection.execute("SELECT 1") }
-      expect(result).to eq([{"1"=>1, 0=>1}])
-    end
-
-    it "raises Octoshark::NoConnectionError" do
-      switcher = Octoshark::ConnectionSwitcher.new({})
-
-      expect { switcher.with_connection(:invalid) }.to raise_error(Octoshark::NoConnectionError)
-    end
-  end
-
-  describe '#without_connection' do
-    it "can reset current connection temporarily inside nested connection block" do
-      switcher = Octoshark::ConnectionSwitcher.new({})
-
-      switcher.with_connection(:default) do |connection|
-        expect(db(switcher.current_connection)).to eq("default")
-
-        switcher.without_connection do |connection|
-          expect { switcher.current_connection }.to raise_error(Octoshark::NoCurrentConnectionError)
-        end
-
-        expect(db(switcher.current_connection)).to eq("default")
-      end
-    end
-  end
-
-  describe "#disconnect!" do
-    it "removes all connections from connection pools" do
-      switcher = Octoshark::ConnectionSwitcher.new({})
-
-      switcher.with_connection(:default) { |connection| connection.execute("SELECT 1") }
-      expect(switcher.find_connection_pool(:default)).to be_connected
-
-      switcher.disconnect!
-
-      expect(switcher.find_connection_pool(:default)).to_not be_connected
-    end
-  end
-end