protobuf 1.4.2 → 2.0.0.rc1

data/ext/ruby_generator/extconf.rb

@@ -0,0 +1,24 @@
+begin
+  require 'mkmf'
+
+  include_directory = File.expand_path(File.join(File.dirname(__FILE__), "..", "protobuf-2.4.1", "src"))
+
+  $CPPFLAGS << " -I#{include_directory}"
+  $CPPFLAGS << " -Wall "
+
+  have_library("pthread")
+  have_library("protoc")
+  have_library("protobuf")
+
+  create_makefile('ruby_generator')
+rescue 
+  $stdout << <<-WARNING
+    Cannot compile native extension.
+
+    If you are running on Jruby or Windows you should compile protocol buffer
+    definitions on another computer and then use those definitions locally.
+
+    Only the compiler is restricted by this.  The definitions should work without issue.
+  WARNING
+  $stdout << $/
+end

data/lib/protobuf.rb

@@ -2,43 +2,65 @@ require 'logger'
 require 'socket'
 require 'pp'
 require 'stringio'
+require 'active_support/all'
 
 module Protobuf
-end
 
-Protobuf::ClientType = ENV['PB_CLIENT_TYPE'] if ENV['PB_CLIENT_TYPE']
-Protobuf::ServerType = ENV['PB_SERVER_TYPE'] if ENV['PB_SERVER_TYPE']
+  # See Protobuf#connector_type documentation.
+  VALID_CONNECTOR_TYPES = [ :socket, :zmq, :evented ].freeze
 
-# Socket Client/Server loaded by default as it has no impact on cross-platform issues
-require 'protobuf/rpc/servers/socket/server'  
-require 'protobuf/rpc/connectors/socket'
-require 'protobuf/rpc/client'
-require 'protobuf/rpc/service'
+  # Default is Socket as it has no external dependencies.
+  DEFAULT_CONNECTOR_TYPE = :socket
 
-# When setting up a client
-case
-when defined?(Protobuf::ClientType) && Protobuf::ClientType =~ /\Asocket\Z/i then 
-  #no-op
-when defined?(Protobuf::ClientType) && Protobuf::ClientType =~ /\Azmq\Z/i then 
-  require 'ffi-rzmq'
-  require 'protobuf/rpc/connectors/zmq'
-else
-  Protobuf::ClientType = "EventMachine"
-  require 'eventmachine'
-  require 'protobuf/ext/eventmachine'
-  require 'protobuf/rpc/connectors/eventmachine'
-end
+	module_function
+
+  # GC Pause during server requests
+  #
+  # Boolean value to tell the server to disable
+  # the Garbage Collector when handling an rpc request.
+  # Once the request is completed, the GC is enabled again.
+  # This optomization provides a huge boost in speed to rpc requests.
+	def self.gc_pause_server_request
+		return @_gc_pause_server_request unless @_gc_pause_server_request.nil?
+		gc_pause_server_request = false
+	end
+
+	def self.gc_pause_server_request=(value)
+		@_gc_pause_server_request = !!value
+	end
+
+  # GC Pause during serializations (server-side only)
+  #
+  # Boolean value to tell the server to disable
+  # the Garbage Collector when serializing a response proto.
+  # Once the serialization is completed, the GC is enabled again.
+  # This optomization provides a large boost in speed to rpc requests.
+  # Note that this option is ignored if gc_pause_server_request is
+  # enabled since serialization is during the request cycle.
+	def self.gc_pause_server_serialization
+		return @_gc_pause_server_serialization unless @_gc_pause_server_serialization.nil?
+		gc_pause_server_serialization = false
+	end
+
+	def self.gc_pause_server_serialization=(value)
+		@_gc_pause_server_serialization = !!value
+	end
+
+  # Connector Type
+  #
+  # Symbol value which denotes the type of connector to use
+  # during client requests to an RPC server.
+  def self.connector_type
+    @_connector_type ||= DEFAULT_CONNECTOR_TYPE
+  end
+
+  def self.connector_type=(type)
+    raise 'Invalid connector type given' unless VALID_CONNECTOR_TYPES.include?(type)
+    @_connector_type = type
+  end
 
-# For running the rpc_server
-case
-when defined?(Protobuf::ServerType) && Protobuf::ServerType =~ /\Asocket\Z/i then
-  #no-op
-when defined?(Protobuf::ServerType) && Protobuf::ServerType =~ /\Azmq\Z/i then
-  require 'ffi-rzmq'
-  require 'protobuf/rpc/servers/zmq/server'
-else
-  Protobuf::ServerType = "Evented::Server"
-  require 'eventmachine'
-  require 'protobuf/ext/eventmachine'
-  require 'protobuf/rpc/servers/evented/server'
 end
+
+require 'protobuf/rpc/client'
+require 'protobuf/rpc/service'
+require 'protobuf/socket'

data/lib/protobuf/cli.rb

