mongoid_connection_pool 1.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzQ5Y2MxMTY1YmMyODFjNTI0YzQ5MDQ4NjhkM2VmNDRiYTExYjY2ZA==
+  data.tar.gz: !binary |-
+    MTMzZTMwYzZjNTlkYTcyMGZjYWJhMTI3ZmNkZDUyNGEwYTMwMzAwNA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzRhMmIwYmY5NmI2YzQ0YzExNzAwMTE4NjA5MjRlMTQ2OTAxMDRhOTU1MzMy
+    ZDA2ZmYzMTc4OGY2NGRmNmVjYWM2MWNmYWUzYWU0YjU5YmI2ZjA5OWM4ZWMw
+    Y2RmNDNjMGExNTAwYTlkZWFhMDBlNzY0MzkzMTI1MmZlNzEzZjk=
+  data.tar.gz: !binary |-
+    YjI1NTkyODUwODQyODgxZTJiMTFjMzViNWIwM2M5OWZjMWQ5YWZmYWExM2Yx
+    MGQzZjEwYjJlMGJjMjM0NjE5ZGYwNTc3YzA5MjEwOWUzZjEyYmIzMWJkZGJm
+    ZGYzNmRiMWQ5ZDhlNDMzN2UxOThhYzJiNmU5ODcyMzYwZTVjMDU=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongoid_connection_pool.gemspec
+gemspec
+
+gem 'mongoid', '~> 3.1.0'
+
+gem 'rspec', groups: [:development, :test]

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Brian Goff
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# MongoidConnectionPool
+
+If you have ever use Mongoid in a threaded environment such as Sidekiq
+with Rubinius or JRuby, you will quickly find out that it is not safe to use Mongoid.
+
+Mongoid by default gives every thread it's own database connection and doesn't
+clean up after itself, so these connections remain open.
+MongoDB will quickly become overloaded and you will no longer be able to connect.
+Often times MongoDB will also likely crash.
+
+This gem monkey patches Mongoid (>= 3.1 < 4.0) to add connection pooling.
+We take over how Mongoid handles it's connections, so there is nothing you need
+to do to take advantage of it.
+
+This was originally submitted as a PR to the Mongoid project but was turned down
+since Moped 2.0(MongoDB database driver used by Mongoid) includes it's own
+implementation of connection pooling.
+This is all well and good but it is still as of yet to be released, and won't
+be supported on Mongoid versions < 4.0 (also unreleased).
+
+This monkey patche passes all of Mongoid's specs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mongoid_connection_pool'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid_connection_pool
+
+## Usage
+
+Just require mongoid_connection_pool AFTER Mongoid.  That's it.  Easy-peasy.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/mongoid_connection_pool.rb

@@ -0,0 +1,3 @@
+require 'mongoid'
+require "mongoid_connection_pool/version"
+require "mongoid_connection_pool/mongoid"

data/lib/mongoid_connection_pool/mongoid.rb

@@ -0,0 +1,11 @@
+require 'thread'
+require 'thread_safe'
+require 'monitor'
+require_relative 'mongoid/config'
+require_relative 'mongoid/sessions'
+
+module Mongoid
+  def with_session(&block)
+    Sessions.with_session(&block)
+  end
+end

data/lib/mongoid_connection_pool/mongoid/config.rb

@@ -0,0 +1,7 @@
+module Mongoid
+  module Config
+    option :session_pool_size, :default        => 5
+    option :session_checkout_timeout, :default => 5
+    option :session_reap_frequency, :default   => 3
+  end
+end

data/lib/mongoid_connection_pool/mongoid/sessions.rb

