protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/rpc/connector.rb

@@ -1,21 +0,0 @@
-require 'protobuf'
-
-module Protobuf
-  module Rpc
-    class Connector
-
-      # Returns a connector class for the pre-defined connector_type.
-      def self.connector_for_client
-        case ::Protobuf.connector_type
-        when :zmq then
-          ::Protobuf::Rpc::Connectors::Zmq
-        when :http then
-          ::Protobuf::Rpc::Connectors::Http
-        else
-          ::Protobuf::Rpc::Connectors::Socket
-        end
-      end
-
-    end
-  end
-end

data/lib/protobuf/rpc/connectors/common.rb

@@ -1,172 +0,0 @@
-require 'protobuf'
-
-module Protobuf
-  module Rpc
-    module Connectors
-      module Common
-
-        attr_reader :error
-
-        def any_callbacks?
-          return [@complete_cb, @failure_cb, @success_cb].inject(false) do |reduction, cb|
-            reduction = (reduction || !cb.nil?)
-          end
-        end
-
-        def request_caller
-          @options[:client_host] || ::Protobuf.client_host
-        end
-
-        def complete
-          @stats.stop
-          log_info { @stats.to_s }
-          log_debug { sign_message('Response proceessing complete') }
-          @complete_cb.call(self) unless @complete_cb.nil?
-        rescue => e
-          log_error { sign_message('Complete callback error encountered') }
-          log_exception(e)
-          raise
-        end
-
-        def data_callback(data)
-          log_debug { sign_message('Using data_callback') }
-          @used_data_callback = true
-          @data = data
-        end
-
-        # All failures should be routed through this method.
-        #
-        # @param [Symbol] code The code we're using (see ::Protobuf::Socketrpc::ErrorReason)
-        # @param [String] message The error message
-        def fail(code, message)
-          @error =  ClientError.new
-          @error.code = Protobuf::Socketrpc::ErrorReason.fetch(code)
-          @error.message = message
-          log_debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
-
-          @stats.failure(code)
-          @failure_cb.call(@error) unless @failure_cb.nil?
-        rescue => e
-          log_error { sign_message("Failure callback error encountered") }
-          log_exception(e)
-          raise
-        ensure
-          complete
-        end
-
-        def initialize_stats
-          @stats = Protobuf::Rpc::Stat.new(:CLIENT)
-          @stats.server = [@options[:port], @options[:host]]
-          @stats.service = @options[:service].name
-          @stats.method_name = @options[:method].to_s
-        rescue => ex
-          log_exception(ex)
-          fail(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
-        end
-
-        def log_signature
-          @_log_signature ||= "[client-#{self.class}]"
-        end
-
-        def parse_response
-          # Close up the connection as we no longer need it
-          close_connection
-
-          log_debug { sign_message("Parsing response from server (connection closed)") }
-
-          # Parse out the raw response
-          @stats.response_size = @response_data.size unless @response_data.nil?
-          response_wrapper = Protobuf::Socketrpc::Response.decode(@response_data)
-
-          # Determine success or failure based on parsed data
-          if response_wrapper.has_field?(:error_reason)
-            log_debug { sign_message("Error response parsed") }
-
-            # fail the call if we already know the client is failed
-            # (don't try to parse out the response payload)
-            fail(response_wrapper.error_reason, response_wrapper.error)
-          else
-            log_debug { sign_message("Successful response parsed") }
-
-            # Ensure client_response is an instance
-            parsed = @options[:response_type].decode(response_wrapper.response_proto.to_s)
-
-            if parsed.nil? and not response_wrapper.has_field?(:error_reason)
-              fail(:BAD_RESPONSE_PROTO, 'Unable to parse response from server')
-            else
-              verify_callbacks
-              succeed(parsed)
-              return @data if @used_data_callback
-            end
-          end
-        end
-
-        def post_init
-          send_data unless error?
-        rescue => e
-          fail(:RPC_ERROR, "Connection error: #{e.message}")
-        end
-
-        def request_bytes
-          validate_request_type!
-          fields = { :service_name => @options[:service].name,
-                     :method_name => @options[:method].to_s,
-                     :request_proto => @options[:request],
-                     :caller => request_caller }
-
-          return ::Protobuf::Socketrpc::Request.encode(fields)
-        rescue => e
-          fail(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
-        end
-
-        def setup_connection
-          initialize_stats
-          @request_data = request_bytes
-          @stats.request_size = request_bytes.size
-        end
-
-        def succeed(response)
-          log_debug { sign_message("Server succeeded request (invoking on_success)") }
-          @stats.success
-          @success_cb.call(response) unless @success_cb.nil?
-        rescue => e
-          log_error { sign_message("Success callback error encountered") }
-          log_exception(e)
-          fail(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
-        ensure
-          complete
-        end
-
-        # Wrap the given block in a timeout of the configured number of seconds.
-        #
-        def timeout_wrap(&block)
-          ::Timeout.timeout(options[:timeout], &block)
-        rescue ::Timeout::Error
-          fail(:RPC_FAILED, "The server took longer than #{options[:timeout]} seconds to respond")
-        end
-
-        def validate_request_type!
-          unless @options[:request].class == @options[:request_type]
-            expected = @options[:request_type].name
-            actual = @options[:request].class.name
-            fail(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
-          end
-        end
-
-        def verify_callbacks
-          unless any_callbacks?
-            log_debug { sign_message("No callbacks set, using data_callback") }
-            @success_cb = @failure_cb = self.method(:data_callback)
-          end
-        end
-
-        def verify_options!
-          # Verify the options that are necessary and merge them in
-          [:service, :method, :host, :port].each do |opt|
-            fail(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
-          end
-        end
-      end
-    end
-  end
-end

data/spec/data/data.bin

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

data/spec/lib/protobuf/logger_spec.rb

@@ -1,145 +0,0 @@
-require 'protobuf/logger'
-require 'stringio'
-require 'fileutils'
-
-describe Protobuf::Logger do
-
-  subject { Protobuf::Logger }
-
-  before(:each) do
-    Protobuf::Logger.reset_device!
-    Protobuf::Logger.file = '/dev/null'
-    Protobuf::Logger.level = ::Logger::INFO
-  end
-
-  after(:all) do
-    ::FileUtils.rm_f('myfile.log')
-  end
-
-  describe '.instance' do
-
-    it 'doesn\'t create a logger if the file was not set' do
-      subject.file = nil
-      subject.instance.should be_nil
-    end
-
-    it 'doesn\'t create a logger if the level was not set' do
-      subject.level = nil
-      subject.instance.should be_nil
-    end
-
-    it 'gets a new instance of the logger when file and level are set' do
-      subject.file.should_not be_nil
-      subject.level.should_not be_nil
-      subject.instance.should_not be_nil
-    end
-
-    it 'keeps the same object from multiple calls to instance' do
-      subject.instance === subject.instance
-    end
-
-  end
-
-  describe '.configure' do
-    before(:each) { subject.reset_device! }
-    it 'sets the file and level in one call' do
-      subject.file.should_not be
-      subject.level.should_not be
-      subject.instance.should_not be
-      subject.configure :file => 'myfile.log', :level => ::Logger::WARN
-      subject.file.should == 'myfile.log'
-      subject.level.should == ::Logger::WARN
-      subject.instance.level.should == ::Logger::WARN
-    end
-
-    context 'specifying logger' do
-      let(:logger) { double('Logger') }
-
-      it 'sets the logger instance' do
-        subject.instance.should_not be
-        subject.configure :logger => logger
-        subject.instance.should == logger
-      end
-    end
-  end
-
-  describe '.reset_device!' do
-
-    it 'resets the logger instance, file, and level' do
-      subject.instance.should be
-      subject.file.should be
-      subject.level.should be
-      subject.reset_device!
-      subject.instance.should_not be
-      subject.file.should_not be
-      subject.level.should_not be
-    end
-
-  end
-
-  context 'when logging' do
-
-    it 'doesn\'t raise errors when log instance is nil' do
-      subject.reset_device!
-      subject.instance.should be_nil
-      expect {
-        subject.debug 'No errors here'
-        subject.info 'No errors here'
-        subject.warn 'No errors here'
-        subject.error 'No errors here'
-        subject.fatal 'No errors here'
-        subject.add 'No errors here'
-        subject.log 'No errors here'
-      }.to_not raise_error
-    end
-
-    it 'logs correctly when instance is valid' do
-      subject.instance.should_not be_nil
-      subject.instance.should_receive(:info).with('Should log great')
-      subject.info 'Should log great'
-    end
-
-  end
-
-  describe Protobuf::Logger::LogMethods do
-
-    context 'when included in another class' do
-
-      before(:all) do
-        class MyTestClass
-          include Protobuf::Logger::LogMethods
-        end
-      end
-
-      subject { MyTestClass.new }
-
-      it { should respond_to(:log_debug) }
-      it { should respond_to(:log_info) }
-      it { should respond_to(:log_warn) }
-      it { should respond_to(:log_error) }
-      it { should respond_to(:log_fatal) }
-      it { should respond_to(:log_add) }
-      it { should respond_to(:log_log) }
-
-      context '#log_exception' do
-        it 'logs the exception message as an error and backtrace as debug' do
-          subject.should_receive(:log_error).twice
-          subject.should_receive(:log_debug)
-          subject.log_exception(RuntimeError.new('this is an exception'))
-        end
-      end
-
-      its(:log_signature) { should eq "[MyTestClass]" }
-      describe '#sign_message' do
-        specify { subject.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
-        specify { subject.class.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
-      end
-
-      it 'passes all embedded log calls to Logger instance' do
-        Protobuf::Logger.instance.should_receive(:debug).with('[MyTestClass] log this')
-        subject.log_debug('log this')
-      end
-
-    end
-  end
-end

data/spec/lib/protobuf/rpc/connector_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'protobuf/socket'
-require 'protobuf/zmq'
-
-describe ::Protobuf::Rpc::Connector do
-
-  describe '.connector_for_client(true)' do
-    subject { described_class.connector_for_client }
-
-    context 'Protobuf.connector_type is socket' do
-      before { ::Protobuf.connector_type = :socket }
-      it { should eq ::Protobuf::Rpc::Connectors::Socket }
-    end
-
-    context 'Protobuf.connector_type is not a known value' do
-      before { ::Protobuf.stub(:connector_type) { :foo } }
-      it { should eq ::Protobuf::Rpc::Connectors::Socket }
-    end
-
-    context 'Protobuf.connector_type is zmq' do
-      before { ::Protobuf.connector_type = :zmq }
-      it { should eq ::Protobuf::Rpc::Connectors::Zmq }
-    end
-  end
-
-end

data/spec/lib/protobuf/rpc/connectors/common_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-require 'protobuf/rpc/service'
-
-describe Protobuf::Rpc::Connectors::Common do
-  let(:common_class) do
-    Class.new(Protobuf::Rpc::Connectors::Base) do
-      include Protobuf::Rpc::Connectors::Common
-      attr_accessor :options
-      attr_accessor :stats
-    end
-  end
-
-  let(:subject_options) { {} }
-
-  subject { @subject ||= common_class.new(subject_options) }
-
-  context "API" do
-    specify { subject.respond_to?(:any_callbacks?).should be_true }
-    specify { subject.respond_to?(:request_caller).should be_true }
-    specify { subject.respond_to?(:data_callback).should be_true }
-    specify { subject.respond_to?(:error).should be_true }
-    specify { subject.respond_to?(:fail).should be_true }
-    specify { subject.respond_to?(:complete).should be_true }
-    specify { subject.respond_to?(:parse_response).should be_true }
-    specify { subject.respond_to?(:verify_options!).should be_true }
-    specify { subject.respond_to?(:verify_callbacks).should be_true }
-  end
-
-  describe "#any_callbacks?" do
-
-    [:@complete_cb, :@success_cb, :@failure_cb].each do |cb|
-      it "returns true if #{cb} is provided" do
-        subject.instance_variable_set(cb, "something")
-        subject.any_callbacks?.should be_true
-      end
-    end
-
-    it "returns false when all callbacks are not provided" do
-      subject.instance_variable_set(:@complete_cb, nil)
-      subject.instance_variable_set(:@success_cb, nil)
-      subject.instance_variable_set(:@failure_cb, nil)
-
-      subject.any_callbacks?.should be_false
-    end
-
-  end
-
-  describe '#request_caller' do
-    its(:request_caller) { should eq ::Protobuf.client_host }
-
-    context 'when "client_host" option is given to initializer' do
-      let(:hostname) { 'myhost.myserver.com' }
-      let(:subject_options) { { :client_host => hostname } }
-
-      its(:request_caller) { should_not eq ::Protobuf.client_host }
-      its(:request_caller) { should eq hostname }
-    end
-  end
-
-  describe "#data_callback" do
-    it "changes state to use the data callback" do
-      subject.data_callback("data")
-      subject.instance_variable_get(:@used_data_callback).should be_true
-    end
-
-    it "sets the data var when using the data_callback" do
-      subject.data_callback("data")
-      subject.instance_variable_get(:@data).should eq("data")
-    end
-  end
-
-  describe '#request_bytes' do
-    let(:service) { Test::ResourceService }
-    let(:method) { :find }
-    let(:request) { '' }
-    let(:client_host) { 'myhost.myservice.com' }
-    let(:subject_options) { { :service => service,
-                              :method => method,
-                              :request => request,
-                              :client_host => client_host } }
-
-    let(:expected) { ::Protobuf::Socketrpc::Request.new({ :service_name => service.name,
-                                                          :method_name => 'find',
-                                                          :request_proto => '',
-                                                          :caller => client_host }) }
-
-    before { subject.stub(:validate_request_type!).and_return(true) }
-    before { subject.should_not_receive(:fail) }
-
-    its(:request_bytes) { should eq expected.encode }
-  end
-
-  describe "#verify_callbacks" do
-
-    it "sets @failure_cb to #data_callback when no callbacks are defined" do
-      subject.verify_callbacks
-      subject.instance_variable_get(:@failure_cb).should eq(subject.method(:data_callback))
-    end
-
-    it "sets @success_cb to #data_callback when no callbacks are defined" do
-      subject.verify_callbacks
-      subject.instance_variable_get(:@success_cb).should eq(subject.method(:data_callback))
-    end
-
-    it "doesn't set @failure_cb when already defined" do
-      set_cb = lambda{ true }
-      subject.instance_variable_set(:@failure_cb, set_cb)
-      subject.verify_callbacks
-      subject.instance_variable_get(:@failure_cb).should eq(set_cb)
-      subject.instance_variable_get(:@failure_cb).should_not eq(subject.method(:data_callback))
-    end
-
-    it "doesn't set @success_cb when already defined" do
-      set_cb = lambda{ true }
-      subject.instance_variable_set(:@success_cb, set_cb)
-      subject.verify_callbacks
-      subject.instance_variable_get(:@success_cb).should eq(set_cb)
-      subject.instance_variable_get(:@success_cb).should_not eq(subject.method(:data_callback))
-    end
-
-  end
-
-  shared_examples "a ConnectorDisposition" do |meth, cb, *args|
-
-    it "calls #complete before exit" do
-      stats = double("Object")
-      stats.stub(:success) { true }
-      stats.stub(:failure) { true }
-      stats.stub(:stop) { true }
-      subject.stats = stats
-
-      subject.should_receive(:complete)
-      subject.method(meth).call(*args)
-    end
-
-    it "calls the #{cb} callback when provided" do
-      stats = double("Object")
-      stats.stub(:success) { true }
-      stats.stub(:failure) { true }
-      stats.stub(:stop) { true }
-      subject.stats = stats
-      _cb = double("Object")
-
-      subject.instance_variable_set("@#{cb}", _cb)
-      _cb.should_receive(:call).and_return(true)
-      subject.method(meth).call(*args)
-    end
-
-    it "calls the complete callback when provided" do
-      stats = double("Object")
-      stats.stub(:success) { true }
-      stats.stub(:failure) { true }
-      stats.stub(:stop) { true }
-      subject.stats = stats
-      comp_cb = double("Object")
-
-      subject.instance_variable_set(:@complete_cb, comp_cb)
-      comp_cb.should_receive(:call).and_return(true)
-      subject.method(meth).call(*args)
-    end
-
-  end
-
-  it_behaves_like("a ConnectorDisposition", :fail, "failure_cb", "code", "message")
-  it_behaves_like("a ConnectorDisposition", :fail, "complete_cb", "code", "message")
-  it_behaves_like("a ConnectorDisposition", :succeed, "complete_cb", "response")
-  it_behaves_like("a ConnectorDisposition", :succeed, "success_cb", "response")
-  it_behaves_like("a ConnectorDisposition", :complete, "complete_cb")
-
-end