ib_ruby_proxy 0.0.1

data/lib/ib_ruby_proxy/server/ib/tick_attrib_bid_ask.rb

@@ -0,0 +1,15 @@
+# ---------------------------------------------
+# File generated automatically by ib_ruby_proxy
+# ---------------------------------------------
+
+java_import "com.ib.client.TickAttribBidAsk"
+
+class Java::ComIbClient::TickAttribBidAsk
+  def to_ruby
+    ruby_object = IbRubyProxy::Client::Ib::TickAttribBidAsk.new
+    ruby_object.bid_past_low = bidPastLow().to_ruby
+    ruby_object.ask_past_high = askPastHigh().to_ruby
+
+    ruby_object
+  end
+end

data/lib/ib_ruby_proxy/server/ib/tick_attrib_last.rb

@@ -0,0 +1,15 @@
+# ---------------------------------------------
+# File generated automatically by ib_ruby_proxy
+# ---------------------------------------------
+
+java_import "com.ib.client.TickAttribLast"
+
+class Java::ComIbClient::TickAttribLast
+  def to_ruby
+    ruby_object = IbRubyProxy::Client::Ib::TickAttribLast.new
+    ruby_object.past_limit = pastLimit().to_ruby
+    ruby_object.unreported = unreported().to_ruby
+
+    ruby_object
+  end
+end

data/lib/ib_ruby_proxy/server/ib_client_adapter.rb

@@ -0,0 +1,51 @@
+java_import 'com.ib.client.EClient'
+
+module IbRubyProxy
+  module Server
+    # This is the Ruby representation of the IB Java +EClient+ class. It adapts ruby invocations
+    # and arguments to invoke the corresponding Java API methods.
+    #
+    # It is the object DRb clients get when connecting to the {IbProxyService proxy service}.
+    #
+    # Mimicking how the Java API works, it collaborates with an {IbWrapperAdapter} that
+    # corresponds with an +EWrapper+ in the Java world. It works by observing callbacks
+    # in this wrapper.
+    #
+    # The usage of observers as a communication mechanism is because it is supported
+    # by DRb and, being DRb a standard implemented in JRuby, enables communicating Ruby and JRuby.
+    # If supporting other rubies was not required this level of indirection would be unnecessary.
+    class IbClientAdapter
+      extend IbRubyProxy::Util::StringUtils
+
+      attr_reader :ib_client, :ib_wrapper_adapter
+
+      # @param [com.ib.client.EClient] ib_client IB +EClient+ object
+      # @param [IbWrapperAdapter] ib_wrapper_adapter
+      def initialize(ib_client, ib_wrapper_adapter)
+        @ib_client = ib_client
+        @ib_wrapper_adapter = ib_wrapper_adapter
+      end
+
+      # @param [IbRubyProxy::Client::IbCallbacksObserver] ib_callbacks_observer
+      def add_ib_callbacks_observer(ib_callbacks_observer)
+        ib_wrapper_adapter.add_observer(ib_callbacks_observer)
+      end
+
+      # @private
+      def self.define_ruby_method_for(java_method)
+        ruby_method_name = to_underscore(java_method.name)
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ruby_method_name}(*arguments)
+            ib_arguments = arguments.collect(&:to_ib)
+            @ib_client.#{java_method.name} *ib_arguments
+          end
+        RUBY
+      end
+
+      EClient.java_class.declared_instance_methods.each do |java_method|
+        define_ruby_method_for(java_method)
+      end
+    end
+  end
+end

data/lib/ib_ruby_proxy/server/ib_proxy_service.rb

