protobuf 1.0.0 → 1.0.1

data/lib/protobuf/compiler/visitors.rb

@@ -168,13 +168,6 @@ module Protobuf
         @file_contents
       end
 
-      def create_bin(out_dir, underscored_name, module_name, service_name, default_port)
-        bin_filename = "#{out_dir}/bin/start_#{underscored_name}"
-        bin_contents = template_erb('rpc_bin').result(binding)
-        create_file_with_backup(bin_filename, bin_contents, true) if @create_file
-        @file_contents[bin_filename] = bin_contents
-      end
-
       def create_service(message_file, out_dir, underscored_name, module_name, service_name, default_port, rpcs, required_file)
         service_filename = "#{out_dir}/#{Util.module_to_path(module_name)}/#{underscored_name}.rb"
         service_contents = template_erb('rpc_service_implementation').result(binding)
@@ -182,13 +175,6 @@ module Protobuf
         @file_contents[service_filename] = service_contents
       end
 
-      def create_client(out_dir, underscored_name, default_port, name, request, response, message_module, required_file)
-        client_filename = "#{out_dir}/clients/#{Util.module_to_path(message_module)}_client_#{underscore name}.rb"
-        client_contents = template_erb('rpc_client').result binding
-        create_file_with_backup(client_filename, client_contents, true) if @create_file
-        @file_contents[client_filename] = client_contents
-      end
-
       private
 
       def underscore(str)
@@ -232,19 +218,19 @@ module Protobuf
       def add_option(name, value)
         options =
           case current_descriptor
-          when Google::Protobuf::FileDescriptorProto
+          when Google::Protobuf::FileDescriptorProto then
             Google::Protobuf::FileOptions.new
-          when Google::Protobuf::DescriptorProto
+          when Google::Protobuf::DescriptorProto then
             Google::Protobuf::MessageOptions.new
-          when Google::Protobuf::FieldDescriptorProto
+          when Google::Protobuf::FieldDescriptorProto then
             Google::Protobuf::FieldOptions.new
-          when Google::Protobuf::EnumDescriptorProto
+          when Google::Protobuf::EnumDescriptorProto then
             Google::Protobuf::EnumOptions.new
-          when Google::Protobuf::EnumValueDescriptorProto
+          when Google::Protobuf::EnumValueDescriptorProto then
             Google::Protobuf::EnumValueOptions.new
-          when Google::Protobuf::ServiceDescriptorProto
+          when Google::Protobuf::ServiceDescriptorProto then
             Google::Protobuf::ServiceOptions.new
-          when Google::Protobuf::MethodDescriptorProto
+          when Google::Protobuf::MethodDescriptorProto then
             Google::Protobuf::MethodOptions.new
           else
             raise ArgumentError, 'Invalid context'
@@ -255,9 +241,9 @@ module Protobuf
 
       def descriptor=(descriptor)
         case current_descriptor
-        when Google::Protobuf::FileDescriptorProto
+        when Google::Protobuf::FileDescriptorProto then
           current_descriptor.message_type << descriptor
-        when Google::Protobuf::DescriptorProto
+        when Google::Protobuf::DescriptorProto then
           current_descriptor.nested_type << descriptor
         else
           raise ArgumentError, 'Invalid context'
@@ -283,9 +269,9 @@ module Protobuf
 
       def field_descriptor=(descriptor)
         case current_descriptor
-        when Google::Protobuf::FileDescriptorProto
+        when Google::Protobuf::FileDescriptorProto then
           current_descriptor.extension << descriptor
-        when Google::Protobuf::DescriptorProto
+        when Google::Protobuf::DescriptorProto then
           current_descriptor.field << descriptor
           #TODO: how should i distiguish between field and extension
           #current_descriptor.extension << descriptor

data/lib/protobuf/descriptor/descriptor_builder.rb

@@ -5,41 +5,41 @@ module Protobuf
     def self.id2type(type_id)
       require 'protobuf/descriptor/descriptor_proto'
       case type_id
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_DOUBLE
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_DOUBLE then
         :double
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FLOAT
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FLOAT then
         :float
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64 then
         :int64
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT64 then
         :unit64
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32 then
         :int64
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED64 then
         :fixed64
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED32 then
         :fixed32
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BOOL
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BOOL then
         :bool
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING then
         :string
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_GROUP
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_GROUP then
         :group
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE then
         :message
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BYTES
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BYTES then
         :bytes
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT32 then
         :uint32
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM then
         :enum
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED32 then
         :sfixed32
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED64 then
         :sfixed64
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT32
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT32 then
         :sint32
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT64
+      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT64 then
         :sint64
       else
         raise ArgumentError, "Invalid type: #{proto.type}"
