ib-api 972.0

data/lib/ib/socket.rb

@@ -0,0 +1,185 @@
+require 'socket'
+module IBSupport
+  refine  Array do
+    def tws
+      if blank?
+	nil.tws
+      else
+	self.flatten.map( &:tws ).join  # [ "", [] , nil].flatten -> ["", nil]
+					# elemets with empty array's are cut 
+					# this is the desired behavior!
+      end
+    end
+  end
+  refine  Symbol do
+    def tws
+      self.to_s.tws
+    end
+  end
+  refine String do
+    def tws
+      if empty?
+	IB::EOL
+      else
+	self[-1] == IB::EOL ? self : self+IB::EOL
+      end
+    end
+  end
+
+  refine  Numeric do
+    def tws
+      self.to_s.tws
+    end
+  end
+
+  refine TrueClass do
+    def tws
+      1.tws
+    end
+  end
+
+  refine  FalseClass do
+    def tws
+      0.tws
+    end
+  end
+
+  refine NilClass do
+    def tws
+     IB::EOL
+    end
+  end
+end
+module IB
+  # includes methods from IBSupport 
+	# which adds a tws-method to  
+	# - Array
+	# - Symbol
+	# - String
+	# - Numeric
+	# - TrueClass, FalseClass and NilClass
+	# 
+  module PrepareData
+    using IBSupport
+		# First call the method #tws on the data-object
+		#
+		# Then transfom into an Array using the #Pack-Method
+		#
+		# The optional Block introduces a user-defined pattern to pack the data.
+		#
+		# Default is "Na*"
+		def prepare_message data
+			data =  data.tws unless data.is_a?(String) && data[-1]== EOL
+			matrize = [data.size,data]
+			if block_given?	    # A user defined decoding-sequence is accepted via block
+				matrize.pack yield
+			else
+				matrize.pack  "Na*"
+			end
+		end
+
+			# The received package is decoded. The parameter (msg) is an Array
+			#
+			# The protocol is simple: Every Element is treated as Character. 
+			# Exception: The first Element determines the expected length. 
+			#
+			# The decoded raw-message can further modified by the optional block.
+			# 
+			# The default is to instantiate a Hash: message_id becomes the key.
+			# The Hash is returned
+			#
+			# If a block is provided, no Hash is build and the modified raw-message is returned
+		def decode_message msg
+			m = Hash.new
+			while not msg.blank?
+				# the first item is the length
+				size= msg[0..4].unpack("N").first
+				msg =  msg[4..-1]
+				# followed by a sequence of characters
+				message =  msg.unpack("A#{size}").first.split("\0")
+				if block_given?
+					yield message
+				else
+					m[message.shift.to_i] = message
+				end
+				msg =  msg[size..-1]
+			end
+			return m unless block_given?
+		end
+
+	end
+
+  class IBSocket < TCPSocket
+    include PrepareData
+    using IBSupport
+
+    def initialising_handshake
+      v100_prefix = "API".tws.encode 'ascii' 
+      v100_version = self.prepare_message Messages::SERVER_VERSION
+      write_data v100_prefix+v100_version
+    ## start tws-log
+    # [QO] INFO  [JTS-SocketListener-49] - State: HEADER, IsAPI: UNKNOWN
+    # [QO] INFO  [JTS-SocketListener-49] - State: STOP, IsAPI: YES
+    # [QO] INFO  [JTS-SocketListener-49] - ArEServer: Adding 392382055 with id 2147483647
+    # [QO] INFO  [JTS-SocketListener-49] - eServersChanged: 1
+    # [QO] INFO  [JTS-EServerSocket-287] - [2147483647:136:136:1:0:0:0:SYS] Starting new conversation with client on 127.0.0.1
+    # [QO] INFO  [JTS-EServerSocketNotifier-288] - Starting async queue thread
+    # [QO] INFO  [JTS-EServerSocket-287] - [2147483647:136:136:1:0:0:0:SYS] Server version is 136
+    # [QO] INFO  [JTS-EServerSocket-287] - [2147483647:136:136:1:0:0:0:SYS] Client version is 136
+    # [QO] INFO  [JTS-EServerSocket-287] - [2147483647:136:136:1:0:0:0:SYS] is 3rdParty true
+    ## end tws-log
+    end
+
+
+    def read_string
+      string = self.gets(EOL)
+
+      until string
+	# Silently ignores nils
+	string = self.gets(EOL)
+	sleep 0.1
+      end
+
+      string.chomp
+    end
+
+
+    # Sends null terminated data string into socket
+    def write_data data
+      self.syswrite data.tws
+    end
+
+    # send the message (containing several instructions) to the socket,
+    # calls prepare_message to convert data-elements into NULL-terminated strings
+    def send_messages *data
+      self.syswrite prepare_message(data)
+    rescue Errno::ECONNRESET =>  e
+      Connection.logger.error{ "Data not accepted by IB \n
+		    #{data.inspect} \n
+		    Backtrace:\n "}
+      Connection.logger.error   e.backtrace
+    end
+
+    def recieve_messages
+      begin
+	complete_message_buffer = []
+	begin 
+	  # this is the blocking version of recv
+	  buffer =  self.recvfrom(4096)[0]
+	# STDOUT.puts "BUFFER:: #{buffer.inspect}"
+	  complete_message_buffer << buffer
+
+	end while buffer.size == 4096
+	complete_message_buffer.join('')
+      rescue Errno::ECONNRESET =>  e
+	    Connection.logger.error{ "Data Buffer is not filling \n
+		    The Buffer: #{buffer.inspect} \n
+		    Backtrace:\n 
+	 #{e.backtrace.join("\n") } " }
+	Kernel.exit
+      end
+    end
+
+  end # class IBSocket
+
+end # module IB

data/lib/ib/support.rb

@@ -0,0 +1,160 @@
+
+module IBSupport
+	refine Array do
+
+		def zero?
+			false
+		end
+		# Returns the integer. 
+		# retuns nil otherwise or if no element is left on the stack
+		def read_int
+			i= self.shift  rescue nil
+			i = i.to_i unless i.blank?			# this includes conversion of string to zero(0)
+			i.is_a?( Integer ) ?  i : nil
+		end
+
+		def read_float
+			i= self.shift  rescue nil
+			i = i.to_f unless i.blank?
+
+		end
+		def read_decimal
+			i= self.shift  rescue nil
+			i = i.to_d unless i.blank?
+			i.is_a?(Numeric)  && i < IB::TWS_MAX ?  i : nil  # return nil, if a very large number is transmitted
+		end
+
+		alias read_decimal_max read_decimal
+
+		## Values -1 and below indicate: Not computed (TickOptionComputation)
+		def read_decimal_limit_1
+			i= read_decimal
+			i <= -1 ? nil : i
+		end
+
+		## Values -2 and below indicate: Not computed (TickOptionComputation)
+		def read_decimal_limit_2
+			i= read_decimal
+			i <= -2 ? nil : i
+		end
+
+
+		def read_string
+			self.shift rescue ""
+		end
+		## reads a string and proofs if NULL ==  IB::TWS_MAX is present.
+		## in that case: returns nil. otherwise: returns the string
+		def read_string_not_null
+			r = read_string
+			rd = r.to_d  unless r.blank?
+			rd.is_a?(Numeric) && rd >= IB::TWS_MAX ? nil : r
+		end
+
+		def read_symbol
+			read_string.to_sym
+		end
+
+		# convert xml into a hash
+		def read_xml
+			Ox.load( read_string(), mode: :hash_no_attrs)
+		end
+
+
+		def read_int_date
+			t= read_int
+				s= Time.at(t)
+	#			s.year == 1970  --> data is most likely a date-string
+				s.year == 1970 ? Date.parse(t.to_s) : s
+		end
+
+		def read_parse_date
+			Time.parse read_string
+		end
+
+		def read_boolean
+
+			v = self.shift  rescue nil
+			case v
+			when "1"
+				true
+			when "0"
+				false
+			else nil
+			end
+		end
+
+
+		def read_datetime
+			the_string = read_string
+			the_string.blank? ? nil : DateTime.parse(the_string)
+		end
+
+		def read_date
+			the_string = read_string
+			the_string.blank? ? nil : Date.parse(the_string)
+		end
+		#    def read_array
+		#      count = read_int
+		#    end
+
+		## originally provided in socket.rb
+		#    # Returns loaded Array or [] if count was 0#
+		#
+		#    Without providing a Block, the elements are treated as string
+		def read_array hashmode:false,  &block
+			count = read_int
+			case	count 
+			when  0 
+				[]
+			when nil
+				nil
+			else
+				count= count + count if hashmode
+				if block_given?
+					Array.new(count, &block) 
+				else
+					Array.new( count ){ read_string }
+				end
+			end 
+		end
+		#   
+		#  Returns a hash 
+		#  Expected Buffer-Format: 
+		#			count (of Hash-elements)
+		#			count* key|Value
+		#	 Key's are transformed to symbols, values are treated as string
+		def read_hash
+			tags = read_array( hashmode: true )  # { |_| [read_string, read_string] }
+		result =   if 	tags.nil? || tags.flatten.empty?
+								 tags
+							 else
+								 interim = if  tags.size.modulo(2).zero? 
+														 Hash[*tags.flatten]
+													 else 
+														 Hash[*tags[0..-2].flatten]  # omit the last element
+													 end
+								 # symbolize Hash
+								 Hash[interim.map { |k, v| [k.to_sym, v] unless k.nil? }.compact]
+							 end
+		end
+		#
+
+		def read_contract  # read a standard contract and return als hash
+			{	 con_id: read_int,
+				 symbol: read_string,
+				 sec_type: read_string,
+				 expiry: read_string,
+				 strike: read_decimal,
+				 right: read_string,
+				 multiplier: read_int,		
+				 exchange: read_string,
+				 currency: read_string,
+				 local_symbol: read_string,
+				 trading_class: read_string }  # new Version 8
+
+		end
+
+
+		alias read_bool read_boolean
+	end
+end

data/lib/ib/version.rb

@@ -0,0 +1,6 @@
+require 'pathname'
+
+module IB
+  VERSION_FILE = Pathname.new(__FILE__).dirname + '../../VERSION' # :nodoc:
+  VERSION = VERSION_FILE.exist? ? VERSION_FILE.read.strip : nil
+end

data/lib/models/ib/account.rb

@@ -0,0 +1,85 @@
+module IB
+	class Account < IB::Model
+		include BaseProperties
+#		include Redis::Objects
+		#  attr_accessible :alias, :account, :connected
+
+		prop :account,  # String 
+			:alias,     # 
+			:type,
+			:last_updated,
+			:connected => :bool
+
+#		redis_id_field :account
+#		value :my_alias
+#		value :the_account
+#		value :active
+
+
+		validates_format_of :account, :with =>  /\A[D]?[UF]{1}\d{5,8}\z/ , :message => 'should be (X)X00000'
+
+		# in tableless mode the scope is ignored
+
+		has_many :account_values
+		has_many :portfolio_values
+		has_many :contracts
+		has_many :orders
+		has_many :focuses
+
+		def default_attributes
+			super.merge account: 'X000000'
+			super.merge alias: ''
+			super.merge type: 'Account'
+			super.merge connected: false
+		end
+
+		def logger  #nodoc#
+			Connection.logger
+		end
+
+		# Setze Account connect/disconnect und undate!
+		def connect!
+			update_attribute :connected , true
+		end 
+		def disconnect!
+			update_attribute :connected , false
+		end 
+
+		def print_type #nodoc#
+			(test_environment? ? "demo_"  : "") + ( user? ? "user" : "advisor" )
+		end
+
+		def advisor?
+			!!(type =~ /Advisor/ || account =~ /\A[D]?[F]{1}/)
+		end
+
+		def user?
+			!!(type =~ /User/ || account =~ /\A[D]?[U]{1}/)
+		end
+
+		def test_environment?
+			!!(account =~ /^[D]{1}/)
+		end
+
+		def == other
+			super(other) ||
+				other.is_a?(self.class) && account == other.account
+		end 
+
+		def to_human
+			a = if self.alias.present?  && self.alias != account
+						" alias: "+ self.alias
+					else
+						""
+					end
+				"<#{print_type} #{account}#{a}>"
+		end
+
+		def name  #nodoc#
+			self.alias.present? ? self.alias : account
+		end
+
+#		alias :id :account
+end # class
+
+end # module

data/lib/models/ib/account_value.rb

@@ -0,0 +1,33 @@
+module IB
+  # Instantiate with a Hash of attributes, to be auto-set via initialize in Model.
+  class AccountValue < IB::Model
+    include BaseProperties
+
+    belongs_to :account 
+
+    prop  :key,
+	  :value,
+	  :currency
+
+
+    #  comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        key == other.key &&
+        currency == other.currency &&
+        value == other.value 
+    end
+    def default_attributes
+      super.merge key: 'AccountValue',
+	value: 0,
+	currency: 'USD'
+    end
+
+    def to_human
+       "<#{key}=#{value} #{currency}>"
+    end
+
+    alias to_s to_human
+  end # class 
+end # module IB