@@ -0,0 +1,176 @@
+require 'thor'
+require 'pry'
+require 'protobuf/version'
+require 'protobuf/common/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 => 9595, :aliases => %w(-p), :desc => '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 :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 :gc_pause_serialization, :type => :boolean, :default => false, :desc => 'Enable/Disable GC pause during serialization.'
+
+    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
+
+      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
+
+      # 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?
+        ::Protobuf.gc_pause_server_serialization = (!options.gc_pause_request? && options.gc_pause_serialization?)
+      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'
+        trap_block = proc {
+          ::Protobuf::Logger.info { 'RPC Server shutting down...' }
+          @start_aborted = true
+          @runner.stop
+          ::Protobuf::Logger.info { 'Shutdown complete' }
+        }
+
+        debug_say 'Registering INT', :blue
+        trap(:INT, &trap_block)
+        debug_say 'Registering QUIT', :blue
+        trap(:QUIT, &trap_block)
+        debug_say 'Registering TERM', :blue
+        trap(:TERM, &trap_block)
+      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 say_and_exit!(message, exception = nil)
+        message = set_color(message, :red) if ::Protobuf::Logger.file == STDOUT
+
+        ::Protobuf::Logger.error { message }
+        if exception
+          ::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(options.dup) do
+          Protobuf::Logger.info { "pid #{::Process.pid} -- #{@mode} RPC Server listening at #{options.host}:#{options.port}" }
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/protobuf/common/logger.rb

@@ -2,7 +2,7 @@ require 'logger'
 
 module Protobuf
   class Logger < ::Logger
-    
+
     class << self
       attr_accessor :file, :level
 
@@ -13,43 +13,43 @@ module Protobuf
         end
       end
     end
-       
+
     # One-line file/level configuration
     def self.configure(options)
       self.file = options.fetch(:file, false)
       self.level = options.fetch(:level, false)
     end
-    
+
     # Use to reset the instance
     def self.reset_device!
       self.file = self.level = @__instance = nil
     end
-    
+
     # Singleton instance
     def self.instance
       @__instance ||= begin
         log = nil
-        
+
         if @file && @level
           log = new(self.file)
           log.level = self.level
         end
-        
+
         log
       end
     end
-    
-    # 
+
+    #
     # LogMethods module for log method including, e.g.:
-    # 
+    #
     # class MyClass
     #   include Protobuf::Logger::LogMethods
     #   ...
     # end
-    # 
+    #
     # Produce a module to allow "include" in other classes to avoid
     # cluttering the namespace of the including class with the other methods defined above
-    # 
+    #
     module LogMethods
       [:debug, :info, :warn, :error, :fatal, :any, :add, :log].each do |m|
         define_method("log_#{m}") do |*params, &block|

data/lib/protobuf/{message/enum.rb → enum.rb}

@@ -1,12 +1,8 @@
 require 'delegate'
-require 'protobuf/descriptor/enum_descriptor'
-require 'protobuf/message/protoable'
 
 module Protobuf
   class Enum
     class << self
-      include Protoable
-
       attr_reader :values
 
       def name_by_value(value)
@@ -24,12 +20,6 @@ module Protobuf
         !! name_by_value(tag)
       end
 
-      def descriptor
-        @descriptor ||= Descriptor::EnumDescriptor.new(self)
-      end
-
-      private
-
       def define(name, value)
         enum_value = EnumValue.new(self, name, value)
         const_set(name, enum_value)

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/field.rb

@@ -0,0 +1,57 @@
+require 'protobuf/field/base_field'
+require 'protobuf/field/bytes_field'
+require 'protobuf/field/float_field'
+require 'protobuf/field/message_field'
+require 'protobuf/field/varint_field'
+require 'protobuf/field/string_field'
+require 'protobuf/field/double_field'
+require 'protobuf/field/enum_field'
+require 'protobuf/field/integer_field'
+require 'protobuf/field/signed_integer_field'
+require 'protobuf/field/uint32_field'
+require 'protobuf/field/uint64_field'
+require 'protobuf/field/int32_field'
+require 'protobuf/field/int64_field'
+require 'protobuf/field/sint32_field'
+require 'protobuf/field/sint64_field'
+require 'protobuf/field/bool_field'
+require 'protobuf/field/sfixed32_field'
+require 'protobuf/field/sfixed64_field'
+require 'protobuf/field/fixed32_field'
+require 'protobuf/field/fixed64_field'
+require 'protobuf/field/extension_fields'
+
+module Protobuf
+  module Field
+    PREDEFINED_TYPES = [
+      ::Protobuf::Field::DoubleField,   
+      ::Protobuf::Field::FloatField,
+      ::Protobuf::Field::Int32Field,    
+      ::Protobuf::Field::Int64Field,
+      ::Protobuf::Field::Uint32Field,   
+      ::Protobuf::Field::Uint64Field,
+      ::Protobuf::Field::Sint32Field,   
+      ::Protobuf::Field::Sint64Field,
+      ::Protobuf::Field::Fixed32Field,
+      ::Protobuf::Field::Fixed64Field,
+      ::Protobuf::Field::Sfixed32Field, 
+      ::Protobuf::Field::Sfixed64Field,
+      ::Protobuf::Field::StringField,   
+      ::Protobuf::Field::BytesField,
+      ::Protobuf::Field::BoolField
+    ].freeze
+
+    def self.build(message_class, rule, type, name, tag, options={})
+      field_class = type_message_or_enum(type) 
+      field_class.new(message_class, rule, type, name, tag, options)
+    end
+
+    def self.type_message_or_enum(defined_type)
+      return defined_type if ::Protobuf::Field::PREDEFINED_TYPES.include?(defined_type)
+      return EnumField if defined_type < Enum
+      return MessageField if defined_type < Message
+      raise "lost in the wilderness #{defined_type}"
+    end
+
+  end
+end