ib-extensions 1.1 → 1.3

data/lib/ib/gateway/order-handling.rb

@@ -11,7 +11,7 @@ The order is identified by local_id and perm_id
 Everything is carried out in a mutex-synchonized environment
 =end
   def update_order_dependent_object order_dependent_object  # :nodoc:
-    account_data  do  | a | 
+   account_data  do  | a |
       order = if order_dependent_object.local_id.present?
                 a.locate_order( :local_id => order_dependent_object.local_id)
               else
@@ -21,7 +21,7 @@ Everything is carried out in a mutex-synchonized environment
     end
   end
   def initialize_order_handling
-    tws.subscribe( :CommissionReport, :ExecutionData, :OrderStatus, :OpenOrder, :OpenOrderEnd, :NextValidId ) do |msg| 
+    tws.subscribe( :CommissionReport, :ExecutionData, :OrderStatus, :OpenOrder, :OpenOrderEnd, :NextValidId ) do |msg|
       case msg
 
       when IB::Messages::Incoming::CommissionReport
@@ -39,7 +39,6 @@ Everything is carried out in a mutex-synchonized environment
         logger.info {  "Order State not assigned-- #{msg.order_state.to_human} ----------" } if success.nil?
 
       when IB::Messages::Incoming::OpenOrder
-        ## todo --> handling of bags --> no con_id
         account_data(msg.order.account) do | this_account |
           # first update the contracts
           # make open order equal to IB::Spreads (include negativ con_id)
@@ -63,9 +62,9 @@ Everything is carried out in a mutex-synchonized environment
           o.executions << msg.execution
           if msg.execution.cumulative_quantity.to_i == o.total_quantity.abs
             logger.info{ "#{o.account} --> #{o.contract.symbol}: Execution completed" }
-            o.order_states.first_or_create( IB::OrderState.new( perm_id: o.perm_id, local_id: o.local_id,
-
-                                                                status: 'Filled' ), :status )
+            o.order_states.first_or_create( IB::OrderState.new( perm_id: o.perm_id,
+                                                               local_id: o.local_id,
+                                                               status: 'Filled' ), :status )
             # update portfoliovalue
             a = @accounts.detect{ | x | x.account == o.account } #  we are in a mutex controlled environment
             pv = a.portfolio_values.detect{ | y | y.contract.con_id == o.contract.con_id}
@@ -86,23 +85,38 @@ Everything is carried out in a mutex-synchonized environment
     end # do
   end # def subscribe
 
-  # Resets the order-array for each account first.
+  # Resets the order-array for each account.
   # Requests all open (eg. pending)  orders from the tws
   #
-  # Waits until the OpenOrderEnd-Message is recieved
+  # Waits until the OpenOrderEnd-Message is received
 
 
   def request_open_orders
 
-    exit_condition = false
-    subscription = tws.subscribe( :OpenOrderEnd ) { exit_condition = true }
-    account_data{| account | account.orders = [] }
+    q =  Queue.new
+    subscription = tws.subscribe( :OpenOrderEnd ) { q.push(true) }  # signal succsess
+    account_data {| account | account.orders = [] }
     send_message :RequestAllOpenOrders
-    i=0; loop{ i+=1; sleep 0.01;  break if i > 1000 || exit_condition }
+    ## the OpenOrderEnd-message usually appears after 0.1 sec.
+    ## we wait for 1 sec.
+    th =  Thread.new{   sleep 1 ; q.close  }
+
+    q.pop # wait for OpenOrderEnd or finishing of thread
+
     tws.unsubscribe subscription
+    if q.closed?
+      5.times do
+      logger.fatal { "Is the API in read-only modus?  No Open Order Message received! "}
+      sleep  0.2
+      end
+    else
+      Thread.kill(th)
+      q.close
+      account_data {| account | account.orders } # reset order array
+    end
   end
 
-  alias update_orders request_open_orders 
+  alias update_orders request_open_orders
 
 
 
@@ -116,17 +130,35 @@ end # module
 module IB
 
   class Order
+    # Auto Adjust implements a simple algotithm to ensure that an order is accepted
+    #
+    # It reads `contract_detail.min_tick`. 
+    #
+    # If min_tick < 0.01, the real tick-increments differ fron the min_tick_value
+    #
+    # For J36 (jardines) min tick is 0.001, but the minimal increment is 0.005
+    # For Tui1 its the samme, min_tick is 0.00001 , minimal increment ist 0.00005
+    #
+    # Thus, for min-tick smaller then 0.01, the value is rounded to the next higer digit.
+    # 
+    # | min-tick     |  round     |
+    # |--------------|------------|
+    # |   10         |   110      |
+    # |    1         |   111      |
+    # |    0.1       |   111.1    |
+    # |    0.001     |   111.11   |
+    # |    0.0001    |   111.11   |
+    # |    0.00001   |   111.111  |
+    # |--------------|------------|
+    #
     def auto_adjust
       # lambda to perform the calculation
       adjust_price = ->(a,b) do
