protobuf 2.2.5-java

data/lib/protobuf/rpc/stat.rb

@@ -0,0 +1,83 @@
+require 'date'
+require 'protobuf/logger'
+
+module Protobuf
+  module Rpc
+    class Stat
+      attr_accessor :mode, :start_time, :end_time, :request_size, :dispatcher
+      attr_accessor :response_size, :client, :server, :service, :method_name
+
+      MODES = [:SERVER, :CLIENT].freeze
+
+      def initialize(mode = :SERVER)
+        @mode = mode
+        start
+      end
+
+      def client=(peer)
+        @client = {:port => peer[0], :ip => peer[1]}
+      end
+
+      def client
+        @client ? "#{@client[:ip]}:#{@client[:port]}" : nil
+      end
+
+      def method_name
+        @method_name ||= @dispatcher.try(:service).try(:rpc)
+      end
+
+      def server=(peer)
+        @server = {:port => peer[0], :ip => peer[1]}
+      end
+
+      def server
+        @server ? "#{@server[:ip]}:#{@server[:port]}" : nil
+      end
+
+      def service
+        @service ||= @dispatcher.try(:service).class.name
+      end
+
+      def sizes
+        "#{@request_size || 0}B/#{@response_size || 0}B"
+      end
+
+      def start
+        @start_time ||= Time.now
+      end
+
+      def stop
+        start if !@start_time
+        @end_time ||= Time.now
+      end
+
+      def rpc
+        service && method_name ? "#{service}##{method_name}" : nil
+      end
+
+      def elapsed_time
+        (start_time && end_time ? "#{(end_time - start_time).round(4)}s" : nil)
+      end
+
+      def server?
+        @mode == :SERVER
+      end
+
+      def client?
+        @mode == :CLIENT
+      end
+
+      def to_s
+        [
+          server? ? "[SRV]" : "[CLT]",
+          rpc,
+          elapsed_time,
+          sizes,
+          server? ? server : client
+        ].compact.join(' - ')
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/socket.rb

@@ -0,0 +1,22 @@
+##
+## Socket Mode
+##
+#
+# Require this file if you wish to run your server and/or client RPC
+# with the raw socket handlers. This is the default run mode for bin/rpc_server.
+#
+# To run with rpc_server either omit any mode switches, or explicitly pass `socket`:
+#
+#   rpc_server myapp.rb
+#   rpc_server --socket myapp.rb
+#
+# To run for client-side only override the require in your Gemfile:
+#
+#   gem 'protobuf', :require => 'protobuf/socket'
+#
+require 'protobuf'
+::Protobuf.connector_type = :socket
+
+require 'protobuf/rpc/servers/socket/server'
+require 'protobuf/rpc/connectors/socket'
+

data/lib/protobuf/version.rb

@@ -0,0 +1,4 @@
+module Protobuf
+  VERSION = '2.2.5'
+  PROTOC_VERSION = '2.4.1'
+end

data/lib/protobuf/wire_type.rb

@@ -0,0 +1,10 @@
+module Protobuf
+  module WireType
+    VARINT           = 0
+    FIXED64          = 1
+    LENGTH_DELIMITED = 2
+    START_GROUP      = 3
+    END_GROUP        = 4
+    FIXED32          = 5
+  end
+end

data/lib/protobuf/zmq.rb

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

data/lib/protobuf.rb