@@ -0,0 +1,85 @@
+require 'ib_ruby_proxy/version'
+require_relative 'ib_wrapper_adapter'
+require_relative 'ib_client_adapter'
+require 'drb'
+
+java_import 'com.ib.client.EClientSocket'
+java_import 'com.ib.client.EJavaSignal'
+java_import 'com.ib.client.EClientSocket'
+java_import 'com.ib.client.EReader'
+
+module IbRubyProxy
+  module Server
+    # Proxy service for invoking IB api through
+    # {https://ruby-doc.org/stdlib-2.6.1/libdoc/drb/rdoc/DRb.html DRb}
+    #
+    # The proxy does essentially 2 things:
+    #
+    # * Starts a DRb process you can connect to invoke the IB api. This will expose an {IbClientAdapter}
+    #   object to its clients
+    # * Starts an IB message-processing thread that will dispatch messages sent to IB client app (
+    #   gateway or TWS)
+    class IbProxyService
+      DEFAULT_IB_GATEWAY_PORT = 4002
+      DEFAULT_DRB_PORT = 1992
+
+      # @param [String] ib_host Hostname for the IB client app (gateway or TWS). Default +localhost+
+      # @param [Integer] ib_port Port for hte IB client app (gateway or TWS). Default +4002+ (gateway)
+      # @param [String] drb_host Hostname for the DRB process. Default +localhost+
+      # @param [Integer] drb_port Port for the . Default +1992+
+      def initialize(ib_host: 'localhost', ib_port: DEFAULT_IB_GATEWAY_PORT,
+                     drb_host: 'localhost', drb_port: DEFAULT_DRB_PORT)
+        @ib_host = ib_host
+        @ib_port = ib_port
+        @drb_host = drb_host
+        @drb_port = drb_port
+
+        @wrapper = IbRubyProxy::Server::IbWrapperAdapter.new
+        @client = wrapper.client
+        @signal = wrapper.signal
+
+        connect
+      end
+
+      # Connects to IB and starts the DRb process
+      #
+      # Clients of the DRb service will get an {IbClientAdapter} object to interact with the IB api
+      # @return [void]
+      def start
+        DRb.start_service("druby://#{drb_host}:#{drb_port}", ib_client_adapter, verbose: true)
+        start_ib_message_processing_thread
+        puts "Ib proxy server started at druby://#{drb_host}:#{drb_port}. Connected to IB at"\
+             " #{ib_host}:#{ib_port}"
+        DRb.thread.join
+      end
+
+      private
+
+      attr_reader :wrapper, :client, :signal, :ib_host, :ib_port, :drb_host, :drb_port
+
+      def start_ib_message_processing_thread
+        reader = EReader.new(client, signal)
+        reader.start
+
+        Thread.new do
+          while client.isConnected
+            signal.waitForSignal
+            begin
+              reader.processMsgs
+            rescue StandardError => e
+              puts "Error while processing ib message: #{e}"
+            end
+          end
+        end
+      end
+
+      def connect
+        client.eConnect(ib_host, ib_port, 2)
+      end
+
+      def ib_client_adapter
+        @ib_client_adapter ||= IbRubyProxy::Server::IbClientAdapter.new(client, wrapper)
+      end
+    end
+  end
+end

data/lib/ib_ruby_proxy/server/ib_ruby_class_files_generator.rb

