ib-ruby 0.4.3 → 0.4.20

data/bin/time_and_sales

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#
+# This script connects to IB API and subscribes to market data for specific symbols.
+# It then prints out all trades that exceed certain size.
+
+require 'pathname'
+LIB_DIR = (Pathname.new(__FILE__).dirname + '../lib/').realpath.to_s
+$LOAD_PATH.unshift LIB_DIR unless $LOAD_PATH.include?(LIB_DIR)
+
+require 'rubygems'
+require 'bundler/setup'
+require 'ib-ruby'
+
+# Define the symbols we're interested in.
+@market = {
+    123 => IB::Symbols::Futures[:gbp],
+    234 => IB::Symbols::Futures[:jpy]
+}
+
+# To determine when the timeout has passed.
+@last_msg_time = Time.now.to_i + 2
+
+# Connect to IB TWS.
+ib = IB::Connection.new
+
+# Subscribe to TWS alerts/errors
+ib.subscribe(:Alert) { |msg| puts msg.to_human }
+
+MIN_SIZE = 0
+
+# This method filters out non-:last type events, and filters out any sale < MIN_SIZE.
+# Note that we have to look the ticker id of each incoming message
+# up in local memory to figure out what it's for.
+# (N.B. The description field is not from IB TWS. It is defined
+#  locally in forex.rb, and is just arbitrary text.)
+def show_sales_and_size(msg)
+  #return if msg.type != :last_price || msg.data[:size] < MIN_SIZE
+  puts @market[msg.data[:id]].description + ": " +
+           (msg.is_a?(IB::Messages::Incoming::TickPrice) ?
+               "#{msg.data[:size]} at #{msg.data[:price]}" : msg.to_human)
+end
+
+def show_size(msg)
+  return if msg.type != :last_size || msg.data[:size] < MIN_SIZE
+end
+
+# Now, subscribe to TickerPrice and TickerSize events.  The code passed in the block
+# will be executed when a message of that type is  received, with the received message
+# as its argument. In this case, we just print out the tick.
+ib.subscribe(:TickPrice, :TickSize, :TickString) { |msg| show_sales_and_size(msg) }
+
+# Now we actually request market data for the symbols we're interested in.
+
+@market.each_pair do |id, contract|
+  ib.send :RequestMarketData, :id => id, :contract => contract
+end
+
+puts "\nSubscribed to TWS market data"
+puts "\n******** Press <Enter> to cancel... *********\n\n"
+gets
+puts "Unsubscribing from TWS market data.."
+
+@market.each_pair { |id, contract| ib.send :CancelMarketData, :id => id }

data/lib/ib-ruby/connection.rb