@@ -0,0 +1,86 @@
+require 'logger'
+require 'socket'
+require 'pp'
+require 'stringio'
+require 'active_support/all'
+
+module Protobuf
+
+  # See Protobuf#connector_type documentation.
+  CONNECTORS = [ :socket, :zmq, :evented ].freeze
+
+  # Default is Socket as it has no external dependencies.
+  DEFAULT_CONNECTOR = :socket
+
+	module_function
+
+  # Connector Type
+  #
+  # Default: socket
+  #
+  # 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
+  end
+
+  def self.connector_type=(type)
+    raise ArgumentError, 'Invalid connector type given' unless CONNECTORS.include?(type)
+    @_connector_type = type
+  end
+
+  # GC Pause during server requests
+  #
+  # Default: false
+  #
+  # 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
+
+  # Print Deprecation Warnings
+  #
+  # Default: true
+  #
+  # Simple boolean to define whether we want field deprecation warnings to
+  # be printed to stderr or not. The rpc_server has an option to set this value
+  # explicitly, or you can turn this option off by setting
+  # ENV['PB_IGNORE_DEPRECATIONS'] to a non-empty value.
+  #
+  # The rpc_server option will override the ENV setting.
+	def self.print_deprecation_warnings?
+		return @_print_deprecation_warnings unless @_print_deprecation_warnings.nil?
+		print_deprecation_warnings = ENV.key?('PB_IGNORE_DEPRECATIONS') ? false : true
+	end
+
+	def self.print_deprecation_warnings=(value)
+		@_print_deprecation_warnings = !!value
+	end
+
+end
+
+require 'protobuf/rpc/client'
+require 'protobuf/rpc/service'
+
+env_connector_type = ENV.fetch('PB_CLIENT_TYPE') {
+  ::Protobuf::DEFAULT_CONNECTOR
+}.to_s.downcase.strip.to_sym
+
+if ::Protobuf::CONNECTORS.include?(env_connector_type)
+  require "protobuf/#{env_connector_type}"
+else
+  $stderr.puts <<-WARN
+    [WARNING] Require attempted on an invalid connector type '#{env_connector_type}'.
+              Falling back to default '#{::Protobuf::DEFAULT_CONNECTOR}' connector.
+  WARN
+
+  require "protobuf/#{::Protobuf::DEFAULT_CONNECTOR}"
+end

data/proto/rpc.pb.rb

@@ -0,0 +1,48 @@
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+
+module Protobuf
+  module Socketrpc
+    ##
+    # Enum Classes
+    #
+    class ErrorReason < ::Protobuf::Enum; end
+    
+    ##
+    # Message Classes
+    #
+    class Request < ::Protobuf::Message; end
+    class Response < ::Protobuf::Message; end
+    
+    ##
+    # Enum Values
+    #
+    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_DATA, 0
+    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_PROTO, 1
+    ::Protobuf::Socketrpc::ErrorReason.define :SERVICE_NOT_FOUND, 2
+    ::Protobuf::Socketrpc::ErrorReason.define :METHOD_NOT_FOUND, 3
+    ::Protobuf::Socketrpc::ErrorReason.define :RPC_ERROR, 4
+    ::Protobuf::Socketrpc::ErrorReason.define :RPC_FAILED, 5
+    ::Protobuf::Socketrpc::ErrorReason.define :INVALID_REQUEST_PROTO, 6
+    ::Protobuf::Socketrpc::ErrorReason.define :BAD_RESPONSE_PROTO, 7
+    ::Protobuf::Socketrpc::ErrorReason.define :UNKNOWN_HOST, 8
+    ::Protobuf::Socketrpc::ErrorReason.define :IO_ERROR, 9
+    
+    
+    ##
+    # Message Fields
+    #
+    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :service_name, 1)
+    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :method_name, 2)
+    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::BytesField, :request_proto, 3)
+    
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BytesField, :response_proto, 1)
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::StringField, :error, 2)
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BoolField, :callback, 3, :default => false)
+    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Socketrpc::ErrorReason, :error_reason, 4)
+    
+    
+  end
+end

data/proto/rpc.proto

@@ -0,0 +1,73 @@
+// Copyright (c) 2009 Shardul Deo
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// Author: Shardul Deo
+//
+// Protobufs needed for socket rpcs.
+
+package protobuf.socketrpc;
+
+message Request {
+
+  // RPC service full name
+  required string service_name = 1;
+  
+  // RPC method name
+  required string method_name = 2;
+  
+  // RPC request proto
+  required bytes request_proto = 3;
+}
+
+message Response {
+
+  // RPC response proto
+  optional bytes response_proto = 1;
+  
+  // Error, if any
+  optional string error = 2;
+  
+  // Was callback invoked
+  optional bool callback = 3 [default = false];
+  
+  // Error Reason
+  optional ErrorReason error_reason = 4;
+}
+
+// Possible error reasons
+// The server-side errors are returned in the response from the server.
+// The client-side errors are returned by the client-side code when it doesn't 
+// have a response from the server.
+enum ErrorReason {
+
+  // Server-side errors
+  BAD_REQUEST_DATA = 0; // Server received bad request data
+  BAD_REQUEST_PROTO = 1; // Server received bad request proto
+  SERVICE_NOT_FOUND = 2; // Service not found on server
+  METHOD_NOT_FOUND = 3; // Method not found on server
+  RPC_ERROR = 4; // Rpc threw exception on server
+  RPC_FAILED = 5; // Rpc failed on server
+  
+  // Client-side errors (these are returned by the client-side code)
+  INVALID_REQUEST_PROTO = 6; // Rpc was called with invalid request proto
+  BAD_RESPONSE_PROTO = 7; // Server returned a bad response proto
+  UNKNOWN_HOST = 8; // Could not find supplied host
+  IO_ERROR = 9; // I/O error while communicating with server
+}

