protobuf 2.8.13 → 3.0.0.rc1

data/lib/protobuf/field/extension_fields.rb

@@ -1,32 +0,0 @@
-module Protobuf
-  module Field
-    class ExtensionFields < Array
-      ##
-      # Constructor
-      #
-      def initialize
-        @ranges = []
-      end
-
-      ##
-      # Public Instance Methods
-      #
-
-      # Append a range to the list of ranges.
-      def add_range(range = (0..-1))
-        @ranges << range
-      end
-
-      # Set value at tag location, if tag is in a valid range.
-      def []=(key, value)
-        raise RangeError, "#{key} is not in #{@ranges.join(', ')}" unless include_tag?(key)
-        super
-      end
-
-      # Check if the given tag exists in any of the defined ranges.
-      def include_tag?(tag)
-        @ranges.any? { |range| range.include?(tag) }
-      end
-    end
-  end
-end

data/lib/protobuf/message/decoder.rb

@@ -1,72 +0,0 @@
-require 'protobuf/wire_type'
-require 'protobuf/exceptions'
-
-module Protobuf
-
-  module Decoder
-
-    module_function
-
-    # Read bytes from +stream+ and pass to +message+ object.
-    def decode(stream, message)
-      until stream.eof?
-        tag, wire_type = read_key(stream)
-        bytes =
-          case wire_type
-          when ::Protobuf::WireType::VARINT then
-            read_varint(stream)
-          when ::Protobuf::WireType::FIXED64 then
-            read_fixed64(stream)
-          when ::Protobuf::WireType::LENGTH_DELIMITED then
-            read_length_delimited(stream)
-          when ::Protobuf::WireType::FIXED32 then
-            read_fixed32(stream)
-          when ::Protobuf::WireType::START_GROUP then
-            raise NotImplementedError, 'Group is deprecated.'
-          when ::Protobuf::WireType::END_GROUP then
-            raise NotImplementedError, 'Group is deprecated.'
-          else
-            raise InvalidWireType, wire_type
-          end
-        message.set_field(tag, bytes)
-      end
-      message
-    end
-
-    # Read key pair (tag and wire-type) from +stream+.
-    def read_key(stream)
-      bits = read_varint(stream)
-      wire_type = bits & 0x07
-      tag = bits >> 3
-      [tag, wire_type]
-    end
-
-    # Read varint integer value from +stream+.
-    def read_varint(stream)
-      value = index = 0
-      begin
-        byte = stream.readbyte
-        value |= (byte & 0x7f) << (7 * index)
-        index += 1
-      end while (byte & 0x80).nonzero?
-      value
-    end
-
-    # Read 32-bit string value from +stream+.
-    def read_fixed32(stream)
-      stream.read(4)
-    end
-
-    # Read 64-bit string value from +stream+.
-    def read_fixed64(stream)
-      stream.read(8)
-    end
-
-    # Read length-delimited string value from +stream+.
-    def read_length_delimited(stream)
-      value_length = read_varint(stream)
-      stream.read(value_length)
-    end
-
-  end
-end

data/lib/protobuf/message/message.rb

@@ -1 +0,0 @@
-require 'protobuf/message' # Need to get rid of this

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

