protobuf 2.2.5-java

data/lib/protobuf/cli.rb

@@ -0,0 +1,188 @@
+require 'thor'
+require 'protobuf/version'
+require 'protobuf/logger'
+require 'protobuf/rpc/servers/evented_runner'
+require 'protobuf/rpc/servers/socket_runner'
+require 'protobuf/rpc/servers/zmq_runner'
+
+module Protobuf
+  class CLI < ::Thor
+    include ::Thor::Actions
+
+    attr_accessor :runner, :mode, :start_aborted
+
+    default_task :start
+
+    desc 'start APP_FILE', 'Run the RPC server in the given mode, preloading the given APP_FILE. This is the default task.'
+
+    option :host,                       :type => :string, :default => '127.0.0.1', :aliases => %w(-o), :desc => 'Host to bind.'
+    option :port,                       :type => :numeric, :default => 9399, :aliases => %w(-p), :desc => 'Master Port to bind.'
+
+    option :backlog,                    :type => :numeric, :default => 100, :aliases => %w(-b), :desc => 'Backlog for listening socket when using Socket Server.'
+    option :threshold,                  :type => :numeric, :default => 100, :aliases => %w(-t), :desc => 'Multi-threaded Socket Server cleanup threshold.'
+    option :threads,                    :type => :numeric, :default => 5, :aliases => %w(-r), :desc => 'Number of worker threads to run. Only applicable in --zmq mode.'
+
+    option :log,                        :type => :string, :aliases => %w(-l), :desc => 'Log file or device. Default is STDOUT.'
+    option :level,                      :type => :numeric, :default => ::Logger::INFO, :aliases => %w(-v), :desc => 'Log level to use, 0-5 (see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/)'
+
+    option :socket,                     :type => :boolean, :aliases => %w(-s), :desc => 'Socket Mode for server and client connections.'
+    option :evented,                    :type => :boolean, :aliases => %w(-m), :desc => 'Evented Mode for server and client connections (uses EventMachine).'
+    option :zmq,                        :type => :boolean, :aliases => %w(-z), :desc => 'ZeroMQ Socket Mode for server and client connections.'
+
+    option :debug,                      :type => :boolean, :default => false, :aliases => %w(-d), :desc => 'Debug Mode. Override log level to DEBUG.'
+    option :gc_pause_request,           :type => :boolean, :default => false, :desc => 'Enable/Disable GC pause during request.'
+    option :print_deprecation_warnings, :type => :boolean, :default => true, :desc => 'Cause use of deprecated fields to be printed or ignored.'
+
+    def start(app_file)
+      debug_say 'Configuring the rpc_server process'
+      @start_aborted = false
+
+      configure_logger
+      configure_traps
+      configure_server_mode
+      require_protobuf!
+      configure_gc
+      configure_deprecation_warnings
+
+      run_if_no_abort { require_application!(app_file) }
+      run_if_no_abort { configure_process_name(app_file) }
+      run_if_no_abort { start_server! }
+
+    rescue => e
+      say_and_exit!('ERROR: RPC Server failed to start.', e)
+    end
+
+    desc 'version', 'Print ruby and protoc versions and exit.'
+    def version
+      say "Ruby Protobuf v#{::Protobuf::VERSION}, protoc v#{::Protobuf::PROTOC_VERSION}"
+    end
+
+    no_tasks do
+
+      # Tell protobuf how to handle the printing of deprecated field usage.
+      def configure_deprecation_warnings
+        ::Protobuf.print_deprecation_warnings = options.print_deprecation_warnings?
+      end
+
+      # If we pause during request we don't need to pause in serialization
+      def configure_gc
+        debug_say 'Configuring gc'
+        ::Protobuf.gc_pause_server_request = options.gc_pause_request?
+      end
+
+      # Setup the protobuf logger.
+      def configure_logger
+        debug_say 'Configuring logger'
+        ::Protobuf::Logger.configure({ :file => options.log || STDOUT,
+                                       :level => options.debug? ? ::Logger::DEBUG : options.level })
+
+        # Debug output the server options to the log file.
+        ::Protobuf::Logger.debug { 'Debugging options:' }
+        ::Protobuf::Logger.debug { options.inspect }
+      end
+
+      # Re-write the $0 var to have a nice process name in ps.
+      def configure_process_name(app_file)
+        debug_say 'Configuring process name'
+        $0 = "rpc_server --#{@mode} #{options.host}:#{options.port} #{app_file}"
+      end
+
+      # Configure the mode of the server and the runner class.
+      def configure_server_mode
+        debug_say 'Configuring runner mode'
+        if options.zmq? && ! options.evented? && ! options.socket?
+          @mode = :zmq
+          @runner = ::Protobuf::Rpc::ZmqRunner
+        elsif options.evented? && ! options.zmq? && ! options.socket?
+          @mode = :evented
+          @runner = ::Protobuf::Rpc::EventedRunner
+        else
+          say 'WARNING: You have provided multiple mode options. Defaulting to socket mode.', :yellow if multi_mode?
+          @mode = :socket
+          @runner = ::Protobuf::Rpc::SocketRunner
+        end
+      end
+
+      # Configure signal traps.
+      # TODO add signal handling for hot-reloading the application.
+      def configure_traps
+        debug_say 'Configuring traps'
+        [:INT, :QUIT, :TERM].each do |signal|
+          debug_say "Registering signal trap for #{signal}", :blue
+          trap(signal) do
+            ::Protobuf::Logger.info { 'RPC Server shutting down...' }
+            @start_aborted = true
+            @runner.stop
+            ::Protobuf::Logger.info { 'Shutdown complete' }
+          end
+        end
+      end
+
+      # Say something if we're in debug mode.
+      def debug_say(message, color = :yellow)
+        say(message, color) if options.debug?
+      end
+
+      # Internal helper to determine if the modes are multi-set which is not valid.
+      def multi_mode?
+        (options.zmq? && (options.evented? || options.socket?)) \
+          && (options.evented? && (options.evented? || options.socket?)) \
+          && (options.zmq? && (options.evented? || options.socket?)) \
+      end
+
+      # Require the application file given, exiting if the file doesn't exist.
+      def require_application!(app_file)
+        debug_say 'Requiring app file'
+        require app_file
+      rescue LoadError => e
+        say_and_exit!("Failed to load application file #{app_file}", e)
+      end
+
+      # Loads protobuf in the given mode, exiting if somehow the mode is wrong.
+      def require_protobuf!
+        require "protobuf/#{@mode}.rb"
+      rescue LoadError => e
+        puts e.message, *(e.backtrace)
+        say_and_exit!("Failed to load protobuf runner #{@mode}", e)
+      end
+
+      def run_if_no_abort
+        yield unless @start_aborted
+      end
+
+      def runner_options
+        { :host => options.host,
+          :port => options.port,
+          :backlog => options.backlog,
+          :threshold => options.threshold,
+          :threads => options.threads }
+      end
+
+      def say_and_exit!(message, exception = nil)
+        message = set_color(message, :red) if ::Protobuf::Logger.file == STDOUT
+
+        ::Protobuf::Logger.error { message }
+        if exception
+          $stderr.puts "[#{exception.class.name}] #{exception.message}" 
+          $stderr.puts exception.backtrace.join("\n")
+
+          ::Protobuf::Logger.error { "[#{exception.class.name}] #{exception.message}" }
+          ::Protobuf::Logger.debug { exception.backtrace.join("\n") }
+        end
+
+        exit(1)
+      end
+
+      # Start the runner and log the relevant options.
+      def start_server!
+        debug_say 'Invoking server start'
+        @runner.run(runner_options) do
+          Protobuf::Logger.info { "pid #{::Process.pid} -- #{@mode} RPC Server listening at #{options.host}:#{options.port}" }
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/protobuf/enum.rb