data/protobuf.gemspec

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+$:.push File.expand_path("./lib", File.dirname(__FILE__))
+require "protobuf/version"
+
+Gem::Specification.new do |s|
+  s.name          = 'protobuf'
+  s.version       = Protobuf::VERSION
+  s.date          = Time.now.strftime('%Y-%m-%d')
+
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt']
+  s.email         = ["bj.neilsen+protobuf@gmail.com", "brandonsdewitt+protobuf@gmail.com"]
+  s.homepage      = "https://github.com/localshred/protobuf"
+  s.summary       = "Google Protocol Buffers v#{Protobuf::PROTOC_VERSION} Serialization and RPC implementation for Ruby."
+  s.description   = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  unless ENV['WITHOUT_PROTO_COMPILER']
+    if defined?(JRUBY_VERSION)
+      s.platform = 'java'
+    else
+      s.extensions << File.join('ext', 'ruby_generator', 'extconf.rb')
+    end
+  end
+
+  s.add_dependency 'activesupport'
+  s.add_dependency 'ffi'
+  s.add_dependency 'multi_json'
+  s.add_dependency 'thor'
+
+  s.add_development_dependency 'eventmachine'
+  s.add_development_dependency 'ffi-rzmq'
+  # s.add_development_dependency 'perftools.rb'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry-nav'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake-compiler'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'yard'
+end

data/spec/benchmark/tasks.rb