-        a = BigDecimal( a, 5 ) 
-        b = BigDecimal( b, 5 ) 
-        _,o = a.divmod(b)
-        a - o
+        count = -Math.log10(b).round.to_i
+        count = count -1 if count > 2
+        a.round count
+
       end
-      # adjust_price[2.6896, 0.1].to_f     => 2.6
-      # adjust_price[2.0896, 0.05].to_f    => 2.05
-      # adjust_price[2.0896, 0.002].to_f   => 2.088
 
 
       error "No Contract provided to Auto adjust" unless contract.is_a? IB::Contract
@@ -134,11 +166,11 @@ module IB
       unless contract.is_a? IB::Bag
         # ensure that contract_details are present
 
-        the_details = contract.contract_detail.present? ? contract.contract_detail : contract.verify.first.contract_detail
-          # there are two attributes to consider: limit_price and aux_price
-          # limit_price +  aux_price may be nil or an empty string. Then ".to_f.zero?" becomes true 
-          self.limit_price= adjust_price.call(limit_price.to_f, the_details.min_tick) unless limit_price.to_f.zero?
-          self.aux_price= adjust_price.call(aux_price.to_f, the_details.min_tick) unless aux_price.to_f.zero?
+        min_tick = contract.verify.first.contract_detail.min_tick
+        # there are two attributes to consider: limit_price and aux_price
+        # limit_price +  aux_price may be nil or an empty string. Then ".to_f.zero?" becomes true 
+        self.limit_price= adjust_price.call(limit_price.to_f, min_tick) unless limit_price.to_f.zero?
+        self.aux_price= adjust_price.call(aux_price.to_f, min_tick) unless aux_price.to_f.zero?
       end
     end
   end  # class Order

data/lib/ib/gateway.rb

@@ -113,7 +113,7 @@ IB::Gateway.new  serial_array: true (, ...)
 			@connection_parameter = { received: serial_array, port: port, host: host, connect: false, logger: logger, client_id: client_id }
 
 			@account_lock = Mutex.new