@@ -0,0 +1,58 @@
+require 'protobuf/enum_value'
+
+module Protobuf
+  class Enum
+
+    def self.define(name, value)
+      enum_value = ::Protobuf::EnumValue.new(self, name, value)
+      const_set(name, enum_value)
+      @values ||= {}
+      @names ||= []
+      @values[name] = enum_value
+      @names[value] = name
+    end
+
+    # Fetch the given enum by a variety of type-checking
+    # mechanisms. This is useful for the enum field setters
+    # as well as repeated enum field construction.
+    def self.fetch(value)
+      case value
+      when ::Protobuf::EnumValue then
+        value
+      when Numeric then
+        enum_by_value(value.to_i)
+      when String, Symbol then
+        value_by_name(value.to_sym)
+      else
+        nil
+      end
+    end
+
+    def self.enum_by_value(value)
+      value_by_name(name_by_value(value))
+    end
+
+    def self.name_by_value(value)
+      value.nil? ? nil : @names[value]
+    end
+
+    def self.valid_tag?(tag)
+      !! name_by_value(tag)
+    end
+
+    def self.value_by_name(name)
+      @values[name]
+    end
+
+    def self.values
+      @values
+    end
+
+    ##
+    # Class Aliases
+    #
+    class << self
+      alias_method :get_name_by_tag, :name_by_value
+    end
+  end
+end