@@ -0,0 +1,51 @@
+require_relative 'sessions/session_pool'
+
+module Mongoid
+  module Sessions
+    class << self
+      def synchronize(&block)
+        @lock ||= Mutex.new
+        @lock.synchronize(&block)
+      end
+
+      def session_pool(name=:default)
+        if !@session_pool || !@session_pool[name]
+          synchronize do
+            @session_pool ||= {}
+            @session_pool[name] ||= SessionPool.new(
+              :size             => Config.session_pool_size,
+              :name             => name,
+              :checkout_timeout => Config.session_checkout_timeout,
+              :reap_frequency   => Config.session_reap_frequency)
+          end
+        end
+        @session_pool[name]
+      end
+
+      def disconnect
+        synchronize do
+          session_pool.each {|s| s.disconnect}
+          @session_pool = nil
+        end
+      end
+
+      def with_name(name)
+        session_pool(name).session_for_thread(Thread.current) ||
+          session_pool(name).checkout
+      end
+
+      def with_session(name=:default)
+        yield
+      ensure
+        reap_current_session(name)
+      end
+
+      private
+
+      def reap_current_session(name, thread = Thread.current)
+        session_pool(name).checkin_from_thread thread
+        true
+      end
+    end
+  end
+end

data/lib/mongoid_connection_pool/mongoid/sessions/session_pool.rb

@@ -0,0 +1,235 @@
+module Mongoid
+  module Sessions
+    class SessionPool
+      class Queue
+        class ConnectionTimeoutError < StandardError; end
+
+        def initialize(lock=Monitor.new)
+          @lock = lock
+          @cond = @lock.new_cond
+          @num_waiting = 0
+          @queue = []
+        end
+
+        def any_waiting?
+          synchronize do
+            @num_waiting > 0
+          end
+        end
+
+        def num_waiting
+          synchronize do
+            @num_waiting
+          end
+        end
+
+        def add(session)
+          synchronize do
+            @queue.push session
+            @cond.signal
+          end
+        end
+
+        def remove
+          synchronize do
+            @queue.shift
+          end
+        end
+
+        def poll(timeout = nil)
+          synchronize do
+            if timeout
+              no_wait_poll || wait_poll(timeout)
+            else
+              no_wait_poll
+            end
+          end
+        end
+
+        def count
+          @queue.count
+        end
+
+        private
+
+        def synchronize(&block)
+          @lock.synchronize(&block)
+        end
+
+        def any?
+          !@queue.empty?
+        end
+
+        def can_remove_no_wait?
+          @queue.size > @num_waiting
+        end
+
+        def no_wait_poll
+          remove if can_remove_no_wait?
+        end
+
+        def wait_poll(timeout)
+          @num_waiting += 1
+
+          t0 = Time.now
+          elapsed = 0
+          loop do
+            @cond.wait(timeout - elapsed)
+
+            return remove if any?
+
+            elapsed = Time.now - t0
+            if elapsed >= timeout
+              msg = 'Timed out waiting for database session'
+              raise ConnectionTimeoutError, msg
+            end
+          end
+        ensure
+          @num_waiting -= 1
+        end
+      end
+
+      include MonitorMixin
+
+      attr_reader :sessions, :size, :reaper, :reserved_sessions, :available
+      def initialize(opts={})
+        super()
+        opts[:name] ||= :default
+
+        @reaper = Reaper.new(opts[:reap_frequency] || 10, self)
+        @reaper.run
+
+        @checkout_timeout = opts[:checkout_timeout] || 5
+
+        @size = opts[:size] || 5
+        @name = opts[:name] || :default
+        @sessions = []
+        @reserved_sessions = ThreadSafe::Cache.new(:initial_capacity => @size)
+        @available = Queue.new self
+      end
+
+      def checkout
+        unless (session = session_for_thread(Thread.current))
+          synchronize do
+            session = get_session
+            reserve(session)
+          end
+        end
+        session
+      end
+
+      # Returns a session back to the available pool
+      def checkin(session)
+        synchronize do
+          @available.add session
+          release(session)
+        end
+        true
+      end
+
+      def clear(thread=nil)
+        if thread
+          @reserved_sessions.delete(thread) if session_for(thread)
+          @sessions.pop
+        else
+          @reserved_sessions = {}
+          @sessions = []
+          @available = Queue.new self
+        end
+        @reserved_sessions
+      end
+
+      def checkin_from_thread(thread)
+        checkin @reserved_sessions[thread]
+        true
+      end
+
+      def count
+        @available.count
+      end
+
+      def reap
+        @reserved_sessions.keys.each do |thread|
+          session = @reserved_sessions[thread]
+          checkin(session) if thread.stop?
+        end
+      end
+
+      def session_for_thread(thread)
+        @reserved_sessions[thread]
+      end
+
+      def session_for(thread)
+        @reserved_sessions[thread]
+      end
+
+
+      private
+
+      def reserve(session)
+        @reserved_sessions[current_session_id] = session
+      end
+
+      def current_session_id
+        Thread.current
+      end
+
+      def release(session)
+        thread =  if @reserved_sessions[current_session_id] == session
+                      current_session_id
+                  else
+                    @reserved_sessions.keys.find do |k|
+                      @reserved_sessions[k] == session
+                    end
+                  end
+        @reserved_sessions.delete thread if thread
+      end
+
+      def get_session
+        if session = @available.poll
+          session
+        elsif @sessions.size < @size
+          checkout_new_session
+        else
+          @available.poll(@checkout_timeout)
+        end
+      end
+
+      def checkout_new_session
+        session = new_session
+        @sessions << session
+        session
+      end
+
+      def new_session
+        Factory.create(@name)
+      end
+
+      class ConnectionTimeoutError < StandardError; end
+
+      def create_new_session
+        Factory.create(@name)
+      end
+
+      class Reaper
+        attr_reader :pool
+        attr_reader :frequency
+        def initialize(frequency, pool)
+          @frequency = frequency
+          @pool = pool
+        end
+
+        def run
+          return unless frequency
+          Thread.new(frequency, pool) do |t, p|
+            while true
+              sleep t
+              p.reap
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid_connection_pool/version.rb

