ib_ruby_proxy 0.0.1

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ib_ruby_proxy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/generate_ruby_classes

@@ -0,0 +1,13 @@
+#!/usr/bin/env jruby
+
+$LOAD_PATH.unshift './lib'
+$LOAD_PATH.unshift File.join(__dir__, '..')
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+
+require 'ib_ruby_proxy'
+require  'server'
+
+client_code_dir = File.join(__dir__, '..', 'lib', 'ib_ruby_proxy', 'client', 'ib')
+server_code_dir = File.join(__dir__, '..', 'lib', 'ib_ruby_proxy', 'server', 'ib')
+IbRubyProxy::Server::IbRubyClassFilesGenerator.new(client_code_dir: client_code_dir, server_code_dir: server_code_dir).generate_all
+

data/bin/ibproxy

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander/import'
+
+$LOAD_PATH.unshift './lib'
+$LOAD_PATH.unshift File.join(__dir__, '..')
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+
+require 'ib_ruby_proxy'
+require 'server'
+
+program :name, 'ibproxy'
+program :version, IbRubyProxy::VERSION
+program :description, 'Invoke Interactive Brokers API from Ruby'
+default_command :server
+
+command :server do |c|
+  c.syntax = 'ibproxy server [options]'
+  c.summary = 'Start ibproxy server'
+  c.option '--ib-port PORT', Integer, "Interactive brokers client port. #{IbRubyProxy::Server::IbProxyService::DEFAULT_IB_GATEWAY_PORT} by default (Gateway). Default for TWS is whatever"
+  c.option '--drb-port PORT', Integer, "Port for the served drb endpoint. #{IbRubyProxy::Server::IbProxyService::DEFAULT_DRB_PORT} by default"
+  c.action do |args, options|
+    options.default ib_port: IbRubyProxy::Server::IbProxyService::DEFAULT_IB_GATEWAY_PORT,
+                    drb_port: IbRubyProxy::Server::IbProxyService::DEFAULT_DRB_PORT
+    ib_port = options.ib_port
+    drb_port = options.drb_port
+    puts "Starting with ib port #{ib_port} and drb port #{drb_port}..."
+    IbRubyProxy::Server::IbProxyService.new(ib_port: ib_port, drb_port: drb_port).start
+  end
+end
+

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/common.rb

@@ -0,0 +1,14 @@
+require 'drb'
+require 'ib_ruby_proxy'
+
+class Securities
+  class << self
+    def emini(expiration_month = '201909')
+      IbRubyProxy::Client::Ib::Contract.new symbol: 'ES',
+                                            sec_type: 'FUT',
+                                            currency: 'USD',
+                                            exchange: 'GLOBEX',
+                                            last_trade_date_or_contract_month: expiration_month
+    end
+  end
+end

data/examples/plain_req_historical_ticks.rb

@@ -0,0 +1,19 @@
+require_relative './common'
+
+client = IbRubyProxy::Client::Client.from_drb
+
+class CallbacksObserver < IbRubyProxy::Client::IbCallbacksObserver
+  def historical_ticks(_request_id, ticks, _done)
+    ap ticks
+  end
+end
+
+aapl = IbRubyProxy::Client::Ib::Contract.new symbol: 'AAPL',
+                                             sec_type: 'STK',
+                                             exchange: 'ISLAND'
+
+client.add_ib_callbacks_observer CallbacksObserver.new
+client.req_historical_ticks(18009, aapl, '20190304 12:00:00', nil, 100,
+                            'MIDPOINT', 1, false, nil)
+
+sleep

data/examples/req_contract_details.rb

@@ -0,0 +1,9 @@
+require_relative './common'
+
+client = IbRubyProxy::Client::Client.from_drb
+
+client.req_contract_details(18009, Securities.emini) do |_callback, _request_id, contract_details|
+  ap contract_details
+end
+
+sleep

data/examples/req_historical_bars_data.rb

@@ -0,0 +1,10 @@
+require_relative './common'
+
+client = IbRubyProxy::Client::Client.from_drb
+
+client.req_historical_data(18009, Securities.emini, '20190304 17:00:01', '1 M', '1 day',
+                           'TRADES', 1, 1, false, nil) do |_callback, _request_id, bar|
+  ap bar
+end
+
+sleep

data/examples/req_historical_ticks.rb

@@ -0,0 +1,10 @@
+require_relative './common'
+
+client = IbRubyProxy::Client::Client.from_drb
+
+client.req_historical_ticks(18009, Securities.emini, nil, '20190304 17:00:00', 100,
+                            'MIDPOINT', 1, false, nil) do |_callback, _request_id, ticks, _done|
+  ap ticks
+end
+
+sleep

data/examples/req_tick_by_tick_data.rb

