bones-rpc 0.0.1

data/lib/bones/rpc/connection/socket.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+require 'bones/rpc/connection/socket/connectable'
+require 'bones/rpc/connection/socket/ssl'
+require 'bones/rpc/connection/socket/tcp'

data/lib/bones/rpc/connection/socket/connectable.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    class Connection
+      module Socket
+        module Connectable
+
+          attr_reader :host, :port
+
+          # Is the socket connection alive?
+          #
+          # @example Is the socket alive?
+          #   socket.alive?
+          #
+          # @return [ true, false ] If the socket is alive.
+          #
+          # @since 1.0.0
+          def alive?
+            io = to_io
+            if Kernel::select([ io ], nil, [ io ], 0)
+              !eof? rescue false
+            else
+              true
+            end
+          rescue IOError
+            false
+          end
+
+          # Bring in the class methods when included.
+          #
+          # @example Extend the class methods.
+          #   Connectable.included(class)
+          #
+          # @param [ Class ] klass The class including the module.
+          #
+          # @since 1.3.0
+          def self.included(klass)
+            klass.send(:extend, ClassMethods)
+          end
+
+          # Read from the TCP socket.
+          #
+          # @param [ Integer ] size The length to read.
+          # @param [ String, NilClass ] buf The string which will receive the data.
+          #
+          # @return [ Object ] The data.
+          #
+          # @since 1.2.0
+          def read(size = nil, buf = nil)
+            check_if_alive!
+            handle_socket_errors { super }
+          end
+
+          # Read from the TCP socket.
+          #
+          # @param [ Integer ] size The maximum length to read.
+          # @param [ String, NilClass ] buf The string which will receive the data.
+          #
+          # @return [ Object ] The data.
+          #
+          # @since 1.2.0
+          def readpartial(maxlen, buf = nil)
+            check_if_alive!
+            handle_socket_errors { super }
+          end
+
+          # Set the encoding of the underlying socket.
+          #
+          # @param [ String ] string The encoding.
+          #
+          # @since 1.3.0
+          def set_encoding(string)
+            to_io.set_encoding(string)
+          end
+
+          # Write to the socket.
+          #
+          # @example Write to the socket.
+          #   socket.write(data)
+          #
+          # @param [ Object ] args The data to write.
+          #
+          # @return [ Integer ] The number of bytes written.
+          #
+          # @since 1.0.0
+          def write(*args)
+            check_if_alive!
+            handle_socket_errors { super }
+          end
+
+          private
+
+          # Before performing a read or write operating, ping the server to check
+          # if it is alive.
+          #
+          # @api private
+          #
+          # @example Check if the connection is alive.
+          #   connectable.check_if_alive!
+          #
+          # @raise [ ConnectionFailure ] If the connectable is not alive.
+          #
+          # @since 1.4.0
+          def check_if_alive!
+            unless alive?
+              raise Errors::ConnectionFailure, "Socket connection was closed by remote host"
+            end
+          end
+
+          # Generate the message for the connection failure based of the system
+          # call error, with some added information.
+          #
+          # @api private
+          #
+          # @example Generate the error message.
+          #   connectable.generate_message(error)
+          #
+          # @param [ SystemCallError ] error The error.
+          #
+          # @return [ String ] The error message.
+          #
+          # @since 1.4.0
+          def generate_message(error)
+            "#{host}:#{port}: #{error.class.name} (#{error.errno}): #{error.message}"
+          end
+
+          # Handle the potential socket errors that can occur.
+          #
+          # @api private
+          #
+          # @example Handle the socket errors while executing the block.
+          #   handle_socket_errors do
+          #     socket.read(128)
+          #   end
+          #
+          # @raise [ Bones::RPC::Errors::ConnectionFailure ] If a system call error or
+          #   IOError occured which can be retried.
+          # @raise [ Bones::RPC::Errors::Unrecoverable ] If a system call error occured
+          #   which cannot be retried and should be re-raised.
+          #
+          # @return [ Object ] The result of the yield.
+          #
+          # @since 1.0.0
+          def handle_socket_errors
+            yield
+          rescue Errno::ECONNREFUSED => e
+            raise Errors::ConnectionFailure, generate_message(e)
+          rescue Errno::EHOSTUNREACH => e
+            raise Errors::ConnectionFailure, generate_message(e)
+          rescue Errno::EPIPE => e
+            raise Errors::ConnectionFailure, generate_message(e)
+          rescue Errno::ECONNRESET => e
+            raise Errors::ConnectionFailure, generate_message(e)
+          rescue Errno::ETIMEDOUT => e
+            raise Errors::ConnectionFailure, generate_message(e)
+          rescue IOError
+            raise Errors::ConnectionFailure, "Connection timed out to Bones RPC on #{host}:#{port}"
+          rescue OpenSSL::SSL::SSLError => e
+            raise Errors::ConnectionFailure, "SSL Error '#{e.to_s}' for connection to Bones RPC on #{host}:#{port}"
+          end
+
+          module ClassMethods
+
+            # Connect to the tcp server.
+            #
+            # @example Connect to the server.
+            #   TCPSocket.connect("127.0.0.1", 27017, 30)
+            #
+            # @param [ String ] host The host to connect to.
+            # @param [ Integer ] post The server port.
+            # @param [ Integer ] timeout The connection timeout.
+            #
+            # @return [ TCPSocket ] The socket.
+            #
+            # @since 1.0.0
+            def connect(host, port, timeout)
+              begin
+                Timeout::timeout(timeout) do
+                  sock = new(host, port)
+                  sock.set_encoding('binary')
+                  timeout_val = [ timeout, 0 ].pack("l_2")
+                  sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+                  sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeout_val)
+                  sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeout_val)
+                  sock
+                end
+              rescue Timeout::Error
+                raise Errors::ConnectionFailure, "Timed out connection to Bones RPC on #{host}:#{port}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/connection/socket/ssl.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'openssl'
+
+module Bones
+  module RPC
+    class Connection
+      module Socket
+
+        # This is a wrapper around a tcp socket.
+        class SSL < ::Celluloid::IO::SSLSocket
+          include Connectable
+
+          # Initialize the new TCPSocket with SSL.
+          #
+          # @example Initialize the socket.
+          #   SSL.new("127.0.0.1", 27017)
+          #
+          # @param [ String ] host The host.
+          # @param [ Integer ] port The port.
+          #
+          # @since 1.2.0
+          def initialize(remote_host, remote_port, local_host = nil, local_port = nil)
+            @host, @port = remote_host, remote_port
+            handle_socket_errors do
+              socket = TCPSocket.new(remote_host, remote_port, local_host, local_port)
+              super(socket)
+              to_io.sync_close = true
+              connect
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/connection/socket/tcp.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    class Connection
+      module Socket
+
+        # This is a wrapper around a ssl socket.
+        class TCP < ::Celluloid::IO::TCPSocket
+          include Connectable
+
+          # Initialize the new TCPSocket.
+          #
+          # @example Initialize the socket.
+          #   TCP.new("127.0.0.1", 27017)
+          #
+          # @param [ String ] remote_host The host.
+          # @param [ Integer ] remote_port The port.
+          #
+          # @since 1.2.0
+          def initialize(remote_host, remote_port, local_host = nil, local_port = nil)
+            @host, @port = remote_host, remote_port
+            handle_socket_errors { super }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/connection/writer.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    class Connection
+      class Writer
+        include Celluloid::IO
+
+        execute_block_on_receiver :initialize
+        finalizer :shutdown
+        trap_exit :reader_died
+
+        def initialize(connection, socket, adapter)
+          @connection = connection
+          @socket = socket
+          @adapter = adapter
+          @resolved = @connection.node.address.resolved
+          @buffer = ""
+          @reader = Reader.new_link(@connection, @socket, @adapter)
+        end
+
+        def write(operations)
+          operations.each do |message, future|
+            message.serialize(@buffer, @adapter)
+            message.attach(@connection.node, future) if future
+          end
+          @socket.write(@buffer)
+          @buffer = ""
+          return true
+        rescue EOFError, Errors::ConnectionFailure => e
+          Loggable.warn("  BONES-RPC:", "#{@resolved} Writer terminating: #{e.message}", "n/a")
+          terminate
+        end
+
+        def shutdown
+          if @reader && @reader.alive?
+            @reader.unlink
+            @reader.async.terminate
+          end
+          @connection.cleanup_socket(@socket)
+        end
+
+        def reader_died(actor, reason)
+          Loggable.warn("  BONES-RPC:", "#{@resolved} Writer terminating: #{reason}", "n/a")
+          @reader = nil
+          terminate
+        end
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/context.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module Bones
+  module RPC
+
+    # The class for interacting with a MongoDB database. One only interacts with
+    # this class indirectly through a session.
+    #
+    # @since 1.0.0
+    class Context
+      include Readable
+
+      # @!attribute session
+      #   @return [ Session ] The database session.
+      attr_reader :session
+
+      # Initialize the database.
+      #
+      # @example Initialize a database object.
+      #   Database.new(session, :artists)
+      #
+      # @param [ Session ] session The session.
+      # @param [ String, Symbol ] name The name of the database.
+      #
+      # @since 1.0.0
+      def initialize(session)
+        @session = session
+      end
+
+      def notify(method, params)
+        read_preference.with_node(cluster) do |node|
+          node.notify(method, params)
+        end
+      end
+
+      def request(method, params)
+        read_preference.with_node(cluster) do |node|
+          node.request(method, params)
+        end
+      end
+
+      def synchronize
+        read_preference.with_node(cluster) do |node|
+          node.synchronize
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/errors.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Errors
+
+      # Raised when the connection pool is saturated and no new connection is
+      # reaped during the wait time.
+      class PoolSaturated < RuntimeError; end
+
+      # Raised when attempting to checkout a connection on a thread that already
+      # has a connection checked out.
+      class ConnectionInUse < RuntimeError; end
+
+      # Raised when attempting to checkout a pinned connection from the pool but
+      # it is already in use by another object on the same thread.
+      class PoolTimeout < RuntimeError; end
+
+      # Generic error class for exceptions related to connection failures.
+      class ConnectionFailure < StandardError; end
+
+      # Raised when an Adapter is invalid.
+      class InvalidAdapter < StandardError; end
+
+      # Raised when a Bones::RPC URI is invalid.
+      class InvalidBonesRPCURI < StandardError; end
+
+      class InvalidExtMessage < StandardError; end
+
+      # Tag applied to unhandled exceptions on a node.
+      module SocketError; end
+    end
+  end
+end

