my-ib-api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 792fc49c490a522dbe2f5bb42ed76c25f72257ad309fad068e2422d7cf7cc320
+  data.tar.gz: c6182a9d72d900a820d0493db2c7f8b8eac9d07c42b826f658d64e47ffa2d5d4
+SHA512:
+  metadata.gz: f96ed40918e1a8ddf63c57618f2b18c84ecfa4ccef23f92aa3073d5bf30dfe4c11b51d962f2eb7e2bbd852b0dbc16f1e4e3441ede1bf4dce5c8cc0ef0da4f966
+  data.tar.gz: 366d962ba84ae4c899d9c0abf897830a2f62d48c9a5a97b14572aba10f9f28d664084db39b95e311c90441a328e8e1c3b41c6e563c4fa7cb0a3eaddfd675c5c8

data/lib/ib-api.rb

@@ -0,0 +1,10 @@
+module IB
+
+end # module IB
+
+IbRuby = IB
+Ib = IB
+
+#puts $LOAD_PATH
+
+require 'ib/requires'

data/lib/ib/base.rb

@@ -0,0 +1,99 @@
+module IB
+
+  # Base class for tableless IB data Models, extends ActiveModel API
+  class Base
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+###    include ActiveModel::Serializers::Xml
+###    include ActiveModel::Serializers::JSON
+
+    define_model_callbacks :initialize
+
+    # If a opts hash is given, keys are taken as attribute names, values as data.
+    # The model instance fields are then set automatically from the opts Hash.
+    def initialize attributes={}, opts={}
+      run_callbacks :initialize do
+        error "Argument must be a Hash", :args unless attributes.is_a?(Hash)
+
+        self.attributes = attributes # set_attribute_defaults is now after_init callback
+      end
+    end
+
+    # ActiveModel API (for serialization)
+
+    def attributes
+      @attributes ||= HashWithIndifferentAccess.new
+    end
+
+    def attributes= attrs
+      attrs.keys.each { |key| self.send("#{key}=", attrs[key]) }
+    end
+
+    # ActiveModel-style read/write_attribute accessors
+    def [] key
+      attributes[key.to_sym]
+    end
+
+    def []= key, val
+      # p key, val
+      attributes[key.to_sym] = val
+    end
+
+    def to_model
+      self
+    end
+
+    def new_record?
+      true
+    end
+
+    def save
+      valid?
+    end
+
+    alias save! save
+
+    ### Noop methods mocking ActiveRecord::Base macros
+
+    def self.attr_protected *args
+    end
+
+    def self.attr_accessible *args
+    end
+
+    ### ActiveRecord::Base association API mocks
+
+    def self.belongs_to model, *args
+      attr_accessor model
+    end
+
+    def self.has_one model, *args
+      attr_accessor model
+    end
+
+    def self.has_many models, *args
+      attr_accessor models
+
+      define_method(models) do
+        self.instance_variable_get("@#{models}") ||
+          self.instance_variable_set("@#{models}", [])
+      end
+    end
+
+    def self.find *args
+      []
+    end
+
+    ### ActiveRecord::Base callback API mocks
+
+    define_model_callbacks :initialize, :only => :after
+
+    ### ActiveRecord::Base misc
+
+    def self.serialize *properties
+    end
+
+  end # Model
+end # module IB

data/lib/ib/base_properties.rb

