octoshark 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8eac1fa769be042b9c258530c49c05ef91723ab
-  data.tar.gz: 1852cb828c3babdcdcb79298e4619581bb72b216
+  metadata.gz: 250485b4a7d40ba746223723276e9edbee4fc8b0
+  data.tar.gz: 0c58c2fd4569f288fe87129c0566bba3d34790aa
 SHA512:
-  metadata.gz: 535e065d62a6cd01e38d6d993e25a02f182a0dfa07df4b3150de13418caabeaf325531bd3560005b62e6e002e39b2835fcea701621d5454c03e01a16916cd325
-  data.tar.gz: 026dee2bd0e09b7f5ea1c3c2300727ff224f6820e51cc562cec57bd33ad92765267e760957168841054dcb76fd0391d19c4dfc99588092c1c49fdd7487887a39
+  metadata.gz: e904f55fa222ea36745a01fedbf936dd2bca0bbfe116b7eaa69ab0e56ae5fef5503fe800d2f5065d8d69d6ee2b7244ba5644e5ff5e5adc66d032f9f3d1fc9470
+  data.tar.gz: 139e493c0f689d4865f218247a8e0bfafee8f9605e7cb14b0ad0c3356422d0a32e731fd5127b52da7d6f05e291112c373af40959324b1fa2c9f5d26799ac4469

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## 0.2.0 2016-08-29
+
+- `Octoshark::ConnectionManager` is split in two managers `Octoshark::ConnectionPoolsManager` for persistent connections and `Octoshark::ConnectionManager` for non-persistent connections.
+- `Octoshark` class methods like `connection_managers`, `reset_connection_managers!`, `disconnect!` are only relevant and moved to `Octoshark::ConnectionPoolsManager` class.
+- `Octoshark::ConnectionManager#use_database` method has been removed and the functionality moved to `Octoshark::ConnectionPoolsManager#with_connection(name, database_name)` where the second optional argument `database_name` when specified will switch the connection to the database using the `use database` MySQL statement.

data/README.md

