bones-rpc 0.0.1

data/lib/bones/rpc/node/registry.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    class Node
+      class Registry
+
+        def initialize
+          @registry = {}
+        end
+
+        def flush(exception = Errors::ConnectionFailure.new("Socket closed"))
+          return true if @registry.empty?
+          @registry.each do |channel, futures|
+            futures.each do |id, future|
+              future.signal(FutureValue.new(exception)) rescue nil
+            end
+          end
+          @registry.clear
+        end
+
+        def get(channel, id)
+          (@registry[channel] ||= {}).delete(id)
+        end
+
+        def set(channel, id, future)
+          (@registry[channel] ||= {})[id] = future
+        end
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/parser.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require 'bones/rpc/parser/buffer'
+
+module Bones
+  module RPC
+    class Parser
+
+      EXT8  = [0xC7].pack('C').freeze
+      EXT16 = [0xC8].pack('C').freeze
+      EXT32 = [0xC9].pack('C').freeze
+
+      attr_reader :stream, :adapter
+
+      def buffer
+        @buffer ||= Bones::RPC::Parser::Buffer.new(@stream)
+      end
+
+      def initialize(stream, adapter)
+        @stream = stream.force_encoding('BINARY')
+        @adapter = Adapter.get(adapter)
+      end
+
+      def parser
+        @parser ||= @adapter.parser(@stream)
+      end
+
+      def read
+        sync do
+          b = buffer.getc
+          buffer.ungetc(b)
+          if b.nil?
+            raise EOFError
+          elsif b.start_with?(EXT8)
+            buffer.skip(1)
+            len, = buffer.read(1).unpack('C')
+            type, = buffer.read(1).unpack('C')
+            check_ext!(type)
+            head, = buffer.read(1).unpack('C')
+            data = buffer.read(len-1)
+            parse_ext!(head, data)
+          elsif b.start_with?(EXT16)
+            buffer.skip(1)
+            len, = buffer.read(2).unpack('n')
+            type, = buffer.read(1).unpack('C')
+            check_ext!(type)
+            head, = buffer.read(1).unpack('C')
+            data = buffer.read(len-1)
+            parse_ext!(head, data)
+          elsif b.start_with?(EXT32)
+            buffer.skip(1)
+            len, = buffer.read(4).unpack('N')
+            type, = buffer.read(1).unpack('C')
+            check_ext!(type)
+            head, = buffer.read(1).unpack('C')
+            data = buffer.read(len-1)
+            parse_ext!(head, data)
+          else
+            object = parser.read
+            buffer.seek(parser.unpacker_pos)
+            map_from!(object)
+          end
+        end
+      end
+
+      private
+
+      def check_ext!(type)
+        raise(Errors::InvalidExtMessage, "bad ext message received of type #{type.inspect} (should be #{0x0D.inspect})") unless valid_ext?(type)
+      end
+
+      def map_from!(object)
+        case object
+        when Array
+          if (3..4).include?(object.size)
+            case object.first
+            when 0
+              Protocol::Request.map_from(object)
+            when 1
+              Protocol::Response.map_from(object)
+            when 2
+              Protocol::Notify.map_from(object)
+            else
+              object
+            end
+          end
+        else
+          object
+        end
+      end
+
+      def parse_ext!(head, data)
+        message = Protocol.get_by_ext_head(head)
+        if message
+          message.unpack(data)
+        else
+          map_from!(Adapter.get_by_ext_head(head).unpack(data))
+        end
+      end
+
+      def sync
+        buffer.transaction do
+          yield
+        end
+      ensure
+        parser.unpacker_seek(buffer.pos) if parser.unpacker_pos != buffer.pos
+      end
+
+      def valid_ext?(type)
+        type == 0x0D
+      end
+
+    end
+  end
+end

