em-synchrony-moped 0.9.4 → 1.0.0.beta.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWM1ZDFhNzU0ZWE3ZjM2MWQ2YTAwODlmOWMzOTliZTU5OTMwZTc2Yg==
+  data.tar.gz: !binary |-
+    MDIxYTY0M2Q1Zjg4NGRjNzBjYjMyZTlmOTEyN2FhOTlhNTk5MTQwOQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZGJhNzU3NmZlM2I3YTcxNWM5NmUzMDk4OWRiNTQwNDExMTA3M2U0NjVlYjFh
+    MDhkMjE5YmViNTZkNDIxY2MwMGFhNDhkZGJkMDBiNjc0ZjgwZmIyNTIzNDZi
+    MDY4Y2ZhZWIwNmE2YmRjZjUzMzE4MjcyMDczYzE2ZmI4MTE5MmI=
+  data.tar.gz: !binary |-
+    MTM0OTE2NTk1MzI4NGZhYmFiMGRmNzM2ZGQ3MjlmMzI0MjlkNWJhZmRlMmI1
+    MTU2YmE3ZDViOTA0MTVkYmIzMDk1M2U1NWJkNzYyNWQyZWIyMDBkNTI3OGU4
+    ZDEzMTBlNGJmNTMyY2RkYjI0MGY5MGNiODBlNjI4ODMyNjU0Yjc=

data/.gitignore

@@ -1 +1,5 @@
 Gemfile.lock
+pkg
+tmp
+.ruby-version
+coverage

