bones-rpc 0.0.1

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Failover
+
+      # Ignore is for the case when we get exceptions we deem are proper user
+      # or datbase errors and should be re-raised.
+      #
+      # @since 2.0.0
+      module Ignore
+        extend self
+
+        # Executes the failover strategy. In the case of ignore, we just re-raise
+        # the exception that was thrown previously.
+        #
+        # @example Execute the ignore strategy.
+        #   Bones::RPC::Failover::Ignore.execute(exception, node)
+        #
+        # @param [ Exception ] exception The raised exception.
+        # @param [ Node ] node The node the exception got raised on.
+        #
+        # @raise [ Exception ] The exception that was previously thrown.
+        #
+        # @since 2.0.0
+        def execute(exception, node)
+          raise(exception)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Bones
+    module RPC
+    module Failover
+
+      # Retry is for the case when we get exceptions around the connection, and
+      # want to make another attempt to try and resolve the issue.
+      #
+      # @since 2.0.0
+      module Retry
+        extend self
+
+        # Executes the failover strategy. In the case of retyr, we disconnect and
+        # reconnect, then try the operation one more time.
+        #
+        # @example Execute the retry strategy.
+        #   Bones::RPC::Failover::Retry.execute(exception, node)
+        #
+        # @param [ Exception ] exception The raised exception.
+        # @param [ Node ] node The node the exception got raised on.
+        #
+        # @raise [ Errors::ConnectionFailure ] If the retry fails.
+        #
+        # @return [ Object ] The result of the block yield.
+        #
+        # @since 2.0.0
+        def execute(exception, node)
+          node.disconnect
+          begin
+            yield if block_given?
+          rescue Exception => e
+            node.down
+            raise(e)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/future.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    class Future < ::Celluloid::Future
+
+      def initialize(*args, &block)
+        @start = Time.now
+        super
+      end
+
+      def signal(*args, &block)
+        @stop = Time.now
+        super
+      end
+
+      def runtime
+        if @stop
+          @stop - @start
+        else
+          Time.now - @start
+        end
+      end
+
+    end
+  end
+end

data/lib/bones/rpc/instrumentable.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require 'bones/rpc/instrumentable/log'
+require 'bones/rpc/instrumentable/noop'
+
+module Bones
+  module RPC
+    module Instrumentable
+
+      # The name of the topic of operations for Bones::RPC.
+      #
+      # @since 2.0.0
+      TOPIC = "bones-rpc.operations"
+
+      # Topic for warning instrumentation.
+      #
+      # @since 2.0.0
+      WARN = "bones-rpc.warn"
+
+      # @!attribute instrumenter
+      #   @return [ Object ] The instrumenter
+      attr_reader :instrumenter
+
+      # Instrument and execute the provided block.
+      #
+      # @example Instrument and execute.
+      #   instrument("bones-rpc.noop") do
+      #     node.connect
+      #   end
+      #
+      # @param [ String ] name The name of the operation.
+      # @param [ Hash ] payload The payload.
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 2.0.0
+      def instrument(name, payload = {}, &block)
+        instrumenter.instrument(name, payload, &block)
+      end
+    end
+  end
+end

