ib-ruby 0.5.0 → 0.5.2

data/HISTORY

@@ -49,3 +49,11 @@
 == 0.5.0 / 2011-10-29
 
 * Rake versioning bug resolved
+
+== 0.5.1 / 2011-10-29
+
+* Connection specs extended
+
+== 0.5.2 / 2011-10-30
+
+* Add nonblocking Connection#process_messages API

data/README.rdoc

@@ -12,7 +12,7 @@ Ruby Implementation of the Interactive Broker' Trader Work Station (TWS) API v.9
 == FEATURES/PROBLEMS:
 
 * This is a BETA release, and should not be used for live trading.
-  Any features contained with are AS-IS and may not work in all conditions
+  Any features contained within are AS-IS and may not work in all conditions
 * This code is not sanctioned or supported by Interactive Brokers
 
 == REQUIREMENTS:
@@ -33,17 +33,17 @@ connections on localhost.
 
 == SYNOPSIS:
 
-First, start up Interactive Broker's Trader Work Station.
+First, start up Interactive Broker's Trader Work Station or Gateway.
 Make sure it is configured to allow API connections on localhost.
 
   >> require 'ib-ruby'
   >> ib = IB::Connection.new
   >> ib.subscribe(:Alert, :AccountValue) { |msg| puts msg.to_human }
-  >> ib.send :RequestAccountData, :subscribe => true
+  >> ib.send_message :RequestAccountData, :subscribe => true
 
-Essentially, all interaction of your code and TWS can be described as an exchange
-of messages. You subscribe to message types you're interested in using
-IB::Connection#subscribe and request data from TWS using IB::Connection#send.
+Essentially, all interaction of your code and TWS can be described as exchange
+of messages. You subscribe to message type(s) you're interested in using
+IB::Connection#subscribe and request data from TWS using IB::Connection#send_message.
 The code blocks (or procs) given to #subscribe will be executed when a message of
 requested type is received, with the received message as its argument.
 

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.2

data/bin/contract_details

@@ -28,10 +28,10 @@ ib.subscribe(IB::Messages::Incoming::Alert) { |msg| puts msg.to_human }
 # message as its argument. In this case, we just print out the data.
 ib.subscribe(:ContractData) { |msg| puts msg.contract.inspect }
 
-# Now we actually request historical data for the symbols we're interested in. TWS will
-# respond with a HistoricalData message, which will be processed by the code above.
+# Now we actually request Contract details for the symbols we're interested in. TWS will
+# respond with ContractData messages, which will be processed by the code above.
 @market.each_pair do |id, contract|
   ib.send_message :RequestContractData, :id => id, :contract => contract
 end
 
-sleep 3 # Wait for IB to respond to our request
+sleep 2 # Wait for IB to respond to our request

data/bin/depth_of_market

@@ -30,9 +30,12 @@ ib.subscribe(:MarketDepth) do |msg|
   puts @market[msg.data[:id]].description + ": " + msg.to_human
 end
 
-# Now we actually request market data for the symbols we're interested in.
+# Now we actually request L2 market data for the symbols we're interested in.
 @market.each_pair do |id, contract|
-  ib.send_message :RequestMarketDepth, :id => id, :contract => contract, :num_rows => 5
+  ib.send_message :RequestMarketDepth,
+                  :id => id,
+                  :contract => contract,
+                  :num_rows => 5
 end
 
 puts "\nSubscribed to market data"
@@ -40,4 +43,4 @@ puts "\n******** Press <Enter> to cancel... *********\n\n"
 gets
 puts "Cancelling market data subscription.."
 
-@market.each_pair { |id, contract| ib.send :CancelMarketDepth, :id => id }
+@market.each_pair { |id, contract| ib.send_message :CancelMarketDepth, :id => id }

data/bin/historic_data

@@ -11,15 +11,14 @@ require 'bundler/setup'
 require 'ib-ruby'
 
 ### Configurable Options
