prepor-protobuf 3.5.0

data/proto/rpc.proto

@@ -0,0 +1,62 @@
+// 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.
+
+// Authors: Shardul Deo, BJ Neilsen
+//
+// Protobufs needed for socket rpcs.
+
+package protobuf.socketrpc;
+
+message Request
+{
+  required string service_name = 1;             // Fully- qualified Service class name
+  required string method_name = 2;              // Service method to invoke
+  optional bytes request_proto = 3;             // Serialized request bytes
+  optional string caller = 4;                   // Calling hostname or address
+}
+
+message Response
+{
+  optional bytes response_proto = 1;            // Serialized response
+  optional string error = 2;                    // Error message, if any
+  optional bool callback = 3 [default = false]; // Was callback invoked (not sure what this is for)
+  optional ErrorReason error_reason = 4;        // Error Reason
+}
+
+// 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,51 @@
+# encoding: UTF-8
+$LOAD_PATH.push ::File.expand_path("../lib", __FILE__)
+require "protobuf/version"
+
+::Gem::Specification.new do |s|
+  s.name          = 'prepor-protobuf'
+  s.version       = ::Protobuf::VERSION
+  s.date          = ::Time.now.strftime('%Y-%m-%d')
+  s.license       = 'MIT'
+
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen', 'Adam Hutchison']
+  s.email         = ['bj.neilsen+protobuf@gmail.com', 'brandonsdewitt+protobuf@gmail.com', 'quixoten@gmail.com', 'liveh2o@gmail.com']
+  s.homepage      = 'https://github.com/localshred/protobuf'
+  s.summary       = "Google Protocol Buffers 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"]
+
+  s.add_dependency 'activesupport', '>= 3.2'
+  s.add_dependency 'middleware'
+  s.add_dependency 'thor'
+  s.add_dependency 'thread_safe'
+
+  s.add_development_dependency 'ffi-rzmq'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '>= 3.0'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'timecop'
+  s.add_development_dependency 'yard'
+
+  # debuggers only work in MRI
+  if RUBY_ENGINE.to_sym == :ruby
+    # we don't support MRI < 1.9.3
+    pry_debugger = if RUBY_VERSION < '2.0.0'
+      'pry-debugger'
+    else
+      'pry-byebug'
+    end
+
+    s.add_development_dependency pry_debugger
+    s.add_development_dependency 'pry-stack_explorer'
+  else
+    s.add_development_dependency 'pry'
+  end
+
+  s.add_development_dependency 'ruby-prof' if RUBY_ENGINE.to_sym == :ruby
+end

data/spec/benchmark/tasks.rb