@@ -2,7 +2,7 @@
 
 ![Travis status](https://travis-ci.org/dalibor/octoshark.png)
 
-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.
+Octoshark is a simple ActiveRecord connection manager. It provides connection switching mechanisms that can be used in various scenarios like master-slave, sharding or multi-tenant architecture.
 
 
 ## Installation
@@ -28,138 +28,142 @@ $ gem install octoshark
 
 ## Usage
 
-Create a new connection manager with connection 2 pools for Octoshark to manage. This usually goes in the app initializer.
+Octoshark has two connection managers: `ConnectionPoolsManager` for managing connection pools using persistent connections and `ConnectionManager` for managing non-persistent connections. It depends on your application performance and scaling requirements which one to use.
 
-```ruby
-CONN_MANAGER = Octoshark::ConnectionManager.new({
-  db1: { adapter: "sqlite3", database: "db/db1.sqlite" },
-  db2: { adapter: "sqlite3", database: "db/db2.sqlite" }
-})
-```
+- If you have a limited number of consumers (application and worker servers), `ConnectionPoolsManager` would be the preferred option. Standard Rails application has a single connection pool, and `ConnectionPoolsManager` just makes it possible for application models to work with multiple connection pools.
+
+- If you have a very big infrastructure with lots of consumers (application and worker servers) and you are hitting max connections limit on database servers, i.e. you need to scale horizontally, `ConnectionManager` is the option to use. Because it uses non-persistent connections it comes up with a performance penalty because connections are re-established over and over again. Some ActiveRecord plugins that depend on having an active database connection all the time might need a change in order to work with non-persistent connections.
 
-Configure which ActiveRecord model will use the Octoshark connection by overriding the `Model.connection` method.
+`ConnectionPoolsManager` and `ConnectionManager` can be combined together and many of them can be used at the same time.
+
+Here is how to create connection pools manager:
 
 ```ruby
-class Post < ActiveRecord::Base
-  def self.connection
-    CONN_MANAGER.current_connection
-  end
-end
+CONN_MANAGER = Octoshark::ConnectionPoolsManager.new({ c1: config1, c2: config2 })
 ```
 
-Alternatively, extract it as a module and include in models.
+`config1` and `config2` are standard ActiveRecord database configs:
 
 ```ruby
-module ShardingModel
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    def connection
-      OCTOSHARK.current_connection
-    end
-  end
-end
+config = {
+  adapter:  'mysql2',
+  host:     'localhost',
+  port:     3306,
+  database: 'database',
+  username: 'root',
+  password: 'pass',
+  pool:     1,
+  encoding: 'utf8',
+  reconnect: false
+}
 ```
 
-To use a specific database connection:
+To switch a connection using a specific pool:
 
 ```ruby
-CONN_MANAGER.with_connection(:db1) do
-  # run queries on db1
-  Post.first
+CONN_MANAGER.with_connection(:c1) do |connection|
+  connection.execute("SELECT 1")
 end
 ```
 
 Multiple `with_connection` blocks can be nested:
 
 ```ruby
-CONN_MANAGER.with_connection(:db1) do
-  # run queries on db1
+CONN_MANAGER.with_connection(config1) do
+  # run queries on connection specified with config1
 
-  CONN_MANAGER.with_connection(:db2) do
-    # run queries on db2
+  CONN_MANAGER.with_connection(config2) do
+    # run queries on connection specified with config2
   end
 
-  # run queries on db1
+  # run queries on connection specified with config1
 end
 ```
 
-`CONN_MANAGER.current_connection` returns the active connection while in the `with_connection` block or raises `Octoshark::Error::NoCurrentConnection` otherwise.
+If you establish a connection to database server instead of to database, then you can use the second optional argument `database_name` to tell the connection manager to switch the connection to that database within the same connection. This is useful when you want to have fewer connection pools and keep number of active connection per database server under control. This option is only MySQL specific for now, it uses `USE database_name` statement to switch the connection.
 
+```ruby
+CONN_MANAGER.with_connection(:c1, database_name) do |connection|
+  connection.execute("SELECT 1")
+end
+```
 
-## Sharding example
-
-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.
+Using non-persistent connections with `Octoshark::ConnectionManager` has the same API:
 
-Switch the connection in a controller with an around filter:
 
 ```ruby
-around_filter :select_shard
+CONN_MANAGER = Octoshark::ConnectionManager.new
+```
 
-def select_shard(&block)
-  CONN_MANAGER.with_connection(current_user.shard, &block)
+Opening a new connection, executing query and closing the connection:
+
+```ruby
+CONN_MANAGER.with_connection(config) do |connection|
+  connection.execute("SELECT 1")
 end
 ```
 
-Similar approach applies to other application entry-points like background jobs.
 
+## Using Octoshark with ActiveRecord models
 
-## Master-Slave example
-
-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.
+To tell an ActiveRecord model to use the Octoshark connection we can override the `Model.connection` method.
 
 ```ruby
-class ActiveRecord::Base
+class Post < ActiveRecord::Base
   def self.connection
-    # Return the current connection (from with_connection block) or default one
-    CONN_MANAGER.current_or_default_connection
+    CONN_MANAGER.current_connection
   end
 end
 ```
 
-`CONN_MANAGER.current_or_default_connection` method returns the current connection while in `with_connection` block or the default ActiveRecord connection when outside.
-
+Alternatively, we can extract it as a module and include in multiple models.
 
-## Multi-tenant example
+```ruby
+module ShardingModel
+  extend ActiveSupport::Concern
 
-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.
+  module ClassMethods
+    def connection
+      CONN_MANAGER.current_connection
+    end
+  end
+end
+```
 
-Switch the connection in a controller with an around filter:
+To use a specific database connection:
 
 ```ruby
-# in initializer
-CONN_MANAGER = Octoshark::ConnectionManager.new
+CONN_MANAGER.with_connection(:c1) do
+  # run queries on c1
+  Post.first
+end
+```
 
-# in controller
+This connection switching in Rails applications is usually done from within an `around_filter` for controllers and in a similar way for other application "entry-points" like background jobs:
+
+```ruby
 around_filter :select_shard
 
 def select_shard(&block)
-  CONN_MANAGER.with_new_connection(name, config, reusable: false, &block)
+  CONN_MANAGER.with_connection(current_user.shard, &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.
+`CONN_MANAGER.current_connection` returns the active connection while the execution is in the `with_connection` block or raises `Octoshark::Error::NoCurrentConnection` outside of the `with_connection` block. In some cases, falling back to the default database connection for the Rails app might be preferable which can be done using `CONN_MANAGER.current_or_default_connection`.
 
-Alternatively, for better performance (only supported on MySQL), database connection can be switched with `use database` statement. Once connection manager is defined with connectino configs to database servers, selecting a database can be done with:
 
-```ruby
-CONN_MANAGER.use_database(:db1, 'database') do
-  # run queries on database server identified by 'db1' using database 'database'
-end
-```
-
-## Octoshark.reset_connection_managers!
+## Octoshark::ConnectionPoolsManager.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:
+When using `Octoshark::ConnectionPoolsManager`, 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
 * Some rake tasks like `rake db:test:prepare`
 
 
-## Database Cleaner
+## Cleaning test databases
 
-RSpec example on how to clean default and Octoshark data with Database Cleaner:
+When using persistent connections, you can use tools like [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner) or [DatabaseRewinder](https://github.com/amatsuda/database_rewinder) to clean test databases. Here's an example of RSpec config for `DatabaseCleaner`:
 
 ```ruby
 config.before(:suite) do
@@ -179,7 +183,7 @@ end
 
 def setup_database_cleaner
   DatabaseCleaner[:active_record, {connection: ActiveRecord::Base.connection_pool}]
-  Octoshark.connection_managers.each do |manager|
+  Octoshark::ConnectionPoolsManager.connection_managers.each do |manager|
     manager.connection_pools.each_pair do |connection_name, connection_pool|
       DatabaseCleaner[:active_record, {connection: connection_pool}]
     end
@@ -187,6 +191,74 @@ def setup_database_cleaner
 end
 ```
 
+When using non-persistent connections where transaction rollback as a cleaning strategy will not work, we can use a custom solution inspired by `DatabaseRewinder`. It also works with dynamic databases created on the fly in the test suite.
+
+```ruby
+module DatabaseCleaner
+  module InsertRecorder
+    def execute(sql, *)
+      DatabaseCleaner.record_inserted_table(self, sql)
+      super
+    end
+
+    def exec_query(sql, *)
+      DatabaseCleaner.record_inserted_table(self, sql)
+      super
+    end
+  end
+
+  @@tables = []
+
+  def self.tables
+    @@tables
+  end
+
+  def self.record_inserted_table(connection, sql)
+    match = sql.match(/\AINSERT(?:\s+IGNORE)?\s+INTO\s+(?:\.*[`"]?([^.\s`"]+)[`"]?)*/i)
+    tables << match[1] if match && !tables.include?(match[1])
+  end
+
+  def self.clean
+    CoreDB.with_connection do |connection|
+      (
+        connection.tables.reject { |t| t == ActiveRecord::Migrator.schema_migrations_table_name } & tables
+      ).each do |table|
+        connection.disable_referential_integrity do
+          connection.execute "DELETE FROM #{connection.quote_table_name(table)};"
+        end
+      end
+    end
+    @@tables = []
+  end
+end
+
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send(:prepend, DatabaseCleaner::InsertRecorder)
+```
+
+
+## Development Setup
+
+Setup database config and create databases:
+
+```bash
+cp spec/support/config.yml.template spec/support/config.yml
+rake db:create
+```
+
+Run specs:
+
+```bash
+bundle exec rspec spec
+```
+
+Install different active record versions defined in `Appraisals` and run specs for all of them:
+
+```bash
+bundle exec appraisal
+bundle exec appraisal rspec spec
+```
+
 
 ## Logo
 

data/lib/octoshark.rb

@@ -3,23 +3,8 @@ require 'active_record'
 require 'octoshark/active_record_extensions'
 
 module Octoshark
-  autoload :ConnectionManager, 'octoshark/connection_manager'
-  autoload :Error,             'octoshark/error'
-
-  # Octoshark needs to keep track of all connection managers in order to
-  # automatically reconnect on connection establish.
-  @@connection_managers = []
-
-  def self.connection_managers
-    @@connection_managers
-  end
-
-  def self.reset_connection_managers!
-    connection_managers.map(&:reset!)
-  end
-
-  def self.disconnect!
-    connection_managers.map(&:disconnect!)
-    @@connection_managers = []
-  end
+  autoload :CurrentConnection,      'octoshark/current_connection'
+  autoload :ConnectionManager,      'octoshark/connection_manager'
+  autoload :ConnectionPoolsManager, 'octoshark/connection_pools_manager'
+  autoload :Error,                  'octoshark/error'
 end

data/lib/octoshark/active_record_extensions.rb

@@ -15,7 +15,7 @@ module Octoshark
       # Octoshark connection managers.
       def establish_connection_with_octoshark(*args)
         establish_connection_without_octoshark(*args)
-        Octoshark.reset_connection_managers!
+        Octoshark::ConnectionPoolsManager.reset_connection_managers!
       end
     end
   end
@@ -30,12 +30,8 @@ module Octoshark
     end
 
     def log_with_octoshark(sql, name = "SQL", *other_args, &block)
-      if connection_name
-        if database_name
-          name = "[Octoshark: #{connection_name} #{database_name}] #{name}"
-        else
-          name = "[Octoshark: #{connection_name}] #{name}"
-        end
+      if connection_name || database_name
+        name = "[Octoshark: #{[connection_name, database_name].compact.join(' ')}] #{name}"
       end
 
       log_without_octoshark(sql, name, *other_args, &block)

data/lib/octoshark/connection_manager.rb

@@ -1,118 +1,20 @@
 module Octoshark
   class ConnectionManager
+    include CurrentConnection
 
-    attr_reader :connection_pools
+    def with_connection(config, connection_name: nil, &block)
+      connection_method = "#{config[:adapter]}_connection"
 
-    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 use_database(name, database_name, &block)
-      connection_pool = find_connection_pool(name)
-      with_connection_pool(name, connection_pool, database_name, &block)
-    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_#{object_id}"
-    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
+      connection = ActiveRecord::Base.send(connection_method, config)
+      connection.connection_name = connection_name
+      connection.database_name = config[:database] if config[:database]
 
       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, database_name = nil, &block)
-      connection_pool.with_connection do |connection|
-        connection.connection_name = name
-        if database_name
-          connection.database_name = database_name
-          connection.execute("use #{database_name}")
-        end
-
         change_connection_reference(connection) do
           yield(connection)
         end
+      ensure
+        connection.disconnect!
       end
     end
   end

data/lib/octoshark/connection_pools_manager.rb

@@ -0,0 +1,85 @@
+module Octoshark
+  class ConnectionPoolsManager
+    include CurrentConnection
+
+    # Octoshark needs to keep track of all persistent connection managers
+    # in order to automatically reconnect on connection establish.
+    @@connection_managers = []
+
+    def self.connection_managers
+      @@connection_managers
+    end
+
+    def self.reset_connection_managers!
+      connection_managers.map(&:reset!)
+    end
+
+    def self.disconnect!
+      connection_managers.map(&:disconnect!)
+      @@connection_managers = []
+    end
+
+    attr_reader :connection_pools
+
+    def initialize(configs = {})
+      @configs = configs.with_indifferent_access
+      setup_connection_pools
+
+      self.class.connection_managers << self
+    end
+
+    def reset!
+      disconnect!
+      setup_connection_pools
+    end
+
+    def with_connection(name, database_name = nil, &block)
+      connection_pool = find_connection_pool(name)
+
+      connection_pool.with_connection do |connection|
+        connection.connection_name = name
+
+        if database_name
+          connection.database_name = database_name
+          connection.execute("use #{database_name}")
+        end
+
+        change_connection_reference(connection) do
+          yield(connection)
+        end
+      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
+
+    private
+    def spec_class
+      if defined?(ActiveRecord::ConnectionAdapters::ConnectionSpecification)
+        spec_class = ActiveRecord::ConnectionAdapters::ConnectionSpecification
+      else
+        spec_class = ActiveRecord::Base::ConnectionSpecification
+      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
+  end
+end

data/lib/octoshark/current_connection.rb

@@ -0,0 +1,37 @@
+module Octoshark
+  module CurrentConnection
+    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 without_connection(&block)
+      change_connection_reference(nil) do
+        yield
+      end
+    end
+
+    def identifier
+      @identifier ||= "octoshark_#{object_id}"
+    end
+
+    private
+    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
+  end
+end

data/lib/octoshark/version.rb

@@ -1,3 +1,3 @@
 module Octoshark
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/octoshark/active_record_extensions_spec.rb

@@ -8,7 +8,7 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    manager = Octoshark::ConnectionManager.new(configs)
+    manager = Octoshark::ConnectionPoolsManager.new(configs)
     manager.with_connection(:db1) do |connection|
       connection.execute("SELECT 1")
     end
@@ -25,8 +25,8 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    manager = Octoshark::ConnectionManager.new(mysql2_configs)
-    manager.use_database(:db1, database_name) do |connection|
+    manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+    manager.with_connection(:db1, database_name) do |connection|
       connection.execute("SELECT 1")
     end
 
@@ -41,7 +41,7 @@ describe "ActiveRecord Extensions" do
 
     ActiveRecord::Base.logger = logger
 
-    manager = Octoshark::ConnectionManager.new(configs)
+    manager = Octoshark::ConnectionPoolsManager.new(configs)
     manager.with_connection(:db1) do |connection|
       ActiveRecord::Base.connection.execute("SELECT 1")
     end

data/spec/octoshark/connection_manager_spec.rb

@@ -1,245 +1,48 @@
 require 'spec_helper'
 
 describe Octoshark::ConnectionManager do
-  describe "#initialize" do
-    it "initializes connection manager with default connection" do
+  describe "#with_connection", mysql2: true do
+    it "creates temporary connection to database server" do
       manager = Octoshark::ConnectionManager.new
+      connection_reference = nil
 
-      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
+      config = mysql2_configs[:db1]
 
-  describe "#identifier" do
-    it "has unique identifiers" do
-      manager1 = Octoshark::ConnectionManager.new
-      manager2 = Octoshark::ConnectionManager.new
-      expect(manager1.identifier).to_not eq(manager2.identifier)
-    end
-  end
+      manager.with_connection(config.except(:database)) do |connection|
+        connection_reference = connection
 
-  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)
+        connection.execute("SELECT 1")
+        expect(connection.database_name).to be_nil
       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
+      expect(connection_reference.active?).to eq(false)
     end
 
-    it "returns false if no current one" do
+    it "creates temporary connection to specific database", mysql2: true do
       manager = Octoshark::ConnectionManager.new
+      connection_reference = nil
 
-      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
+      config = mysql2_configs[:db1]
+      database_name = config.fetch('database')
 
-    it "returns default connection when no current connection" do
-      manager = Octoshark::ConnectionManager.new
+      manager.with_connection(config) do |connection|
+        connection_reference = connection
 
-      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")
+        connection.execute("SELECT 1")
+        expect(connection.database_name).to eq(database_name)
       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
+      expect(connection_reference.active?).to eq(false)
     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
+      config = configs[:db1]
+      result = manager.with_connection(config) do |connection|
+        connection.execute("SELECT 1")
       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 "#use_database" do
-    it "can nest connection", mysql2: true do
-      manager = Octoshark::ConnectionManager.new(mysql2_configs)
-
-      db1 = mysql2_configs[:db1]['database']
-      db2 = mysql2_configs[:db2]['database']
-
-      manager.use_database(:db1, db1) do
-        expect(db(manager.current_connection)).to eq(db1)
-
-        manager.use_database(:db2, 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", mysql2: true do
-      manager = Octoshark::ConnectionManager.new(mysql2_configs)
-      db1 = mysql2_configs[:db1]['database']
-      result = manager.use_database(:db1, db1) { |connection| connection.execute("SELECT 1") }.to_a
-      expect(result).to eq([[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/connection_pools_manager_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe Octoshark::ConnectionPoolsManager do
+  describe "#initialize" do
+    it "initializes connection manager with default connection" do
+      manager = Octoshark::ConnectionPoolsManager.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::ConnectionPoolsManager.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::ConnectionPoolsManager.new(configs)
+
+      expect { manager.connection_pools[:db1].connection }.not_to raise_error
+    end
+  end
+
+  describe '#find_connection_pool' do
+    it "can find connection pool by name" do
+      manager = Octoshark::ConnectionPoolsManager.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::ConnectionPoolsManager.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::ConnectionPoolsManager.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::ConnectionPoolsManager.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::ConnectionPoolsManager.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::ConnectionPoolsManager.new({})
+
+      expect { manager.with_connection(:invalid) }.to raise_error(Octoshark::Error::NoConnection)
+    end
+
+    context "using specific database", mysql2: true do
+      it "can use specific database" do
+        manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+
+        db1 = mysql2_configs[:db1]['database']
+        db2 = mysql2_configs[:db2]['database']
+
+        manager.with_connection(:db1, db1) do
+          expect(db(manager.current_connection)).to eq(db1)
+
+          manager.with_connection(:db2, db2) do
+            expect(db(manager.current_connection)).to eq(db2)
+          end
+
+          expect(db(manager.current_connection)).to eq(db1)
+        end
+      end
+
+      it "sets database name on the connection" do
+        manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+
+        db1 = mysql2_configs[:db1]['database']
+
+        manager.with_connection(:db1, db1) do |connection|
+          expect(connection.database_name).to eq('octoshark_db1')
+        end
+      end
+
+      it "returns value from execution" do
+        manager = Octoshark::ConnectionPoolsManager.new(mysql2_configs)
+        db1 = mysql2_configs[:db1]['database']
+        result = manager.with_connection(:db1, db1) { |connection| connection.execute("SELECT 1") }.to_a
+        expect(result).to eq([[1]])
+      end
+    end
+  end
+
+  describe "#disconnect!" do
+    it "removes all connections from connection pools" do
+      manager = Octoshark::ConnectionPoolsManager.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::ConnectionPoolsManager.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
+
+  describe ".reset_connection_managers!" do
+    it "resets connection managers" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+      old_pools = manager.connection_pools.map(&:object_id)
+
+      Octoshark::ConnectionPoolsManager.reset_connection_managers!
+
+      new_pools = manager.connection_pools.map(&:object_id)
+      expect(new_pools).to_not eq(old_pools)
+    end
+  end
+
+  describe ".disconnect!" do
+    it "disconnects connection managers" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      Octoshark::ConnectionPoolsManager.disconnect!
+
+      expect(Octoshark::ConnectionPoolsManager.connection_managers).to be_blank
+    end
+
+    it "cleans old connections" do
+      manager = Octoshark::ConnectionPoolsManager.new(configs)
+
+      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)
+
+      Octoshark::ConnectionPoolsManager.disconnect!
+
+      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/octoshark/current_connection_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe "connection manager" do
+  let(:config) { configs[:db1] }
+
+  describe "#identifier" do
+    it "has unique identifiers" do
+      manager1 = Octoshark::ConnectionManager.new
+      manager2 = Octoshark::ConnectionManager.new
+      expect(manager1.identifier).to_not eq(manager2.identifier)
+    end
+  end
+
+  describe "#current_connection" do
+    it "returns last used connection as current one" do
+      manager = Octoshark::ConnectionManager.new
+      manager.with_connection(config) 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
+      manager.with_connection(config) 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
+      manager.with_connection(config) do |connection|
+        expect(manager.current_or_default_connection).to eq(connection)
+      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 '#without_connection' do
+    it "can reset current connection temporarily inside nested connection block" do
+      manager = Octoshark::ConnectionManager.new
+
+      manager.with_connection(config) 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
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: octoshark
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Dalibor Nasevic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2016-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -120,6 +120,7 @@ files:
 - ".ruby-version"
 - ".travis.yml"
 - Appraisals
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -132,12 +133,15 @@ files:
 - lib/octoshark.rb
 - lib/octoshark/active_record_extensions.rb
 - lib/octoshark/connection_manager.rb
+- lib/octoshark/connection_pools_manager.rb
+- lib/octoshark/current_connection.rb
 - lib/octoshark/error.rb
 - lib/octoshark/version.rb
 - octoshark.gemspec
 - spec/octoshark/active_record_extensions_spec.rb
 - spec/octoshark/connection_manager_spec.rb
-- spec/octoshark_spec.rb
+- spec/octoshark/connection_pools_manager_spec.rb
+- spec/octoshark/current_connection_spec.rb
 - spec/spec_helper.rb
 - spec/support/config.yml.template
 - spec/support/config.yml.travis
@@ -169,7 +173,8 @@ summary: Octoshark is an ActiveRecord connection switcher
 test_files:
 - spec/octoshark/active_record_extensions_spec.rb
 - spec/octoshark/connection_manager_spec.rb
-- spec/octoshark_spec.rb
+- spec/octoshark/connection_pools_manager_spec.rb
+- spec/octoshark/current_connection_spec.rb
 - spec/spec_helper.rb
 - spec/support/config.yml.template
 - spec/support/config.yml.travis

data/spec/octoshark_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Octoshark do
-
-  describe ".reset_connection_managers!" do
-    it "resets connection managers" do
-      manager = Octoshark::ConnectionManager.new(configs)
-      old_pools = manager.connection_pools.map(&:object_id)
-
-      Octoshark.reset_connection_managers!
-
-      new_pools = manager.connection_pools.map(&:object_id)
-      expect(new_pools).to_not eq(old_pools)
-    end
-  end
-
-  describe ".disconnect!" do
-    it "disconnects connection managers" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      Octoshark.disconnect!
-
-      expect(Octoshark.connection_managers).to be_blank
-    end
-
-    it "cleans old connections" do
-      manager = Octoshark::ConnectionManager.new(configs)
-
-      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)
-
-      Octoshark.disconnect!
-
-      expect(manager.connection_pools[:db1].connections.count).to eq(0)
-      expect(manager.connection_pools[:db2].connections.count).to eq(0)
-    end
-  end
-end