-Quiet = false # if Quiet == false, status data will be printed to STDERR
-Timeout = 10 # How long to wait for messages from TWS before exiting, sec
+QUIET = false # if Quiet == false, status data will be printed to STDERR
 
 # Definition of what we want data for.  We have to keep track of what ticker id
 # corresponds to what symbol ourselves, because the ticks don't include any other
 # identifying information. The choice of ticker ids is, as far as I can tell, arbitrary.
 @market = {123 => IB::Symbols::Stocks[:wfc],
            456 => IB::Symbols::Futures[:ym],
-           789 => IB::Symbols::Forex[:gbpusd] # No historical market data for GBP/CASH@IDEALPRO Last 60
+           789 => IB::Symbols::Forex[:gbpusd] # No historical data for GBP/CASH@IDEALPRO
 }
 
 # Connect to IB TWS.
@@ -28,19 +27,20 @@ ib = IB::Connection.new
 # Subscribe to TWS alerts/errors
 ib.subscribe(:Alert) { |msg| puts msg.to_human }
 
-# Now, subscribe to HistoricalData incoming events.  The code passed in the block
+# Subscribe to HistoricalData incoming 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 data.
 #
 # Note that we have to look the ticker id of each incoming message
 # up in local memory to figure out what it's for.
 ib.subscribe(IB::Messages::Incoming::HistoricalData) do |msg|
-  STDERR.puts @market[msg.data[:id]].description + ": " + msg.data[:count].to_s + " items:" unless Quiet
+  STDERR.puts @market[msg.data[:id]].description + ": " +
+                  msg.data[:count].to_s + " items:" unless QUIET
 
   msg.data[:results].each do |datum|
     @last_msg_time = Time.now.to_i
 
-    STDERR.puts "  " + datum.to_s unless Quiet
+    STDERR.puts "  " + datum.to_s unless QUIET
   end
 end
 
@@ -51,8 +51,8 @@ end
                       :id => id,
                       :contract => contract,
                       :end_date_time => Time.now.to_ib,
-                      :duration => '2 D', # ?
-                      :bar_size => '1 min', #IB::OutgoingMessages::BAR_SIZES.key(:hour),
+                      :duration => '2 D', #    ?
+                      :bar_size => '1 min', #  IB::BAR_SIZES.key(:hour)?
                       :what_to_show => :trades,
                       :use_rth => 1,
                       :format_date => 1)

data/bin/historic_data_cli

@@ -26,8 +26,6 @@ opt = Getopt::Long.getopts(
     ["--header", BOOLEAN],
     ["--dateformat", REQUIRED],
     ["--nonregularhours", BOOLEAN],
-    ["--verbose", BOOLEAN],
-    ["--veryverbose", BOOLEAN]
 )
 
 if opt["help"] || opt["security"].nil? || opt["security"].empty?
@@ -107,12 +105,8 @@ Possible values (from the IB documentation):
 
 --header : if present, prints a 1 line CSV header describing the fields in the CSV.
 
---veryverbose : if present, prints very verbose debugging info.
---verbose : if present, prints all messages received from IB, and print the data in human-readable
-  format.
-
- Otherwise, in the default mode, prints only the historic data (and any errors), and prints the
- data in CSV format.
+ Otherwise, in the default mode, prints only the historic data (and any errors),
+ and prints the data in CSV format.
 
 ENDHELP
 
@@ -171,9 +165,6 @@ REGULAR_HOURS_ONLY = opt["nonregularhours"] ? 0 : 1
 
 DATE_FORMAT = (opt["dateformat"] && opt["dateformat"].to_i) || 1
 
-VERYVERBOSE = !opt["veryverbose"].nil?
-VERBOSE = !opt["verbose"].nil?
-
 #
 # Definition of what we want market data for.  We have to keep track
 # of what ticker id corresponds to what symbol ourselves, because the
@@ -186,16 +177,7 @@ VERBOSE = !opt["verbose"].nil?
 @market = {123 => opt["security"]}
 
 # First, connect to IB TWS.
-ib = IB::IB.new
-
-# Default level is quiet, only warnings printed.
-# IB::IBLogger.level = Logger::Severity::ERROR
-
-# For verbose printing of each message:
-# IB::IBLogger.level = Logger::Severity::INFO if VERBOSE
-
-# For very verbose debug messages:
-# IB::IBLogger.level = Logger::Severity::DEBUG if VERYVERBOSE
+ib = IB::Connection.new
 
 puts "datetime,open,high,low,close,volume,wap,has_gaps" if !opt["header"].nil?
 