@@ -0,0 +1,139 @@
+require 'benchmark'
+require 'protobuf/socket'
+require 'support/all'
+require 'support/test/resource_service'
+
+case RUBY_ENGINE.to_sym
+when :ruby
+  require 'ruby-prof'
+when :rbx
+  require 'rubinius/profiler'
+when :jruby
+  require 'jruby/profiler'
+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__)
+  Protobuf::Logging.initialize_logger(debug_log, ::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 sock_client_sock_server(number_tests, test_length, global_bench = nil)
+    load "protobuf/socket.rb"
+
+    port = 1000 + Kernel.rand(2**16 - 1000)
+
+    StubServer.new(:server => Protobuf::Rpc::Socket::Server, :port => port) do
+      client = ::Test::ResourceService.client(:port => port)
+
+      benchmark_wrapper(global_bench) do |bench|
+        bench.report("SS / SC") do
+          Integer(number_tests).times { client.find(:name => "Test Name" * Integer(test_length), :active => true) }
+        end
+      end
+    end
+  end
+
+  def zmq_client_zmq_server(number_tests, test_length, global_bench = nil)
+    load "protobuf/zmq.rb"
+
+    port = 1000 + Kernel.rand(2**16 - 1000)
+
+    StubServer.new(:port => port, :server => Protobuf::Rpc::Zmq::Server) do
+      client = ::Test::ResourceService.client(:port => port)
+
+      benchmark_wrapper(global_bench) do |bench|
+        bench.report("ZS / ZC") do
+          Integer(number_tests).times { client.find(:name => "Test Name" * Integer(test_length), :active => true) }
+        end
+      end
+    end
+  end
+
+  desc "benchmark ZMQ client with ZMQ server"
+  task :zmq_client_zmq_server, [:number, :length] do |_task, 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 |_task, args|
+    args.with_defaults(:number => 1000, :length => 100, :profile_output => "/tmp/zmq_profiler_#{Time.now.to_i}")
+
+    profile_code(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 |_task, 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 }
+    profile_code(args[:profile_output]) do
+      Integer(args[:number]).times { Test::Resource.new(create_params) }
+    end
+
+    puts args[:profile_output]
+  end
+
+  desc "benchmark Protobuf Message #serialize"
+  task :profile_protobuf_serialize, [:number, :profile_output] do |_task, 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 }
+    profile_code(args[:profile_output]) do
+      Integer(args[:number]).times { Test::Resource.new(create_params).serialize }
+    end
+
+    puts args[:profile_output]
+  end
+
+  def profile_code(output, &block)
+    case RUBY_ENGINE.to_sym
+    when :ruby
+      profile_data = RubyProf.profile(&block)
+      RubyProf::FlatPrinter.new(profile_data).print(:path => output)
+    when :rbx
+      profiler = Rubinius::Profiler::Instrumenter.new
+      profiler.profile(false, &block)
+      File.open(output, 'w') do |f|
+        profiler.show(f)
+      end
+    when :jruby
+      profile_data = JRuby::Profiler.profile(&block)
+      File.open(output, 'w') do |f|
+        JRuby::Profiler::FlatProfilePrinter.new(profile_data).printProfile(f)
+      end
+    end
+  end
+
+  desc "benchmark Socket client with Socket server"
+  task :sock_client_sock_server, [:number, :length] do |_task, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    sock_client_sock_server(args[:number], args[:length])
+  end
+
+  desc "benchmark server performance"
+  task :servers, [:number, :length] do |_task, args|
+    args.with_defaults(:number => 1000, :length => 100)
+
+    Benchmark.bm(10) do |bench|
+      zmq_client_zmq_server(args[:number], args[:length], bench)
+      sock_client_sock_server(args[:number], args[:length], bench)
+    end
+  end
+end

data/spec/bin/protoc-gen-ruby_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+RSpec.describe 'protoc-gen-ruby' do
+  let(:binpath) { ::File.expand_path('../../../bin/protoc-gen-ruby', __FILE__) }
+  let(:package) { 'test' }
+  let(:request_bytes) do
+    ::Google::Protobuf::Compiler::CodeGeneratorRequest.encode(
+      :proto_file => [{ :package => package }],
+    )
+  end
+
+  it 'reads the serialized request bytes and outputs serialized response bytes' do
+    ::IO.popen(binpath, 'w+') do |pipe|
+      pipe.write(request_bytes)
+      pipe.close_write # needed so we can implicitly read until EOF
+      response_bytes = pipe.read
+      response = ::Google::Protobuf::Compiler::CodeGeneratorResponse.decode(response_bytes)
+      expect(response.file.first.content).to include("module #{package.titleize}")
+    end
+  end
+end

data/spec/data/data.bin

@@ -0,0 +1,3 @@
+
+John Doe�	jdoe@example.com"
+555-4321