@@ -49,42 +49,42 @@ module Protobuf
     def self.type2id(type)
       require 'protobuf/descriptor/descriptor_proto'
       case type
-      when :double
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_DOUBLE
-      when :float
+      when :double then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_DOUBLE 
+      when :float then
         Google::Protobuf::FieldDescriptorProto::Type::TYPE_FLOAT
-      when :int64
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64
-      when :unit64
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT64
-      when :int64
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32
-      when :fixed64
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED64
-      when :fixed32
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED32
-      when Google::Protobuf::FieldDescriptorProto::Type::TYPE_BOOL
-        :bool
-      when :string
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING
-      when :group
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_GROUP
-      when :message
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
-      when :bytes
+      when :int64 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT64 
+      when :unit64 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT64 
+      when :int64 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_INT32 
+      when :fixed64 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED64 
+      when :fixed32 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_FIXED32 
+      when :bool then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_BOOL 
+      when :string then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_STRING 
+      when :group then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_GROUP 
+      when :message then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE 
+      when :bytes then
         Google::Protobuf::FieldDescriptorProto::Type::TYPE_BYTES
-      when :uint32
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT32
-      when :enum
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM
-      when :sfixed32
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED32
-      when :sfixed64
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED64
-      when :sint32
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT32
-      when :sint64
-        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT64
+      when :uint32 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_UINT32 
+      when :enum then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_ENUM 
+      when :sfixed32 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED32 
+      when :sfixed64 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SFIXED64 
+      when :sint32 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT32 
+      when :sint64 then
+        Google::Protobuf::FieldDescriptorProto::Type::TYPE_SINT64 
       else
         Google::Protobuf::FieldDescriptorProto::Type::TYPE_MESSAGE
       end
@@ -93,11 +93,11 @@ module Protobuf
     def self.id2label(label_id)
       require 'protobuf/descriptor/descriptor_proto'
       case label_id
-      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED
+      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED then
         :required
-      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL
+      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL then
         :optional
-      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED
+      when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED then
         :repeated
       else
         raise ArgumentError, "Invalid label: #{proto.label}"
@@ -108,11 +108,11 @@ module Protobuf
       require 'protobuf/descriptor/descriptor_proto'
       case label
       when :required
-        Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED
+        Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED then
       when :optional
-        Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL
+        Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL then
       when :repeated
-        Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED
+        Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED then
       else
         raise ArgumentError, "Invalid label: #{label}"
       end

data/lib/protobuf/descriptor/field_descriptor.rb

@@ -32,9 +32,9 @@ module Protobuf
         field_proto.default_value = @field_instance.default.to_s if @field_instance.default
 
         case parent_proto
-        when Google::Protobuf::FileDescriptorProto
+        when Google::Protobuf::FileDescriptorProto then
           parent_proto.extension << field_proto
-        when Google::Protobuf::DescriptorProto
+        when Google::Protobuf::DescriptorProto then
           if extension
             parent_proto.extension << field_proto
           else

data/lib/protobuf/ext/eventmachine.rb

@@ -0,0 +1,16 @@
+require 'fiber'
+
+# Method and concept from em-synchrony
+# https://github.com/igrigorik/em-synchrony
+#
+# A convenience method for wrapping EM.run body within
+# a Ruby Fiber such that async operations can be transparently
+# paused and resumed based on IO scheduling
+module EventMachine
+  def self.fiber_run(blk=nil, tail=nil, &block)
+    blk ||= block
+    context = Proc.new{ Fiber.new{ blk.call }.resume }
+
+    self.run(context, tail)
+  end
+end

data/lib/protobuf/message/decoder.rb

@@ -13,17 +13,17 @@ module Protobuf
         tag, wire_type = read_key(stream)
         bytes =
           case wire_type
-          when WireType::VARINT
+          when WireType::VARINT then
             read_varint(stream)
-          when WireType::FIXED64
+          when WireType::FIXED64 then
             read_fixed64(stream)
