my-ib-api 0.0.1

data/lib/ib/flex.rb

@@ -0,0 +1,106 @@
+require 'net/http'
+require 'net/https'
+require 'xmlsimple'
+
+module IB
+
+  # FLEX is a web-based service from IB that helps you to retrieve your activity,
+  # trades and positions. It is working independently from TWS or Gateway, using your
+  # internet connection directly. See /misc/flex for extended FLEX documentation.
+  #
+  # In order to use this service, activate it and configure your token first.
+  # Your Token is located at Account Management->Reports->Delivery Settings->Flex Web Service.
+  # You need to activate Flex Web Service and generate new token(s) there.
+  # Your Flex Query Ids are in Account Management->Reports->Activity->Flex Queries.
+  # Create new Flex query and make sure to set its output format to XML.
+  #
+  # IB::Flex object incapsulates a single pre-defined Flex query.
+  class Flex
+    class << self
+      attr_accessor :token, :uri
+
+      # By default, uri is a well known FLEX Web Service URI
+      def uri
+        #@uri || 'https://www.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest'
+        @uri || 'https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest'
+      end
+    end
+
+    #  Create new Flex query with options:
+    #    :token => 1111111111111111111111111111111111  # CHANGE to your actual token!
+    #    :query_id => 11111                            # CHANGE to actual query id!
+    #    :format => :xml (default) / :csv
+    #    :verbose => true / false (default)
+    def initialize opts
+      @query_id = opts[:query_id]
+      @token = opts[:token] || Flex.token
+      @format = opts[:format] || :xml
+      @verbose = !!opts[:verbose]
+      yield self if block_given?
+    end
+
+    # Run a pre-defined Flex query against IB Flex Web Service
+    # Returns a (parsed) report or raises FlexError in case of problems
+    def run
+      # Initiate FLEX request at a known FLEX Web Service URI
+      resp = get_content Flex.uri, :t => @token, :q => @query_id, :v => 3
+      error("#{resp['ErrorCode']}: #{resp['ErrorMessage']}", :flex) if resp['Status'] == 'Fail'
+
+      reference_code = resp['ReferenceCode']
+      report_uri = resp['Url']
+
+      # Retrieve the FLEX report
+      report = nil
+      until report do
+        report = get_content(report_uri, :t => @token, :q => reference_code, :v => 3,
+                               :text_ok => @format != :xml)
+
+          # If Status is specified, returned xml contains only error message, not actual report
+          if report.is_a?(Hash) && report['Status'] =~ /Fail|Warn/
+            error_code = report['ErrorCode'].to_i
+            error_message = "#{error_code}: #{report['ErrorMessage']}"
+
+            case error_code
+            when 1001..1009, 1018, 1019, 1021
+              # Report is just not ready yet, wait and retry
+              puts error_message if @verbose
+              report = nil
+              sleep 1
+            else # Fatal error
+              error error_message, :flex
+            end
+          end
+      end
+      report
+    end
+
+    # Helper method to get (and parse XML) responses from IB Flex Web Service
+    def get_content address, fields
+      text_ok = fields.delete(:text_ok)
+      resp = get address, fields
+      if resp.content_type == 'text/xml'
+        XmlSimple.xml_in(resp.body, :ForceArray => false)
+      else
+        error("Expected xml, got #{resp.content_type}", :flex) unless text_ok
+        resp.body
+      end
+    end
+
+    # Helper method to get raw responses from IB Flex Web Service
+    def get address, fields
+      uri = URI("#{address}?" + fields.map { |k, v| "#{k}=#{URI.encode(v.to_s)}" }.join('&'))
+
+      server = Net::HTTP.new(uri.host, uri.port)
+      server.use_ssl = (uri.scheme == 'https')
+      server.verify_mode = OpenSSL::SSL::VERIFY_NONE if server.use_ssl? # Avoid OpenSSL failures
+
+      resp = server.start do |http|
+        req = Net::HTTP::Get.new(uri.request_uri)
+        http.request(req)
+      end
+      error("URI responded with #{resp.code}", :flex) unless resp.code.to_i == 200
+      resp
+    end
+
+  end
+end

data/lib/ib/logger.rb