data/lib/bones/rpc/failover.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require 'bones/rpc/failover/disconnect'
+require 'bones/rpc/failover/ignore'
+require 'bones/rpc/failover/retry'
+
+module Bones
+  module RPC
+
+    # Provides behaviour around failover scenarios for different types of
+    # exceptions that get raised on connection and execution of operations.
+    #
+    # @since 2.0.0
+    module Failover
+      extend self
+
+      # Hash lookup for the failover classes based off the exception type.
+      #
+      # @since 2.0.0
+      STRATEGIES = {
+        Errors::ConnectionFailure => Retry
+      }.freeze
+
+      # Get the appropriate failover handler given the provided exception.
+      #
+      # @example Get the failover handler for an IOError.
+      #   Bones::RPC::Failover.get(IOError)
+      #
+      # @param [ Exception ] exception The raised exception.
+      #
+      # @return [ Object ] The failover handler.
+      #
+      # @since 2.0.0
+      def get(exception)
+        STRATEGIES.fetch(exception.class, Disconnect)
+      end
+    end
+  end
+end

data/lib/bones/rpc/failover/disconnect.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Failover
+
+      # Disconnect is for the case when we get exceptions we do not know about,
+      # and need to disconnect the node to cleanup the problem.
+      #
+      # @since 2.0.0
+      module Disconnect
+        extend self
+
+        # Executes the failover strategy. In the case of disconnect, we just re-raise
+        # the exception that was thrown previously extending a socket error and
+        # disconnect.
+        #
+        # @example Execute the disconnect strategy.
+        #   Bones::RPC::Failover::Disconnect.execute(exception, node)
+        #
+        # @param [ Exception ] exception The raised exception.
+        # @param [ Node ] node The node the exception got raised on.
+        #
+        # @raise [ Errors::SocketError ] The extended exception that was thrown.
+        #
+        # @since 2.0.0
+        def execute(exception, node)
+          node.disconnect
+          raise(exception.extend(Errors::SocketError))
+        end
+      end
+    end
+  end
+end