@@ -211,43 +193,38 @@ lastMessageTime = Queue.new # for communicating with the reader thread.
 # up in local memory to figure out what security it relates to.
 # The incoming message packet from TWS just identifies it by ticker id.
 #
-ib.subscribe(IB::IncomingMessages::HistoricalData, lambda { |msg|
+ib.subscribe(:HistoricalData) do |msg|
   STDERR.puts @market[msg.data[:req_id]].description + ": " + msg.data[:item_count].to_s("F") + " items:" if VERBOSE
 
-  msg.data[:history].each { |datum|
-    puts(if VERBOSE
-           datum.to_s
-         else
-           "#{datum.date},#{datum.open.to_s("F")},#{datum.high.to_s("F")},#{datum.low.to_s("F")}," +
-               "#{datum.close.to_s("F")},#{datum.volume},#{datum.wap.to_s("F")},#{datum.has_gaps}"
-         end
-    )
-  }
+  msg.data[:results].each do |datum|
+    if VERBOSE
+      puts datum.to_s
+    else
+      puts "#{datum.date},#{datum.open},#{datum.high},#{datum.low}," +
+               "#{datum.close},#{datum.volume},#{datum.wap},#{datum.has_gaps}"
+    end
+  end
   lastMessageTime.push(Time.now)
-})
+end
 
 # Now we actually request historical data for the symbols we're
 # interested in.  TWS will respond with a HistoricalData message,
 # which will be received by the code above.
-
 @market.each_pair { |id, contract|
-  msg = IB::OutgoingMessages::RequestHistoricalData.new({
-                                                            :ticker_id => id,
-                                                            :contract => contract,
-                                                            :end_date_time => END_DATE_TIME,
-                                                            :duration => DURATION, # seconds == 1 hour
-                                                            :bar_size => BAR_SIZE, # 1 minute bars
-                                                            :what_to_show => WHAT,
-                                                            :use_RTH => REGULAR_HOURS_ONLY,
-                                                            :format_date => DATE_FORMAT
-                                                        })
-  ib.send_message(msg)
-}
+  ib.send_message :RequestHistoricalData,
+                  :id => id,
+                  :contract => contract,
+                  :end_date_time => END_DATE_TIME,
+                  :duration => DURATION, # seconds == 1 hour
+                  :bar_size => BAR_SIZE, # 1 minute bars
+                  :what_to_show => WHAT,
+                  :use_RTH => REGULAR_HOURS_ONLY,
+                  :format_date => DATE_FORMAT
 
+}
 
 # A complication here is that IB does not send any indication when all historic data is done being delivered.
 # So we have to guess - when there is no more new data for some period, we interpret that as "end of data" and exit.
-
 while true
   lastTime = lastMessageTime.pop # blocks until a message is ready on the queue
   sleep 2 # .. wait ..

data/bin/market_data

@@ -25,13 +25,8 @@ ib.subscribe(:Alert) { |msg| puts msg.to_human }
 
 # 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.
-#
-# 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.)
+# argument. In this case, we just print out the tick. NB: The description field is not
+# from IB TWS. It is defined locally in forex.rb, and is just arbitrary text.
 ib.subscribe(:TickPrice, :TickSize) do |msg|
   puts @market[msg.data[:id]].description + ": " + msg.to_human
 end

data/bin/time_and_sales

@@ -46,7 +46,6 @@ end
 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_message :RequestMarketData, :id => id, :contract => contract
 end
@@ -56,4 +55,4 @@ 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 }
+@market.each_pair { |id, contract| ib.send_message :CancelMarketData, :id => id }

data/lib/ib-ruby/connection.rb

@@ -20,12 +20,14 @@ module IB
     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
+                       :port => '4001', # IB Gateway connection (default)
+                       #:port => '7496', # TWS connection, with annoying pop-ups
+                       :connect => true,
+                       :reader => true
     }
 
-    attr_reader :next_order_id, # Next valid order id
-                :server #         Info about server and server connection state
+    attr_reader :server, #         Info about IB server and server connection state
+                :next_order_id #  Next valid order id
 
     def initialize(opts = {})
       @options = DEFAULT_OPTIONS.merge(opts)
@@ -34,7 +36,8 @@ module IB
       @next_order_id = nil
       @server = Hash.new
 
