maria_db_cluster_pool 0.0.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Microting A/S
+
+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.rdoc

@@ -0,0 +1,36 @@
+== Database Cluster
+
+MariaDB Cluster Pool gem is designed for usage with Maria DB Galera Cluster, so this gem will only support a master/master setup
+
+= Configuration
+
+== The pool configuration
+
+The cluster connections are configured in database.yml using the maria_db_cluster_pool adapter. Any properties you configure for the connection will be inherited by all connections in the pool. In this way, you can configure ports, usernames, etc. once instead of for each connection. One exception is that you can set the pool_adapter property which each connection will inherit as the adapter property. Each connection in the pool uses all the same configuration properties as normal for the adapters.
+
+== Example configuration
+
+  development:
+      adapter: maria_db_cluster_pool
+      database: mydb_development
+      username: read_user
+      password: abc123
+      pool_adapter: mysql
+      port: 3306
+      server_pool:
+        - host: read-db-1.example.com
+          pool_weight: 1
+        - host: read-db-2.example.com
+          pool_weight: 2
+
+== License
+
+This software is a derived work of https://github.com/bdurand/seamless_database_pool the parts which derives from that codes is copyrighted by Brian Durand
+
+Copyright (C) 2013 Microting A/S
+
+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/Rakefile

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'rake'
+require 'yaml'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+  
+  #namespace :test do
+  #  desc "Run all tests including for all database adapters"
+  #  task :all do
+  #    save_val = ENV['TEST_ADAPTERS']
+  #    begin
+  #      ENV['TEST_ADAPTERS'] = YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.join(' ')
+  #      Rake::Task["test"].execute
+  #    ensure
+  #      ENV['TEST_ADAPTERS'] = save_val
+  #    end
+  #  end
+  #
+  #  desc "Test all database adapters defined in database.yml or just the one specified in TEST_ADAPTERS"
+  #  task :adapters do
+  #    save_val = ENV['TEST_ADAPTERS']
+  #    begin
+  #      ENV['TEST_ADAPTERS'] ||= YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.join(' ')
+  #      Rake::Task["test:adapters:specified"].execute
+  #    ensure
+  #      ENV['TEST_ADAPTERS'] = save_val
+  #    end
+  #  end
+  #
+  #  namespace :adapters do
+  #    desc "Internal task to run database adapter tests"
+  #    RSpec::Core::RakeTask.new(:specified) do |t|
+  #      t.pattern = FileList.new('spec/connection_adapters_spec.rb')
+  #    end
+  #
+  #    YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.each do |adapter_name|
+  #      desc "Test the #{adapter_name} database adapter"
+  #      task adapter_name do
+  #        save_val = ENV['TEST_ADAPTERS']
+  #        begin
+  #          ENV['TEST_ADAPTERS'] = adapter_name
+  #          Rake::Task["test:adapters:specified"].execute
+  #        ensure
+  #          ENV['TEST_ADAPTERS'] = save_val
+  #        end
+  #      end
+  #    end
+  #  end
+  #end
+rescue LoadError
+  task :test do
+    STDERR.puts "You must have rspec >= 2.0 to run the tests"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "maria_db_cluster_pool"
+    gem.summary = "Add support for master/master database clusters in ActiveRecord to improve performance."
+    gem.email = "rm@microting.com"
+    gem.homepage = "https://github.com/renemadsen/maria_db_cluster_pool"
+    gem.authors = ["René Schultz Madsen"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile", "MIT-LICENSE"].to_a
+    gem.has_rdoc = true
+    gem.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
+  
+    gem.add_dependency('activerecord', '>= 2.2.2')
+    gem.add_development_dependency('rspec', '>= 2.0')
+    gem.add_development_dependency('jeweler')
+    gem.add_development_dependency('mysql')
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+end

data/lib/active_record/connection_adapters/maria_db_cluster_pool_adapter.rb

@@ -0,0 +1,324 @@
+require 'maria_db_cluster_pool/connect_timeout'
+
+module ActiveRecord
+  class Base
+    class << self
+      def maria_db_cluster_pool_connection(config)
+        pool_weights = {}
+
+        config = config.with_indifferent_access
+        default_config = {:pool_weight => 1}.merge(config.merge(:adapter => config[:pool_adapter])).with_indifferent_access
+        default_config.delete(:server_pool)
+        default_config.delete(:pool_adapter)
+
+        pool_connections = []
+        config[:server_pool].each do |server_config|
+          server_config = default_config.merge(server_config).with_indifferent_access
+          server_config[:pool_weight] = server_config[:pool_weight].to_i
+          begin
+            establish_adapter(server_config[:adapter])
+            conn = send("#{server_config[:adapter]}_connection".to_sym, server_config)
+            conn.class.send(:include, MariaDBClusterPool::ConnectTimeout) unless conn.class.include?(MariaDBClusterPool::ConnectTimeout)
+            conn.connect_timeout = server_config[:connect_timeout]
+            pool_connections << conn
+            pool_weights[conn] = server_config[:pool_weight]
+          rescue Exception => e
+            if logger
+              logger.error("Error connecting to read connection #{server_config.inspect}")
+              logger.error(e)
+            end
+          end
+        end if config[:server_pool]
+
+        @maria_db_cluster_pool_classes ||= {}
+        klass = @maria_db_cluster_pool_classes[pool_connections[0].class]
+        unless klass
+          klass = ActiveRecord::ConnectionAdapters::MariaDBClusterPoolAdapter.adapter_class(pool_connections[0])
+          @maria_db_cluster_pool_classes[pool_connections[0].class] = klass
+        end
+
+        return klass.new(pool_connections[0], logger, pool_connections, pool_weights)
+      end
+
+      def establish_adapter(adapter)
+        raise AdapterNotSpecified.new("database configuration does not specify adapter") unless adapter
+        raise AdapterNotFound.new("database pool must specify adapters") if adapter == 'MariaDB_Cluster_Pool'
+
+        begin
+          require 'rubygems'
+          gem "activerecord-#{adapter}-adapter"
+          require "active_record/connection_adapters/#{adapter}_adapter"
+        rescue LoadError
+          begin
+            require "active_record/connection_adapters/#{adapter}_adapter"
+          rescue LoadError
+            raise "Please install the #{adapter} adapter: `gem install activerecord-#{adapter}-adapter` (#{$!})"
+          end
+        end
+
+        adapter_method = "#{adapter}_connection"
+        if !respond_to?(adapter_method)
+          raise AdapterNotFound, "database configuration specifies nonexistent #{adapter} adapter"
+        end
+      end
+    end
+    
+    module MariaDBClusterPoolBehavior
+      def self.included(base)
+        base.alias_method_chain(:reload, :maria_db_cluster_pool)
+      end
+      
+      # Force reload to use the master connection since it's probably being called for a reason.
+      def reload_with_maria_db_cluster_pool(*args)
+        reload_without_maria_db_Cluster_Pool(*args)
+      end
+    end
+    
+    include(MariaDBClusterPoolBehavior) unless include?(MariaDBClusterPoolBehavior)
+  end
+
+  module ConnectionAdapters
+    class MariaDBClusterPoolAdapter < AbstractAdapter
+      
+      attr_reader :connections # The total sum of connections
+      attr_reader :master_connection # The current connection in use
+      attr_reader :available_connections # The list of connections usable to the class
+
+      class << self
+        # Create an anonymous class that extends this one and proxies methods to the pool connections.
+        def adapter_class(master_connection)
+          # Define methods to proxy to the appropriate pool
+          master_methods = []
+          master_connection_classes = [AbstractAdapter, Quoting, DatabaseStatements, SchemaStatements]
+          master_connection_classes << DatabaseLimits if const_defined?(:DatabaseLimits)
+          master_connection_class = master_connection.class
+          while ![Object, AbstractAdapter].include?(master_connection_class) do
+            master_connection_classes << master_connection_class
+            master_connection_class = master_connection_class.superclass
+          end
+          master_connection_classes.each do |connection_class|
+            master_methods.concat(connection_class.public_instance_methods(false))
+            master_methods.concat(connection_class.protected_instance_methods(false))
+          end
+          master_methods.uniq!
+          master_methods -= public_instance_methods(false) + protected_instance_methods(false) + private_instance_methods(false)
+          master_methods = master_methods.collect{|m| m.to_sym}
+
+          klass = Class.new(self)
+          master_methods.each do |method_name|
+            klass.class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{method_name}(*args, &block)
+                return proxy_connection_method(master_connection, :#{method_name}, *args, &block)
+              end
+            EOS
+          end
+
+          return klass
+        end
+      
+        # Set the arel visitor on the connections.
+        def visitor_for(pool)
+          # This is ugly, but then again, so is the code in ActiveRecord for setting the arel
+          # visitor. There is a note in the code indicating the method signatures should be updated.
+          config = pool.spec.config.with_indifferent_access
+          adapter = config[:master][:adapter] || config[:pool_adapter]
+          MariaDBClusterPool.adapter_class_for(adapter).visitor_for(pool)
+        end
+      end
+      
+      def initialize(connection, logger, connections, pool_weights)
+        super(connection, logger)
+
+        @available_connections = []
+        @master_connection = connection
+        @connections = connections.dup.freeze
+
+        pool_weights.each_pair do |conn, weight|
+          @available_connections[weight] = AvailableConnection.new(conn)
+        end
+      end
+      
+      def adapter_name #:nodoc:
+        'MariaDB_Cluster_Pool'
+      end
+      
+      # Returns an array of the master connection and the read pool connections
+      def all_connections
+        @connections
+      end
+
+      def requires_reloading?
+        false
+      end
+      
+      def visitor=(visitor)
+        all_connections.each{|conn| conn.visitor = visitor}
+      end
+      
+      def visitor
+        connection.visitor
+      end
+      
+      def active?
+        active = true
+        do_to_connections {|conn| active &= conn.active?}
+        return active
+      end
+
+      def reconnect!
+        do_to_connections {|conn| conn.reconnect!}
+      end
+
+      def disconnect!
+        do_to_connections {|conn| conn.disconnect!}
+      end
+
+      def reset!
+        do_to_connections {|conn| conn.reset!}
+      end
+
+      def verify!(*ignored)
+        do_to_connections {|conn| conn.verify!(*ignored)}
+      end
+
+      def reset_runtime
+        total = 0.0
+        do_to_connections {|conn| total += conn.reset_runtime}
+        total
+      end
+
+      class DatabaseConnectionError < StandardError
+      end
+      
+      # This simple class puts an expire time on an array of connections. It is used so the a connection
+      # to a down database won't try to reconnect over and over.
+      class AvailableConnection
+        attr_reader :connection
+        attr_writer :failed_connection
+        attr_writer :expires
+        
+        def initialize(connection, failed_connection = false, expires = nil)
+          @connection = connection
+          @failed_connection = failed_connection
+          @expires = expires
+        end
+        
+        def expired?
+          @expires ? @expires <= Time.now : false
+        end
+
+        def failed?
+          @failed_connection
+        end
+
+        def reconnect!
+          @connection.reconnect!
+          if @connection.active?
+            @failed_connection = false
+            @expires = nil
+          else
+            raise DatabaseConnectionError.new
+          end
+        end
+      end
+      
+      # Get the available weighted connections. When a connection is dead and cannot be reconnected, it will
+      # be temporarily removed from the read pool so we don't keep trying to reconnect to a database that isn't
+      # listening.
+      def available_connections
+        @available_connections.each do |a|
+          if a != nil
+            if a.expired?
+              begin
+              @logger.info("Adding dead database connection back to the pool : #{a.connection.inspect}") if @logger
+              a.reconnect!
+              rescue  => e
+                a.expires = 30.seconds.from_now
+                @logger.warn("Failed to reconnect to database when adding connection back to the pool")
+                @logger.warn(e)
+              end
+            end
+          end
+        end
+
+        @available_connections
+
+      end
+      
+      def reset_available_connections
+        @available_connections.each do |a|
+          if a != nil
+            a.reconnect! rescue nil
+          end
+        end
+      end
+      
+      # Temporarily remove a connection from the read pool.
+      def suppress_connection(conn, expire)
+        available = available_connections
+        available.each do |a|
+          if a != nil
+            if a.connection == conn
+              a.failed_connection = true
+              a.expires = expire.seconds.from_now
+              @logger.info("Supressing database connection from the pool : #{a.connection.inspect}") if @logger
+            end
+          end
+        end
+      end
+
+      def next_usable_connection
+        available = available_connections
+        available.each do |a|
+          if a != nil
+            unless a.failed?
+              if a.connection.active?
+                @logger.info("New master connection is now : #{a.connection.inspect}") if @logger
+                @master_connection = a.connection
+                break
+              end
+            end
+          end
+        end
+      end
+
+      private
+      
+      def proxy_connection_method(connection, method, *args, &block)
+        available_connections
+        begin
+          connection.send(method, *args, &block)
+        rescue ArgumentError
+          begin
+            connection.send(method, *args)
+          rescue ArgumentError
+            connection.send(method)
+          end
+        rescue
+          # If the statement was a read statement and it wasn't forced against the master connection
+          # try to reconnect if the connection is dead and then re-run the statement.
+          unless connection.active?
+            suppress_connection(@master_connection, 30)
+            next_usable_connection
+          end
+          proxy_connection_method(@master_connection, method, *args, &block)
+        end
+      end
+
+      # Yield a block to each connection in the pool. If the connection is dead, ignore the error
+      def do_to_connections
+        all_connections.each do |conn|
+          begin
+            yield(conn)
+          rescue => e
+            if @logger
+              @logger.warn("Error in do_to_connections")
+              @logger.warn(e.message)
+              @logger.warn(e.backtrace.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maria_db_cluster_pool/arel_compiler.rb

@@ -0,0 +1,27 @@
+module Arel
+  module SqlCompiler
+    # Hook into arel to use the compiler used by the master connection.
+    class MariaDBClusterPoolCompiler < GenericCompiler
+      def self.new(relation)
+        @compiler_classes ||= {}
+        master_adapter = relation.engine.connection.master_connection.adapter_name
+        compiler_class = @compiler_classes[master_adapter]
+        unless compiler_class
+          begin
+            require "arel/engines/sql/compilers/#{master_adapter.downcase}_compiler"
+          rescue LoadError
+            begin
+              # try to load an externally defined compiler, in case this adapter has defined the compiler on its own.
+              require "#{master_adapter.downcase}/arel_compiler"
+            rescue LoadError
+              raise "#{master_adapter} is not supported by Arel."
+            end
+          end
+          compiler_class = Arel::SqlCompiler.const_get("#{master_adapter}Compiler")
+          @compiler_classes[master_adapter] = compiler_class
+        end
+        compiler_class.new(relation)
+      end
+    end
+  end
+end

data/lib/maria_db_cluster_pool/connect_timeout.rb

@@ -0,0 +1,24 @@
+require 'timeout'
+
+module MariaDBClusterPool
+  # This module is mixed into connection adapters to allow the reconnect! method to timeout if the
+  # IP address becomes unreachable. The default timeout is 1 second, but you can change it by setting
+  # the connect_timeout parameter in the adapter configuration.
+  module ConnectTimeout
+    attr_accessor :connect_timeout
+    
+    def self.included(base)
+      base.alias_method_chain :reconnect!, :connect_timeout
+    end
+    
+    def reconnect_with_connect_timeout!
+      begin
+        timeout(connect_timeout || 1) do
+          reconnect_without_connect_timeout!
+        end
+      rescue Timeout::Error
+        raise ActiveRecord::ConnectionTimeoutError.new("reconnect timed out")
+      end
+    end
+  end
+end

data/lib/maria_db_cluster_pool.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(__FILE__), 'maria_db_cluster_pool', 'connect_timeout.rb')
+#require File.join(File.dirname(__FILE__), 'mariadb_cluster_pool', 'connection_statistics.rb')
+#require File.join(File.dirname(__FILE__), 'mariadb_cluster_pool', 'controller_filter.rb')
+require File.join(File.dirname(__FILE__), 'active_record', 'connection_adapters', 'maria_db_cluster_pool_adapter.rb')
+$LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+
+# This module allows setting the read pool connection type. Generally you will use one of
+#
+#   - use_random_connection
+#   - use_persistent_read_connection
+#   - use_master_connection
+#
+# Each of these methods can take an optional block. If they are called with a block, they
+# will set the read connection type only within the block. Otherwise they will set the default
+# read connection type. If none is ever called, the read connection type will be :master.
+
+module MariaDBClusterPool
+    
+  # Adapter name to class name map. This exists because there isn't an obvious way to translate things like
+  # sqlite3 to SQLite3. The adapters that ship with ActiveRecord are defined here. If you use
+  # an adapter that doesn't translate directly to camel case, then add the mapping here in an initializer.
+  ADAPTER_TO_CLASS_NAME_MAP = {"sqlite" => "SQLite", "sqlite3" => "SQLite3", "postgresql" => "PostgreSQL"}
+  
+  #READ_CONNECTION_METHODS = [:master, :persistent, :random]
+
+  class << self
+    # Call this method to use a random connection from the read pool for every select statement.
+    # This method is good if your replication is very fast. Otherwise there is a chance you could
+    # get inconsistent results from one request to the next. This can result in mysterious failures
+    # if your code selects a value in one statement and then uses in another statement. You can wind
+    # up trying to use a value from one server that hasn't been replicated to another one yet.
+    # This method is best if you have few processes which generate a lot of queries and you have
+    # fast replication.
+    #def use_random_connection
+    #  if block_given?
+    #    set_read_only_connection_type(:random){yield}
+    #  else
+    #    Thread.current[:read_only_connection] = :random
+    #  end
+    #end
+  
+    # Call this method to pick a random connection from the read pool and use it for all subsequent
+    # select statements. This provides consistency from one select statement to the next. This
+    # method should always be called with a block otherwise you can end up with an imbalanced read
+    # pool. This method is best if you have lots of processes which have a relatively few select
+    # statements or a slow replication mechanism. Generally this is the best method to use for web
+    # applications.
+    #def use_persistent_read_connection
+    #  if block_given?
+    #    set_read_only_connection_type(:persistent){yield}
+    #  else
+    #    Thread.current[:read_only_connection] = {}
+    #  end
+    #end
+  
+    # Call this method to use the master connection for all subsequent select statements. This
+    # method is most useful when you are doing lots of updates since it guarantees consistency
+    # if you do a select immediately after an update or insert.
+    #
+    # The master connection will also be used for selects inside any transaction blocks. It will
+    # also be used if you pass :readonly => false to any ActiveRecord.find method.
+    #def use_master_connection
+    #  if block_given?
+    #    set_read_only_connection_type(:master){yield}
+    #  else
+    #    Thread.current[:read_only_connection] = :master
+    #  end
+    #end
+  
+    # Set the read only connection type to either :master, :random, or :persistent.
+    #def set_read_only_connection_type(connection_type)
+    #  saved_connection = Thread.current[:read_only_connection]
+    #  retval = nil
+    #  begin
+    #    connection_type = {} if connection_type == :persistent
+    #    Thread.current[:read_only_connection] = connection_type
+    #    retval = yield if block_given?
+    #  ensure
+    #    Thread.current[:read_only_connection] = saved_connection
+    #  end
+    #  return retval
+    #end
+  
+    # Get the read only connection type currently in use. Will be one of :master, :random, or :persistent.
+    #def read_only_connection_type(default = :master)
+    #  connection_type = Thread.current[:read_only_connection] || default
+    #  connection_type = :persistent if connection_type.kind_of?(Hash)
+    #  return connection_type
+    #end
+  
+    # Get a connection from a connection pool.
+    #def get_a_connection(pool_connection)
+    #  #return pool_connection.master_connection if pool_connection.using_master_connection?
+    #  #connection_type = Thread.current[:read_only_connection]
+    #
+    #  if connection_type.kind_of?(Hash)
+    #    connection = connection_type[pool_connection]
+    #    unless connection
+    #      connection = pool_connection.random_connection
+    #      connection_type[pool_connection] = connection
+    #    end
+    #    return connection
+    #  elsif connection_type == :random
+    #    return pool_connection.random_connection
+    #  else
+    #    return pool_connection.master_connection
+    #  end
+    #end
+  
+    # This method is provided as a way to change the persistent connection when it fails and a new one is substituted.
+    #def set_persistent_read_connection(pool_connection, read_connection)
+    #  connection_type = Thread.current[:read_only_connection]
+    #  connection_type[pool_connection] = read_connection if connection_type.kind_of?(Hash)
+    #end
+  
+    #def clear_read_only_connection
+    #  Thread.current[:read_only_connection] = nil
+    #end
+    
+    # Get the connection adapter class for an adapter name. The class will be loaded from
+    # ActiveRecord::ConnectionAdapters::NameAdapter where Name is the camelized version of the name.
+    # If the adapter class does not fit this pattern (i.e. sqlite3 => SQLite3Adapter), then add
+    # the mapping to the +ADAPTER_TO_CLASS_NAME_MAP+ Hash.
+    def adapter_class_for(name)
+      name = name.to_s
+      class_name = ADAPTER_TO_CLASS_NAME_MAP[name] || name.camelize
+      "ActiveRecord::ConnectionAdapters::#{class_name}Adapter".constantize
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification 
+name: maria_db_cluster_pool
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- "Ren\xC3\xA9 Schultz Madsen"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-04 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 3
+        - 11
+        version: 2.3.11
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 2
+        - 2
+        version: 2.2.2
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+description: 
+email: rm@microting.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/active_record/connection_adapters/maria_db_cluster_pool_adapter.rb
+- lib/maria_db_cluster_pool.rb
+- lib/maria_db_cluster_pool/arel_compiler.rb
+- lib/maria_db_cluster_pool/connect_timeout.rb
+has_rdoc: true
+homepage: https://github.com/renemadsen/maria_db_cluster_pool
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Add support for master/master database clusters in ActiveRecord to improve performance.
+test_files: []
+