-			@watchlists = watchlists
+      @watchlists = watchlists.map{ |b| IB::Symbols.allocate_collection b }
 			@gateway_parameter = { s_m_a: subscribe_managed_accounts,
 													s_a: subscribe_alerts,
 													s_o_m: subscribe_order_messages,
@@ -133,7 +133,7 @@ IB::Gateway.new  serial_array: true (, ...)
 				begin
 					i+=1
 					if connect(100)  # tries to connect for about 2h
-						get_account_data(watchlists: watchlists.map{|b| IB::Symbols.allocate_collection b})  if get_account_data
+						get_account_data()
 						#    request_open_orders() if request_open_orders || get_account_data
 					else
 						@accounts = []   # definitivley reset @accounts
@@ -156,6 +156,10 @@ IB::Gateway.new  serial_array: true (, ...)
 		def active_watchlists
 			@watchlists
 		end
+    def add_watchlist watchlist
+     new_watchlist = IB::Symbols.allocate_collection( watchlist ) 
+     @watchlists <<  new_watchlist unless @watchlists.include?( new_watchlist )
+    end
 
 		def get_host
 			"#{@connection_parameter[:host]}: #{@connection_parameter[:port] }"
@@ -196,28 +200,21 @@ Weiterhin meldet sich die Anwendung zur Auswertung von Messages der TWS an.
 					return false
 				end
 			rescue Errno::EHOSTUNREACH => e
-				logger.error 'Cannot connect to specified host'
-				logger.error  e
+				error "Cannot connect to specified host  #{e}", :reader, true
 				return false
 			rescue SocketError => e
-				logger.error 'Wrong Adress, connection not possible'
+				error 'Wrong Adress, connection not possible', :reader, true
 				return false
+      rescue IB::Error => e
+        logger.info e
 			end
 
-			tws.start_reader
-			# let NextValidId-Event appear
-			(1..30).each do |r|
-				break if tws.next_local_id.present?
-				sleep 0.1
-				if r == 30
-					error "Connected, NextLocalId is not initialized. Repeat with another client_id"
-				end
-			end
 			# initialize @accounts (incl. aliases)
 			tws.send_message( :RequestFA, fa_data_type: 3) if fa?
 			logger.debug { "Communications successfully established" }
       # update open orders
       request_open_orders if @gateway_parameter[:s_o_m] || @gateway_parameter[:g_a_d]
+      true #  return gatway object
 		end	# def
 
 
@@ -227,7 +224,7 @@ Weiterhin meldet sich die Anwendung zur Auswertung von Messages der TWS an.
 		def reconnect
 			if tws.present?
 				disconnect
-				sleep 1
+        sleep 0.1
 			end
 			logger.info "trying to reconnect ..."
 			connect
@@ -312,13 +309,28 @@ account_data provides a thread-safe access to linked content of accounts
 It returns an Array of the return-values of the block
 
 If called without a parameter, all clients are accessed
+
+Example
+
+```
+g = IB::Gateway.current
+# thread safe access
+g.account_data &:portfolio_values
+
+g.account_data &:account_values
+
+# primitive access
+g.clients.map &:portfolio_values
+g.clients.map &:account_values
+
+```
 =end
 
 		def account_data account_or_id=nil
 
 			safe = ->(account) do
 				@account_lock.synchronize do
-					yield account 
+          yield account
 				end
 			end
 
@@ -349,10 +361,9 @@ If called without a parameter, all clients are accessed
 			## a possible response is best defined before the connect-attempt is done
 			# ##  Attention
 			# ##  @accounts are not initialized yet (empty array)
-			if block_given?
-				yield  self
+      yield  self if block_given?
+
 
-			end
 		end
 
 =begin
@@ -364,7 +375,7 @@ Its always active.
 		def initialize_managed_accounts
 			rec_id = tws.subscribe( :ReceiveFA )  do |msg|
 				msg.accounts.each do |a|
-					account_data( a.account  ){| the_account | the_account.update_attribute :alias, a.alias } unless a.alias.blank?
+					account_data( a.account ){| the_account | the_account.update_attribute :alias, a.alias } unless a.alias.blank?
 				end
 				logger.info { "Accounts initialized \n #{@accounts.map( &:to_human  ).join " \n " }" }
 			end
@@ -407,25 +418,28 @@ Its always active.
 		#   => 0.00066005
 		#
 		def check_connection
-			answer = nil; count=0
-			z= tws.subscribe( :CurrentTime ) { answer = true }
-			while (answer.nil?)
+      q =  Queue.new 
+      count = 0
+      result = nil
+      z= tws.subscribe( :CurrentTime ) { q.push true }
+			loop do
 				begin
 					tws.send_message(:RequestCurrentTime)												# 10 ms  ##
-					i=0; loop{ break if answer || i > 40; i+=1; sleep 0.0001}
+          th = Thread.new{ sleep 1 ; q.push nil }
+          result =  q.pop 
+          count+=1
+          break if result || count > 10
 				rescue IOError, Errno::ECONNREFUSED   # connection lost
-					count = 6
+					count +=1 
+          retry
 				rescue IB::Error # not connected
 					reconnect 
-					count +=1
-					sleep 1
-					retry if count <= 5
+					count = 0
+					retry
 				end
-				count +=1
-				break if count > 5
 			end
 			tws.unsubscribe z
-			count < 5  && answer #  return value
+			result #  return value
 		end
 	private
 

data/lib/ib/market-price.rb

@@ -21,114 +21,125 @@ module IB
 # 
 # If last_price is received, its returned. 
 # If not, midpoint (bid+ask/2) is used. Else the closing price will be returned.
-# 
+#
 # Any  value (even 0.0) which is stored in IB::Contract.misc indicates that the contract is 
 # accepted by `place_order`.
-# 
-# The result can be customized by a provided block.
-# 
-# 	IB::Symbols::Stocks.sie.market_price{ |x| x }
-# 	-> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
-#  
-# 
-#  Raw-data are stored in the _bars_-attribute of IB::Contract 
-#  (volatile, ie. data are not preserved when the Object is copied)
-#  
-#Example:  IB::Stock.new(symbol: :ge).market_price
-# returns the current market-price
 #
-#Example:  IB::Stock.new(symbol: :ge).market_price(thread: true).join 
-# assigns IB::Symbols.sie.misc with the value of the :last (or delayed_last) TickPrice-Message
-# and returns this value, too
-#
-#Raises IB::Error 
-#  if no Marketdata Subscription is present and delayed: false is specified
-#  
-#
-#  Solutions: Catch the Error and retry with delayed: true
-#
-#             if that fails use alternative exchanges  (look to Contract.valid_exchanges)
+# The result can be customized by a provided block.
 #
-			def market_price delayed:  true, thread: false
+#	IB::Symbols::Stocks.sie.market_price{ |x| x }
+#	-> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
+   #
+   #
+   #  Raw-data are stored in the _bars_-attribute of IB::Contract
+   #  (volatile, ie. data are not preserved when the Object is copied)
+   #
+   #Example:  IB::Stock.new(symbol: :ge).market_price
+   # returns the current market-price
+   #
+   #Example:  IB::Stock.new(symbol: :ge).market_price(thread: true).join
+   # assigns IB::Symbols.sie.misc with the value of the :last (or delayed_last) TickPrice-Message
+   # and returns this value, too
+   #
+
+   def market_price delayed:  true, thread: false, no_error: false
 
-				tws=  Connection.current 		 # get the initialized ib-ruby instance
-				the_id , the_price =  nil, nil
-				tickdata =  Hash.new
-				# define requested tick-attributes
-				last, close, bid, ask	 = 	[ [ :delayed_last , :last_price ] , [:delayed_close , :close_price ],
-																[  :delayed_bid , :bid_price ], [  :delayed_ask , :ask_price ]] 
-				request_data_type =  delayed ? :frozen_delayed :  :frozen
+     tws=  Connection.current		 # get the initialized ib-ruby instance
+     the_id , the_price =  nil, nil
+     tickdata =  Hash.new
+     q =  Queue.new
+     # define requested tick-attributes
+     last, close, bid, ask	 =	[ [ :delayed_last , :last_price ] , [:delayed_close , :close_price ],
+                                 [  :delayed_bid , :bid_price ], [  :delayed_ask , :ask_price ]]
+     request_data_type = delayed ? :frozen_delayed :  :frozen
 
-				tws.send_message :RequestMarketDataType, :market_data_type =>  IB::MARKET_DATA_TYPES.rassoc( request_data_type).first
+     # From the tws-documentation (https://interactivebrokers.github.io/tws-api/market_data_type.html)
+     # Beginning in TWS v970, a IBApi.EClient.reqMarketDataType callback of 1 will occur automatically
+     # after invoking reqMktData if the user has live data permissions for the instrument.
+     #
+     # so - even if "delayed" is specified, realtime-data are returned if RT-permissions are present
+     #
 
-				#keep the method-call running until the request finished
-				#and cancel subscriptions to the message handler
-				# method returns the (running) thread
-				th = Thread.new do
- 					finalize, raise_delay_alert = false, false
-					s_id = tws.subscribe(:TickSnapshotEnd){|x| finalize = true if x.ticker_id == the_id }
+     # method returns the (running) thread
+     th = Thread.new do
+       # about 11 sec after the request, the TWS returns :TickSnapshotEnd if no ticks are transmitted
+       # we don't have to implement out own timeout-criteria
+       s_id = tws.subscribe(:TickSnapshotEnd){|x| q.push(true) if x.ticker_id == the_id }
+       a_id = tws.subscribe(:Alert){|x| q.push(x) if [200, 354, 10167, 10168].include?( x.code )  && x.error_id == the_id }
+       # TWS Error 354: Requested market data is not subscribed.
+       #					r_id = tws.subscribe(:TickRequestParameters) {|x| } # raise_snapshot_alert =  true  if x.snapshot_permissions.to_i.zero?  && x.ticker_id == the_id  }
 
-				e_id = tws.subscribe(:Alert){|x| raise_delay_alert = true if x.code == 354 && x.error_id == the_id } 
-					# TWS Error 354: Requested market data is not subscribed.
-#					r_id = tws.subscribe(:TickRequestParameters) {|x| } # raise_snapshot_alert =  true  if x.snapshot_permissions.to_i.zero?  && x.ticker_id == the_id  }
-								 
-					# subscribe to TickPrices
-					sub_id = tws.subscribe(:TickPrice ) do |msg| #, :TickSize,  :TickGeneric, :TickOption) do |msg|
-						[last,close,bid,ask].each do |x| 
-							tickdata[x] = msg.the_data[:price] if x.include?( IB::TICK_TYPES[ msg.the_data[:tick_type]]) 
-							#  fast exit condition
-							finalize = true if tickdata.size >= 4  || ( tickdata[bid].present? && tickdata[ask].present? )  
-						end if  msg.ticker_id == the_id 
-					end
-					# initialize »the_id« that is used to identify the received tick messages
-					# by firing the market data request
-					the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true 
+       # subscribe to TickPrices
+       sub_id = tws.subscribe(:TickPrice ) do |msg| #, :TickSize,  :TickGeneric, :TickOption) do |msg|
+         [last,close,bid,ask].each do |x|
+           tickdata[x] = msg.the_data[:price] if x.include?( IB::TICK_TYPES[ msg.the_data[:tick_type]])
+           #  fast exit condition
+           q.push(true) if tickdata.size >= 4
+         end if  msg.ticker_id == the_id
+       end
+       # initialize »the_id« that is used to identify the received tick messages
+       # by firing the market data request
+       the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
 
-					# todo implement config-feature to set timeout in configuration   (DRY-Feature)
-					# Alternative zu Timeout
-					# Thread.new do 
-					#     i=0; loop{ i+=1; sleep 0.1; break if finalize || i > 1000 }
+       while !q.closed? do
+         result = q.pop
+         if result.is_a? IB::Messages::Incoming::Alert
+           tws.logger.debug result.message
+           case result.code
+           when 200
+             q.close
+             error "#{to_human} --> #{result.message}"   unless no_error
+           when 354, #   not subscribed to market data
+             10167,
+             10168
+             if delayed && !(result.message =~ /market data is not available/)
+               tws.logger.debug  "#{to_human} --> requesting delayed data"
+               tws.send_message :RequestMarketDataType, :market_data_type => 3
+               self.misc = :delayed
+               sleep 0.1
+               the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
+             else
+               q.close
+               tws.logger.error "#{to_human} --> No marketdata permissions"  unless no_error
+             end
+           end
+         elsif result.present?
+           q.close
+           tz = -> (z){ z.map{|y| y.to_s.split('_')}.flatten.count_duplicates.max_by{|k,v| v}.first.to_sym}
+           data =  tickdata.map{|x,y| [tz[x],y]}.to_h
+           valid_data = ->(d){ !(d.to_i.zero? || d.to_i == -1) }
+           self.bars << data											#  store raw data in bars
+           the_price = if block_given?
+                         yield data
+                         # yields {:bid=>0.10142e3, :ask=>0.10144e3, :last=>0.10142e3, :close=>0.10172e3}
+                       else # behavior if no block is provided
+                         if valid_data[data[:last]]
+                           data[:last]
+                         elsif valid_data[data[:bid]]
+                           (data[:bid]+data[:ask])/2
+                         elsif data[:close].present?
+                           data[:close]
+                         else
+                           nil
+                         end
+                       end
 
-					i=0; 
-					loop{ i+=1; break if i > 1000 || finalize || raise_delay_alert; sleep 0.05 } 
-					tws.unsubscribe sub_id, s_id, e_id 
-					# reduce :close_price delayed_close  to close a.s.o 
-					if raise_delay_alert && !delayed
-						error "No Marketdata Subscription, use delayed data <-- #{to_human}" 
-			#		elsif raise_snapshot_alert
-			#			error "No Snapshot Permissions, try alternative exchange  <-- #{to_human}"
-					elsif i <= 1000
-						tz = -> (z){ z.map{|y| y.to_s.split('_')}.flatten.count_duplicates.max_by{|k,v| v}.first.to_sym}
-						data =  tickdata.map{|x,y| [tz[x],y]}.to_h
-						valid_data = ->(d){ !(d.to_i.zero? || d.to_i == -1) }
-						self.bars << data											#  store raw data in bars
-						the_price = if block_given? 
-													yield data 
-													# yields {:bid=>0.10142e3, :ask=>0.10144e3, :last=>0.10142e3, :close=>0.10172e3}
-												else # behavior if no block is provided
-													if valid_data[data[:last]]
-														data[:last] 
-													elsif valid_data[data[:bid]]
-														(data[:bid]+data[:ask])/2
-													elsif data[:close].present? 
-														data[:close]
-													else
-														nil
-													end
-												end
-						self.misc =  the_price if thread  # store internally if in thread modus
-					else   #  i > 1000
-						tws.logger.info{ "#{to_human} --> No Marketdata received " }
-					end
+           self.misc = misc == :delayed ? { :delayed =>  the_price }  : { realtime: the_price }
+         else
+           q.close
+           error "#{to_human} --> No Marketdata received "
+         end
+       end
 
-				end
-				if thread
-					th		# return thread
-				else
-					th.join
-					the_price	# return 
-				end
-			end #
+       tws.unsubscribe sub_id, s_id, a_id
+     end
+     if thread
+       th	# return thread
+     else
+       th.join
+       the_price	# return
+     end
+   end #
 
  end
 end