bones-rpc 0.0.1

data/lib/bones/rpc/protocol/notify.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Protocol
+      class Notify
+        include AdapterHelper
+
+        integer :op_code
+        binary :method
+        list :params
+
+        finalize
+
+        def initialize(method, params)
+          @method = method
+          @params = params
+        end
+
+        undef op_code
+
+        def op_code
+          2
+        end
+
+        def log_inspect
+          type = "NOTIFY"
+          fields = []
+          fields << ["%-12s", type]
+          fields << ["method=%s", method]
+          fields << ["params=%s", params]
+          f, v = fields.transpose
+          f.join(" ") % v
+        end
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/protocol/request.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Protocol
+      class Request
+        include AdapterHelper
+
+        integer :op_code
+        integer :id
+        binary :method
+        list :params
+
+        finalize
+
+        def initialize(id, method, params)
+          @id = id
+          @method = method
+          @params = params
+        end
+
+        undef op_code
+
+        def op_code
+          0
+        end
+
+        def log_inspect
+          type = "REQUEST"
+          fields = []
+          fields << ["%-12s", type]
+          fields << ["id=%s", id]
+          fields << ["method=%s", method]
+          fields << ["params=%s", params]
+          f, v = fields.transpose
+          f.join(" ") % v
+        end
+
+        def attach(node, future)
+          node.attach(:request, id, future)
+        end
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/protocol/response.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Protocol
+      class Response
+        include AdapterHelper
+
+        integer :op_code
+        integer :id
+        any :error
+        any :result
+
+        finalize
+
+        def initialize(id, error, result)
+          @id = id
+          @error = error
+          @result = result
+        end
+
+        undef op_code
+
+        def op_code
+          @op_code ||= 1
+        end
+
+        def log_inspect
+          type = "RESPONSE"
+          fields = []
+          fields << ["%-12s", type]
+          fields << ["id=%s", id]
+          fields << ["error=%s", error]
+          fields << ["result=%s", result]
+          f, v = fields.transpose
+          f.join(" ") % v
+        end
+
+        def self.map_from(object)
+          message = allocate
+          message.op_code = object[0]
+          message.id = object[1]
+          message.error = object[2]
+          message.result = object[3]
+          message
+        end
+
+        def get(node)
+          node.detach(:request, id)
+        end
+
+        def signal(future)
+          future.signal(FutureValue.new(self))
+        end
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/protocol/synchronize.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Protocol
+      class Synchronize < ExtMessage
+
+        uint32 :id
+        binary :adapter
+
+        finalize
+
+        def initialize(id, adapter)
+          self.id = id
+          self.adapter = adapter
+        end
+
+        undef ext_head
+        undef :adapter=
+        undef serialize_adapter
+
+        def ext_head
+          0
+        end
+
+        def adapter=(adapter)
+          @adapter = Adapter.get(adapter)
+        end
+
+        def deserialize_adapter(buffer)
+          self.adapter = buffer.read(ext_length - 5)
+        end
+
+        def serialize_adapter(buffer)
+          buffer << adapter.adapter_name.to_s
+        end
+
+        def log_inspect
+          type = "SYNCHRONIZE"
+          fields = []
+          fields << ["%-12s", type]
+          fields << ["id=%s", id]
+          fields << ["adapter=%s", adapter]
+          f, v = fields.transpose
+          f.join(" ") % v
+        end
+
+        def self.deserialize(buffer, adapter = nil)
+          message = super
+          message.deserialize_id(buffer)
+          message.deserialize_adapter(buffer)
+          message
+        end
+
+        def self.unpack(data)
+          buffer = StringIO.new(data)
+          id, = buffer.read(4).unpack('N')
+          adapter = buffer.read
+          new(id, adapter)
+        end
+
+        def attach(node, future)
+          node.attach(:synack, id, future)
+        end
+
+        Protocol.register_ext_head self, 0
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/read_preference.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'bones/rpc/read_preference/selectable'
+require 'bones/rpc/read_preference/nearest'
+
+module Bones
+  module RPC
+
+    # Provides behaviour around getting various read preference implementations.
+    #
+    # @since 2.0.0
+    module ReadPreference
+      extend self
+
+      # Hash lookup for the read preference classes based off the symbols
+      # provided in configuration.
+      #
+      # @since 2.0.0
+      PREFERENCES = {
+        nearest: Nearest
+      }.freeze
+
+      # Get a read preference for the provided name. Valid names are:
+      #   - :nearest
+      #   - :primary
+      #   - :primary_preferred
+      #   - :secondary
+      #   - :secondary_preferred
+      #
+      # @example Get the primary read preference.
+      #   Bones::RPC::ReadPreference.get(:primary)
+      #
+      # @param [ Symbol ] name The name of the preference.
+      # @param [ Array<Hash> ] tags The tag sets to match the node on.
+      #
+      # @return [ Object ] The appropriate read preference.
+      #
+      # @since 2.0.0
+      def get(name, tags = nil)
+        PREFERENCES.fetch(name.to_sym).new(tags)
+      end
+    end
+  end
+end