@@ -0,0 +1,179 @@
+require 'benchmark'
+require 'support/all'
+require 'support/test/resource_service'
+
+begin
+  require 'perftools'
+rescue LoadError
+  $stderr.puts 'perftools must be uncommented in the gemspec before you can run this benchmark task'
+  exit(1)
+end
+
+# Including a way to turn on debug logger for spec runs
+if ENV["DEBUG"]
+  puts 'debugging'
+  debug_log = File.expand_path('../debug_bench.log', File.dirname(__FILE__) )
+  Protobuf::Logger.configure(:file => debug_log, :level => ::Logger::DEBUG)
+end
+
+namespace :benchmark do
+
+  def benchmark_wrapper(global_bench = nil)
+    if global_bench
+      yield global_bench
+    else
+      Benchmark.bm(10) do |bench|
+        yield bench
+      end
+    end
+  end
+
+  def em_client_em_server(number_tests, test_length, global_bench = nil)
+    EM.stop if EM.reactor_running?
+
+    EventMachine.fiber_run do
+      StubServer.new do |server|
+        client = ::Test::ResourceService.client
+
+        benchmark_wrapper(global_bench) do |bench|
+          bench.report("ES / EC") do
+            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          end
+        end
+      end
+
+      EM.stop
+    end
+  end
+
+  def em_client_sock_server(number_tests, test_length, global_bench = nil)
+    EM.stop if EM.reactor_running?
+
+    EventMachine.fiber_run do
+      StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
+        client = ::Test::ResourceService.client(:port => 9399)
+
+        benchmark_wrapper(global_bench) do |bench|
+          bench.report("SS / EC") do
+            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          end
+        end
+      end
+
+      EM.stop
+    end
+  end
+
+  def sock_client_sock_server(number_tests, test_length, global_bench = nil)
+    load "protobuf/socket.rb"
+    EM.stop if EM.reactor_running?
+
+    StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => 9399) do |server|
+      client = ::Test::ResourceService.client(:port => 9399)
+
+      benchmark_wrapper(global_bench) do |bench|
+        bench.report("SS / SC") do
+          (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+        end
+      end
+    end
+  end
+
+  def sock_client_em_server(number_tests, test_length, global_bench = nil)
+    load "protobuf/socket.rb"
+    EM.stop if EM.reactor_running?
+    em_thread = Thread.new { EM.run }
+    Thread.pass until EM.reactor_running?
+
+    StubServer.new(:port => 9399) do |server|
+      client = ::Test::ResourceService.client(:port => 9399)
+
+      benchmark_wrapper(global_bench) do |bench|
+        bench.report("ES / SC") do
+          (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+        end
+      end
+    end
+
+    EM.stop
+    Thread.kill(em_thread) if em_thread
+  end
+
+  def zmq_client_zmq_server(number_tests, test_length, global_bench = nil)
+    load "protobuf/zmq.rb"
+    StubServer.new(:port => 9399, :server => Protobuf::Rpc::Zmq::Server) do |server|
+      client = ::Test::ResourceService.client(:port => 9399)
+
+      benchmark_wrapper(global_bench) do |bench|
+        bench.report("ZS / ZC") do
+          (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+        end
+      end
+      server.stop
+    end
+  end
+
+  desc "benchmark ZMQ client with ZMQ server"
+  task :zmq_client_zmq_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    zmq_client_zmq_server(args[:number], args[:length])
+  end
+
+  desc "benchmark ZMQ client with ZMQ server and profile"
+  task :zmq_profile, [:number, :length, :profile_output] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100, :profile_output => "/tmp/zmq_profiler_#{Time.now.to_i}")
+    ::PerfTools::CpuProfiler.start(args[:profile_output]) do
+      zmq_client_zmq_server(args[:number], args[:length])
+    end
+
+    puts args[:profile_output]
+  end
+
+  desc "benchmark Protobuf Message #new"
+  task :profile_protobuf_new, [:number, :profile_output] do |t, args|
+    args.with_defaults(:number => 1000, :profile_output => "/tmp/profiler_new_#{Time.now.to_i}")
+    create_params = { :name => "The name that we set", :date_created => Time.now.to_i, :status => 2 }
+    ::PerfTools::CpuProfiler.start(args[:profile_output]) do
+      args[:number].to_i.times { Test::Resource.new(create_params) }
+    end
+
+    puts args[:profile_output]
+  end
+
+  desc "benchmark EventMachine client with EventMachine server"
+  task :em_client_em_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    em_client_em_server(args[:number], args[:length])
+  end
+
+  desc "benchmark EventMachine client with Socket server"
+  task :em_client_sock_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    em_client_sock_server(args[:number], args[:length])
+  end
+
+  desc "benchmark Socket client with Socket server"
+  task :sock_client_sock_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    sock_client_sock_server(args[:number], args[:length])
+  end
+
+  desc "benchmark Socket client with EventMachine server"
+  task :sock_client_em_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    sock_client_em_server(args[:number], args[:length])
+  end
+
+  desc "benchmark server performance"
+  task :servers, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+
+    Benchmark.bm(10) do |bench|
+      # zmq_client_zmq_server(args[:number], args[:length], bench)
+      #      em_client_em_server(args[:number], args[:length], bench)
+      #      em_client_sock_server(args[:number], args[:length], bench)
+      sock_client_sock_server(args[:number], args[:length], bench)
+      #      sock_client_em_server(args[:number], args[:length], bench)
+    end
+  end
+end

data/spec/functional/embedded_service_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'An Embedded Service Call Hierarchy' do
+  
+  
+  
+end

data/spec/functional/evented_server_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+describe 'Functional EventMachine Client' do
+  before(:each) do
+    load 'protobuf/evented.rb'
+  end
+
+  it 'runs fine when required fields are set' do
+    expect {
+      EventMachine.fiber_run do
+        StubServer.new do |server|
+          client = ::Test::ResourceService.client(:timeout => 5)
+
+          client.find(:name => 'Test Name', :active => true) do |c|
+            c.on_success do |succ|
+              succ.name.should eq("Test Name")
+              succ.status.should eq(::Test::StatusType::ENABLED)
+            end
+
+            c.on_failure do |err|
+              raise err.inspect
+            end
+          end
+        end
+        EM.stop
+      end
+    }.to_not raise_error
+  end
+
+  it 'calls the on_failure callback when a message is malformed' do
+    error = nil
+    EventMachine.fiber_run do
+      StubServer.new do |server|
+        request = ::Test::ResourceFindRequest.new(:active => true)
+        client = ::Test::ResourceService.client
+
+        client.find(request) do |c|
+          c.on_success { raise "shouldn't pass"}
+          c.on_failure {|e| error = e}
+        end
+      end
+      EM.stop
+    end
+    error.message.should =~ /ResourceFindRequest.*fields.*improperly set/
+  end
+
+  it 'calls the on_failure callback when the request type is wrong' do
+    error = nil
+    EventMachine.fiber_run do
+      StubServer.new do |server|
+        request = ::Test::Resource.new(:name => 'Test Name')
+        client = ::Test::ResourceService.client
+
+        client.find(request) do |c|
+          c.on_success { raise "shouldn't pass"}
+          c.on_failure {|e| error = e}
+        end
+      end
+      EM.stop
+    end
+    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
+  end
+end