@@ -0,0 +1,25 @@
+require "logger"
+
+# Add default_logger accessor into Object
+def default_logger
+  @default_logger ||= Logger.new(STDOUT).tap do |logger|
+    time_format = RUBY_VERSION =~ /1\.8\./ ? '%H:%M:%S.%N' : '%H:%M:%S.%3N'
+    logger.formatter = proc do |level, time, prog, msg|
+      # "#{time.strftime(time_format)} #{msg}\n"
+      "#{time.strftime('%Y-%m-%d %H:%M:%S')} #{msg}\n"
+      # Hardcoded 20201204 by PA!
+    end
+    logger.level = Logger::INFO
+  end
+end
+
+def default_logger= logger
+  @default_logger = logger
+end
+
+# Add universally accessible log method/accessor into Object
+def log *args
+  default_logger.tap do |logger|
+    logger.fatal *args unless args.empty?
+  end
+end

data/lib/ib/messages.rb

@@ -0,0 +1,88 @@
+module IB
+  module Messages
+  	# This gem supports incoming/outgoing IB messages compatible with the following
+  	# IB client/server versions:
+    CLIENT_VERSION = 59 # 59? Maximal client version implemented
+    SERVER_VERSION = 62 # 38? 53? 62? Minimal server version required
+  end
+end
+
+require 'ib/messages/outgoing'
+require 'ib/messages/incoming'
+
+__END__
+    // Client version history
+    //
+    //  6 = Added parentId to orderStatus
+    //  7 = The new execDetails event returned for an order filled status and reqExecDetails
+    //     Also market depth is available.
+    //  8 = Added lastFillPrice to orderStatus() event and permId to execution details
+    //  9 = Added 'averageCost', 'unrealizedPNL', and 'unrealizedPNL' to updatePortfolio event
+    // 10 = Added 'serverId' to the 'open order' & 'order status' events.
+    //      We send back all the API open orders upon connection.
+    //      Added new methods reqAllOpenOrders, reqAutoOpenOrders()
+    //      Added FA support - reqExecution has filter.
+    //                       - reqAccountUpdates takes acct code.
+    // 11 = Added permId to openOrder event.
+    // 12 = requsting open order attributes ignoreRth, hidden, and discretionary
+    // 13 = added goodAfterTime
+    // 14 = always send size on bid/ask/last tick
+    // 15 = send allocation description string on openOrder
+    // 16 = can receive account name in account and portfolio updates, and fa params in openOrder
+    // 17 = can receive liquidation field in exec reports, and notAutoAvailable field in mkt data
+    // 18 = can receive good till date field in open order messages, and request intraday backfill
+    // 19 = can receive rthOnly flag in ORDER_STATUS
+    // 20 = expects TWS time string on connection after server version >= 20.
+    // 21 = can receive bond contract details.
+    // 22 = can receive price magnifier in version 2 contract details message
+    // 23 = support for scanner
+    // 24 = can receive volatility order parameters in open order messages
+    // 25 = can receive HMDS query start and end times
+    // 26 = can receive option vols in option market data messages
+    // 27 = can receive delta neutral order type and delta neutral aux price in place order version 20: API 8.85
+    // 28 = can receive option model computation ticks: API 8.9
+    // 29 = can receive trail stop limit price in open order and can place them: API 8.91
+    // 30 = can receive extended bond contract def, new ticks, and trade count in bars
+    // 31 = can receive EFP extensions to scanner and market data, and combo legs on open orders
+    //    ; can receive RT bars
+    // 32 = can receive TickType.LAST_TIMESTAMP
+    //    ; can receive "whyHeld" in order status messages
+    // 33 = can receive ScaleNumComponents and ScaleComponentSize is open order messages
+    // 34 = can receive whatIf orders / order state
+    // 35 = can receive contId field for Contract objects
+    // 36 = can receive outsideRth field for Order objects
+    // 37 = can receive clearingAccount and clearingIntent for Order objects
+    // 38 = can receive multiplier and primaryExchange in portfolio updates
+    //    ; can receive cumQty and avgPrice in execution
+    //    ; can receive fundamental data
+    //    ; can receive underComp for Contract objects
+    //    ; can receive reqId and end marker in contractDetails/bondContractDetails
+    //    ; can receive ScaleInitComponentSize and ScaleSubsComponentSize for Order objects
+    // 39 = can receive underConId in contractDetails
+    // 40 = can receive algoStrategy/algoParams in openOrder
+    // 41 = can receive end marker for openOrder
+    //    ; can receive end marker for account download
+    //    ; can receive end marker for executions download
+    // 42 = can receive deltaNeutralValidation
+    // 43 = can receive longName(companyName)
+    //    ; can receive listingExchange
+    //    ; can receive RTVolume tick
+    // 44 = can receive end market for ticker snapshot
+    // 45 = can receive notHeld field in openOrder
+    // 46 = can receive contractMonth, industry, category, subcategory fields in contractDetails
+    //    ; can receive timeZoneId, tradingHours, liquidHours fields in contractDetails
+    // 47 = can receive gamma, vega, theta, undPrice fields in TICK_OPTION_COMPUTATION
+    // 48 = can receive exemptCode in openOrder
+    // 49 = can receive hedgeType and hedgeParam in openOrder
+    // 50 = can receive optOutSmartRouting field in openOrder
+    // 51 = can receive smartComboRoutingParams in openOrder
+    // 52 = can receive deltaNeutralConId, deltaNeutralSettlingFirm, deltaNeutralClearingAccount and deltaNeutralClearingIntent in openOrder
+    // 53 = can receive orderRef in execution
+    // 54 = can receive scale order fields (PriceAdjustValue, PriceAdjustInterval, ProfitOffset, AutoReset,
+    //      InitPosition, InitFillQty and RandomPercent) in openOrder
+    // 55 = can receive orderComboLegs (price) in openOrder
+    // 56 = can receive trailingPercent in openOrder
+    // 57 = can receive commissionReport message
+    // 58 = can receive CUSIP/ISIN/etc. in contractDescription/bondContractDescription
+    // 59 = can receive evRule, evMultiplier in contractDescription/bondContractDescription/executionDetails
+    //      can receive multiplier in executionDetails