@@ -0,0 +1,77 @@
+module IbRubyProxy
+  module Server
+    # Source code generator that interacts with {IbRubyClassSourceGenerator} and writes down the
+    # actual files with the source for both Ruby classes representing IB classes and Ruby extensions
+    # for these.
+    class IbRubyClassFilesGenerator
+      attr_reader :client_code_dir, :server_code_dir
+
+      # @param [String] client_code_dir
+      # @param [String] server_code_dir
+      def initialize(client_code_dir:, server_code_dir:)
+        @client_code_dir = client_code_dir
+        @server_code_dir = server_code_dir
+
+        import_ruby_classes
+      end
+
+      # Generate client files and server class extensions
+      #
+      # It will format the generated code with {https://github.com/ruby-formatter/rufo Rufo}.
+      #
+      # @see IbRubyClassSourceGenerator#ruby_class_source
+      # @see IbRubyClassSourceGenerator#ib_class_extension_source
+      def generate_all
+        do_generate_all
+        format_code
+      end
+
+      private
+
+      def import_ruby_classes
+        ruby_classes.each do |class_name|
+          java_import "com.ib.client.#{class_name}"
+        end
+      end
+
+      def ruby_classes
+        @ruby_classes ||= IbRubyProxy.config['classes']
+      end
+
+      def do_generate_all
+        ruby_classes.each do |class_name|
+          generate_files class_name
+        end
+      end
+
+      def generate_files(class_name)
+        ib_class = Java::ComIbClient.const_get(class_name)
+        generator = IbRubyClassSourceGenerator.new(ib_class,
+                                                   namespace: 'IbRubyProxy::Client::Ib')
+
+        file_name = "#{IbRubyProxy::Util::StringUtils.to_underscore(class_name)}.rb"
+        generate_client_file(generator, file_name)
+        generate_server_file(generator, file_name)
+      end
+
+      def generate_client_file(generator, file_name)
+        target_file = File.join(client_code_dir, file_name)
+        puts "Generating client file: #{target_file}..."
+        File.open(target_file, 'w') { |file| file.write(generator.ruby_class_source) }
+      end
+
+      def generate_server_file(generator, file_name)
+        target_file = File.join(server_code_dir, file_name)
+        puts "Generating server file: #{target_file}..."
+        File.open(target_file, 'w') { |file| file.write(generator.ib_class_extension_source) }
+      end
+
+      def format_code
+        [server_code_dir, client_code_dir].each do |dir|
+          puts "Formatting #{dir}..."
+          system "rufo #{dir}"
+        end
+      end
+    end
+  end
+end

data/lib/ib_ruby_proxy/server/ib_ruby_class_source_generator.rb