data/lib/protobuf/enum_value.rb

@@ -0,0 +1,59 @@
+require 'protobuf/enum'
+
+module Protobuf
+  class EnumValue
+    include Comparable
+
+    attr_reader :parent_class, :name, :value
+
+    ##
+    # Constructor
+    #
+    def initialize(parent_class, name, value)
+      @parent_class = parent_class
+      @name = name
+      @value = value
+    end
+
+    ## 
+    # Public Instance Methods
+    #
+    def <=>(compared_value)
+      case compared_value
+      when ::Protobuf::EnumValue then
+        value <=> compared_value.value
+      when Numeric then
+        value <=> compared_value.to_i
+      end
+    end
+
+    # Overriding the class so ActiveRecord/Arel visitor will visit the enum as a Fixnum
+    def class
+      Fixnum
+    end
+
+    def inspect
+      "\#<Protobuf::EnumValue #{@parent_class}::#{@name}=#{@value}>"
+    end
+
+    def to_hash_value
+      self.to_i
+    end
+
+    def to_i
+      @value.to_i
+    end
+
+    def to_s(format = :value_string)
+      case format
+      when :value_string then
+        self.to_i.to_s
+      when :name then
+        name.to_s
+      else
+        self.to_i.to_s
+      end
+    end
+  end
+end
+

data/lib/protobuf/evented.rb

@@ -0,0 +1,22 @@
+##
+## Evented Mode
+##
+#
+# Require this file if you wish to run your server and/or client RPC
+# with the evented handlers via EventMachine.
+#
+# To run with rpc_server specify the switch `evented`:
+#
+#   rpc_server --evented myapp.rb
+#
+# To run for client-side only override the require in your Gemfile:
+#
+#   gem 'protobuf', :require => 'protobuf/evented'
+#
+require 'protobuf'
+Protobuf.connector_type = :evented
+
+require 'eventmachine'
+require 'protobuf/ext/eventmachine'
+require 'protobuf/rpc/servers/evented/server'
+require 'protobuf/rpc/connectors/eventmachine'

data/lib/protobuf/exceptions.rb

@@ -0,0 +1,11 @@
+module Protobuf
+
+  class Error < StandardError; end
+
+  class InvalidWireType < Error; end
+
+  class NotInitializedError < Error; end
+
+  class TagCollisionError < Error; end
+
+end

data/lib/protobuf/ext/eventmachine.rb

@@ -0,0 +1,14 @@
+require 'fiber'
+
+# Method from em-synchrony
+# https://github.com/igrigorik/em-synchrony
+#
+# A convenience method for wrapping EM.run body within
+# a Ruby Fiber such that async operations can be transparently
+# paused and resumed based on IO scheduling
+module EventMachine
+  def self.fiber_run(blk=nil, tail=nil, &block)
+    context = Proc.new{ Fiber.new{ (b = blk || block) and b.call }.resume }
+    self.run(context, tail)
+  end
+end