data/lib/ib/messages/abstract_message.rb

@@ -0,0 +1,89 @@
+module IB
+  module Messages
+
+    # This is just a basic generic message from the server.
+    #
+    # Class variables:
+    # @message_id - int: message id.
+    # @message_type - Symbol: message type (e.g. :OpenOrderEnd)
+    #
+    # Instance attributes (at least):
+    # @version - int: current version of message format.
+    # @data - Hash of actual data read from a stream.
+    class AbstractMessage
+
+      # Class methods
+      def self.data_map # Map for converting between structured message and raw data
+        @data_map ||= []
+      end
+
+      def self.version # Per class, minimum message version supported
+        @version || 1
+      end
+
+      def self.message_id
+        @message_id
+      end
+
+      # Returns message type Symbol (e.g. :OpenOrderEnd)
+      def self.message_type
+        to_s.split(/::/).last.to_sym
+      end
+
+      def message_id
+        self.class.message_id
+      end
+
+      def message_type
+        self.class.message_type
+      end
+
+      attr_accessor :created_at, :data
+
+      def to_human
+        "<#{self.message_type}:" +
+        @data.map do |key, value|
+          unless [:version].include?(key)
+            " #{key} #{ value.is_a?(Hash) ? value.inspect : value}"
+          end
+        end.compact.join(',') + " >"
+      end
+
+    end # class AbstractMessage
+
+    # Macro that defines short message classes using a one-liner.
+    #   First arg is either a [message_id, version] pair or just message_id (version 1)
+    #   data_map contains instructions for processing @data Hash. Format:
+    #      Incoming messages: [field, type] or [group, field, type]
+    #      Outgoing messages: field, [field, default] or [field, method, [args]]
+    def def_message message_id_version, *data_map, &to_human
+      base = data_map.first.is_a?(Class) ? data_map.shift : self::AbstractMessage
+      message_id, version = message_id_version
+
+      # Define new message class
+      message_class = Class.new(base) do
+        @message_id, @version = message_id, version || 1
+        @data_map = data_map
+
+        @data_map.each do |(name, _, type_args)|
+          # Avoid redefining existing accessor methods
+          unless instance_methods.include?(name.to_s) || instance_methods.include?(name.to_sym)
+            if type_args.is_a?(Symbol) # This is Incoming with [group, field, type]
+              attr_reader name
+            else
+              define_method(name) { @data[name] } 
+            end
+          end
+        end
+
+        define_method(:to_human, &to_human) if to_human
+      end
+
+      # Add defined message class to Classes Hash keyed by its message_id
+      self::Classes[message_id] = message_class
+
+      message_class
+    end
+
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming.rb