@@ -1,84 +0,0 @@
-# Handles client connections to the server
-module Protobuf
-  module Rpc
-    module Connectors
-
-      class EMClient < EM::Connection
-        include Protobuf::Logger::LogMethods
-        include Protobuf::Rpc::Connectors::Common
-
-        attr_reader :options, :request, :response
-        attr_reader :error, :error_reason, :error_message
-
-        ##
-        # Constructor
-        #
-        def initialize(options = {}, &failure_cb)
-          @failure_cb = failure_cb
-          @options = DEFAULT_OPTIONS.merge(options)
-          @response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
-          verify_options!
-
-          log_debug { sign_message("Client Initialized: #{options.inspect}") }
-        rescue => e
-          fail(:RPC_ERROR, "Failed to initialize connection: #{e.message}")
-        end
-
-        ##
-        # Class Methods
-        #
-        def self.connect(options = {})
-          options = DEFAULT_OPTIONS.merge(options)
-          log_debug { sign_message("Connecting to server: #{options.inspect}") }
-          EM.connect(options[:host], options[:port], self, options)
-        end
-
-        # turn post_init back into a no-op for event machine
-        def post_init
-        end
-
-        ##
-        # Instance Methods
-        #
-        # Completion callback registration
-        def on_complete(&complete_cb)
-          @complete_cb = complete_cb
-        end
-
-        # Failure callback registration
-        def on_failure(&failure_cb)
-          @failure_cb = failure_cb
-        end
-
-        # Success callback registration
-        def on_success(&success_cb)
-          @success_cb = success_cb
-        end
-
-        def receive_data(data)
-          log_debug { sign_message("receive_data: #{data}") }
-          @response_buffer << data
-          @response_data = @response_buffer.data
-          parse_response if !@response_data.nil? && @response_buffer.flushed?
-        end
-
-        def send_data
-          request_buffer = ::Protobuf::Rpc::Buffer.new(:write)
-          request_buffer.set_data(@request_data)
-          log_debug { sign_message("sending data: #{request_buffer.inspect}") }
-          super(request_buffer.write)
-        rescue => e
-          fail(:RPC_ERROR, "Connection error: #{e.message}")
-        end
-
-        # overwriting this method for java because it's broken in eventmachine. See https://github.com/eventmachine/eventmachine/issues/14
-        if RUBY_PLATFORM =~ /java/
-          def error?
-            !!@error
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-require 'protobuf/rpc/connectors/base'
-require 'protobuf/rpc/connectors/em_client'
-
-module Protobuf
-  module Rpc
-    module Connectors
-      class EventMachine < Base
-
-        def send_request
-          ensure_em_running do
-            f = Fiber.current
-
-            ::EM.next_tick do
-              log_debug { sign_message('Scheduling EventMachine client request to be created on next tick') }
-              cnxn = EMClient.connect(options, &ensure_cb)
-              cnxn.on_success(&success_cb) if success_cb
-              cnxn.on_failure(&ensure_cb)
-              cnxn.on_complete { resume_fiber(f) }
-              cnxn.setup_connection
-              cnxn.send_data
-              log_debug { sign_message('Connection scheduled') }
-            end
-
-            set_timeout_and_validate_fiber
-          end
-        end
-
-        # Returns a callable that ensures any errors will be returned to the client
-        #
-        # If a failure callback was set, just use that as a direct assignment
-        # otherwise implement one here that simply throws an exception, since we
-        # don't want to swallow the black holes.
-        #
-        def ensure_cb
-          @ensure_cb ||= (@failure_cb || lambda { |error| raise "#{error.code.name}: #{error.message}" })
-        end
-
-        def log_signature
-          @_log_signature ||= "client-#{self.class}"
-        end
-
-        private
-
-        def ensure_em_running(&blk)
-          if ::EM.reactor_running?
-            @using_global_reactor = true
-            yield
-          else
-            @using_global_reactor = false
-            ::EM.fiber_run do
-              blk.call
-              ::EM.stop
-            end
-          end
-        end
-
-        def resume_fiber(fib)
-          ::EM::cancel_timer(@timeout_timer)
-          fib.resume(true)
-        rescue => ex
-          log_exception(ex)
-          message = "Synchronous client failed: #{ex.message}"
-          error_stop_reactor(message)
-        end
-
-        def set_timeout_and_validate_fiber
-          @timeout_timer = ::EM::add_timer(@options[:timeout]) do
-            message = "Client timeout of #{@options[:timeout]} seconds expired"
-            error_stop_reactor(message)
-          end
-
-          Fiber.yield
-        rescue FiberError => ex
-          log_exception(ex)
-          message = "Synchronous calls must be in 'EM.fiber_run' block"
-          error_stop_reactor(message)
-        end
-
-        def error_stop_reactor(message)
-          err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
-          ensure_cb.call(err)
-          ::EM.stop unless @using_global_reactor
-        end
-      end
-    end
-  end
-end