-      self.open(@options) if @options[:open]
+      connect if @options[:connect]
+      start_reader if @options[:reader]
     end
 
     # Message subscribers. Key is the message class to listen for.
@@ -45,18 +48,16 @@ module IB
       @subscribers ||= Hash.new { |hash, key| hash[key] = Hash.new }
     end
 
-    def open(opts = {})
+    def connect
       raise Exception.new("Already connected!") if @connected
 
-      opts = @options.merge(opts)
-
       # TWS always sends NextValidID message at connect - save this id
       self.subscribe(: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])
+      @server[:socket] = IBSocket.open(@options[:host], @options[:port])
 
       # Secret handshake
       @server[:socket].send(CLIENT_VERSION)
@@ -70,24 +71,26 @@ module IB
       @server[:client_id] = random_id
       @server[:socket].send(@server[:client_id])
 
-      # Starting reader thread
-      Thread.abort_on_exception = true
-      @server[:reader_thread] = Thread.new { self.reader }
-
       @connected = true
       puts "Connected to server, version: #{@server[:version]}, connection time: " +
                "#{@server[:local_connect_time]} local, " +
                "#{@server[:remote_connect_time]} remote."
     end
 
-    def close
-      @server[:reader_thread].kill # Thread uses blocking I/O, so join is useless.
+    alias open connect # Legacy alias
+
+    def disconnect
+      if @server[:reader]
+        @reader_running = false
+        @server[:reader].join
+      end
       @server[:socket].close
       @server = Hash.new
-      @server[:version] = nil
       @connected = false
     end
 
+    alias close disconnect # Legacy alias
+
     def connected?
       @connected
     end
@@ -117,7 +120,7 @@ module IB
       subscriber_id
     end
 
-    # Remove subscriber(s) with specific subscriber id
+    # Remove all subscribers with specific subscriber id
     def unsubscribe(subscriber_id)
 
       subscribers.each do |message_class, message_subscribers|
@@ -136,38 +139,56 @@ module IB
             when what.is_a?(Symbol)
               Messages::Outgoing.const_get(what).new *args
             else
-              raise ArgumentError.new("Only able to send Messages::Outgoing")
+              raise ArgumentError.new "Only able to send outgoing IB messages"
           end
       message.send_to(@server)
     end
 
-    protected
+    alias dispatch send_message # Legacy alias
 
-    def random_id
-      rand 999999999
+    # Process incoming messages during *poll_time* (200) msecs (nonblocking)
+    def process_messages poll_time = 200 # in msec
+      time_out = Time.now + poll_time/1000.0
+      while (time_left = time_out - Time.now) > 0
+        # If server socket is readable, process single incoming message
+        process_message if select [@server[:socket]], nil, nil, time_left
+      end
     end
 
-    def reader
-      loop do
-        # This read blocks, so Thread#join is useless.
-        msg_id = @server[:socket].read_int
+    # Process single incoming message (blocking)
+    def process_message
+      # This read blocks!
+      msg_id = @server[:socket].read_int
+
+      # Debug:
+      unless [1, 2, 4, 6, 7, 8, 9, 12, 21, 53].include? msg_id
+        puts "Got message #{msg_id} (#{Messages::Incoming::Table[msg_id]})"
+      end
 
-        # 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 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])
 
-        # Create 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])
+      subscribers[msg.class].each { |_, subscriber| subscriber.call(msg) }
+      puts "No subscribers for message #{msg.class}!" if subscribers[msg.class].empty?
+    end
 
-        subscribers[msg.class].each { |_, subscriber| subscriber.call(msg) }
-        puts "No subscribers for incoming message #{msg.class}!" if subscribers[msg.class].empty?
-      end # loop
-    end # reader
+    protected
 
-  end
+    def random_id
+      rand 999999999
+    end
 
-  # class Connection
+    # Start reader thread that continuously reads messages from server in background.
+    # If you don't start reader, you should manually poll @server[:socket] for messages
+    # or use #process_messages(msec) API.
+    def start_reader
+      Thread.abort_on_exception = true
+      @reader_running = true
+      @server[:reader] = Thread.new { process_messages while @reader_running }
+    end
+
+  end # class Connection
   IB = Connection # Legacy alias
+
 end # module IB