data/lib/bones/rpc/instrumentable/log.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Instrumentable
+
+      # Provides logging instrumentation for compatibility with active support
+      # notifications.
+      #
+      # @since 2.0.0
+      class Log
+
+        class << self
+
+          # Instrument the log payload.
+          #
+          # @example Instrument the log payload.
+          #   Log.instrument("bones-rpc.ops", {})
+          #
+          # @param [ String ] name The name of the logging type.
+          # @param [ Hash ] payload The log payload.
+          #
+          # @return [ Object ] The result of the yield.
+          #
+          # @since 2.0.0
+          def instrument(name, payload = {})
+            started = Time.new
+            begin
+              yield if block_given?
+            rescue Exception => e
+              payload[:exception] = [ e.class.name, e.message ]
+              raise e
+            ensure
+              runtime = ("%.4fms" % (1000 * (Time.now.to_f - started.to_f)))
+              if name == TOPIC
+                Bones::RPC::Loggable.log_operations(payload[:prefix], payload[:ops], runtime)
+              else
+                Bones::RPC::Loggable.debug(payload[:prefix], payload.reject { |k,v| k == :prefix }, runtime)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/instrumentable/noop.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Instrumentable
+
+      # Does not instrument anything, just yields.
+      #
+      # @since 2.0.0
+      class Noop
+
+        class << self
+
+          # Do not instrument anything.
+          #
+          # @example Do not instrument.
+          #   Noop.instrument("bones-rpc.noop") do
+          #     node.connect
+          #   end
+          #
+          # @param [ String ] name The name of the operation.
+          # @param [ Hash ] payload The payload.
+          #
+          # @return [ Object ] The result of the yield.
+          #
+          # @since 2.0.0
+          def instrument(name, payload = {})
+            yield payload if block_given?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/loggable.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+module Bones
+  module RPC
+
+    # Contains behaviour for logging.
+    #
+    # @since 1.0.0
+    module Loggable
+
+      # Log the provided operations.
+      #
+      # @example Log the operations.
+      #   Loggable.log_operations("BONES-RPC", {}, 30)
+      #
+      # @param [ String ] prefix The prefix for all operations in the log.
+      # @param [ Array ] ops The operations.
+      # @param [ String ] runtime The runtime in formatted ms.
+      #
+      # @since 2.0.0
+      def self.log_operations(prefix, ops, runtime)
+        indent  = " "*prefix.length
+        if ops.length == 1
+          Bones::RPC.logger.debug([ prefix, ops.first.log_inspect, "runtime: #{runtime}" ].join(' '))
+        else
+          first, *middle, last = ops
+          Bones::RPC.logger.debug([ prefix, first.log_inspect ].join(' '))
+          middle.each { |m| Bones::RPC.logger.debug([ indent, m.log_inspect ].join(' ')) }
+          Bones::RPC.logger.debug([ indent, last.log_inspect, "runtime: #{runtime}" ].join(' '))
+        end
+      end
+
+      # Log the payload to debug.
+      #
+      # @example Log to debug.
+      #   Loggable.debug("BONES-RPC", payload "30.012ms")
+      #
+      # @param [ String ] prefix The log prefix.
+      # @param [ String ] payload The log operations.
+      # @param [ String ] runtime The runtime in formatted ms.
+      #
+      # @since 2.0.0
+      def self.debug(prefix, payload, runtime)
+        Bones::RPC.logger.debug([ prefix, payload, "runtime: #{runtime}" ].join(' '))
+      end
+
+      # Log the payload to warn.
+      #
+      # @example Log to warn.
+      #   Loggable.warn("BONES-RPC", payload "30.012ms")
+      #
+      # @param [ String ] prefix The log prefix.
+      # @param [ String ] payload The log operations.
+      # @param [ String ] runtime The runtime in formatted ms.
+      #
+      # @since 2.0.0
+      def self.warn(prefix, payload, runtime)
+        Bones::RPC.logger.warn([ prefix, payload, "runtime: #{runtime}" ].join(' '))
+      end
+
+      # Get the logger.
+      #
+      # @example Get the logger.
+      #   Loggable.logger
+      #
+      # @return [ Logger ] The logger.
+      #
+      # @since 1.0.0
+      def logger
+        return @logger if defined?(@logger)
+        @logger = rails_logger || default_logger
+      end
+
+      # Get the rails logger.
+      #
+      # @example Get the rails logger.
+      #   Loggable.rails_logger
+      #
+      # @return [ Logger ] The Rails logger.
+      #
+      # @since 1.0.0
+      def rails_logger
+        defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      end
+
+      # Get the default logger.
+      #
+      # @example Get the default logger.
+      #   Loggable.default_logger
+      #
+      # @return [ Logger ] The default logger.
+      #
+      # @since 1.0.0
+      def default_logger
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::INFO
+        logger
+      end
+
+      # Set the logger.
+      #
+      # @example Set the logger.
+      #   Loggable.logger = logger
+      #
+      # @return [ Logger ] The logger.
+      #
+      # @since 1.0.0
+      def logger=(logger)
+        @logger = logger
+      end
+    end
+  end
+end