@@ -0,0 +1,9 @@
+require_relative './common'
+
+client = IbRubyProxy::Client::Client.from_drb
+
+client.req_tick_by_tick_data(18002, Securities.emini, 'Last', 0, false) do |*arguments|
+  ap arguments
+end
+
+sleep

data/ib_ruby_proxy.gemspec

@@ -0,0 +1,43 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ib_ruby_proxy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ib_ruby_proxy'
+  spec.version       = IbRubyProxy::VERSION
+  spec.authors       = ['Jorge Manrubia']
+  spec.email         = ['jorge.manrubia@gmail.com']
+
+  spec.summary       = 'Invoke IB Java API from Ruby'
+  spec.description   = 'Invoke IB Java API from Ruby'
+  spec.homepage      = 'https://github.com/jorgemanrubia/ib_ruby_proxy'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/jorgemanrubia/ib_ruby_proxy'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'awesome_print'
+  spec.add_dependency 'commander'
+  spec.add_dependency 'concurrent-ruby'
+  spec.add_development_dependency 'bundler', '~> 2.0.1'
+  spec.add_development_dependency 'impersonator'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.8.0'
+  spec.add_development_dependency 'rspec_junit_formatter'
+end

data/lib/ib_ruby_proxy.rb

@@ -0,0 +1,35 @@
+require 'ib_ruby_proxy/version'
+require 'awesome_print'
+require 'drb'
+require 'logger'
+require 'concurrent-ruby'
+require 'yaml'
+
+Dir["#{__dir__}/ib_ruby_proxy/util/**/*.rb"].each { |file| require file }
+Dir["#{__dir__}/ib_ruby_proxy/client/**/*.rb"].each { |file| require file }
+
+module IbRubyProxy
+  LOGGER_LEVEL = Logger::DEBUG
+
+  # Gem logger
+  #
+  # @return [Logger]
+  def self.logger
+    @logger ||= Logger.new(STDOUT).tap do |logger|
+      logger.level = LOGGER_LEVEL
+    end
+  end
+
+  # Configuration options parsed from +ib_ruby_proxy/config.yml+
+  #
+  # @return [Hash]
+  def self.config
+    @config ||= begin
+      file_path = File.join(__dir__, 'ib_ruby_proxy/config.yml')
+      YAML.load_file(file_path)
+    end
+  end
+
+  class Error < StandardError
+  end
+end

data/lib/ib_ruby_proxy/client/callbacks_response_handler.rb

@@ -0,0 +1,135 @@
+module IbRubyProxy
+  module Client
+    # This class maps callbacks with method invocations that originated them so that
+    # a block can be passed to the api method and it will be invoked when a callback is
+    # received
+    class CallbacksResponseHandler
+      IB_CALLBACKS_MAPPING = {
+        req_historical_ticks: { callbacks: %i[historical_ticks historical_ticks_bid_ask
+                                              historical_ticks_last],
+                                discriminate_by_argument_nth: 0 },
+        req_contract_details: { callbacks: %i[contract_details contract_details_end],
+                                discriminate_by_argument_nth: 0 },
+        req_tick_by_tick_data: { callbacks: %i[tick_by_tick_bid_ask tick_by_tick_all_last
+                                               tick_by_tick_mid_point],
+                                 discriminate_by_argument_nth: 0 },
+        req_historical_data: { callbacks: %i[historical_data historical_data_end
+                                             historical_data_update],
+                               discriminate_by_argument_nth: 0 }
+      }.freeze
+
+      def initialize
+        @method_handlers = {}
+        @callback_handlers = {}
+      end
+
+      # Handle invoked method
+      #
+      # @param [String, Symbol] method_name
+      # @param [Array<Object>] arguments
+      # @param [Proc] block
+      def method_invoked(method_name, *arguments, &block)
+        method_name = method_name.to_sym
+        method_handlers[method_name]&.method_invoked(*arguments, &block)
+      end
+
+      # Handle callback received: it will invoke the block passed in the corresponding
+      # {#method_invoked}, if any.
+      #
+      # @param [Symbol] callback_name
+      # @param [Array<Object>] arguments
+      def callback_received(callback_name, *arguments)
+        callback_name = callback_name.to_sym
+        callback_handlers[callback_name]&.callback_received(callback_name, *arguments)
+      end
+
+      # @private
+      def self.for_ib
+        new.tap do |handler|
+          IbRubyProxy.config['mapped_callbacks'].each do |method, callback_config|
+            nth_argument = callback_config['discriminate_by_argument_nth']
+            handler.configure_block_callback method: method.to_sym,
+                                             callbacks: callback_config['callbacks'],
+                                             discriminate_by_argument_nth: nth_argument
+          end
+        end
+      end
+
+      # Configures a mapping between a method invocation and a received callback
+      #
+      # @param [String, Symbol] method
+      # @param [String, Symbol] callbacks
+      # @param [Integer, nil] discriminate_by_argument_nth The position of the argument that
+      #   will be used to discriminate received callbacks and match them with invocation methods.
+      #   +nil+ indicates no argument should be used for discriminating (default)
+      def configure_block_callback(method:, callbacks:, discriminate_by_argument_nth: nil)
+        validate_can_add_callback_on_method!(method)
+
+        handler = BlockCallbackHandler.new(discriminate_by_argument_nth)
+
+        configure_callbacks_handler(callbacks, handler)
+        configure_method_handler(method, handler)
+      end
+
+      private
+
+      attr_reader :method_handlers, :callback_handlers
+
+      def configure_method_handler(method, handler)
+        method_handlers[method.to_sym] = handler
+      end
+
+      def configure_callbacks_handler(callbacks, handler)
+        callbacks << :error
+        callbacks.each do |callback_name|
+          callback_handlers[callback_name.to_sym] = handler
+        end
+      end
+
+      def validate_can_add_callback_on_method!(method)
+        raise "Already configured handler for #{method}" if method_handlers[method]
+      end
+
+      # b_proxy_service.rb:13@private
+      class BlockCallbackHandler
+        include IbRubyProxy::Util::HasLogger
+
+        attr_reader :discriminate_by_argument_nth, :block
+
+        def initialize(discriminate_by_argument_nth)
+          @discriminate_by_argument_nth = discriminate_by_argument_nth
+          @blocks_by_discriminator = {}
+        end
+
+        def method_invoked(*arguments, &block)
+          if @discriminate_by_argument_nth
+            discrminator = arguments[@discriminate_by_argument_nth]
+            unless discrminator
+              raise "No argument #{@discriminate_by_argument_nth} to discriminate with?"\
+                    " #{arguments.inspect}"
+            end
+
+            @blocks_by_discriminator[discrminator] = block
+          else
+            @block = block
+          end
+          nil
+        end
+
+        def callback_received(callback_name, *arguments)
+          if callback_name.to_s == 'error'
+            raise StandardError, arguments.join('. ')
+          else
+            block = if @discriminate_by_argument_nth
+                      @blocks_by_discriminator[arguments[@discriminate_by_argument_nth]]
+                    else
+                      @block
+                    end
+
+            block&.call(callback_name, *arguments)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ib_ruby_proxy/client/client.rb