data/lib/bones/rpc/read_preference/nearest.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module ReadPreference
+
+      # Encapsulates behaviour around a nearest read preference.
+      #
+      # @since 2.0.0
+      class Nearest
+        include Selectable
+
+        # Get the name for the read preference on the server side.
+        #
+        # @example Get the name of the read preference.
+        #   nearest.name
+        #
+        # @return [ Symbol ] :nearest.
+        #
+        # @since 2.0.0
+        def name
+          :nearest
+        end
+
+        # Execute the provided block on the node with the lowest latency,
+        # allowing either primary or secondary.
+        #
+        # @example Read from the nearest node in the cluster.
+        #   preference.with_node(cluster) do |node|
+        #     node.command(ismaster: 1)
+        #   end
+        #
+        # @note If tag sets are provided then selection will need to
+        #   match the provided tags.
+        #
+        # @param [ Cluster ] cluster The cluster of nodes to select from.
+        # @param [ Proc ] block The block to execute on the node.
+        #
+        # @raise [ Errors::ConnectionFailure ] If no node was available in the
+        #   cluster.
+        #
+        # @return [ Object ] The result of the block.
+        #
+        # @since 2.0.0
+        def with_node(cluster, &block)
+          with_retry(cluster) do
+            nearest = cluster.nodes.sort_by(&:latency).first
+            if nearest
+              block.call(nearest)
+            else
+              raise Errors::ConnectionFailure, "No nodes available to select in the cluster"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/read_preference/selectable.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module ReadPreference
+
+      # Provides the shared behaviour for read preferences that can filter by a
+      # tag set or add query options.
+      #
+      # @since 2.0.0
+      module Selectable
+
+        # @!attribute tags
+        #   @return [ Array<Hash> ] The tag sets.
+        attr_reader :tags
+
+        # Instantiate the new taggable read preference.
+        #
+        # @example Instantiate the taggable.
+        #   Bones::RPC::ReadPreference::Secondary.new({ east_coast: 1 })
+        #
+        # @param [ Array<Hash> ] tags The tag sets.
+        #
+        # @since 2.0.0
+        def initialize(tags = nil)
+          @tags = tags
+        end
+
+        # Get the provided options as query options for this read preference.
+        #
+        # @example Get the query options.
+        #   preference.query_options({})
+        #
+        # @param [ Hash ] options The existing options for the query.
+        #
+        # @return [ Hash ] The options plus additional query options.
+        #
+        # @since 2.0.0
+        def query_options(options)
+          options[:flags] ||= []
+          options[:flags] |= [ :slave_ok ]
+          options
+        end
+
+        private
+
+        # Execute the provided block on the cluster and retry if the execution
+        # fails.
+        #
+        # @api private
+        #
+        # @example Execute with retry.
+        #   preference.with_retry(cluster) do
+        #     cluster.with_primary do |node|
+        #       node.refresh
+        #     end
+        #   end
+        #
+        # @param [ Cluster ] cluster The cluster.
+        # @param [ Integer ] retries The number of times to retry.
+        #
+        # @return [ Object ] The result of the block.
+        #
+        # @since 2.0.0
+        def with_retry(cluster, retries = cluster.max_retries, &block)
+          begin
+            block.call
+          rescue Errors::ConnectionFailure => e
+            if retries > 0
+              Loggable.warn("  BONES-RPC:", "Retrying connection attempt #{retries} more time(s).", "n/a")
+              sleep(cluster.retry_interval)
+              cluster.refresh
+              with_retry(cluster, retries - 1, &block)
+            else
+              raise e
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bones/rpc/readable.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Bones
+  module RPC
+
+    # Provides behaviour around readable objects.
+    #
+    # @since 2.0.0
+    module Readable
+
+      private
+
+      # Convenience method for getting the cluster from the session.
+      #
+      # @api private
+      #
+      # @example Get the cluster from the session.
+      #   database.cluster
+      #
+      # @return [ Cluster ] The cluster.
+      #
+      # @since 2.0.0
+      def cluster
+        session.cluster
+      end
+
+      # Convenience method for getting the read preference from the session.
+      #
+      # @api private
+      #
+      # @example Get the read preference.
+      #   database.read_preference
+      #
+      # @return [ Object ] The session's read preference.
+      #
+      # @since 2.0.0
+      def read_preference
+        session.read_preference
+      end
+
+      # Get the query options from the read preference.
+      #
+      # @api private
+      #
+      # @example Get the query options.
+      #   database.query_options
+      #
+      # @param [ Hash ] options The existing options on the query.
+      #
+      # @return [ Hash ] The new query options.
+      #
+      # @since 2.0.0
+      def query_options(options = {})
+        read_preference.query_options(options)
+      end
+    end
+  end
+end