data/lib/protobuf/field/base_field.rb

@@ -0,0 +1,240 @@
+require 'protobuf/wire_type'
+require 'protobuf/field/field_array'
+
+module Protobuf
+  module Field
+    class BaseField
+      ##
+      # Attributes
+      #
+      attr_reader :message_class, :rule, :type, :name, :tag, :default, :default_value, :setter_method_name, :getter_method_name
+
+      ##
+      # Class Methods
+      #
+      def self.default
+        nil
+      end
+
+      ##
+      # Constructor
+      #
+      def initialize(message_class, rule, type, name, tag, options)
+        @message_class, @rule, @type, @name, @tag = \
+          message_class, rule, type, name, tag
+
+        @getter_method_name = name
+        @setter_method_name = "#{name}=".to_sym
+        @default   = options.delete(:default)
+        @extension = options.delete(:extension)
+        @packed    = repeated? && options.delete(:packed)
+        @deprecated = options.delete(:deprecated)
+        unless options.empty?
+          warn "WARNING: Invalid options: #{options.inspect} (in #{@message_class.name.split('::').last}.#{@name})"
+        end
+
+        if packed? && ! [WireType::VARINT, WireType::FIXED32, WireType::FIXED64].include?(wire_type)
+          raise "Can't use packed encoding for `#{@type}' type"
+        end
+
+        @default_value = \
+          case @rule
+          when :repeated then
+            FieldArray.new(self).freeze
+          when :required then
+            nil
+          when :optional then
+            typed_default_value
+          end
+
+        define_accessor
+      end
+
+      ##
+      # Public Instance Methods
+      #
+      def acceptable?(value)
+        true
+      end
+
+      def enum?
+        return @_enum unless @_enum.nil?
+        @_enum = (self.class < ::Protobuf::Field::EnumField)
+      end
+
+      def message?
+        return @_message unless @_message.nil?
+        @_message = (self.class < ::Protobuf::Field::MessageField)
+      end
+
+      def initialized?(message_instance)
+        value = message_instance.__send__(getter_method_name)
+        case @rule
+        when :required then
+          ! value.nil? && (! kind_of?(MessageField) || value.initialized?)
+        when :repeated then
+          value.all? {|msg| ! kind_of?(MessageField) || msg.initialized? }
+        when :optional then
+          value.nil? || ! kind_of?(MessageField) || value.initialized?
+        end
+      end
+
+      # Decode +bytes+ and pass to +message_instance+.
+      def set(message_instance, bytes)
+        if packed?
+          array = message_instance.__send__(getter_method_name)
+          method = \
+            case wire_type
+            when WireType::FIXED32 then :read_fixed32
+            when WireType::FIXED64 then :read_fixed64
+            when WireType::VARINT  then :read_varint
+            end
+          stream = StringIO.new(bytes)
+          until stream.eof?
+            array << decode(Decoder.__send__(method, stream))
+          end
+        else
+          value = decode(bytes)
+          if repeated?
+            message_instance.__send__(getter_method_name) << value
+          else
+            message_instance.__send__(setter_method_name, value)
+          end
+        end
+      end
+
+      # Decode +bytes+ and return a field value.
+      def decode(bytes)
+        raise NotImplementedError, "#{self.class.name}\#decode"
+      end
+
+      # Encode +value+ and return a byte string.
+      def encode(value)
+        raise NotImplementedError, "#{self.class.name}\#encode"
+      end
+
+      def extension?
+        !!@extension
+      end
+
+      # Is this a repeated field?
+      def repeated?
+        return @_repeated unless @_repeated.nil?
+        @_repeated = (@rule == :repeated)
+      end
+
+      # Is this a required field?
+      def required?
+        return @_required unless @_required.nil?
+        @_required = (@rule == :required)
+      end
+
+      # Is this a optional field?
+      def optional?
+        return @_optional unless @_optional.nil?
+        @_optional = (@rule == :optional)
+      end
+
+      # Is this a deprecated field?
+      def deprecated?
+        !! @deprecated
+      end
+
+      # Is this a packed repeated field?
+      def packed?
+        !! @packed
+      end
+
+      # Upper limit for this field.
+      def max
+        self.class.max
+      end
+
+      # Lower limit for this field.
+      def min
+        self.class.min
+      end
+
+      def to_s
+        "#{@rule} #{@type} #{@name} = #{@tag} #{@default ? "[default=#{@default.inspect}]" : ''}"
+      end
+
+      def warn_if_deprecated
+        if ::Protobuf.print_deprecation_warnings? && deprecated?
+          $stderr.puts("[WARNING] #{@message_class.name}##{@name} field usage is deprecated.")
+        end
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+      def define_accessor
+        if repeated?
+          define_array_getter
+          define_array_setter
+        else
+          define_getter
+          define_setter
+        end
+      end
+
+      def define_array_getter
+        field = self
+        @message_class.class_eval do
+          define_method(field.getter_method_name) do
+            field.warn_if_deprecated
+            @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
+          end
+        end
+      end
+
+      def define_array_setter
+        field = self
+        @message_class.class_eval do
+          define_method(field.setter_method_name) do |val|
+            field.warn_if_deprecated
+            @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
+            @values[field.name].replace(val)
+          end
+        end
+      end
+
+      def define_getter
+        field = self
+        @message_class.class_eval do
+          define_method(field.getter_method_name) do
+            field.warn_if_deprecated
+            @values.fetch(field.name, field.default_value)
+          end
+        end
+      end
+
+      def define_setter
+        field = self
+        @message_class.class_eval do
+          define_method(field.setter_method_name) do |val|
+            field.warn_if_deprecated
+            if val.nil?
+              @values.delete(field.name)
+            elsif field.acceptable?(val)
+              @values[field.name] = val
+            else
+              raise TypeError, "unacceptable value #{val} for type #{field.type}"
+            end
+          end
+        end
+      end
+
+      def typed_default_value
+        if @default.nil?
+          self.class.default
+        else
+          @default
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/bool_field.rb

@@ -0,0 +1,36 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class BoolField < VarintField
+      def self.default
+        false
+      end
+
+      def acceptable?(val)
+        raise TypeError unless [true, false].include?(val)
+        true
+      end
+
+      def decode(value)
+        value == 1
+      end
+
+      def define_getter
+        super
+
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.getter_method_name}?") do
+            field.warn_if_deprecated
+            @values.fetch(field.name, field.default_value)
+          end
+        end
+      end
+
+      def encode(value)
+        [value ? 1 : 0].pack('C')
+      end
+    end
+  end
+end

