protobuf 2.2.5-java

data/lib/protobuf/message/decoder.rb

@@ -0,0 +1,83 @@
+require 'protobuf/wire_type'
+require 'protobuf/exceptions'
+
+module Protobuf
+
+  module Decoder
+
+    module_function
+
+    # Read bytes from +stream+ and pass to +message+ object.
+    def decode(stream, message)
+      until stream.eof?
+        tag, wire_type = read_key(stream)
+        bytes =
+          case wire_type
+          when WireType::VARINT then
+            read_varint(stream)
+          when WireType::FIXED64 then
+            read_fixed64(stream)
+          when WireType::LENGTH_DELIMITED then
+            read_length_delimited(stream)
+          when WireType::START_GROUP then
+            read_start_group(stream)
+          when WireType::END_GROUP then
+            read_end_group(stream)
+          when WireType::FIXED32 then
+            read_fixed32(stream)
+          else
+            raise InvalidWireType, wire_type
+          end
+        message.set_field(tag, bytes)
+      end
+      message
+    end
+
+    # Read key pair (tag and wire-type) from +stream+.
+    def read_key(stream)
+      bits = read_varint(stream)
+      wire_type = bits & 0x07
+      tag = bits >> 3
+      [tag, wire_type]
+    end
+
+    # Read varint integer value from +stream+.
+    def read_varint(stream)
+      read_method = stream.respond_to?(:readbyte) ? :readbyte : :readchar
+      value = index = 0
+      begin
+        byte = stream.__send__(read_method)
+        value |= (byte & 0x7f) << (7 * index)
+        index += 1
+      end while (byte & 0x80).nonzero?
+      value
+    end
+
+    # Read 32-bit string value from +stream+.
+    def read_fixed32(stream)
+      stream.read(4)
+    end
+
+    # Read 64-bit string value from +stream+.
+    def read_fixed64(stream)
+      stream.read(8)
+    end
+
+    # Read length-delimited string value from +stream+.
+    def read_length_delimited(stream)
+      value_length = read_varint(stream)
+      stream.read(value_length)
+    end
+
+    # Not implemented.
+    def read_start_group(stream)
+      raise NotImplementedError, 'Group is deprecated.'
+    end
+
+    # Not implemented.
+    def read_end_group(stream)
+      raise NotImplementedError, 'Group is deprecated.'
+    end
+
+  end
+end

data/lib/protobuf/message/encoder.rb

@@ -0,0 +1,48 @@
+require 'protobuf/wire_type'
+require 'protobuf/exceptions'
+
+module Protobuf
+
+  module Encoder
+
+    module_function
+
+    # Encode +message+ and write to +stream+.
+    def encode(stream, message)
+      # FIXME make this not as ghetto
+      unless message.initialized?
+        raise NotInitializedError, "Message #{message.class.name} is not initialized (one or more fields is improperly set): #{JSON.parse(message.to_json)}"
+      end
+
+      message.each_field do |field, value|
+        next unless message.has_field?(field.name)
+
+        if field.repeated?
+          if field.packed?
+            key = (field.tag << 3) | WireType::LENGTH_DELIMITED
+            packed_value = value.map {|val| field.encode(val) }.join
+            stream.write(Field::VarintField.encode(key))
+            stream.write(Field::VarintField.encode(packed_value.size))
+            stream.write(packed_value)
+          else
+            value.each do |val|
+              write_pair(stream, field, val)
+            end
+          end
+        else
+          write_pair(stream, field, value)
+        end
+      end
+    end
+
+    # Encode key and value, and write to +stream+.
+    def write_pair(stream, field, value)
+      key = (field.tag << 3) | field.wire_type
+      key_bytes = Field::VarintField.encode(key)
+      stream.write(key_bytes)
+      bytes = field.encode(value)
+      stream.write(bytes)
+    end
+
+  end
+end

data/lib/protobuf/message/extend.rb