@@ -0,0 +1,155 @@
+module IbRubyProxy
+  module Server
+    # Given a value object class from Interactive Broker API, this generator can build Ruby source
+    # code for:
+    #
+    # * A ruby class to manipulate the same class in Ruby
+    # * An extension to the original Java class for converting instances into Ruby
+    class IbRubyClassSourceGenerator
+      include IbRubyProxy::Util::StringUtils
+
+      attr_reader :ib_class, :namespace_list
+
+      # @param [Class] ib_class Class from IB broker to mimic in Ruby. It is meant to be used with
+      #   value objects, as only properties are translated. That is the case for classes that
+      #   represent either arguments or returned values (via callbacks) in the API.
+      # @param [String] namespace The namespace to generate the classes in. Default
+      #   +IbRubyProxy::Client::Ib+
+      def initialize(ib_class, namespace: 'IbRubyProxy::Client::Ib')
+        @ib_class = Reflection::IbClass.new(ib_class)
+        @namespace_list = namespace.split('::')
+      end
+
+      # Source for a ruby class translates into Ruby the Java properties of the target
+      # ib class.
+      #
+      # It generates a {Struct} with the list of properties, that admits a keyword-based
+      # constructor, and that includes a +to_ib+ method for converting the ruby back into its
+      # original Java counterpart.
+      #
+      # @return [String]
+      def ruby_class_source
+        <<-RUBY
+        #{header}
+
+        #{generate_ruby_class}
+        RUBY
+      end
+
+      # Source for a ruby class that extends the original IB Java class with a +to_ruby+ method,
+      # to convert Java Ib objects into their Ruby counterparts generated in {#ruby_class_source}
+      #
+      # @return [String]
+      def ib_class_extension_source
+        <<-RUBY
+        #{header}
+
+        #{generate_ib_class_extension}
+        RUBY
+      end
+
+      private
+
+      def header
+        <<-RUBY
+        # ---------------------------------------------
+        # File generated automatically by ib_ruby_proxy
+        # ---------------------------------------------
+        RUBY
+      end
+
+      def generate_ib_class_extension
+        <<-RUBY
+        java_import "com.ib.client.#{ib_class.name}"
+
+        class #{ib_class.full_name}
+          #{generate_to_ruby_method}
+        end
+        RUBY
+      end
+
+      def generate_ruby_class
+        <<-RUBY
+        #{generate_namespace_open}
+
+        #{generate_class_declaration}
+          #{generate_constructor}
+          #{generate_to_ib_method}
+        end
+
+        #{generate_namespace_close}
+        RUBY
+      end
+
+      def generate_namespace_open
+        namespace_list.collect { |namespace| "module #{namespace}" }.join("\n")
+      end
+
+      def generate_namespace_close
+        namespace_list.length.times.collect { 'end' }.join("\n")
+      end
+
+      def generate_class_declaration
+        struct_init_properties = ib_class.ruby_property_names.collect { |property| ":#{property}" }
+                                         .join(', ')
+        struct_init_properties << ', keyword_init: true'
+
+        <<-RUBY
+          #{ib_class.name} = Struct.new(#{struct_init_properties}) do
+        RUBY
+      end
+
+      def generate_constructor
+        constructor_declarations = ib_class.zipped_ruby_and_java_properties
+                                           .collect do |ruby_property, java_field|
+          "#{ruby_property}: #{java_field.default_value_as_string}"
+        end
+
+        assignment_statements = ib_class.ruby_property_names.collect do |ruby_property|
+          <<-RUBY
+        self.#{ruby_property} = #{ruby_property}
+          RUBY
+        end
+        <<-RUBY
+        def initialize(#{constructor_declarations.join(', ')})
+          #{assignment_statements.join('')}
+        end
+        RUBY
+      end
+
+      def generate_to_ib_method
+        property_copy_sentences = ib_class.zipped_ruby_and_java_properties
+                                          .collect do |ruby_property, java_field|
+          <<-RUBY
+          ib_object.#{java_field.name}(#{ruby_property}).to_java
+          RUBY
+        end
+
+        <<-RUBY
+        def to_ib
+          ib_object = #{ib_class.klass.name}.new
+          #{property_copy_sentences.join('')}
+          ib_object
+        end
+        RUBY
+      end
+
+      def generate_to_ruby_method
+        property_copy_sentences = ib_class.zipped_ruby_and_java_properties
+                                          .collect do |ruby_property, java_field|
+          <<-RUBY
+          ruby_object.#{ruby_property} = #{java_field.name}().to_ruby
+          RUBY
+        end
+
+        <<-RUBY
+        def to_ruby
+          ruby_object = #{namespace_list.join('::')}::#{ib_class.name}.new
+          #{property_copy_sentences.join('')}
+          ruby_object
+        end
+        RUBY
+      end
+    end
+  end
+end

data/lib/ib_ruby_proxy/server/ib_wrapper_adapter.rb

@@ -0,0 +1,47 @@
+java_import 'com.ib.client.EWrapper'
+require 'drb/observer'
+
+module IbRubyProxy
+  module Server
+    # Ruby representation of the IB +EWrapper+ class. It delegates received callbacks by
+    # triggering an observer notification. It will translate the name of the java method to
+    # Ruby (underscore), as well as translate the parameters from IB to the Ruby world.
+    #
+    # @see IbClientAdapter
+    class IbWrapperAdapter
+      # include DRb::DRbObservable
+      include EWrapper
+      include DRb::DRbObservable
+      include IbRubyProxy::Util::HasLogger
+      extend IbRubyProxy::Util::StringUtils
+
+      attr_reader :signal, :client
+
+      def initialize
+        @signal = EJavaSignal.new
+        @client = EClientSocket.new(self, @signal)
+      end
+
+      # @private
+      def self.define_ruby_method_for(java_method)
+        ruby_method_name = to_underscore(java_method.name)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{java_method.name}(*arguments)
+            ruby_arguments = arguments.collect(&:to_ruby)
+            if count_observers > 0
+              changed
+              notify_observers *(["#{ruby_method_name}"] + ruby_arguments)
+            else
+              logger.debug "Received #{ruby_method_name}"
+              logger.debug ruby_arguments.inspect
+            end
+          end
+        RUBY
+      end
+
+      EWrapper.java_class.declared_instance_methods.each do |java_method|
+        define_ruby_method_for(java_method)
+      end
+    end
+  end
+end