protobuf 1.0.0

data/lib/protobuf/rpc/stat.rb

@@ -0,0 +1,70 @@
+require 'date'
+require 'protobuf/common/logger'
+
+module Protobuf
+  module Rpc
+    class Stat
+      attr_accessor :type, :start_time, :end_time, :request_size, :response_size, :client, :server, :service, :method
+      
+      TYPES = [:SERVER, :CLIENT]
+      
+      def initialize type=:SERVER, do_start=true
+        @type = type
+        start if do_start
+      end
+      
+      def client= peer
+        @client = {:port => peer[0], :ip => peer[1]}
+      end
+      
+      def client
+        @client ? '%s:%d' % [@client[:ip], @client[:port]] : nil
+      end
+      
+      def server= peer
+        @server = {:port => peer[0], :ip => peer[1]}
+      end
+      
+      def server
+        @server ? '%s:%d' % [@server[:ip], @server[:port]] : nil
+      end
+      
+      def sizes
+        '%dB/%dB' % [@request_size || 0, @response_size || 0]
+      end
+      
+      def start
+        @start_time ||= Time.now
+      end
+      
+      def end
+        start if !@start_time
+        @end_time ||= Time.now
+      end
+      
+      def rpc
+        service && method ? '%s#%s' % [service, method] : nil
+      end
+      
+      def elapsed_time
+        (start_time && end_time ? '%ss' % (end_time - start_time).round(4) : nil)
+      end
+      
+      def log_stats
+        Protobuf::Logger.info to_s
+      end
+      
+      def to_s
+        [
+          @type == :SERVER ? '[SRV]' : '[CLT]',
+          rpc,
+          elapsed_time,
+          sizes,
+          @type == :SERVER ? server : client
+        ].delete_if{|v| v.nil? }.join(' - ')
+      end
+      
+    end
+  end
+end
+

data/lib/protobuf/version.rb