@@ -0,0 +1,8 @@
+require 'protobuf/message/message'
+
+module Protobuf
+  class Extend < Message
+    MIN = -1.0/0
+    MAX = 1.0/0
+  end
+end

data/lib/protobuf/message/message.rb

@@ -0,0 +1 @@
+require 'protobuf/message' # Need to get rid of this

data/lib/protobuf/message.rb

@@ -0,0 +1,320 @@
+require 'set'
+require 'protobuf/field'
+require 'protobuf/enum'
+require 'protobuf/message/decoder'
+require 'protobuf/message/encoder'
+
+module Protobuf
+  class Message
+    ##
+    # Error Classes
+    #
+    class FieldNotDefinedError < StandardError; end
+
+    ##
+    # Constants
+    #
+    STRING_ENCODING = "ASCII-8BIT".freeze
+
+    ##
+    # Class Methods
+    #
+    def self.all_fields
+      @all_fields ||= begin
+                        all_fields_array = []
+                        max_fields = fields.size > extension_fields.size ? fields.size : extension_fields.size
+                        max_fields.times do |field_number|
+                          all_fields_array << (fields[field_number] || extension_fields[field_number])
+                        end
+                        all_fields_array.compact!
+                        all_fields_array
+                      end
+    end
+
+    # Define a field. Don't use this method directly.
+    def self.define_field(rule, type, fname, tag, options)
+      field_array = options[:extension] ? extension_fields : fields
+      field_name_hash = options[:extension] ? extension_field_name_to_tag : field_name_to_tag
+
+      if field_array[tag]
+        raise TagCollisionError, %!{Field number #{tag} has already been used in "#{self.name}" by field "#{fname}".!
+      end
+
+      field_definition = Field.build(self, rule, type, fname, tag, options)
+      field_name_hash[fname] = tag
+      field_array[tag] = field_definition
+    end
+
+    # Reserve field numbers for extensions. Don't use this method directly.
+    def self.extensions(range)
+      extension_fields.add_range(range)
+    end
+    
+    def self.extension_field_name_to_tag
+      @extension_fields_by_name ||= {}
+    end
+
+    # An extension field object.
+    def self.extension_fields
+      @extension_fields ||= ::Protobuf::Field::ExtensionFields.new
+    end
+
+    def self.extension_tag?(tag)
+      extension_fields.include_tag?(tag)
+    end
+
+    # A collection of field object.
+    def self.fields
+      @fields ||= []
+    end
+
+    def self.field_name_to_tag
+      @field_name_to_tag ||= {}
+    end
+
+    def self.get_ext_field_by_name(name)
+      # Check if the name has been used before, if not then set it to the sym value
+      extension_fields[extension_field_name_to_tag[name.to_sym]]
+    rescue TypeError, NoMethodError => e
+      name = 'nil' if name.nil?
+      raise FieldNotDefinedError.new("Field '#{name}' is not defined on message '#{self.name}'")
+    end
+
+    def self.get_ext_field_by_tag(tag)
+      extension_fields[tag]
+    end
+
+    # Find a field object by +name+.
+    def self.get_field_by_name(name)
+      # Check if the name has been used before, if not then set it to the sym value
+      fields[field_name_to_tag[name.to_sym]]
+    rescue TypeError, NoMethodError => e
+      name = 'nil' if name.nil?
+      raise FieldNotDefinedError.new("Field '#{name}' is not defined on message '#{self.name}'")
+    end
+
+    # Find a field object by +tag+ number.
+    def self.get_field_by_tag(tag)
+      fields[tag]
+    rescue TypeError => e
+      tag = tag.nil? ? 'nil' : tag.to_s
+      raise FieldNotDefinedError.new("Tag '#{tag}' does not reference a message field for '#{self.name}'")
+    end
+
+    # Define a optional field. Don't use this method directly.
+    def self.optional(type, name, tag, options = {})
+      define_field(:optional, type, name, tag, options)
+    end
+
+    # Define a repeated field. Don't use this method directly.
+    def self.repeated(type, name, tag, options = {})
+      define_field(:repeated, type, name, tag, options)
+    end
+
+    # Define a required field. Don't use this method directly.
+    def self.required(type, name, tag, options = {})
+      define_field(:required, type, name, tag, options)
+    end
+
+    ##
+    # Constructor
+    #
+    def initialize(values = {})
+      @values = {}
+      values = values.to_hash
+      values.each { |name, val| self[name] = val unless val.nil? }
+    end
+
+    ##
+    # Public Instance Methods
+    #
+    def all_fields
+      self.class.all_fields
+    end
+
+    def clear!
+      @values.delete_if do |_, value|
+        if value.is_a?(Field::FieldArray)
+          value.clear
+          false
+        else
+          true
+        end
+      end
+      self
+    end
+
+    def clone
+      copy_to(super, :clone)
+    end
+
+    def dup
+      copy_to(super, :dup)
+    end
+
+    # Iterate over a field collection.
+    #   message.each_field do |field_object, value|
+    #     # do something
+    #   end
+    def each_field
+      all_fields.each do |field|
+        value = __send__(field.name)
+        yield(field, value)
+      end
+    end
+
+    # Returns extension fields. See Message#fields method.
+    def extension_fields
+      self.class.extension_fields
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def get_ext_field_by_name(name) # :nodoc:
+      self.class.get_ext_field_by_name(name)
+    end
+
+    def get_ext_field_by_tag(tag) # :nodoc:
+      self.class.get_ext_field_by_tag(tag)
+    end
+
+    # Returns field object or +nil+.
+    def get_field_by_name(name)
+      self.class.get_field_by_name(name)
+    end
+
+    # Returns field object or +nil+.
+    def get_field_by_tag(tag)
+      self.class.get_field_by_tag(tag)
+    end
+
+    def has_field?(name)
+      @values.has_key?(name)
+    end
+
+    def initialized?
+      all_fields.all? { |field| field.initialized?(self) }
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def parse_from_string(string)
+      parse_from(StringIO.new(string))
+    end
+
+    def parse_from(stream)
+      Decoder.decode(stream, self)
+    end
+
+    def respond_to_has?(key)
+      self.respond_to?(key) && self.has_field?(key)
+    end
+
+    def respond_to_has_and_present?(key)
+      self.respond_to_has?(key) && 
+        (self.__send__(key).present? || [true, false].include?(self.__send__(key)))
+    end
+
+    def serialize_to(stream)
+      Encoder.encode(stream, self)
+    end
+
+    def serialize_to_string(string='')
+      io = StringIO.new(string)
+      serialize_to(io)
+      result = io.string
+      result.force_encoding(::Protobuf::Message::STRING_ENCODING) if result.respond_to?(:force_encoding)
+      result
+    end
+
+    def set_field(tag, bytes)
+      field = (get_field_by_tag(tag) || get_ext_field_by_tag(tag))
+      field.set(self, bytes) if field
+    end
+
+    # Return a hash-representation of the given fields for this message type.
+    def to_hash
+      result = Hash.new
+
+      @values.keys.each do |field_name|
+        value = __send__(field_name)
+        hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        result.merge!(field_name => hashed_value)
+      end
+
+      return result
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def ==(obj)
+      return false unless obj.is_a?(self.class)
+      each_field do |field, value|
+        return false unless value == obj.__send__(field.name)
+      end
+      true
+    end
+
+    def [](name)
+      if field = get_field_by_name(name) || get_ext_field_by_name(name)
+        __send__(field.name)
+      else
+        raise NoMethodError, "No such field: #{name.inspect}"
+      end
+    end
+
+    def []=(name, value)
+      if field = get_field_by_name(name) || get_ext_field_by_name(name)
+        __send__(field.setter_method_name, value)
+      else
+        raise NoMethodError, "No such field: #{name.inspect}"
+      end
+    end
+
+    ##
+    # Instance Aliases
+    #
+    alias_method :to_hash_value, :to_hash
+    alias_method :to_s, :serialize_to_string
+    alias_method :responds_to_has?, :respond_to_has?
+    alias_method :respond_to_and_has?, :respond_to_has?
+    alias_method :responds_to_and_has?, :respond_to_has?
+    alias_method :respond_to_has_present?, :respond_to_has_and_present?
+    alias_method :respond_to_and_has_present?, :respond_to_has_and_present?
+    alias_method :respond_to_and_has_and_present?, :respond_to_has_and_present?
+    alias_method :responds_to_has_present?, :respond_to_has_and_present?
+    alias_method :responds_to_and_has_present?, :respond_to_has_and_present?
+    alias_method :responds_to_and_has_and_present?, :respond_to_has_and_present?
+
+    ##
+    # Private Instance Methods
+    #
+    private
+
+    def copy_to(object, method)
+      duplicate = proc { |obj|
+        case obj
+        when Message, String then obj.__send__(method)
+        else                      obj
+        end
+      }
+
+      object.__send__(:initialize)
+      @values.each do |name, value|
+        if value.is_a?(Field::FieldArray)
+          object.__send__(name).replace(value.map {|v| duplicate.call(v)})
+        else
+          object.__send__("#{name}=", duplicate.call(value))
+        end
+      end
+      object
+    end
+
+  end
+end

data/lib/protobuf/rpc/buffer.rb

@@ -0,0 +1,79 @@
+module Protobuf
+  module Rpc
+    class Buffer
+
+      attr_accessor :mode, :data, :size
+
+      MODES = [:read, :write]
+
+      # constantize this so we don't re-initialize the regex every time we need it
+      SIZE_REGEX = /^\d+-/
+
+      def initialize(mode=:read)
+        @flush = false
+        @data = ""
+        @size = 0
+        self.mode = mode
+      end
+
+      def mode=(mode)
+        if MODES.include?(mode)
+          @mode = mode
+        else
+          @mode = :read
+        end
+      end
+
+      def write(force_mode=true)
+        if force_mode and reading?
+          mode = :write
+        elsif not force_mode and reading?
+          raise = 'You chose to write the buffer when in read mode'
+        end
+
+        @size = @data.length
+        "#{@size}-#{@data}"
+      end
+
+      def <<(data)
+        @data << data
+        if reading?
+          get_data_size
+          check_for_flush
+        end
+      end
+
+      def set_data(data)
+        @data = data.is_a?(::Protobuf::Message) ? data.serialize_to_string : data.to_s
+        @size = @data.size
+      end
+
+      def reading?
+        mode == :read
+      end
+
+      def writing?
+        mode == :write
+      end
+
+      def flushed?
+        @flush
+      end
+
+      def get_data_size
+        if @size == 0 || @data.match(SIZE_REGEX)
+          sliced_size = @data.slice!(SIZE_REGEX)
+          @size = sliced_size.gsub('-', '').to_i unless sliced_size.nil?
+        end
+      end
+
+    private
+
+      def check_for_flush
+        if !@size.nil? && @data.length == @size
+          @flush = true
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/client.rb

@@ -0,0 +1,166 @@
+require 'forwardable'
+require 'protobuf'
+require 'protobuf/logger'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/connector'
+
+module Protobuf
+  module Rpc
+    class Client
+      extend Forwardable
+      include Protobuf::Logger::LogMethods
+
+      delegate [:options, :complete_cb, :success_cb, :failure_cb] => :@connector
+      attr_reader :connector
+
+      # Create a new client with default options (defined in ClientConnection)
+      # See Service#client for a more convenient way to create a client, as well
+      # as Client#method_missing defined below.
+      #
+      #   request = WidgetFindRequest.new
+      #   client = Client.new({
+      #     :service => WidgetService,
+      #     :method => "find",
+      #     :request_type => "WidgetFindRequest",
+      #     :response_type => "WidgetList",
+      #     :request => request
+      #   })
+      #
+      def initialize(options = {})
+        raise "Invalid client configuration. Service must be defined." if options[:service].nil?
+        @connector = Connector.connector_for_client.new(options)
+        log_debug { sign_message("Initialized with options: #{options.inspect}") }
+      end
+
+      def log_signature
+        @_log_signature ||= "client-#{self.class}"
+      end
+
+      # Set a complete callback on the client to return the object (self).
+      #
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_complete {|obj| ... }
+      #
+      def on_complete(&complete_cb)
+        @connector.complete_cb = complete_cb
+      end
+
+      def on_complete=(callable)
+        if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
+          raise "callable must take a single argument and respond to :call"
+        end
+
+        @connector.complete_cb = callable
+      end
+
+      # Set a failure callback on the client to return the
+      # error returned by the service, if any. If this callback
+      # is called, success_cb will NOT be called.
+      #
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_failure {|err| ... }
+      #
+      def on_failure(&failure_cb)
+        @connector.failure_cb = failure_cb
+      end
+
+      def on_failure=(callable)
+        if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
+          raise "Callable must take a single argument and respond to :call"
+        end
+
+        @connector.failure_cb = callable
+      end
+
+      # Set a success callback on the client to return the
+      # successful response from the service when it is returned.
+      # If this callback is called, failure_cb will NOT be called.
+      #
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_success {|res| ... }
+      #
+      def on_success(&success_cb)
+        @connector.success_cb = success_cb
+      end
+
+      def on_success=(callable)
+        if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
+          raise "Callable must take a single argument and respond to :call"
+        end
+
+        @connector.success_cb = callable
+      end
+
+      # Provides a mechanism to call the service method against the client
+      # which will automatically setup the service_class and method_name
+      # in the wrapper protobuf request.
+      #
+      #   # The :find method is not defined by Client which will trigger method_missing
+      #   Client.new(:service => WidgetService).find do |c|
+      #     # This block will be invoked before the request is made
+      #     # `c` in this case is the client object you created above
+      #     c.on_success {|res| ... }
+      #     c.on_failure {|err| ... }
+      #   end
+      #
+      def method_missing(method_name, *params)
+        service = options[:service]
+        unless service.rpc_method?(method_name)
+          log_error { sign_message("#{service.name}##{method_name.to_s} not rpc method, passing to super") }
+          super(method_name, *params)
+        else
+          log_debug { sign_message("#{service.name}##{method_name.to_s}") }
+          rpc = service.rpcs[method_name.to_sym]
+
+          options[:request_type] = rpc.request_type
+          log_debug { sign_message("Request Type: #{options[:request_type].name}") }
+
+          options[:response_type] = rpc.response_type
+          log_debug { sign_message("Response Type: #{options[:response_type].name}") }
+
+          options[:method] = method_name.to_s
+          options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
+          log_debug { sign_message("Request Data: #{options[:request].inspect}") }
+
+          # Call client to setup on_success and on_failure event callbacks
+          if block_given?
+            log_debug { sign_message("client setup callback given, invoking") }
+            yield(self)
+          else
+            log_debug { sign_message("no block given for callbacks") }
+          end
+
+          send_request
+        end
+      end
+
+      # Send the request to the service through eventmachine.
+      # This method is usually never called directly
+      # but is invoked by method_missing (see docs above).
+      #
+      #   request = WidgetFindRequest.new
+      #   client = Client.new({
+      #     :service => WidgetService,
+      #     :method => "find",
+      #     :request_type => "WidgetFindRequest",
+      #     :response_type => "WidgetList",
+      #     :request => request
+      #   })
+      #
+      #   client.on_success do |res|
+      #     res.widgets.each{|w| puts w.inspect }
+      #   end
+      #
+      #   client.on_failure do |err|
+      #     puts err.message
+      #   end
+      #
+      #   client.send_request
+      #
+      def send_request
+        @connector.send_request
+      end
+
+    end
+  end
+end