@@ -0,0 +1,154 @@
+
+require 'active_model'
+#require "active_model_serializers"
+
+require 'active_support/concern'
+require 'active_support/hash_with_indifferent_access'
+
+module IB
+
+  # Module adds prop Macro and
+  module BaseProperties
+    extend ActiveSupport::Concern
+
+    ### Instance methods
+
+    # Default presentation
+    def to_human
+      "<#{self.class.to_s.demodulize}: " + attributes.map do |attr, value|
+        "#{attr}: #{value}" unless value.nil?
+      end.compact.sort.join(' ') + ">"
+    end
+
+    # Comparison support
+    def content_attributes
+      HashWithIndifferentAccess[attributes.reject do |(attr, _)|
+                                  attr.to_s =~ /(_count)\z/ ||
+                                    [:created_at, :updated_at, :type,
+                                     :id, :order_id, :contract_id].include?(attr.to_sym)
+      end]
+    end
+
+    # Update nil attributes from given Hash or model
+    def update_missing attrs
+      attrs = attrs.content_attributes unless attrs.kind_of?(Hash)
+
+      attrs.each { |attr, val| send "#{attr}=", val if send(attr).blank? }
+      self # for chaining
+    end
+
+    # Default Model comparison
+    def == other
+      case other
+      when String # Probably a Rails URI, delegate to AR::Base
+        super(other)
+      else
+        content_attributes.keys.inject(true) { |res, key|
+          res && other.respond_to?(key) && (send(key) == other.send(key)) }
+      end
+    end
+
+    ### Default attributes support
+
+    def default_attributes
+      {:created_at => Time.now,
+       :updated_at => Time.now,
+       }
+    end
+
+    def set_attribute_defaults
+      default_attributes.each do |key, val|
+        self.send("#{key}=", val) if self.send(key).nil?
+        # self.send("#{key}=", val) if self[key].nil? # Problems with association defaults
+      end
+    end
+
+    included do
+
+      after_initialize :set_attribute_defaults
+
+      ### Class macros
+
+      def self.prop *properties
+        prop_hash = properties.last.is_a?(Hash) ? properties.pop : {}
+
+        properties.each { |names| define_property names, nil }
+        prop_hash.each { |names, type| define_property names, type }
+      end
+
+      def self.define_property names, body
+        aliases = [names].flatten
+        name = aliases.shift
+        instance_eval do
+
+          define_property_methods name, body
+
+          aliases.each do |ali|
+            alias_method "#{ali}", name
+            alias_method "#{ali}=", "#{name}="
+          end
+        end
+      end
+
+      def self.define_property_methods name, body={}
+        #p name, body
+        case body
+        when '' # default getter and setter
+          define_property_methods name
+
+        when Array # [setter, getter, validators]
+          define_property_methods name,
+            :get => body[0],
+            :set => body[1],
+            :validate => body[2]
+
+        when Hash # recursion base case
+          getter = case # Define getter
+          when body[:get].respond_to?(:call)
+            body[:get]
+          when body[:get]
+            proc { self[name].send "to_#{body[:get]}" }
+          when VALUES[name] # property is encoded
+            proc { VALUES[name][self[name]] }
+          else
+            proc { self[name] }
+          end
+          define_method name, &getter if getter
+
+          setter = case # Define setter
+          when body[:set].respond_to?(:call)
+            body[:set]
+          when body[:set]
+            proc { |value| self[name] = value.send "to_#{body[:set]}" }
+          when CODES[name] # property is encoded
+            proc { |value| self[name] = CODES[name][value] || value }
+          else
+            proc { |value| self[name] = value } # p name, value;
+          end
+          define_method "#{name}=", &setter if setter
+
+          # Define validator(s)
+          [body[:validate]].flatten.compact.each do |validator|
+            case validator
+            when Proc
+              validates_each name, &validator
+            when Hash
+              validates name, validator.dup
+            end
+          end
+
+          # TODO define self[:name] accessors for :virtual and :flag properties
+
+        else # setter given
+          define_property_methods name, :set => body, :get => body
+        end
+      end
+
+      # Timestamps in lightweight models
+      unless defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
+        prop :created_at, :updated_at
+      end
+
+    end # included
+  end # module BaseProperties
+end

data/lib/ib/connection.rb