data/lib/bones/rpc/node.rb

@@ -0,0 +1,317 @@
+# encoding: utf-8
+require 'bones/rpc/address'
+require 'bones/rpc/connection'
+require 'bones/rpc/failover'
+require 'bones/rpc/future'
+require 'bones/rpc/instrumentable'
+require 'bones/rpc/node/registry'
+
+module Bones
+  module RPC
+
+    # Represents a client to a node in a server cluster.
+    #
+    # @since 1.0.0
+    class Node
+      include Celluloid
+      include Instrumentable
+
+      # @!attribute address
+      #   @return [ Address ] The address.
+      # @!attribute down_at
+      #   @return [ Time ] The time the node was marked as down.
+      # @!attribute latency
+      #   @return [ Integer ] The latency in milliseconds.
+      # @!attribute options
+      #   @return [ Hash ] The node options.
+      # @!attribute refreshed_at
+      #   @return [ Time ] The last time the node did a refresh.
+      attr_reader :cluster, :address, :down_at, :latency, :refreshed_at
+
+      # Is this node equal to another?
+      #
+      # @example Is the node equal to another.
+      #   node == other
+      #
+      # @param [ Node ] other The other node.
+      #
+      # @return [ true, false ] If the addresses are equal.
+      #
+      # @since 1.0.0
+      def ==(other)
+        return false unless other.is_a?(Node)
+        id == other.id
+      end
+      alias :eql? :==
+
+      def adapter
+        @adapter ||= Adapter.get(options[:adapter] || :msgpack)
+      end
+
+      def attach(channel, id, future)
+        @registry.set(channel, id, future)
+      end
+
+      def cleanup_socket(socket)
+        @registry.flush
+      end
+
+      # Connect the node on the underlying connection.
+      #
+      # @example Connect the node.
+      #   node.connect
+      #
+      # @raise [ Errors::ConnectionFailure ] If connection failed.
+      #
+      # @return [ true ] If the connection suceeded.
+      #
+      # @since 2.0.0
+      def connect
+        start = Time.now
+        @connection.connect
+        @latency = Time.now - start
+        @down_at = nil
+        true
+      end
+
+      # Is the node currently connected?
+      #
+      # @example Is the node connected?
+      #   node.connected?
+      #
+      # @return [ true, false ] If the node is connected or not.
+      #
+      # @since 2.0.0
+      def connected?
+        @connection.alive?
+      end
+
+      def detach(channel, id)
+        @registry.get(channel, id)
+      end
+
+      # Force the node to disconnect from the server.
+      #
+      # @example Disconnect the node.
+      #   node.disconnect
+      #
+      # @return [ true ] If the disconnection succeeded.
+      #
+      # @since 1.2.0
+      def disconnect
+        @connection.disconnect
+        true
+      end
+
+      # Is the node down?
+      #
+      # @example Is the node down?
+      #   node.down?
+      #
+      # @return [ Time, nil ] The time the node went down, or nil if up.
+      #
+      # @since 1.0.0
+      def down?
+        !!@down_at
+      end
+
+      # Mark the node as down.
+      #
+      # @example Mark the node as down.
+      #   node.down
+      #
+      # @return [ nil ] Nothing.
+      #
+      # @since 2.0.0
+      def down
+        @down_at = Time.new
+        @latency = nil
+        disconnect if connected?
+      end
+
+      # Yields the block if a connection can be established, retrying when a
+      # connection error is raised.
+      #
+      # @example Ensure we are connection.
+      #   node.ensure_connected do
+      #     #...
+      #   end
+      #
+      # @raises [ ConnectionFailure ] When a connection cannot be established.
+      #
+      # @return [ nil ] nil.
+      #
+      # @since 1.0.0
+      def ensure_connected(&block)
+        begin
+          connect unless connected?
+          yield(current_actor)
+        rescue Exception => e
+          Failover.get(e).execute(e, current_actor, &block)
+        end
+      end
+
+      def handle_message(message)
+        logging(message) do
+          if future = message.get(current_actor)
+            message.signal(future)
+          end
+        end
+      end
+
+      def initialize(cluster, address)
+        @cluster = cluster
+        @address = address
+        @connection = Connection.new(current_actor)
+        @down_at = nil
+        @refreshed_at = nil
+        @latency = nil
+        @instrumenter = @cluster.options[:instrumenter] || Instrumentable::Log
+        @registry = Node::Registry.new
+        @request_id = 0
+        @synack_id = 0
+        @address.resolve(self)
+      end
+
+      # Get the node as a nice formatted string.
+      #
+      # @example Inspect the node.
+      #   node.inspect
+      #
+      # @return [ String ] The string inspection.
+      #
+      # @since 1.0.0
+      def inspect
+        "<#{self.class.name} resolved_address=#{address.resolved.inspect}>"
+      end
+
+      # Does the node need to be refreshed?
+      #
+      # @example Does the node require refreshing?
+      #   node.needs_refresh?(time)
+      #
+      # @param [ Time ] time The next referesh time.
+      #
+      # @return [ true, false] Whether the node needs to be refreshed.
+      #
+      # @since 1.0.0
+      def needs_refresh?(time)
+        !refreshed_at || refreshed_at < time
+      end
+
+      def notify(method, params)
+        without_future(Protocol::Notify.new(method, params))
+      end
+
+      def options
+        cluster.options
+      end
+
+      # Refresh information about the node, such as it's status in the replica
+      # set and it's known peers.
+      #
+      # @example Refresh the node.
+      #   node.refresh
+      #
+      # @raise [ ConnectionFailure ] If the node cannot be reached.
+      #
+      # @raise [ ReplicaSetReconfigured ] If the node is no longer a primary node and
+      #   refresh was called within an +#ensure_primary+ block.
+      #
+      # @return [ nil ] nil.
+      #
+      # @since 1.0.0
+      def refresh
+        if address.resolve(self)
+          begin
+            @refreshed_at = Time.now
+            if synchronize.value(timeout)
+              cluster.handle_refresh(current_actor)
+            else
+              down
+            end
+          rescue Timeout::Error
+            down
+          end
+        end
+      end
+
+      def request(method, params)
+        with_future(Protocol::Request.new(next_request_id, method, params))
+      end
+
+      def synchronize
+        with_future(Protocol::Synchronize.new(next_synack_id, adapter))
+      end
+
+      # Get the timeout, in seconds, for this node.
+      #
+      # @example Get the timeout in seconds.
+      #   node.timeout
+      #
+      # @return [ Integer ] The configured timeout or the default of 5.
+      #
+      # @since 1.0.0
+      def timeout
+        @timeout ||= (options[:timeout] || 5)
+      end
+
+      private
+
+      # Yield the block with logging.
+      #
+      # @api private
+      #
+      # @example Yield with logging.
+      #   logging(operations) do
+      #     node.command(ismaster: 1)
+      #   end
+      #
+      # @param [ Array<Message> ] operations The operations.
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 2.0.0
+      def logging(message)
+        instrument(TOPIC, prefix: "  BONES-RPC: #{address.resolved}", ops: [message]) do
+          yield if block_given?
+        end
+      end
+
+      def next_request_id
+        @request_id += 1
+        if @request_id >= 1 << 31
+          @request_id = 0
+        end
+        @request_id
+      end
+
+      def next_synack_id
+        @synack_id += 1
+        if @synack_id >= (1 << 32) - 1
+          @synack_id = 0
+        end
+        @synack_id
+      end
+
+      def process(message, future = nil)
+        logging(message) do
+          ensure_connected do
+            @connection.write([[message, future]])
+          end
+        end
+        return future
+      rescue Exception => e
+        abort(e)
+      end
+
+      def with_future(message)
+        process(message, Future.new)
+      end
+
+      def without_future(message)
+        process(message, nil)
+      end
+    end
+  end
+end