-          when WireType::LENGTH_DELIMITED
+          when WireType::LENGTH_DELIMITED then
             read_length_delimited(stream)
-          when WireType::START_GROUP
+          when WireType::START_GROUP then
             read_start_group(stream)
-          when WireType::END_GROUP
+          when WireType::END_GROUP then
             read_end_group(stream)
-          when WireType::FIXED32
+          when WireType::FIXED32 then
             read_fixed32(stream)
           else
             raise InvalidWireType, wire_type

data/lib/protobuf/message/field.rb

@@ -59,11 +59,11 @@ module Protobuf
 
         @default_value = \
           case @rule
-          when :repeated
+          when :repeated then
             FieldArray.new(self).freeze
-          when :required
+          when :required then
             nil
-          when :optional
+          when :optional then
             typed_default_value
           end
 
@@ -77,11 +77,11 @@ module Protobuf
       def initialized?(message_instance)
         value = message_instance.__send__(@name)
         case @rule
-        when :required
+        when :required then
           ! value.nil? && (! kind_of?(MessageField) || value.initialized?)
-        when :repeated
+        when :repeated then
           value.all? {|msg| ! kind_of?(MessageField) || msg.initialized? }
-        when :optional
+        when :optional then
           value.nil? || ! kind_of?(MessageField) || value.initialized?
         end
       end
@@ -625,11 +625,11 @@ module Protobuf
         @message_class.class_eval do
           define_method("#{field.name}=") do |val|
             case val
-            when nil
+            when nil then
               @values.delete(field.name)
-            when Hash
+            when Hash then
               @values[field.name] = field.type.new(val)
-            when field.type
+            when field.type then
               @values[field.name] = val
             else
               raise TypeError, "Expected value of type '#{field.type}', but got '#{val.class}'"
@@ -647,9 +647,9 @@ module Protobuf
     class EnumField < VarintField
       def acceptable?(val)
         case val
-        when Symbol
+        when Symbol then
           raise TypeError unless @type.const_defined?(val)
-        when EnumValue
+        when EnumValue then
           raise TypeError if val.parent_class != @type
         else
           raise TypeError unless @type.valid_tag?(val)
@@ -680,11 +680,11 @@ module Protobuf
             else
               val = \
                 case val
-                when Symbol
+                when Symbol then
                   field.type.const_get(val) rescue nil
-                when Integer
+                when Integer then
                   field.type.const_get(field.type.name_by_value(val)) rescue nil
-                when EnumValue
+                when EnumValue then
                   raise TypeError, "Invalid value: #{val.inspect}" if val.parent_class != field.type
                   val
                 end

data/lib/protobuf/message/message.rb

@@ -213,13 +213,13 @@ module Protobuf
             ''
           else
             case field
-            when Field::MessageField
+            when Field::MessageField then
               if value.nil?
                 "#{i}#{field.name} {}\n"
               else
                 "#{i}#{field.name} {\n#{value.inspect(indent + 1)}#{i}}\n"
               end
-            when Field::EnumField
+            when Field::EnumField then
               if value.is_a?(EnumValue)
                 "#{i}#{field.name}: #{value.name}\n"
               else
