ib-extensions 1.2 → 1.3.1

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,36 +21,36 @@ 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 
+#
+#	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 
+   #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
+     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 ]] 
+     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
 
      # From the tws-documentation (https://interactivebrokers.github.io/tws-api/market_data_type.html)
@@ -62,42 +62,42 @@ module IB
 
      # method returns the (running) thread
      th = Thread.new do
-       # about 11 sec after the request, the TES returns :TickSnapshotEnd if no ticks are transmitted
-       # we don't have to implement out ow timeout-criteria
+       # 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 } 
+       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  }
 
        # 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]]) 
+         [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 
+           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 
+       the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
 
        while !q.closed? do
          result = q.pop
          if result.is_a? IB::Messages::Incoming::Alert
-           tws.logger.info result.message
+           tws.logger.debug result.message
            case result.code
-           when 200 
+           when 200
              q.close
              error "#{to_human} --> #{result.message}"   unless no_error
            when 354, #   not subscribed to market data
              10167,
              10168
-             if delayed
-               tws.logger.info  "#{to_human} --> requesting delayed data" 
-               tws.send_message :RequestMarketDataType, :market_data_type => 3 
+             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 
+               the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
              else
                q.close
                tws.logger.error "#{to_human} --> No marketdata permissions"  unless no_error
@@ -109,25 +109,25 @@ module IB
            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 
+           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] 
+                           data[:last]
                          elsif valid_data[data[:bid]]
                            (data[:bid]+data[:ask])/2
-                         elsif data[:close].present? 
+                         elsif data[:close].present?
                            data[:close]
                          else
                            nil
                          end
                        end
 
-           self.misc = misc == :delayed ? { :delayed =>  the_price }  : { realtime: the_price }   
+           self.misc = misc == :delayed ? { :delayed =>  the_price }  : { realtime: the_price }
          else
            q.close
-           error "#{to_human} --> No Marketdata received " 
+           error "#{to_human} --> No Marketdata received "
          end
        end
 
@@ -137,7 +137,7 @@ module IB
        th	# return thread
      else
        th.join
-       the_price	# return 
+       the_price	# return
      end
    end #