@@ -0,0 +1,3 @@
+module MongoidConnectionPool
+  VERSION = "1.0.2"
+end

data/mongoid_connection_pool.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid_connection_pool/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongoid_connection_pool"
+  spec.version       = MongoidConnectionPool::VERSION
+  spec.authors       = ["Brian Goff"]
+  spec.email         = ["cpuguy83@gmail.com"]
+  spec.description   = %q{Provides connection pooling for Mongoid}
+  spec.summary       = %q{Provides connection pooling for Mongoid}
+  spec.homepage      = "http://www.github.com/cpuguy83/mongoid_connection_pool"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_runtime_dependency "mongoid", "~> 3.1.0"
+end

data/spec/session_pool_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Mongoid::Sessions::SessionPool do
+
+  let!(:session_pool) do
+    Mongoid::Sessions.session_pool(:default)
+  end
+
+  let!(:before_run_available_sessions) do
+    session_pool.available
+  end
+
+  describe '.checkout' do
+
+    it 'Checks out session from the available pool and put in reserved_sessions' do
+      expect(session_pool.checkout).to be_a(Moped::Session)
+      expect(session_pool.session_for(Thread.current)).
+        to be_a(Moped::Session)
+
+      unless before_run_available_sessions.count == 0
+        expect(session_pool.available.count).
+          to eq (before_run_available_sessions.count - 1)
+      else
+        expect(session_pool.available.count).to eq(0)
+      end
+    end
+
+    context 'When all sessions are checked out' do
+      let(:session_pool) do
+        Mongoid::Sessions::SessionPool.new(
+          size: 0,
+          name: :default,
+          checkout_timeout: 0.001)
+      end
+
+      it 'Waits the checkout_timeout period and returns an error' do
+        expect { session_pool.checkout }.
+          to raise_error(Mongoid::Sessions::SessionPool::Queue::ConnectionTimeoutError)
+      end
+    end
+
+  end
+
+  describe '.checkin' do
+    before do
+      session_pool.clear
+    end
+
+    let(:session) do
+      session_pool.checkout
+    end
+
+    it 'Checks a session back into the available pool' do
+      expect(session_pool.checkin(session)).to be true
+
+      expect(session_pool.available.count).to eq 1
+
+      expect(session_pool.session_for(Thread.current)).
+        to be nil
+
+      expect(session_pool.sessions.count).to eq 1
+    end
+  end
+
+  describe '.checkin_from_thread' do
+    let(:session) do
+      session_pool.checkout
+    end
+
+    it 'Checks in the session for the given thread' do
+      expect(session_pool.checkin_from_thread(Thread.current)).
+        to be true
+    end
+  end
+
+  describe '.clear' do
+    before do
+      # Make sure there is something in session.sessions first
+      session_pool.checkout
+    end
+
+    before do
+      session_pool.clear
+    end
+
+    it 'Clears the sessions for the given thread' do
+      expect(session_pool.sessions.count).to be 0
+    end
+
+  end
+
+  describe '.reap' do
+
+    let(:thread) do
+      Thread.new { session_pool.checkout }
+    end
+
+    it 'Reaps sessions from dead/sleeping threads' do
+      thread.join
+
+      expect(session_pool.reap).to be_true
+
+      session_pool.session_for(thread).should be_nil
+    end
+
+  end
+
+  describe '.session_for' do
+
+    before do
+      session_pool.clear
+      session_pool.checkout
+    end
+
+    it 'Gets the session for the given thread' do
+      expect(session_pool.session_for(Thread.current)).
+        to be_a Moped::Session
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'mongoid_connection_pool'
+
+# These environment variables can be set if wanting to test against a database
+# that is not on the local machine.
+ENV["MONGOID_SPEC_HOST"] ||= "localhost"
+ENV["MONGOID_SPEC_PORT"] ||= "27017"
+
+# These are used when creating any connection in the test suite.
+HOST = ENV["MONGOID_SPEC_HOST"]
+PORT = ENV["MONGOID_SPEC_PORT"].to_i
+
+# Moped.logger.level = Logger::DEBUG
+# Mongoid.logger.level = Logger::DEBUG
+
+# When testing locally we use the database named mongoid_test. However when
+# tests are running in parallel on Travis we need to use different database
+# names for each process running since we do not have transactions and want a
+# clean slate before each spec run.
+def database_id
+  "mongoid_test"
+end
+
+def database_id_alt
+  "mongoid_test_alt"
+end
+
+CONFIG = {
+  sessions: {
+    default: {
+      database: database_id,
+      hosts: [ "#{HOST}:#{PORT}" ]
+    }
+  }
+}
+
+# Can we connect to MongoHQ from this box?
+def mongohq_connectable?
+  ENV["MONGOHQ_REPL_PASS"].present?
+end
+
+def purge_database_alt!
+  session = Mongoid::Sessions.default
+  session.use(database_id_alt)
+  session.collections.each do |collection|
+    collection.drop
+  end
+end
+
+# Set the database that the spec suite connects to.
+Mongoid.configure do |config|
+  config.load_configuration(CONFIG)
+end
+

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_connection_pool
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Brian Goff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  prerelease: false
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: Provides connection pooling for Mongoid
+email:
+- cpuguy83@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mongoid_connection_pool.rb
+- lib/mongoid_connection_pool/mongoid.rb
+- lib/mongoid_connection_pool/mongoid/config.rb
+- lib/mongoid_connection_pool/mongoid/sessions.rb
+- lib/mongoid_connection_pool/mongoid/sessions/session_pool.rb
+- lib/mongoid_connection_pool/version.rb
+- mongoid_connection_pool.gemspec
+- spec/session_pool_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.github.com/cpuguy83/mongoid_connection_pool
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Provides connection pooling for Mongoid
+test_files:
+- spec/session_pool_spec.rb
+- spec/spec_helper.rb