@@ -0,0 +1,327 @@
+require 'thread'
+require 'ib/socket'
+require 'ib/logger'
+require 'ib/messages'
+
+module IB
+  # Encapsulates API connection to TWS or Gateway
+  class Connection
+
+    # Please note, we are realizing only the most current TWS protocol versions,
+    # thus improving performance at the expense of backwards compatibility.
+    # Older protocol versions support can be found in older gem versions.
+
+    DEFAULT_OPTIONS = {:host =>'127.0.0.1',
+                       :port => '4001', # IB Gateway connection (default)
+                       #:port => '7496', # TWS connection
+                       :connect => true, # Connect at initialization
+                       :reader => true, # Start a separate reader Thread
+                       :received => true, # Keep all received messages in a @received Hash
+                       :logger => nil,
+                       :client_id => nil, # Will be randomly assigned
+                       :client_version => IB::Messages::CLIENT_VERSION,
+                       :server_version => IB::Messages::SERVER_VERSION
+                       }
+
+    # Singleton to make active Connection universally accessible as IB::Connection.current
+    class << self
+      attr_accessor :current
+    end
+
+    attr_accessor :options, #  Connection options
+      :socket, #   Socket to IB server (TWS or Gateway)
+      :reader, # Reader thread
+      :client_version,
+      :server_version,
+      :remote_connect_time,
+      :local_connect_time,
+      :client_id, # Client id of this Connection (as seen bu IB server)
+      :next_local_id # Next valid order id
+
+    alias next_order_id next_local_id
+    alias next_order_id= next_local_id=
+
+    def initialize opts = {}
+      @options = DEFAULT_OPTIONS.merge(opts)
+
+      # A couple of locks to avoid race conditions in JRuby
+      @subscribe_lock = Mutex.new
+      @receive_lock = Mutex.new
+
+      self.default_logger = options[:logger] if options[:logger]
+      @connected = false
+      self.next_local_id = nil
+
+      connect if options[:connect]
+      Connection.current = self
+    end
+
+    ### Working with connection
+
+    def connect
+      error "Already connected!" if connected?
+
+      # TWS always sends NextValidId message at connect - save this id
+      self.subscribe(:NextValidId) do |msg|
+        self.next_local_id = msg.local_id
+        log.info "Got next valid order id: #{next_local_id}."
+      end
+
+      @socket = IBSocket.open(options[:host], options[:port])
+
+      # Secret handshake
+      @client_version = options[:client_version]
+      socket.write_data @client_version
+      @server_version = socket.read_int
+      if @server_version < options[:server_version]
+        error "Server version #{@server_version}, #{options[:server_version]} required."
+      end
+      @remote_connect_time = socket.read_string
+      @local_connect_time = Time.now
+
+      # Sending (arbitrary) client ID to identify subsequent communications.
+      # The client with a client_id of 0 can manage the TWS-owned open orders.
+      # Other clients can only manage their own open orders.
+      @client_id = options[:client_id] || random_id
+      socket.write_data @client_id
+
+      @connected = true
+      log.info "Connected to server, ver: #{@server_version}, connection time: " +
+        "#{@local_connect_time} local, " +
+        "#{@remote_connect_time} remote."
+
+      start_reader if options[:reader] # Allows reconnect
+    end
+
+    alias open connect # Legacy alias
+
+    def disconnect
+      if reader_running?
+        @reader_running = false
+        @reader.join
+      end
+      if connected?
+        socket.close
+        @connected = false
+      end
+    end
+
+    alias close disconnect # Legacy alias
+
+    def connected?
+      @connected
+    end
+
+    ### Working with message subscribers
+
+    # Subscribe Proc or block to specific type(s) of incoming message events.
+    # Listener will be called later with received message instance as its argument.
+    # Returns subscriber id to allow unsubscribing
+    def subscribe *args, &block
+      @subscribe_lock.synchronize do
+        subscriber = args.last.respond_to?(:call) ? args.pop : block
+        id = random_id
+
+        error "Need subscriber proc or block", :args unless subscriber.is_a? Proc
+
+        args.each do |what|
+          message_classes =
+          case
+          when what.is_a?(Class) && what < Messages::Incoming::AbstractMessage
+            [what]
+          when what.is_a?(Symbol)
+            [Messages::Incoming.const_get(what)]
+          when what.is_a?(Regexp)
+            Messages::Incoming::Classes.values.find_all { |klass| klass.to_s =~ what }
+          else
+            error "#{what} must represent incoming IB message class", :args
+          end
+          message_classes.flatten.each do |message_class|
+            # TODO: Fix: RuntimeError: can't add a new key into hash during iteration
+            subscribers[message_class][id] = subscriber
+          end
+        end
+        id
+      end
+    end
+
+    # Remove all subscribers with specific subscriber id (TODO: multiple ids)
+    def unsubscribe *ids
+      @subscribe_lock.synchronize do
+        removed = []
+        ids.each do |id|
+          removed_at_id = subscribers.map { |_, subscribers| subscribers.delete id }.compact
+          error "No subscribers with id #{id}" if removed_at_id.empty?
+          removed << removed_at_id
+        end
+        removed.flatten
+      end
+    end
+
+    # Message subscribers. Key is the message class to listen for.
+    # Value is a Hash of subscriber Procs, keyed by their subscription id.
+    # All subscriber Procs will be called with the message instance
+    # as an argument when a message of that type is received.
+    def subscribers
+      @subscribers ||= Hash.new { |hash, subs| hash[subs] = Hash.new }
+    end
+
+    ### Working with received messages Hash
+
+    # Clear received messages Hash
+    def clear_received *message_types
+      @receive_lock.synchronize do
+        if message_types.empty?
+          received.each { |message_type, container| container.clear }
+        else
+          message_types.each { |message_type| received[message_type].clear }
+        end
+      end
+    end
+
+    # Hash of received messages, keyed by message type
+    def received
+      @received ||= Hash.new { |hash, message_type| hash[message_type] = Array.new }
+    end
+
+    # Check if messages of given type were received at_least n times
+    def received? message_type, times=1
+      @receive_lock.synchronize do
+        received[message_type].size >= times
+      end
+    end
+
+    # Check if all given conditions are satisfied
+    def satisfied? *conditions
+      !conditions.empty? &&
+      conditions.inject(true) do |result, condition|
+        result && if condition.is_a?(Symbol)
+        received?(condition)
+        elsif condition.is_a?(Array)
+          received?(*condition)
+        elsif condition.respond_to?(:call)
+          condition.call
+        else
+          error "Unknown wait condition #{condition}"
+        end
+      end
+    end
+
+    # Wait for specific condition(s) - given as callable/block, or
+    # message type(s) - given as Symbol or [Symbol, times] pair.
+    # Timeout after given time or 1 second.
+    def wait_for *args, &block
+      timeout = args.find { |arg| arg.is_a? Numeric } # extract timeout from args
+      end_time = Time.now + (timeout || 1) # default timeout 1 sec
+      conditions = args.delete_if { |arg| arg.is_a? Numeric }.push(block).compact
+
+      until end_time < Time.now || satisfied?(*conditions)
+        if @reader
+          sleep 0.05
+        else
+          process_messages 50
+        end
+      end
+    end
+
+    ### Working with Incoming messages from IB
+
+    # Start reader thread that continuously reads messages from @socket in background.
+    # If you don't start reader, you should manually poll @socket for messages
+    # or use #process_messages(msec) API.
+    def start_reader
+      Thread.abort_on_exception = true
+      @reader_running = true
+      @reader = Thread.new do
+        process_messages while @reader_running
+      end
+    end
+
+    def reader_running?
+      @reader_running && @reader && @reader.alive?
+    end
+
+    # 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 socket is readable, process single incoming message
+        process_message if select [socket], nil, nil, time_left
+      end
+    end
+
+    # Process single incoming message (blocking!)
+    def process_message
+      msg_id = socket.read_int # This read blocks!
+
+      # Debug:
+      log.debug "Got message #{msg_id} (#{Messages::Incoming::Classes[msg_id]})"
+
+      # Create new instance of the appropriate message type,
+      # and have it read the message from socket.
+      # NB: Failure here usually means unsupported message type received
+      error "Got unsupported message #{msg_id}" unless Messages::Incoming::Classes[msg_id]
+      msg = Messages::Incoming::Classes[msg_id].new(socket)
+
+      # Deliver message to all registered subscribers, alert if no subscribers
+      @subscribe_lock.synchronize do
+        subscribers[msg.class].each { |_, subscriber| subscriber.call(msg) }
+      end
+      log.warn "No subscribers for message #{msg.class}!" if subscribers[msg.class].empty?
+
+      # Collect all received messages into a @received Hash
+      if options[:received]
+        @receive_lock.synchronize do
+          received[msg.message_type] << msg
+        end
+      end
+    end
+
+    ### Sending Outgoing messages to IB
+
+    # Send an outgoing message.
+    def send_message what, *args
+      message =
+      case
+      when what.is_a?(Messages::Outgoing::AbstractMessage)
+        what
+      when what.is_a?(Class) && what < Messages::Outgoing::AbstractMessage
+        what.new *args
+      when what.is_a?(Symbol)
+        Messages::Outgoing.const_get(what).new *args
+
+      else
+        error "Only able to send outgoing IB messages", :args
+      end
+      error "Not able to send messages, IB not connected!" unless connected?
+      message.send_to socket
+    end
+
+    alias dispatch send_message # Legacy alias
+
+    # Place Order (convenience wrapper for send_message :PlaceOrder).
+    # Assigns client_id and order_id fields to placed order. Returns assigned order_id.
+    def place_order order, contract
+      order.place contract, self  if order.is_a? IB::Order
+    end
+
+    # Modify Order (convenience wrapper for send_message :PlaceOrder). Returns order_id.
+    def modify_order order, contract
+      order.modify contract, self
+    end
+
+    # Cancel Orders by their local ids (convenience wrapper for send_message :CancelOrder).
+    def cancel_order *local_ids
+      local_ids.each do |local_id|
+        send_message :CancelOrder, :local_id => local_id.to_i
+      end
+    end
+
+    protected
+
+    def random_id
+      rand 999999999
+    end
+
+  end # class Connection
+end # module IB