@@ -0,0 +1,69 @@
+require 'drb/timeridconv'
+
+module IbRubyProxy
+  module Client
+    # A client for interacting with the DRb service
+    #
+    # If can be instantiated directly from the DRb service with {.create_drb_ib_client}
+    #
+    # It offers the same interface than a {IbRubyProxy::Server::IbClientAdapter} and, also,
+    # configures a {CallbacksResponseHandler} so that you can use Ruby blocks to capture
+    # callbacks invocations based on the semantics of the invoked methods.
+    #
+    # @see CallbacksResponseHandler
+    class Client
+      attr_reader :ib_client
+
+      # @return [Client]
+      # @param [String] host DRb host +localhost+ by default
+      # @param [Object] port DRb port +1992+ by default
+      def self.from_drb(host: 'localhost', port: 1992)
+        new(create_drb_ib_client(host: host, port: port))
+      end
+
+      # @param [IbRubyProxy::Server::IbClientAdapter] ib_client
+      def initialize(ib_client)
+        @ib_client = ib_client
+        @promises_by_request_id = {}
+        @callbacks_response_handler = CallbacksResponseHandler.for_ib
+        @ib_client.add_ib_callbacks_observer ResponseHandleObserver.new(@callbacks_response_handler)
+      end
+
+      # @private
+      def self.create_drb_ib_client(host:, port:)
+        drb_ib_client = DRbObject.new(nil, "druby://#{host}:#{port}")
+        DRb::DRbServer.verbose = true
+        DRb.install_id_conv ::DRb::TimerIdConv.new 60
+        DRb.start_service
+        drb_ib_client
+      end
+
+      private
+
+      def respond_to_missing?(name, include_private = false)
+        @ib_client.respond_to?(name, include_private)
+      end
+
+      def method_missing(method, *arguments, &block)
+        @ib_client.public_send(method, *arguments, &block)
+        @callbacks_response_handler.method_invoked method, *arguments, &block
+      end
+    end
+
+    # An observer that will delegate callbacks to a {CallbacksResponseHandler}
+    #
+    # @private
+    class ResponseHandleObserver
+      include DRb::DRbUndumped
+
+      def initialize(callbacks_response_handler)
+        @callbacks_response_handler = callbacks_response_handler
+      end
+
+      def update(*params)
+        method, *arguments = params
+        @callbacks_response_handler.callback_received(method, *arguments)
+      end
+    end
+  end
+end