@@ -0,0 +1,134 @@
+require 'ib/messages/incoming/abstract_message'
+
+# EClientSocket.java uses sendMax() rather than send() for a number of these.
+# It sends an EOL rather than a number if the value == Integer.MAX_VALUE (or Double.MAX_VALUE).
+# These fields are initialized to this MAX_VALUE.
+# This has been implemented with nils in Ruby to represent the case where an EOL should be sent.
+
+# TODO: Don't instantiate messages, use their classes as just namespace for .encode/decode
+# TODO: realize Message#fire method that raises EWrapper events
+
+module IB
+  module Messages
+
+    # Incoming IB messages (received from TWS/Gateway)
+    module Incoming
+      extend Messages # def_message macros
+
+      ### Define short message classes in-line:
+
+      AccountValue = def_message([6, 2], [:key, :string],
+                                 [:value, :string],
+                                 [:currency, :string],
+                                 [:account_name, :string]) do
+        "<AccountValue: #{account_name}, #{key}=#{value} #{currency}>"
+      end
+
+      AccountUpdateTime = def_message 8, [:time_stamp, :string]
+
+      NewsBulletins =
+          def_message 14, [:request_id, :int], # unique incrementing bulletin ID.
+                      [:type, :int], # Type of bulletin. Valid values include:
+                      #     1 = Regular news bulletin
+                      #     2 = Exchange no longer available for trading
+                      #     3 = Exchange is available for trading
+                      [:text, :string], # The bulletin's message text.
+                      [:exchange, :string] # Exchange from which this message originated.
+
+      ManagedAccounts =
+          def_message 15, [:accounts_list, :string]
+
+      # Receives previously requested FA configuration information from TWS.
+      ReceiveFA =
+          def_message 16, [:type, :int], # type of Financial Advisor configuration data
+                      #                    being received from TWS. Valid values include:
+                      #                    1 = GROUPS, 2 = PROFILE, 3 = ACCOUNT ALIASES
+                      [:xml, :string] # XML string with requested FA configuration information.
+
+      # Receives an XML document that describes the valid parameters that a scanner
+      # subscription can have (for outgoing RequestScannerSubscription message).
+      ScannerParameters = def_message 19, [:xml, :string]
+
+      # Receives the current system time on the server side.
+      CurrentTime = def_message 49, [:time, :int] # long!
+
+      # Receive Reuters global fundamental market data. There must be a subscription to
+      # Reuters Fundamental set up in Account Management before you can receive this data.
+      FundamentalData = def_message 51, [:request_id, :int], [:xml, :string]
+
+      ContractDataEnd = def_message 52, [:request_id, :int]
+
+      OpenOrderEnd = def_message 53
+
+      AccountDownloadEnd = def_message 54, [:account_name, :string]
+
+      ExecutionDataEnd = def_message 55, [:request_id, :int]
+
+      MarketDataType = def_message 58, [:request_id, :int], [:market_data_type, :int]
+
+      CommissionReport =
+          def_message 59, [:exec_id, :string],
+                      [:commission, :decimal], # Commission amount.
+                      [:currency, :string], # Commission currency
+                      [:realized_pnl, :decimal_max],
+                      [:yield, :decimal_max],
+                      [:yield_redemption_date, :int] # YYYYMMDD format
+
+      ### Require standalone source files for more complex message classes:
+
+      require 'ib/messages/incoming/alert'
+      require 'ib/messages/incoming/contract_data'
+      require 'ib/messages/incoming/delta_neutral_validation'
+      require 'ib/messages/incoming/execution_data'
+      require 'ib/messages/incoming/historical_data'
+      require 'ib/messages/incoming/market_depths'
+      require 'ib/messages/incoming/next_valid_id'
+      require 'ib/messages/incoming/open_order'
+      require 'ib/messages/incoming/order_status'
+      require 'ib/messages/incoming/portfolio_value'
+      require 'ib/messages/incoming/real_time_bar'
+      require 'ib/messages/incoming/scanner_data'
+      require 'ib/messages/incoming/ticks'
+
+    end # module Incoming
+  end # module Messages
+end # module IB
+
+
+__END__
+    // incoming msg id's
+    static final int TICK_PRICE		= 1; *
+    static final int TICK_SIZE		= 2; *
+    static final int ORDER_STATUS	= 3; *
+    static final int ERR_MSG		= 4;   *
+    static final int OPEN_ORDER         = 5;  *
+    static final int ACCT_VALUE         = 6;  *
+    static final int PORTFOLIO_VALUE    = 7;  *
+    static final int ACCT_UPDATE_TIME   = 8;  *
+    static final int NEXT_VALID_ID      = 9;  *
+    static final int CONTRACT_DATA      = 10; *
+    static final int EXECUTION_DATA     = 11; ?
+    static final int MARKET_DEPTH     	= 12; *
+    static final int MARKET_DEPTH_L2    = 13; *
+    static final int NEWS_BULLETINS    	= 14; *
+    static final int MANAGED_ACCTS    	= 15; *
+    static final int RECEIVE_FA    	    = 16; *
+    static final int HISTORICAL_DATA    = 17; *
+    static final int BOND_CONTRACT_DATA = 18; *
+    static final int SCANNER_PARAMETERS = 19; *
+    static final int SCANNER_DATA       = 20; *
+    static final int TICK_OPTION_COMPUTATION = 21; *
+    static final int TICK_GENERIC = 45;       *
+    static final int TICK_STRING = 46;        *
+    static final int TICK_EFP = 47;           *
+    static final int CURRENT_TIME = 49;       *
+    static final int REAL_TIME_BARS = 50;     *
+    static final int FUNDAMENTAL_DATA = 51;   *
+    static final int CONTRACT_DATA_END = 52;  *
+    static final int OPEN_ORDER_END = 53;     *
+    static final int ACCT_DOWNLOAD_END = 54;  *
+    static final int EXECUTION_DATA_END = 55; *
+    static final int DELTA_NEUTRAL_VALIDATION = 56; *
+    static final int TICK_SNAPSHOT_END = 57;  *
+    static final int MARKET_DATA_TYPE = 58;   ?
+    static final int COMMISSION_REPORT = 59;  ?