data/spec/encoding/all_types_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+RSpec.describe ::Protobuf do
+  it "correctly encodes all types" do
+    message = GoogleUnittest::TestAllTypes.new(
+      :optional_int32 => 101,
+      :optional_int64 => 102,
+      :optional_uint32 => 103,
+      :optional_uint64 => 104,
+      :optional_sint32 => 105,
+      :optional_sint64 => 106,
+      :optional_fixed32 => 107,
+      :optional_fixed64 => 108,
+      :optional_sfixed32 => 109,
+      :optional_sfixed64 => 110,
+      :optional_float => 111,
+      :optional_double => 112,
+      :optional_bool => true,
+      :optional_string => "115",
+      :optional_bytes => "116",
+      :optional_nested_message => GoogleUnittest::TestAllTypes::NestedMessage.new(:bb => 118),
+      :optional_foreign_message => GoogleUnittest::ForeignMessage.new(:c => 119),
+      :optional_import_message => GoogleUnittestImport::ImportMessage.new(:d => 120),
+      :optional_nested_enum => GoogleUnittest::TestAllTypes::NestedEnum::BAZ,
+      :optional_foreign_enum => GoogleUnittest::ForeignEnum::FOREIGN_BAZ,
+      :optional_import_enum => GoogleUnittestImport::ImportEnum::IMPORT_BAZ,
+      :optional_string_piece => "124",
+      :optional_cord => "125",
+      :optional_public_import_message => GoogleUnittestImport::PublicImportMessage.new(:e => 126),
+      :optional_lazy_message => GoogleUnittest::TestAllTypes::NestedMessage.new(:bb => 127),
+      :repeated_int32 => [201, 301],
+      :repeated_int64 => [202, 302],
+      :repeated_uint32 => [203, 303],
+      :repeated_uint64 => [204, 304],
+      :repeated_sint32 => [205, 305],
+      :repeated_sint64 => [206, 306],
+      :repeated_fixed32 => [207, 307],
+      :repeated_fixed64 => [208, 308],
+      :repeated_sfixed32 => [209, 309],
+      :repeated_sfixed64 => [210, 310],
+      :repeated_float => [211, 311],
+      :repeated_double => [212, 312],
+      :repeated_bool => [true, false],
+      :repeated_string => ["215", "315"],
+      :repeated_bytes => ["216", "316"],
+      :repeated_nested_message => [
+        ::GoogleUnittest::TestAllTypes::NestedMessage.new(:bb => 218),
+        ::GoogleUnittest::TestAllTypes::NestedMessage.new(:bb => 318),
+      ],
+      :repeated_foreign_message => [
+        ::GoogleUnittest::ForeignMessage.new(:c => 219),
+        ::GoogleUnittest::ForeignMessage.new(:c => 319),
+      ],
+      :repeated_import_message => [
+        ::GoogleUnittestImport::ImportMessage.new(:d => 220),
+        ::GoogleUnittestImport::ImportMessage.new(:d => 320),
+      ],
+      :repeated_nested_enum => [
+        ::GoogleUnittest::TestAllTypes::NestedEnum::BAR,
+        ::GoogleUnittest::TestAllTypes::NestedEnum::BAZ,
+      ],
+      :repeated_foreign_enum => [
+        ::GoogleUnittest::ForeignEnum::FOREIGN_BAR,
+        ::GoogleUnittest::ForeignEnum::FOREIGN_BAZ,
+      ],
+      :repeated_import_enum => [
+        ::GoogleUnittestImport::ImportEnum::IMPORT_BAR,
+        ::GoogleUnittestImport::ImportEnum::IMPORT_BAZ,
+      ],
+      :repeated_string_piece => ["224", "324"],
+      :repeated_cord => ["225", "325"],
+      :repeated_lazy_message => [
+        ::GoogleUnittest::TestAllTypes::NestedMessage.new(:bb => 227),
+        ::GoogleUnittest::TestAllTypes::NestedMessage.new(:bb => 327),
+      ],
+      :default_int32 => 401,
+      :default_int64 => 402,
+      :default_uint32 => 403,
+      :default_uint64 => 404,
+      :default_sint32 => 405,
+      :default_sint64 => 406,
+      :default_fixed32 => 407,
+      :default_fixed64 => 408,
+      :default_sfixed32 => 409,
+      :default_sfixed64 => 410,
+      :default_float => 411,
+      :default_double => 412,
+      :default_bool => false,
+      :default_string => "415",
+      :default_bytes => "416",
+      :default_nested_enum => ::GoogleUnittest::TestAllTypes::NestedEnum::FOO,
+      :default_foreign_enum => ::GoogleUnittest::ForeignEnum::FOREIGN_FOO,
+      :default_import_enum => ::GoogleUnittestImport::ImportEnum::IMPORT_FOO,
+      :default_string_piece => "424",
+      :default_cord => "425",
+    )
+
+    data_file_path = File.expand_path('../../support/test/all_types.data.bin', __FILE__)
+    data = File.open(data_file_path, 'rb') do |file|
+      file.read
+    end
+
+    expect(data).to eq(message.serialize_to_string)
+  end
+end

