protobuffy 3.1.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/protobuffy.gemspec

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+$:.push ::File.expand_path("../lib", __FILE__)
+require "protobuf/version"
+
+::Gem::Specification.new do |s|
+  s.name          = 'protobuffy'
+  s.version       = ::Protobuf::VERSION
+  s.date          = ::Time.now.strftime('%Y-%m-%d')
+  s.license       = 'WTFPL'
+
+  s.authors       = ['BJ Neilsen', 'Brandon Dewitt', 'Devin Christensen', 'Adam Hutchison', 'R. Tyler Croy',]
+  s.email         = ['bj.neilsen+protobuf@gmail.com', 'brandonsdewitt+protobuf@gmail.com', 'quixoten@gmail.com', 'liveh2o@gmail.com', 'tyler@monkeypox.org']
+  s.homepage      = 'https://github.com/lookout/protobuffy'
+  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 'multi_json'
+  s.add_dependency 'thor'
+
+  s.add_development_dependency 'rack'
+  s.add_development_dependency 'faraday'
+  s.add_development_dependency 'ffi-rzmq'
+  s.add_development_dependency 'pry-nav'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '2.99.0'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'timecop'
+  s.add_development_dependency 'perftools.rb'
+end

data/spec/benchmark/tasks.rb

@@ -0,0 +1,113 @@
+require 'benchmark'
+require 'protobuf/socket'
+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 sock_client_sock_server(number_tests, test_length, global_bench = nil)
+    load "protobuf/socket.rb"
+
+    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 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 Protobuf Message #serialize"
+  task :profile_protobuf_serialize, [: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).serialize }
+    end
+
+    puts args[:profile_output]
+  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 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)
+      sock_client_sock_server(args[:number], args[:length], bench)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+require 'protobuf/code_generator'
+
+describe 'protoc-gen-ruby' do
+  let(:binpath) { ::File.expand_path('../../../bin/protoc-gen-ruby', __FILE__) }
+  let(:request_bytes) { ::Google::Protobuf::Compiler::CodeGeneratorRequest.new(:file_to_generate => [ "test/foo.proto" ]) }
+  let(:expected_file) { ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => 'test/foo.pb.rb') }
+  let(:expected_response_bytes) { ::Google::Protobuf::Compiler::CodeGeneratorRequest.encode(:files => [ expected_file ]) }
+
+  it 'reads the serialized request bytes and outputs serialized response bytes' do
+    ::IO.popen(binpath, 'w+') do |pipe|
+      pipe.write(request_bytes)
+      pipe.read(expected_response_bytes.size).should eq expected_response_bytes
+    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,91 @@
+require 'spec_helper'
+
+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
+
+    data.should eq message.serialize_to_string
+  end
+end

data/spec/functional/socket_server_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+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 {
+      client = ::Test::ResourceService.client
+
+      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
+    }.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 { raise "shouldn't pass"}
+      c.on_failure {|e| error = e}
+    end
+    error.message.should =~ /name.*required/
+  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 { raise "shouldn't pass"}
+      c.on_failure {|e| error = e}
+    end
+    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
+  end
+end
+

data/spec/functional/zmq_server_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+require 'spec/support/test/resource_service'
+require 'protobuf/rpc/service_directory'
+
+describe 'Functional ZMQ Client' do
+  before(:all) do
+    load "protobuf/zmq.rb"
+    @runner = ::Protobuf::Rpc::ZmqRunner.new({ :host => "127.0.0.1",
+                                               :port => 9399,
+                                               :worker_port => 9408,
+                                               :backlog => 100,
+                                               :threshold => 100,
+                                               :threads => 5 })
+    @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 {
+      client = ::Test::ResourceService.client
+
+      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
+    }.to_not raise_error
+  end
+
+  it 'runs under heavy load' do
+    10.times do |x|
+      5.times.map do |y|
+        Thread.new do
+          client = ::Test::ResourceService.client
+
+          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
+      end.each(&:join)
+    end
+  end
+
+  context 'when a message is malformed' do
+    it 'calls the on_failure callback' do
+      error = nil
+      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
+      error.message.should match(/name.*required/)
+    end
+  end
+
+  context 'when the request type is wrong' do
+    it 'calls the on_failure callback' do
+      error = nil
+      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
+      error.message.should match(/expected request.*ResourceFindRequest.*Resource instead/i)
+    end
+  end
+
+  context 'when the server takes too long to respond' do
+    it 'responds with a timeout error' do
+      error = nil
+      client = ::Test::ResourceService.client(:timeout => 1)
+
+      client.find_with_sleep(:sleep => 2) do |c|
+        c.on_success { raise "shouldn't pass" }
+        c.on_failure { |e| error = e }
+      end
+      error.message.should match(/The server repeatedly failed to respond/)
+    end
+  end
+
+end