@@ -0,0 +1,166 @@
+require 'ib-ruby/socket'
+require 'logger'
+
+if RUBY_VERSION < "1.9"
+  require 'sha1'
+else
+  require 'digest/sha1'
+  include Digest
+end
+
+# Add method to_ib to render datetime in IB format (zero padded "yyyymmdd HH:mm:ss")
+class Time
+  def to_ib
+    "#{self.year}#{sprintf("%02d", self.month)}#{sprintf("%02d", self.day)} " +
+        "#{sprintf("%02d", self.hour)}:#{sprintf("%02d", self.min)}:#{sprintf("%02d", self.sec)}"
+  end
+end # Time
+
+module IB
+  # Encapsulates API connection to TWS or Gateway
+  class Connection
+
+    # Please note, we are realizing only the most current TWS protocol versions,
+    # thus improving performance at the expense of backwards compatibility.
+    # Older protocol versions support can be found in older gem versions.
+
+    CLIENT_VERSION = 48 # Was 27 in original Ruby code
+    SERVER_VERSION = 53 # Minimal server version. Latest, was 38 in current Java code.
+    DEFAULT_OPTIONS = {:host =>"127.0.0.1",
+                       :port => '4001', # Gateway, TWS: '7496'
+                       :open => true
+    }
+
+    attr_reader :next_order_id
+
+    def initialize(opts = {})
+      @options = DEFAULT_OPTIONS.merge(opts)
+
+      @connected = false
+      @next_order_id = nil
+      @server = Hash.new # information about server and server connection state
+
+      # Message listeners. Key is the message class to listen for.
+      # Value is an Array of Procs. The proc will be called with the populated message
+      # instance as its argument when a message of that type is received.
+      # TODO: change Array of Procs into a Hash to allow unsubscribing
+      @listeners = Hash.new { |hash, key| hash[key] = Array.new }
+
+      self.open(@options) if @options[:open]
+    end
+
+    def server_version
+      @server[:version]
+    end
+
+    def open(opts = {})
+      raise Exception.new("Already connected!") if @connected
+
+      opts = @options.merge(opts)
+
+      # Subscribe to the NextValidID message from TWS that is always
+      # sent at connect, and save the id.
+      self.subscribe(Messages::Incoming::NextValidID) do |msg|
+        @next_order_id = msg.data[:id]
+        puts "Got next valid order id #{@next_order_id}."
+      end
+
+      @server[:socket] = IBSocket.open(opts[:host], opts[:port])
+
+      # Secret handshake.
+      @server[:socket].send(CLIENT_VERSION)
+      @server[:version] = @server[:socket].read_int
+      @server[:local_connect_time] = Time.now()
+      raise(Exception.new("TWS version >= #{SERVER_VERSION} required.")) if @server[:version] < SERVER_VERSION
+
+      puts "\tGot server version: #{@server[:version]}."
+      #logger.debug("\tGot server version: #{@server[:version]}.")
+
+      # Server version >= 20 sends the server time back. Our min server version is 38
+      @server[:remote_connect_time] = @server[:socket].read_string
+      #logger.debug("\tServer connect time: #{@server[:remote_connect_time]}.")
+
+      # Server wants an arbitrary client ID at this point. This can be used
+      # to identify subsequent communications.
+      @server[:client_id] = SHA1.digest(Time.now.to_s + $$.to_s).unpack("C*").join.to_i % 999999999
+      @server[:socket].send(@server[:client_id])
+      #logger.debug("\tSent client id # #{@server[:client_id]}.")
+
+      #logger.debug("Starting reader thread..")
+      Thread.abort_on_exception = true
+      @server[:reader_thread] = Thread.new { self.reader }
+
+      @connected = true
+    end
+
+    def close
+      @server[:reader_thread].kill # Thread uses blocking I/O, so join is useless.
+      @server[:socket].close()
+      @server = Hash.new
+      @@server_version = nil
+      @connected = false
+      #logger.debug("Disconnected.")
+    end
+
+    def to_s
+      "IB Connector: #{ @connected ? "connected." : "disconnected."}"
+    end
+
+    # Subscribe to incoming message events of type message_class.
+    # code is a Proc that will be called with the message instance as its argument.
+    def subscribe(*args, &block)
+      code = args.last.respond_to?(:call) ? args.pop : block
+
+      raise ArgumentError.new "Need listener proc or block" unless code.is_a? Proc
+
+      args.each do |message_class|
+        if message_class.is_a? Symbol
+          message_class = Messages::Incoming.const_get(message_class)
+        end
+
+        unless message_class < Messages::Incoming::AbstractMessage
+          raise ArgumentError.new "#{message_class} must be an IB message class"
+        end
+
+        @listeners[message_class].push(code)
+      end
+    end
+
+    # Send an outgoing message.
+    def send(message, *args)
+      if message.is_a? Symbol
+        message = Messages::Outgoing.const_get(message).new *args
+      end
+
+      raise Exception.new("only sending Messages::Outgoing") unless message.is_a? Messages::Outgoing::AbstractMessage
+
+      message.send(@server)
+    end
+
+    protected
+
+    def reader
+      loop do
+        # this blocks, so Thread#join is useless.
+        msg_id = @server[:socket].read_int
+
+        # Debug:
+        unless [1, 2, 4, 6, 7, 8, 9, 21, 53].include? msg_id
+          puts "Got message #{msg_id} (#{Messages::Incoming::Table[msg_id]})"
+        end
+
+        # Create a new instance of the appropriate message type, and have it read the message.
+        # NB: Failure here usually means unsupported message type received
+        msg = Messages::Incoming::Table[msg_id].new(@server[:socket], @server[:version])
+
+        if @listeners[msg.class].size > 0
+          @listeners[msg.class].each { |listener| listener.call(msg) }
+        else
+          # Warn if nobody listened to an incoming message.
+          puts " WARNING: Nobody listened to incoming message #{msg.class}"
+        end
+      end # loop
+    end # reader
+  end # class Connection
+  IB = Connection # Legacy alias
+end # module IB

data/lib/ib-ruby/constants.rb