data/lib/bones/rpc/parser/buffer.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    class Parser
+      class Buffer
+
+        attr_reader :io
+
+        def initialize(data)
+          @io = StringIO.new(data)
+        end
+
+        def getc
+          io.getc
+        end
+
+        def pos
+          io.pos
+        end
+
+        def read(n)
+          i = pos
+          data = io.read(n)
+          if data.bytesize < n
+            seek(i)
+            raise EOFError
+          else
+            data
+          end
+        end
+
+        def rewind
+          io.rewind
+        end
+
+        def seek(pos)
+          io.seek(pos)
+        end
+
+        def size
+          io.size
+        end
+
+        def skip(n)
+          seek(pos + n)
+        end
+
+        def sync(*others)
+          yield
+        ensure
+          others.each { |other| other.seek(pos) }
+        end
+
+        def to_str
+          i = pos
+          begin
+            io.read || ""
+          ensure
+            seek(i)
+          end
+        end
+
+        def transaction
+          i = pos
+          begin
+            yield
+          rescue EOFError => e
+            seek(i)
+            raise e
+          end
+        end
+
+        def ungetc(c)
+          io.ungetc(c)
+        end
+
+      end
+    end
+  end
+end

data/lib/bones/rpc/protocol.rb

@@ -0,0 +1,106 @@
+module Bones #:nodoc:
+  module RPC
+
+    # The +Bones::RPC::Protocol+ namespace contains convenience classes for
+    # building all of the possible messages defined in the Bones RPC Protocol.
+    module Protocol
+      extend self
+
+      def get_by_ext_head(head)
+        ext_heads[head]
+      end
+
+      def register_ext_head(message, head)
+        ext_heads[head] ||= message
+        return message
+      end
+
+      private
+
+      def ext_heads
+        @ext_heads ||= {}
+      end
+    end
+  end
+end
+
+require 'bones/rpc/protocol/adapter_helper'
+require 'bones/rpc/protocol/binary_helper'
+
+require 'bones/rpc/protocol/ext_message'
+require 'bones/rpc/protocol/acknowledge'
+require 'bones/rpc/protocol/synchronize'
+
+require 'bones/rpc/protocol/notify'
+require 'bones/rpc/protocol/request'
+require 'bones/rpc/protocol/response'
+
+module Bones
+  module RPC
+    module Protocol
+
+      def deserialize(buffer, adapter = nil)
+        char = buffer.getc
+        buffer.ungetc(char)
+        if sub = MAP[char]
+          sub.deserialize(buffer, adapter)
+        elsif adapter
+          Adapter.get(adapter).deserialize(buffer)
+        else
+          raise NotImplementedError, "Unknown data received: #{char.inspect}"
+        end
+      end
+
+      module MessagePackExtended
+        extend self
+
+        def deserialize(buffer, adapter = nil)
+          ext8 = buffer.getc
+          len = buffer.getc
+          type = buffer.getc
+          buffer.ungetc(type)
+          buffer.ungetc(len)
+          buffer.ungetc(ext8)
+          if sub = MAP[type]
+            sub.deserialize(buffer, adapter)
+          else
+            raise NotImplementedError, "Unknown MessagePackExtended data received: {ext8: #{ext8.inspect}, len: #{len.inspect}, type: #{type.inspect}}"
+          end
+        end
+
+        module BonesRPC
+          extend self
+
+          def deserialize(buffer, adapter = nil)
+            ext8 = buffer.getc
+            len = buffer.getc
+            type = buffer.getc
+            head = buffer.getc
+            buffer.ungetc(head)
+            buffer.ungetc(type)
+            buffer.ungetc(len)
+            buffer.ungetc(ext8)
+            if sub = MAP[head]
+              sub.deserialize(buffer, adapter)
+            else
+              raise NotImplementedError, "Unknown BonesRPC data received: {ext8: #{ext8.inspect}, len: #{len.inspect}, type: #{type.inspect}, head: #{head.inspect}}"
+            end
+          end
+
+          MAP = {
+            [0].pack('C').freeze => Synchronize,
+            [1].pack('C').freeze => Acknowledge
+          }.freeze
+        end
+
+        MAP = {
+          [0x0d].pack('C').freeze => BonesRPC
+        }.freeze
+      end
+
+      MAP = {
+        [0xc7].pack('C').freeze => MessagePackExtended
+      }.freeze
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Protocol
+      class Acknowledge < ExtMessage
+
+        uint32 :id
+        uint8 :ready
+
+        finalize
+
+        def initialize(id, ready)
+          self.id = id
+          self.ready = ready
+        end
+
+        undef ext_head
+        undef ready
+        undef :ready=
+        undef serialize_ready
+
+        def ext_head
+          1
+        end
+
+        def ready
+          @ready
+        end
+
+        def ready=(val)
+          @ready = case val
+          when 0xC2
+            false
+          when 0xC3
+            true
+          else
+            !!val
+          end
+        end
+
+        def serialize_ready(buffer)
+          buffer << [ready ? 0xC3 : 0xC2].pack('C')
+        end
+
+        def log_inspect
+          type = "ACKNOWLEDGE"
+          fields = []
+          fields << ["%-12s", type]
+          fields << ["id=%s", id]
+          fields << ["ready=%s", ready]
+          f, v = fields.transpose
+          f.join(" ") % v
+        end
+
+        def self.deserialize(buffer, adapter = nil)
+          message = super
+          message.deserialize_id(buffer)
+          message.deserialize_ready(buffer)
+          message
+        end
+
+        def self.unpack(data)
+          buffer = StringIO.new(data)
+          id, = buffer.read(4).unpack('N')
+          ready = buffer.read(1)
+          new(id, ready)
+        end
+
+        def get(node)
+          node.detach(:synack, id)
+        end
+
+        def signal(future)
+          future.signal(FutureValue.new(self))
+        end
+
+        Protocol.register_ext_head self, 1
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# encoding: utf-8
+module Bones
+  module RPC
+    module Protocol
+
+      module AdapterHelper
+
+        # Default implementation for a message is to do nothing when receiving
+        # replies.
+        #
+        # @example Receive replies.
+        #   message.receive_replies(connection)
+        #
+        # @param [ Connection ] connection The connection.
+        #
+        # @return [ nil ] nil.
+        #
+        # @since 1.0.0
+        def receive_replies(connection); end
+
+        # Serializes the message and all of its fields to a new buffer or to the
+        # provided buffer.
+        #
+        # @example Serliaze the message.
+        #   message.serialize
+        #
+        # @param [ String ] buffer A buffer to serialize to.
+        #
+        # @return [ String ] The result of serliazing this message
+        #
+        # @since 1.0.0
+        def serialize(buffer, adapter)
+          Adapter.get(adapter).serialize(process, buffer)
+        end
+
+        class << self
+
+          # Extends the including class with +ClassMethods+.
+          #
+          # @param [Class] subclass the inheriting class
+          def included(base)
+            super
+            base.extend(ClassMethods)
+          end
+          private :included
+        end
+
+        # Provides a DSL for defining struct-like fields for building messages
+        # for the Mongo Wire.
+        #
+        # @example
+        #   class Command
+        #     extend Message::ClassMethods
+        #
+        #     int32 :length
+        #   end
+        #
+        #   Command.fields # => [:length]
+        #   command = Command.new
+        #   command.length = 12
+        #   command.serialize_length("") # => "\f\x00\x00\x00"
+        module ClassMethods
+
+          def deserialize(adapter, buffer="")
+            adapter = Adapter.get(adapter)
+            message = adapter.deserialize(buffer)
+            message.shift
+            new(adapter, *message)
+          end
+
+          # @return [Array] the fields defined for this message
+          def fields
+            @fields ||= []
+          end
+
+          def any(name)
+            attr_accessor name
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def process_#{name}
+                #{name}
+              end
+            RUBY
+
+            fields << name
+          end
+
+          # Declare a binary field.
+          #
+          # @example
+          #   class Query < Message
+          #     binary :collection
+          #   end
+          #
+          # @param [String] name the name of this field
+          def binary(name)
+            attr_accessor name
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def process_#{name}
+                #{name}
+              end
+            RUBY
+
+            fields << name
+          end
+
+          def integer(name)
+            attr_accessor name
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                @#{name} ||= 0
+              end
+
+              def process_#{name}
+                #{name}
+              end
+            RUBY
+
+            fields << name
+          end
+
+          def list(name)
+            attr_accessor name
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                @#{name} ||= []
+              end
+
+              def process_#{name}
+                #{name}
+              end
+            RUBY
+
+            fields << name
+          end
+
+          # Declares the message class as complete, and defines its serialization
+          # method from the declared fields.
+          def finalize
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def process
+                list = []
+                #{fields.map { |f| "list << process_#{f}" }.join("\n")}
+                list
+              end
+            EOS
+          end
+
+          private
+
+          # This ensures that subclasses of the primary wire message classes have
+          # identical fields.
+          def inherited(subclass)
+            super
+            subclass.fields.replace(fields)
+          end
+        end
+      end
+    end
+  end
+end