data/lib/ib/messages/incoming/abstract_message.rb

@@ -0,0 +1,99 @@
+require 'ib/messages/abstract_message'
+
+module IB
+  module Messages
+    module Incoming
+
+      # Container for specific message classes, keyed by their message_ids
+      Classes = {}
+
+      class AbstractMessage < IB::Messages::AbstractMessage
+
+        attr_accessor :socket
+
+        def version # Per message, received messages may have the different versions
+          @data[:version]
+        end
+
+        def check_version actual, expected
+          unless actual == expected || expected.is_a?(Array) && expected.include?(actual)
+            error "Unsupported version #{actual} received, expected #{expected}"
+          end
+        end
+
+        # Create incoming message from a given source (IB Socket or data Hash)
+        def initialize source
+          @created_at = Time.now
+          if source.is_a?(Hash)  # Source is a @data Hash
+            @data = source
+          else # Source is a Socket
+            @socket = source
+            @data = Hash.new
+            self.load
+          end
+        end
+
+        # Every message loads received message version first
+        # Override the load method in your subclass to do actual reading into @data.
+        def load
+          if socket
+            @data[:version] = socket.read_int
+
+            check_version @data[:version], self.class.version
+
+            load_map *self.class.data_map
+          else
+            raise "Unable to load, no socket"
+          end
+
+        rescue => e
+          error "Reading #{self.class}: #{e.class}: #{e.message}", :load, e.backtrace
+        end
+
+        # Load @data from the socket according to the given data map.
+        #
+        # map is a series of Arrays in the format of
+        #   [ :name, :type ], [  :group, :name, :type]
+        # type identifiers must have a corresponding read_type method on socket (read_int, etc.).
+        # group is used to lump together aggregates, such as Contract or Order fields
+        def load_map(*map)
+          map.each do |instruction|
+            # We determine the function of the first element
+            head = instruction.first
+            case head
+            when Integer # >= Version condition: [ min_version, [map]]
+              load_map *instruction.drop(1) if version >= head
+
+            when Proc # Callable condition: [ condition, [map]]
+              load_map *instruction.drop(1) if head.call
+
+            when true # Pre-condition already succeeded!
+              load_map *instruction.drop(1)
+
+            when nil, false # Pre-condition already failed! Do nothing...
+
+            when Symbol # Normal map
+              group, name, type, block =
+              if  instruction[2].nil? || instruction[2].is_a?(Proc)
+                [nil] + instruction # No group, [ :name, :type, (:block) ]
+              else
+                instruction # [ :group, :name, :type, (:block)]
+              end
+
+              data = socket.__send__("read_#{type}", &block)
+              if group
+                @data[group] ||= {}
+                @data[group][name] = data
+              else
+                @data[name] = data
+              end
+            else
+              error "Unrecognized instruction #{instruction}"
+            end
+          end
+        end
+
+      end # class AbstractMessage
+    end # module Incoming
+  end # module Messages
+end # module IB