@@ -0,0 +1,91 @@
+module IB
+  ### Widely used TWS constants:
+
+  EOL = "\0"
+
+  #FaMsgTypeName = {1 => "GROUPS",
+  #                 2 => "PROFILES",
+  #                 3 =>"ALIASES"}
+
+  # Enumeration of data types
+  DATA_TYPES = [:trades, :midpoint, :bid, :ask]
+
+  # Enumeration of bar size types for convenience.
+  # Bar sizes less than 30 seconds do not work for some securities.
+  BAR_SIZES = ['1 sec', '5 secs', '15 secs', '30 secs',
+               '1 min', '2 mins', '3 mins', '5 mins',
+               '15 mins', '30 mins', '1 hour', '1 day']
+
+  # Tick types as received in TickPrice and TickSize messages (enumeration)
+  TICK_TYPES = {
+      # int id => :Description #  Corresponding API Event/Function/Method
+      0 => :bid_size, #               tickSize()
+      1 => :bid_price, #              tickPrice()
+      2 => :ask_price, #              tickPrice()
+      3 => :ask_size, #               tickSize()
+      4 => :last_price, #             tickPrice()
+      5 => :last_size, #              tickSize()
+      6 => :high, #                   tickPrice()
+      7 => :low, #                    tickPrice()
+      8 => :volume, #                 tickSize()
+      9 => :close_price, #            tickPrice()
+      10 => :bid_option, #            tickOptionComputation() See Note 1 below
+      11 => :ask_option, #            tickOptionComputation() See => :Note 1 below
+      12 => :last_option, #           tickOptionComputation()  See Note 1 below
+      13 => :model_option, #          tickOptionComputation() See Note 1 below
+      14 => :open_tick, #             tickPrice()
+      15 => :low_13_week, #           tickPrice()
+      16 => :high_13_week, #          tickPrice()
+      17 => :low_26_week, #           tickPrice()
+      18 => :high_26_week, #          tickPrice()
+      19 => :low_52_week, #           tickPrice()
+      20 => :high_52_week, #          tickPrice()
+      21 => :avg_volume, #            tickSize()
+      22 => :open_interest, #         tickSize()
+      23 => :option_historical_vol, # tickGeneric()
+      24 => :option_implied_vol, #    tickGeneric()
+      25 => :option_bid_exch, #   not USED
+      26 => :option_ask_exch, #   not USED
+      27 => :option_call_open_interest, # tickSize()
+      28 => :option_put_open_interest, #  tickSize()
+      29 => :option_call_volume, #        tickSize()
+      30 => :option_put_volume, #         tickSize()
+      31 => :index_future_premium, #      tickGeneric()
+      32 => :bid_exch, #                  tickString()
+      33 => :ask_exch, #                  tickString()
+      34 => :auction_volume, #    not USED
+      35 => :auction_price, #     not USED
+      36 => :auction_imbalance, # not USED
+      37 => :mark_price, #              tickPrice()
+      38 => :bid_efp_computation, #     tickEFP()
+      39 => :ask_efp_computation, #     tickEFP()
+      40 => :last_efp_computation, #    tickEFP()
+      41 => :open_efp_computation, #    tickEFP()
+      42 => :high_efp_computation, #    tickEFP()
+      43 => :low_efp_computation, #     tickEFP()
+      44 => :close_efp_computation, #   tickEFP()
+      45 => :last_timestamp, #          tickString()
+      46 => :shortable, #               tickGeneric()
+      47 => :fundamental_ratios, #      tickString()
+      48 => :rt_volume, #               tickGeneric()
+      49 => :halted, #           see Note 2 below.
+      50 => :bid_yield, #               tickPrice() See Note 3 below
+      51 => :asky_ield, #               tickPrice() See Note 3 below
+      52 => :last_yield, #              tickPrice() See Note 3 below
+      53 => :cust_option_computation, # tickOptionComputation()
+      54 => :trade_count, #             tickGeneric()
+      55 => :trade_rate, #              tickGeneric()
+      56 => :volume_rate, #             tickGeneric()
+      57 => :last_rth_trade, #            ?
+      #   Note 1: Tick types BID_OPTION, ASK_OPTION, LAST_OPTION, and MODEL_OPTION return
+      #           all Greeks (delta, gamma, vega, theta), the underlying price and the
+      #           stock and option reference price when requested.
+      #           MODEL_OPTION also returns model implied volatility.
+      #   Note 2: When trading is halted for a contract, TWS receives a special tick:
+      #           haltedLast=1. When trading is resumed, TWS receives haltedLast=0.
+      #           A tick type, HALTED, tick ID= 49, is now available in regular market
+      #           data via the API to indicate this halted state. Possible values for
+      #           this new tick type are: 0 = Not halted, 1 = Halted.
+      #   Note 3: Applies to bond contracts only.
+  }
+end # module IB