@@ -368,9 +368,9 @@ module Protobuf
       build_value = lambda {|field, value|
         if !field.optional? || (field.optional? && has_field?(field.name))
           case field
-          when Field::MessageField
+          when Field::MessageField then
             value.to_hash
-          when Field::EnumField
+          when Field::EnumField then
             if value.is_a?(EnumValue)
               value.to_i
             elsif value.is_a?(Symbol)

data/lib/protobuf/rpc/client.rb

@@ -1,16 +1,16 @@
-require 'eventmachine'
+require 'forwardable'
 require 'protobuf/common/logger'
-require 'protobuf/rpc/client_connection'
-require 'protobuf/rpc/buffer'
 require 'protobuf/rpc/error'
-require 'timeout'
+require 'protobuf/rpc/connector'
 
 module Protobuf
   module Rpc
     class Client
+      extend Forwardable
       include Protobuf::Logger::LogMethods
       
-      attr_reader :error, :options, :do_block
+      delegate [:options, :success_cb, :failure_cb, :async?] => :@connector
+      attr_reader :connector
       
       # Create a new client with default options (defined in ClientConnection)
       # See Service#client for a more convenient way to create a client, as well
@@ -25,83 +25,68 @@ module Protobuf
       #     :request => request
       #   })
       #
-      def initialize options={}
-        raise "Invalid client configuration. Service must be defined." if !options[:service] || options[:service].nil?
-        @error = {}
-        @options = ClientConnection::DEFAULT_OPTIONS.merge(options)
-        @success_callback = nil
-        @failure_callback = nil
-        @do_block = !@options[:async]
-        log_debug '[client] Initialized with options: %s' % @options.inspect
+      def initialize opts={}
+        raise "Invalid client configuration. Service must be defined." if !opts[:service] || opts[:service].nil?
+        @connector = Connector.connector_for_platform.new(opts)
+        log_debug '[client] Initialized with options: %s' % opts.inspect
       end
       
       # Set a success callback on the client to return the
       # successful response from the service when it is returned.
-      # If this callback is called, failure_callback will NOT be called.
+      # If this callback is called, failure_cb will NOT be called.
       # Callback is called regardless of :async setting.
       # 
-      #   Client(:service => WidgetService).new.find do |c|
-      #     c.on_success {|res| ... }
-      #   end
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_success {|res| ... }
       # 
-      def on_success &success_callback
-        @success_callback = success_callback
+      def on_success &success_cb
+        @connector.success_cb = success_cb
       end
       
       # Set a failure callback on the client to return the
       # error returned by the service, if any. If this callback
-      # is called, success_callback will NOT be called.
+      # is called, success_cb will NOT be called.
       # Callback is called regardless of :async setting.
       # 
-      #   Client(:service => WidgetService).new.find do |c|
-      #     c.on_failure {|err| ... }
-      #   end
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_failure {|err| ... }
       # 
-      def on_failure &failure_callback
-        @failure_callback = failure_callback
+      def on_failure &failure_cb
+        @connector.failure_cb = failure_cb
       end
       
       # Provides a mechanism to call the service method against the client
-      # and will automatically setup the service_class and method_name
+      # which will automatically setup the service_class and method_name
       # in the wrapper protobuf request.
       #
-      #   # find is not defined by Client which will trigger method_missing
-      #   Client(:service => WidgetService).new.find
+      #   # The :find method is not defined by Client which will trigger method_missing
+      #   Client.new(:service => WidgetService).find do |c|
+      #     # This block will be invoked before the request is made
+      #     # `c` in this case is the client object you created above
+      #     c.on_success {|res| ... }
+      #     c.on_failure {|err| ... }
+      #   end
       # 
-      def method_missing method, *params, &client_callback
-        service = @options[:service]
+      def method_missing method, *params
+        service = options[:service]
         unless service.rpcs[service].keys.include?(method)
           log_error '[client] %s#%s not rpc method, passing to super' % [service.name, method.to_s]
           super method, *params
         else
           log_debug '[client] %s#%s' % [service.name, method.to_s]
           rpc = service.rpcs[service][method.to_sym]
-          @options[:request_type] = rpc.request_type
-          log_debug '[client] Request Type: %s' % @options[:request_type].name
-          @options[:response_type] = rpc.response_type
-          log_debug '[client] Response Type: %s' % @options[:response_type].name
-          @options[:method] = method.to_s
-          @options[:request] = params[0].is_a?(Hash) ? @options[:request_type].new(params[0]) : params[0]
-          log_debug '[client] Request Data: %s' % @options[:request].inspect
+          options[:request_type] = rpc.request_type
+          log_debug '[client] Request Type: %s' % options[:request_type].name
+          options[:response_type] = rpc.response_type
+          log_debug '[client] Response Type: %s' % options[:response_type].name
+          options[:method] = method.to_s
+          options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
+          log_debug '[client] Request Data: %s' % options[:request].inspect
           
-          #### TODO remove first part here once we are able to convert everything to the new event based way of handling success/failure
-          unless client_callback.nil?
-            if client_callback.arity == 2
-              @options[:version] = 1.0
-              log_debug '[client] version = 1.0'
-              
-              log_warn deprecation_warning
-              STDOUT.puts deprecation_warning unless Protobuf::Logger.configured?
-              
-              on_success {|res| client_callback.call(self, res) }
-              on_failure {|err| client_callback.call(self, nil) }
-            else
-              ### TODO Replace block above with this once all client definitions use new event driven approach
-              # Call client to setup on_success and on_failure event callbacks
-              @options[:version] = 2.0
-              log_debug '[client] version = 2.0'
-              client_callback.call(self)
-            end
+          # Call client to setup on_success and on_failure event callbacks
+          if block_given?
+            log_debug '[client] client setup callback given, invoking'
+            yield(self)
           else
             log_debug '[client] no callbacks given'
           end
@@ -134,135 +119,9 @@ module Protobuf
       #   client.send_request
       #
       def send_request
-        Thread.new { EM.run } unless EM.reactor_running?
-        
-        EM.schedule do
-          log_debug '[client] Scheduling client connection to be created on next tick'
-          connection = ClientConnection.connect @options, &ensure_callback
-          connection.on_success &@success_callback unless @success_callback.nil?
-          connection.on_failure &ensure_callback
-          connection.on_complete { @do_block = false } if @do_block
-          log_debug '[client] Connection scheduled'
-        end
-        
-        return synchronize_or_return
-      end
-      
-      # Block the client call to send_request from returning if
-      # async is false, otherwise do nothing.
-      # Simple blocking algorithm to sleep while @do_block is set to true.
-      # The eventmachine connection has a registered callback to flip 
-      # @do_block to false as soon as the response has been received and processed.
-      # If any errors are returned an appropriate RPC_ERROR is sent back to the client
-      # through the failure callback.
-      # 
-      def synchronize_or_return
-        if @do_block
-          begin
-            Timeout.timeout(@options[:timeout]) do
-              sleep 0.5 while @do_block
-              true
-            end
-          rescue => ex
-            log_error 'An exception occurred while waiting for server response:'
-            log_error ex.message
-            log_error ex.backtrace.join("\n")
-          
-            if ex.is_a?(Timeout::Error)
-              message = 'Client timeout of %d seconds expired' % @options[:timeout]
-            else
-              message = 'Client failed: %s' % ex.message
-            end
-          
-            err = ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
-            ensure_callback.call(err)
-          end
-        else
-          true
-        end
-      end
-      
-      # Returns a proc 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.
-      # 
-      # TODO: remove "else" portion below once 1.0 is gone
-      # 
-      def ensure_callback
-        @ensure_callback ||= begin
-          if @options[:version] == 2.0
-            if @failure_callback.nil?
-              cbk = proc do |error|
-                raise '%s: %s' % [error.code.name, error.message]
-              end
-            else
-              cbk = @failure_callback
-            end
-          else
-            cbk = proc do |error|
-              @error = error
-              @failure_callback ? @failure_callback.call(self) : raise('%s: %s' % [error.code.name, error.message])
-            end
-          end
-          cbk
-        end
-      end
-      
-      # Annoying deprecation warning to print if you are still on v1 DSL
-      def deprecation_warning
-        %Q{
-##################################################
-# Deprecation Warning - Upgrade Client Callbacks
-# ==============================================
-# 
-# You are attempting to use two block arguments (presumably client and response)
-# in your client callback for the call to #{@options[:service].name}.client.#{@options[:method]}.
-# 
-# The next version of ruby-protobuf will completely remove the 
-# style of client calls that accepts two arguments in favor of a more explicit evented approach.
-# 
-# You should refactor the code before upgrading to the next version of this gem. An example of callback style v1:
-# 
-#     #{@options[:service]}.client.#{@options[:method]}(request) do |client, response|
-#       if client.failed?
-#         # do something with client.error or client.message
-#       else
-#         # do something with response
-#       end
-#     end
-# 
-# Refactor the previous example of callback style v1 usage to v2 with the following:
-# 
-#     #{@options[:service]}.client.#{@options[:method]}(request) do |c|
-#       c.on_failure do |error|
-#         # do something with error.code or error.message
-#       end
-#       c.on_success do |response|
-#         # do something with response
-#       end
-#     end
-# 
-##################################################
-}
-      end
-      
-      # Controller error/failure methods
-      # TODO remove these when v1 is gone
-      def failed?
-        !@error.nil? and !@error[:code].nil?
-      end
-      def error
-        @error[:message] if failed?
-      end
-      def error_reason
-        Protobuf::Socketrpc::ErrorReason.name_by_value(@error[:code]).to_s if failed?
-      end
-      def error_message
-        "%s: %s" % [error_reason, error] if failed?
+        @connector.send_request
       end
       
     end
   end
-end
+end