@@ -0,0 +1,3 @@
+module Protobuf
+  VERSION = '1.0.0'
+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,25 @@
+# -*- 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          = %q{2011-11-06}
+
+  s.authors       = ['BJ Neilsen']
+  s.email         = ["bj.neilsen@gmail.com"]
+  s.homepage      = %q{https://github.com/localshred/protobuf}
+  s.summary       = 'Ruby implementation for Protocol Buffers. Works with other protobuf rpc implementations (e.g. Java, Python, C++).'
+  s.description   = s.summary + "\n\nThis gem has diverged from https://github.com/macks/ruby-protobuf. All credit for serialization and rprotoc work most certainly goes to the original authors. All RPC implementation code (client/server/service) was written and is maintained by this author. Attempts to reconcile the original codebase with the current RPC implementation went unsuccessful."
+  
+  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 'eventmachine', '~> 0.12.10'
+  
+  s.add_development_dependency 'rake', '~> 0.8.7'
+  s.add_development_dependency 'rspec', '~> 2.7.0'
+end

data/script/mk_parser

@@ -0,0 +1,2 @@
+#!/bin/sh
+racc -E lib/protobuf/compiler/proto.y -o lib/protobuf/compiler/proto_parser.rb

data/spec/functional/embedded_service_spec.rb

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

data/spec/proto/test.pb.rb

@@ -0,0 +1,31 @@
+### Generated by rprotoc. DO NOT EDIT!
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/extend'
+
+module Spec
+  module Proto
+    class StatusType < ::Protobuf::Enum
+      define :PENDING, 0
+      define :ENABLED, 1
+      define :DISABLED, 2
+      define :DELETED, 3
+    end
+    class ResourceFindRequest < ::Protobuf::Message
+      optional :string, :name, 1
+      optional :bool, :active, 2
+    end
+    class Resource < ::Protobuf::Message
+      optional :string, :name, 1
+      optional :int64, :date_created, 2
+      optional :StatusType, :status, 3
+      repeated :StatusType, :repeated_enum, 4
+    end
+    class Nested < ::Protobuf::Message
+      optional :string, :name, 1
+      optional :Resource, :resource, 2
+      repeated :Resource, :multiple_resources, 3
+      optional :StatusType, :status, 4
+    end
+  end
+end

data/spec/proto/test.proto

@@ -0,0 +1,31 @@
+package spec.proto;
+
+enum StatusType {
+  PENDING = 0;
+  ENABLED = 1;
+  DISABLED = 2;
+  DELETED = 3;
+}
+
+message ResourceFindRequest {
+  optional string name = 1;
+  optional bool active = 2;
+}
+
+message Resource {
+  optional string name = 1;
+  optional int64 date_created = 2;
+  optional StatusType status = 3;
+  repeated StatusType repeated_enum = 4;
+}
+
+message Nested {
+  optional string name = 1;
+  optional Resource resource = 2;
+  repeated Resource multiple_resources = 3;
+  optional StatusType status = 4;
+}
+
+service TestService {
+  rpc Find (ResourceFindRequest) returns (Resource);
+}

data/spec/proto/test_service.rb

@@ -0,0 +1,30 @@
+require 'protobuf/rpc/service'
+require 'spec/proto/test.pb'
+
+##	!! DO NOT EDIT THIS FILE !!
+## 
+##	To implement this service as defined by the protobuf, simply
+##	reopen Spec::Proto::TestService and implement each service method:
+## 
+## module Spec
+## 	module Proto
+## 		class TestService
+## 		
+## 			# request -> Spec::Proto::ResourceFindRequest
+## 			# response -> Spec::Proto::Resource
+## 			def find
+## 				# TODO: implement find
+## 			end
+## 		
+## 		end
+## 	end
+## end
+##
+
+module Spec
+	module Proto
+		class TestService < Protobuf::Rpc::Service
+		  rpc :find, ResourceFindRequest, Resource
+		end
+	end
+end

data/spec/proto/test_service_impl.rb

@@ -0,0 +1,17 @@
+require 'spec/proto/test_service'
+
+module Spec
+  module Proto
+    class TestService
+      located_at "localhost:9191"
+    
+      # request -> Spec::Proto::ResourceFindRequest
+      # response -> Spec::Proto::Resource
+      def find
+        response.name = request.name
+        response.status = request.active ? 1 : 0
+      end
+    
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development, :test
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end
+
+$:.push File.expand_path('..', File.dirname(__FILE__))
+$:.push File.expand_path('../lib', File.dirname(__FILE__))
+require 'protobuf'
+
+require 'protobuf/rpc/client'
+class ::Protobuf::Rpc::Client
+  def == other
+   options == other.options && \
+   error == other.error && \
+   do_block == other.do_block && \
+   @success_callback == other.instance_variable_get(:@success_callback) && \
+   @failure_callback == other.instance_variable_get(:@failure_callback)
+  end
+end
+
+def reset_service_location service
+  service.instance_variable_set :@locations, nil
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'spec/proto/test_service_impl'
+
+describe Protobuf::Rpc::Client do
+  
+  context 'when creating a client from a service' do
+    
+    it 'should be able to get a client through the Service#client helper method' do
+      Spec::Proto::TestService.client(:port => 9191).should == Protobuf::Rpc::Client.new(:service => Spec::Proto::TestService, :port => 9191)
+    end
+    
+    it "should be able to override a service location's host and port" do
+      Spec::Proto::TestService.located_at 'somewheregreat.com:12345'
+      clean_client = Spec::Proto::TestService.client
+      clean_client.options[:host].should == 'somewheregreat.com'
+      clean_client.options[:port].should == 12345
+      
+      updated_client = Spec::Proto::TestService.client(:host => 'amazing.com', :port => 54321)
+      updated_client.options[:host].should == 'amazing.com'
+      updated_client.options[:port].should == 54321
+    end
+    
+    it 'should be able to define the syncronicity of the client request' do
+      client = Spec::Proto::TestService.client(:async => false)
+      client.options[:async].should be_false
+      client.do_block.should be_true
+      
+      client = Spec::Proto::TestService.client(:async => true)
+      client.options[:async].should be_true
+      client.do_block.should be_false
+    end
+    
+    it 'should be able to define which service to create itself for' do
+      client = Protobuf::Rpc::Client.new :service => Spec::Proto::TestService
+      client.options[:service].should == Spec::Proto::TestService
+    end
+    
+    it 'should have a hard default for host and port on a service that has not been configured' do
+      reset_service_location Spec::Proto::TestService
+      client = Spec::Proto::TestService.client
+      client.options[:host].should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
+      client.options[:port].should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
+    end
+
+  end
+  
+  context 'when calling methods on a service client' do
+    
+    # NOTE: we are assuming the service methods are accurately 
+    # defined inside spec/proto/test_service.rb,
+    # namely the :find method
+    
+    it 'should respond to defined service methods' do
+      client = Spec::Proto::TestService.client
+      client.should_receive(:send_request).and_return(nil)
+      expect { client.find(nil) }.should_not raise_error
+    end
+    
+    it 'raises a NameError when accessing a var that does not exist' do
+      pending
+    end
+    
+    it 'should be able to set and get local variables within client response blocks' do
+      outer_value = 'OUTER'
+      inner_value = 'INNER'
+      client = Spec::Proto::TestService.client(:async => true)
+      
+      EM.should_receive(:reactor_running?).and_return(true)
+      EM.stub!(:schedule) do
+        client.instance_variable_get(:@success_callback).call(inner_value)
+      end
+      
+      client.find(nil) do |c|
+        c.on_success do |response|
+          outer_value.should == 'OUTER'
+          outer_value = response
+        end
+      end
+      outer_value.should == inner_value
+    end
+    
+  end
+  
+  context 'when receiving request objects' do
+    
+    it 'should be able to create the correct request object if passed a hash' do
+      client = Spec::Proto::TestService.client
+      client.should_receive(:send_request)
+      client.find({:name => 'Test Name', :active => false})
+      client.options[:request].should be_a Spec::Proto::ResourceFindRequest
+      client.options[:request].name.should == 'Test Name'
+      client.options[:request].active.should == false
+    end
+    
+  end
+  
+  describe '#synchronize_or_return' do
+    
+    context 'when a timeout error occurs' do
+      it 'returns a timeout error' do
+        client = Spec::Proto::TestService.client :timeout => 1
+        client.stub(:ensure_callback).and_return(proc {|err|
+          err.should be_a Protobuf::Rpc::ClientError
+          err.message.should == 'Client timeout of 1 seconds expired'
+          err.code.should == Protobuf::Socketrpc::ErrorReason::RPC_ERROR
+        })
+        Timeout.timeout(2) { client.synchronize_or_return }
+      end
+    end
+    
+    context 'when any other error occurs' do
+      it 'returns the error' do
+        client = Spec::Proto::TestService.client
+        client.stub(:ensure_callback).and_return(proc {|err|
+          err.should be_a Protobuf::Rpc::ClientError
+          err.message.should == 'Client failed: This is another type of error'
+          err.code.should == Protobuf::Socketrpc::ErrorReason::RPC_ERROR
+        })
+        Timeout.timeout(2) {
+          Timeout.stub(:timeout).and_raise(RuntimeError.new('This is another type of error'))
+          client.synchronize_or_return
+        }
+      end
+    end
+    
+  end
+  
+end