data/lib/protobuf/rpc/servers/evented/server.rb

@@ -1,36 +0,0 @@
-require 'protobuf/rpc/server'
-
-module Protobuf
-  module Rpc
-    module Evented
-      class Server < ::EventMachine::Connection
-        include ::Protobuf::Rpc::Server
-        include ::Protobuf::Logger::LogMethods
-
-        # Initialize a new read buffer for storing client request info
-        def post_init
-          initialize_request!
-          @request_buffer = Protobuf::Rpc::Buffer.new(:read)
-        end
-
-        # Receive a chunk of data, potentially flushed to handle_client
-        def receive_data(data)
-          log_debug { sign_message("receive_data: #{data}") }
-
-          @request_buffer << data
-          @request_data = @request_buffer.data
-
-          handle_client if @request_buffer.flushed?
-        end
-
-        def send_data
-          response_buffer = Protobuf::Rpc::Buffer.new(:write)
-          response_buffer.set_data(@response)
-          @stats.response_size = response_buffer.size
-          log_debug { sign_message("sending data: #{response_buffer.inspect}") }
-          super(response_buffer.write)
-        end
-      end
-    end
-  end
-end

data/lib/protobuf/rpc/servers/evented_runner.rb

@@ -1,31 +0,0 @@
-module Protobuf
-  module Rpc
-    class EventedRunner
-
-      def initialize(options)
-        @options = options
-      end
-
-      def run
-        # Startup and run the rpc server
-        ::EventMachine.schedule do
-          ::EventMachine.start_server(
-            @options[:host],
-            @options[:port],
-            ::Protobuf::Rpc::Evented::Server
-          )
-        end
-
-        # Join or start the reactor
-        yield if block_given?
-
-        ::EM.reactor_running? ? ::EM.reactor_thread.join : ::EM.run
-      end
-
-      def stop
-        ::EventMachine.stop_event_loop if ::EventMachine.reactor_running?
-      end
-
-    end
-  end
-end

data/spec/functional/embedded_service_spec.rb

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

data/spec/functional/evented_server_spec.rb

@@ -1,64 +0,0 @@
-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 =~ /name.*required/
-  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

data/spec/lib/protobuf/enum_value_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Protobuf::EnumValue do
-
-	subject { Test::EnumTestType::ONE }
-  its(:class) { should eq(Fixnum) }
-	its(:parent_class) { should eq(Test::EnumTestType) }
-	its(:name) { should eq(:ONE) }
-	its(:value) { should eq(1) }
-	its(:to_hash_value) { should eq(1) }
-	its(:to_s) { should eq("1") }
-	its(:inspect) { should eq('#<Protobuf::EnumValue Test::EnumTestType::ONE=1>') }
-  specify { subject.to_s(:name).should eq("ONE") }
-
-  it "can be used as the index to an array" do
-    array = [0, 1, 2, 3]
-    array[::Test::EnumTestType::ONE].should eq(1)
-  end
-
-  describe '#try' do
-    specify { subject.try(:class).should eq subject.class }
-    specify { subject.try(:name).should eq subject.name }
-    specify { subject.try(:value).should eq subject.value }
-    specify { subject.try(:to_i).should eq subject.to_i }
-    specify { subject.try(:to_int).should eq subject.to_int }
-    specify { subject.try { |yielded| yielded.should eq subject } }
-  end
-
-end

data/spec/lib/protobuf/rpc/servers/evented_server_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'spec/support/test/resource_service'
-require 'protobuf/rpc/servers/evented_runner'
-require 'protobuf/evented'
-
-describe Protobuf::Rpc::Evented::Server do
-
-  it "provides a Runner class" do
-    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner")
-    expect { runner_class.constantize }.to_not raise_error
-  end
-
-  it "Runner provides a stop method" do
-    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner").constantize
-    runner = runner_class.new({})
-    runner.respond_to?(:stop).should be_true
-  end
-
-end