data/lib/protobuf/field/bytes_field.rb

@@ -0,0 +1,38 @@
+module Protobuf
+  module Field
+    class BytesField < BaseField
+      def self.default
+        ''
+      end
+
+      def wire_type
+        WireType::LENGTH_DELIMITED
+      end
+
+      def acceptable?(val)
+        if val.is_a?(::Protobuf::Message) || val.instance_of?(String)
+          return true
+        end
+
+        raise TypeError
+      end
+
+      def decode(bytes)
+        bytes.force_encoding(::Protobuf::Message::STRING_ENCODING) if bytes.respond_to?(:force_encoding)
+        bytes
+      end
+
+      def encode(value)
+        if value.is_a?(::Protobuf::Message)
+          value = value.serialize_to_string
+        else
+          value = value.dup
+          value.force_encoding(::Protobuf::Message::STRING_ENCODING) if value.respond_to?(:force_encoding)
+        end
+
+        string_size = VarintField.encode(value.size)
+        string_size << value
+      end
+    end
+  end
+end

data/lib/protobuf/field/double_field.rb

@@ -0,0 +1,19 @@
+require 'protobuf/field/float_field'
+
+module Protobuf
+  module Field
+    class DoubleField < FloatField
+      def wire_type
+        WireType::FIXED64
+      end
+
+      def decode(bytes)
+        bytes.unpack('E').first
+      end
+
+      def encode(value)
+        [value].pack('E')
+      end
+    end
+  end
+end