data/spec/functional/class_inheritance_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+RSpec.describe 'works through class inheritance' do
+  module Corp
+    module Protobuf
+      class Error < ::Protobuf::Message
+        required :string, :foo, 1
+      end
+    end
+  end
+  module Corp
+    class ErrorHandler < Corp::Protobuf::Error
+    end
+  end
+
+  let(:args) { { :foo => 'bar' } }
+  let(:parent_class) { Corp::Protobuf::Error }
+  let(:inherited_class) { Corp::ErrorHandler }
+
+  specify '#encode' do
+    expected_result = "\n\x03bar"
+    expected_result.force_encoding(Encoding::BINARY)
+    expect(parent_class.new(args).encode).to eq(expected_result)
+    expect(inherited_class.new(args).encode).to eq(expected_result)
+  end
+
+  specify '#to_hash' do
+    expect(parent_class.new(args).to_hash).to eq(args)
+    expect(inherited_class.new(args).to_hash).to eq(args)
+  end
+
+  specify '#to_json' do
+    expect(parent_class.new(args).to_json).to eq(args.to_json)
+    expect(inherited_class.new(args).to_json).to eq(args.to_json)
+  end
+
+  specify '.encode' do
+    expected_result = "\n\x03bar"
+    expected_result.force_encoding(Encoding::BINARY)
+    expect(parent_class.encode(args)).to eq(expected_result)
+    expect(inherited_class.encode(args)).to eq(expected_result)
+  end
+
+  specify '.decode' do
+    raw_value = "\n\x03bar"
+    raw_value.force_encoding(Encoding::BINARY)
+    expect(parent_class.decode(raw_value).to_hash).to eq(args)
+    expect(inherited_class.decode(raw_value).to_hash).to eq(args)
+  end
+
+end

data/spec/functional/socket_server_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+RSpec.describe 'Functional Socket Client' do
+  before(:all) do
+    load "protobuf/socket.rb"
+    @options = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    @runner = ::Protobuf::Rpc::SocketRunner.new(@options)
+    @server_thread = Thread.new(@runner) { |runner| runner.run }
+    Thread.pass until @runner.running?
+  end
+
+  after(:all) do
+    @runner.stop
+    @server_thread.join
+  end
+
+  it 'runs fine when required fields are set' do
+    expect do
+      client = ::Test::ResourceService.client
+
+      client.find(:name => 'Test Name', :active => true) do |c|
+        c.on_success do |succ|
+          expect(succ.name).to eq("Test Name")
+          expect(succ.status).to eq(::Test::StatusType::ENABLED)
+        end
+
+        c.on_failure do |err|
+          fail err.inspect
+        end
+      end
+    end.to_not raise_error
+  end
+
+  it 'calls the on_failure callback when a message is malformed' do
+    error = nil
+    request = ::Test::ResourceFindRequest.new(:active => true)
+    client = ::Test::ResourceService.client
+
+    client.find(request) do |c|
+      c.on_success { fail "shouldn't pass" }
+      c.on_failure { |e| error = e }
+    end
+
+    expect(error.message).to match(/Required field.*does not have a value/)
+  end
+
+  it 'calls the on_failure callback when the request type is wrong' do
+    error = nil
+    request = ::Test::Resource.new(:name => 'Test Name')
+    client = ::Test::ResourceService.client
+
+    client.find(request) do |c|
+      c.on_success { fail "shouldn't pass" }
+      c.on_failure { |e| error = e }
+    end
+    expect(error.message).to match(/expected request.*ResourceFindRequest.*Resource instead/i)
+  end
+end