data/Guardfile

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'rubocop' do
+  watch(%r{.+\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/Rakefile

@@ -1,16 +1,10 @@
 require "bundler/gem_tasks"
 
-begin
-  require 'rspec/core'
-  require 'rspec/core/rake_task'
+require 'rspec/core'
+require 'rspec/core/rake_task'
 
-  task :default => [:spec]
-  task :test => [:spec]
+task :default => [:spec]
+task :test => [:spec]
 
-  desc "Run all RSpec tests"
-  RSpec::Core::RakeTask.new(:spec)
-
-
-rescue LoadError
-  # silent failure for when rspec is not installed (production mode)
-end
+desc "Run all RSpec tests"
+RSpec::Core::RakeTask.new(:spec)

data/em-synchrony-moped.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'em-synchrony-moped'
-  s.version = "0.9.4"
+  s.version = "1.0.0.beta.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Lebsack"]
@@ -18,11 +18,18 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'eventmachine'
+  s.add_runtime_dependency 'eventmachine',      '~> 1.0'
   s.add_runtime_dependency 'em-synchrony',      '~> 1.0'
-  s.add_runtime_dependency 'moped',             '~> 1.4.5'
+  s.add_runtime_dependency 'moped',             '~> 1.5.1'
   s.add_runtime_dependency 'em-resolv-replace', '~> 1.1.3'
 
   s.add_development_dependency 'rspec',         '~> 2.12.0'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'guard-bundler'
+  s.add_development_dependency 'guard-rubocop'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'spork'
+  s.add_development_dependency 'simplecov'
 
 end

data/lib/em-synchrony/moped/cluster.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'moped/cluster'
+
+module Moped
+  # Our patches to Moped::Cluster
+  module EventedCluster
+    def sleep(seconds)
+      if EventMachine.reactor_thread?
+        EM::Synchrony.sleep(seconds)
+      else
+        Kernel.sleep(seconds)
+      end
+    end
+  end
+
+  class Cluster
+    include EventedCluster
+  end
+end

data/lib/em-synchrony/moped/connection.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Moped
+  class Connection
+    def connect
+      if EventMachine.reactor_thread?
+        if !!options[:ssl]
+          @sock = Sockets::EmSSL.em_connect(host, port, timeout, options)
+        else
+          @sock = Sockets::EmTCP.em_connect(host, port, timeout, options)
+        end
+      else # use old driver
+        if !!options[:ssl]
+          @sock = Sockets::SSL.connect(host, port, timeout)
+        else
+          @sock = Sockets::TCP.connect(host, port, timeout)
+        end
+      end
+    end
+  end # class Cnnection
+
+  module Sockets
+    module Connectable
+      module ClassMethods
+        def em_connect(host, port, timeout, options)
+          socket = EventMachine.connect(host, port, self) do |c|
+            c.pending_connect_timeout = timeout
+            c.options = options
+          end
+          # In TCPSocket, new against a closed port raises Errno::ECONNREFUSED.
+          # In EM, connect against a closed port result in a call to unbind
+          # with a reason param of Errno::ECONNREFUSED as a class, not an
+          # instance.
+          unless socket.sync(:in)  # wait for connection
+            fail socket.unbind_reason.new if socket.unbind_reason.is_a? Class
+            fail SocketError, socket.unbind_reason
+          end
+          socket
+
+        rescue Errno::ETIMEDOUT
+          fail Errors::ConnectionFailure,
+               "Timed out connection to Mongo on #{host}:#{port}"
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EPIPE,
+               Errno::ECONNRESET, IOError => error
+          fail Errors::ConnectionFailure,
+               "#{host}:#{port}: #{error.class.name} (#{error.errno}): " +
+               "#{error.message}"
+        rescue SocketError => error
+          fail Errors::ConnectionFailure,
+               "#{host}:#{port}: #{error.class.name}: #{error.message}"
+        rescue OpenSSL::SSL::SSLError => error
+          fail Errors::ConnectionFailure,
+               "#{host}:#{port}: #{error.class.name} (#{error.errno}): " +
+               "#{error.message}"
+        end
+      end
+    end
+
+    # The EM-Synchrony flavor of Moped::Sockets::TCP
+    class EmTCP < EventMachine::Synchrony::TCPSocket
+      include Connectable
+
+      # TODO: re-evaluate the options call.  Can't we pass the caller
+      # up to the connection or something?
+      attr_accessor :options
+
+      def alive?
+        !closed?
+      end
+    end
+
+    # The EM-Synchrony flavor of Moped::Sockets::SSL
+    class EmSSL < EmTCP
+      def connection_completed
+        @verified = false
+        if @options[:ssl].is_a?(Hash)
+          start_tls(@options[:ssl])
+        else
+          start_tls
+        end
+      end
+
+      def ssl_verify_peer(pem)
+        unless (cert_store = @options[:ssl][:cert_store])
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.add_file(@options[:ssl][:verify_cert])
+        end
+
+        if (cert = OpenSSL::X509::Certificate.new(pem) rescue nil)
+          if cert_store.verify(cert)
+
+            cert.extensions.each do |e|
+              if e.oid == 'basicConstraints' && e.value == 'CA:TRUE'
+                return true
+              end
+            end
+
+            host = @options[:ssl][:verify_host]
+            if OpenSSL::SSL.verify_certificate_identity(cert, host)
+              @verified = true
+              return true
+            end
+          end
+        end
+
+        true
+      rescue
+        unbind 'Failed to verify SSL certificate of peer'
+        false
+      end
+
+      def ssl_handshake_completed
+        if @options[:ssl][:verify_peer] && !@verified
+          unbind 'Failed to verify SSL certificate of peer'
+        else
+          @opening = false
+          @in_req.succeed self
+        end
+      end
+    end
+  end
+end

data/lib/em-synchrony/moped/node.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'moped/node'
+require 'em-dns-resolver'
+require 'fiber'
+
+module Moped
+  # Our monkey patches to Moped::Node
+  module EventedNode
+    # Override to support non-blocking DNS requests
+    def parse_address
+      return super if EM.reactor_thread?
+      host, port = address.split(':')
+      @port = (port || 27_017).to_i
+
+      @ip_address = em_lookup_address(host)
+      fail SocketError unless @ip_address
+      @resolved_address = "#{@ip_address}:#{@port}"
+    rescue Resolv::ResolvError
+      raise SocketError
+    end
+
+    def em_lookup_address(value)
+      # Lookup in /etc/hosts
+      result = []
+      @hosts ||= Resolv::Hosts.new
+      @hosts.send(:each_address, value) { |x| result << x.to_s }
+      return result unless result.empty?
+
+      # Nothing, hit DNS
+      fiber = Fiber.current
+      df = EM::DnsResolver.send(:resolve, value)
+      df.callback do |a|
+        fiber.resume(a)
+      end
+      df.errback do |*a|
+        fiber.resume(ResolvError.new(a.inspect))
+      end
+      result = Fiber.yield
+      raise result if result.is_a?(StandardError)
+      result
+    end
+  end
+
+  class Node
+    include EventedNode
+  end
+end

data/lib/em-synchrony/moped.rb

@@ -1,182 +1,6 @@
-require "moped/connection"
-require "moped/node"
-require 'em-resolv-replace'
+# encoding: utf-8
 
-silence_warnings do
-  module Moped
-    class Cluster
-      def sleep(seconds)
-        EM::Synchrony.sleep(seconds)
-      end
-
-      # MONKEY PATCH: if all available connections are down, use the seeds
-      # again to determine, where the application should connect. This is a
-      # implementation detail and unlikely to be main line. Therefore no pull
-      # request here. The assumtion is, that if we can't connect to any mongodb
-      # that they are relocated and available under a different DNS address.
-      def nodes(opts = {})
-        current_time = Time.new
-        down_boundary = current_time - down_interval
-        refresh_boundary = current_time - refresh_interval
-
-        # Find the nodes that were down but are ready to be refreshed, or those
-        # with stale connection information.
-        needs_refresh, available = @nodes.partition do |node|
-          node.down? ? (node.down_at < down_boundary) : node.needs_refresh?(refresh_boundary)
-        end
-
-        # Refresh those nodes.
-        available.concat refresh(needs_refresh)
-
-        # Now return all the nodes that are available and participating in the
-        # replica set.
-        avail_not_down = available.reject do |node|
-          node.down? || !member?(node) || (!opts[:include_arbiters] && node.arbiter?)
-        end
-
-        if avail_not_down.empty?
-          if logger = Moped.logger
-            logger.warn " MOPED: reinitialize cluster because all nodes " \
-                        "are down with #{@seeds.inspect}"
-          end
-          @nodes = @seeds.map { |host| Node.new(host, @options) }
-        end
-
-        avail_not_down
-      end
-    end
-
-    class Node
-      # Override to support non-blocking DNS requests
-      def parse_address
-        host, port = address.split(":")
-        @port = (port || 27017).to_i
-
-        @resolver ||= Resolv.new([Resolv::Hosts.new, Resolv::DNS.new])
-
-        # For now, limit the IPs only to IPv4 hosts.  In order to support IPv6,
-        # the node should be able to handle fallback connections.
-        @resolver.getaddresses(host).each do |ip|
-          if ip =~ Resolv::IPv4::Regex
-            @ip_address = ip
-            break
-          end
-        end
-        raise SocketError unless @ip_address
-        @resolved_address = "#{@ip_address}:#{@port}"
-      rescue Resolv::ResolvError
-        raise SocketError
-      end
-    end
-
-
-    class Connection
-      def connected?
-        @sock && !@sock.instance_variable_get("@remote_closed") && !@sock.closed?
-      end
-
-      def connect
-        @sock = if !!options[:ssl]
-          Sockets::SSL.connect(host, port, timeout, options)
-        else
-          Sockets::TCP.connect(host, port, timeout, options)
-        end
-      end
-    end
-
-    Sockets.send(:remove_const, :TCP)
-    Sockets.send(:remove_const, :SSL)
-    module Sockets
-      module Connectable
-        attr_accessor :options
-
-        def alive?
-          !closed?
-        end
-
-        module ClassMethods
-
-          def connect(host, port, timeout, options={})
-            socket = EM.connect(host, port, self) do |c|
-              c.pending_connect_timeout = timeout
-              c.options = options.merge(:host => host)
-            end
-            # In TCPSocket, new against a closed port raises Errno::ECONNREFUSED.
-            # In EM, connect against a closed port result in a call to unbind with
-            # a reason param of Errno::ECONNREFUSED as a class, not an instance.
-            unless socket.sync(:in)  # wait for connection
-              raise socket.unbind_reason.new if socket.unbind_reason.is_a? Class
-              raise SocketError, socket.unbind_reason
-            end
-            socket
-
-          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EPIPE, Errno::ECONNRESET, Errno::ETIMEDOUT, IOError => error
-            raise Errors::ConnectionFailure, "#{host}:#{port}: #{error.class.name} (#{error.errno}): #{error.message}"
-          rescue SocketError => error
-            raise Errors::ConnectionFailure, "#{host}:#{port}: #{error.class.name}: #{error.message}"
-          rescue OpenSSL::SSL::SSLError => error
-            raise Errors::ConnectionFailure, "#{host}:#{port}: #{error.class.name} (#{error.errno}): #{error.message}"
-          end
-
-
-        end
-      end
-
-      class TCP < EventMachine::Synchrony::TCPSocket
-        include Connectable
-      end
-
-      class SSL < EventMachine::Synchrony::TCPSocket
-        include Connectable
-
-        def connection_completed
-          @verified = false
-          if @options[:ssl].is_a?(Hash)
-            start_tls(@options[:ssl])
-          else
-            start_tls
-          end
-        end
-
-        def ssl_verify_peer(pem)
-          unless cert_store = @options[:ssl][:cert_store]
-            cert_store = OpenSSL::X509::Store.new
-            cert_store.add_file(@options[:ssl][:verify_cert])
-          end
-
-          if cert = OpenSSL::X509::Certificate.new(pem) rescue nil
-            if cert_store.verify(cert)
-
-              cert.extensions.each do |e|
-                if e.oid == 'basicConstraints' && e.value == 'CA:TRUE'
-                  return true
-                end
-              end
-
-              host = @options[:ssl][:verify_host]
-              if OpenSSL::SSL.verify_certificate_identity(cert, host)
-                @verified = true
-                return true
-              end
-            end
-          end
-
-          true
-        rescue => e
-          unbind "Failed to verify SSL certificate of peer"
-          false
-        end
-
-        def ssl_handshake_completed
-          if @options[:ssl][:verify_peer] && !@verified
-            unbind "Failed to verify SSL certificate of peer"
-          else
-            @opening = false
-            @in_req.succeed self
-          end
-        end
-
-      end
-    end
-  end
-end
+require 'em-synchrony'
+require 'em-synchrony/moped/cluster'
+require 'em-synchrony/moped/node'
+require 'em-synchrony/moped/connection'

data/spec/lib/em-synchrony/moped/cluster_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+require 'moped'
+require 'em-synchrony/moped'
+
+describe Moped::Cluster do
+  let(:mongod_options) { {} }
+  let(:server1) { FakeMongodServer.new(mongod_options) }
+  let(:server1_port) { server1.port }
+
+  let(:server2) { FakeMongodServer.new(mongod_options.merge(master: 0)) }
+  let(:server2_port) { server2.port }
+
+  after do
+    server1.stop if server1
+    server2.stop if server2
+  end
+
+  shared_context 'common cluster' do
+    let(:options) { {} }
+    let(:seeds) do
+      ["#{server1.host}:#{server1_port}", "#{server2.host}:#{server2_port}"]
+    end
+    let(:cluster) { Moped::Cluster.new(seeds, options.merge(timeout: 1)) }
+
+    describe '#with_primary' do
+      it 'should get a primary node' do
+        cluster.with_primary do |node|
+          expect(node).to be_primary
+        end
+      end
+    end
+
+    describe '#with_secondary' do
+      it 'should get a secondary node' do
+        cluster.with_secondary do |node|
+          expect(node).to be_secondary
+        end
+      end
+    end
+  end
+
+  context 'evented' do
+    include_context 'with em-synchrony'
+    include_context 'common cluster'
+  end
+  context 'threaded' do
+    include_context 'without em-synchrony'
+    include_context 'common cluster'
+  end
+end

data/spec/lib/em-synchrony/moped/connection_spec.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+require 'spec_helper'
+
+require 'moped'
+require 'em-synchrony/moped'
+
+# TODO: clean up a bit.  we're basically testing Connection through Node.
+# we should be able to test Connection by itself.
+
+describe Moped::Connection do
+  it 'should have patches included' do
+    expect { Moped::Sockets::EmTCP }.not_to raise_error(NameError)
+  end
+
+  let(:mongod_options) { {} }
+  let(:server) { FakeMongodServer.new(mongod_options) }
+  let(:server_port) { server.port }
+  after { server.stop }
+
+  let(:node_options) { {} }
+  let(:node) do
+    options = node_options.merge(timeout: 1)
+    host = options.delete(:host) || 'localhost'
+    Moped::Node.new("#{host}:#{server_port}", options)
+  end
+
+  shared_context 'common connection' do
+    context 'with a running server' do
+      it 'should connect' do
+        node.refresh
+        node.should be_primary
+        node.should be_connected
+      end
+
+      it 'should detect a disconnect' do
+        node.refresh
+        node.should be_primary
+        node.should be_connected
+        server.stop
+        expect do
+          node.command('admin', ismaster: 1)
+        end.to raise_error(
+          Moped::Errors::ConnectionFailure # TODO: check the message
+        )
+        node.should_not be_connected
+      end
+    end
+
+    context 'with an unpresponsive host' do
+      # 127.0.0.2 seems to timeout for my tests...
+      let(:node_options) { { host: '127.0.0.2' } }
+      it 'should raise a timeout error' do
+        expect { node.refresh }.to raise_error(
+          Moped::Errors::ConnectionFailure,
+          /^Timed out connection to Mongo on/)
+      end
+    end
+
+    context 'without a server' do
+      it 'should raise a connection error on connection refused' do
+        server.stop
+        expect { node.refresh }.to raise_error(
+          Moped::Errors::ConnectionFailure, /ECONNREFUSED/)
+      end
+    end
+  end
+
+  shared_context 'common connection ssl' do
+    context 'with ssl server' do
+      let(:mongod_options) do
+        {
+          ssl: {
+            private_key_file: "#{SSL_DIR}/server.key",
+            cert_chain_file: "#{SSL_DIR}/server.crt",
+            verify_peer: false
+          }
+        }
+      end
+
+      context 'without verifying peer' do
+        let(:node_options) { { ssl: { verify_peer: false } } }
+        it 'should connect' do
+          node.refresh
+          node.should be_primary
+        end
+      end
+
+      context 'when verifying peer' do
+        let(:node_options) do
+          { ssl: {
+              verify_peer: true,
+              verify_cert: "#{SSL_DIR}/ca_cert.pem",
+              verify_host: 'localhost'
+            }
+          }
+        end
+        it 'should connect' do
+          node.refresh
+          node.should be_primary
+        end
+
+        context 'with untrusted key on server' do
+          let(:mongod_options) do
+            {
+              ssl: {
+                private_key_file: "#{SSL_DIR}/untrusted.key",
+                cert_chain_file: "#{SSL_DIR}/untrusted.crt",
+                verify_peer: false
+              }
+            }
+          end
+
+          it 'should connect and fail to verify peer' do
+            expect do
+              node.refresh
+              node.should be_primary
+            end.to raise_error(
+              Moped::Errors::ConnectionFailure,
+              /Failed to verify SSL certificate of peer/
+            )
+          end
+        end
+      end
+    end
+  end
+
+  context 'evented' do
+    include_context 'with em-synchrony'
+    include_context 'common connection'
+    include_context 'common connection ssl'
+  end
+  context 'threaded' do
+    include_context 'without em-synchrony'
+    include_context 'common connection'
+  end
+
+end