dtn 0.0.0 → 0.1.0

data/lib/dtn/messages/system/no_data_characters.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Messages
+    module System
+      # Empty response abstraction
+      class NoDataCharacters < MessageWithSimpleParser
+        class << self
+          def fields
+            @fields ||= {
+              request_id: :to_i
+            }
+          end
+        end
+
+        def termination?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/dtn/messages/system/stats.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Messages
+    module System
+      # All stats
+      class Stats < MessageWithSimpleParser
+        class << self
+          # rubocop:disable Metrics/MethodLength
+          def fields
+            @fields ||= {
+              server_ip: :to_s,
+              server_port: :to_i,
+              max_symbols: :to_i,
+              number_of_symbols: :to_i,
+              clients_connected: :to_i,
+              seconds_since_last_update: :to_i,
+              reconnections: :to_i,
+              attemptedReconnections: :to_i,
+              start_time: :to_datetime,
+              market_time: :to_datetime,
+              status: :to_s,
+              iq_feed_version: :to_s,
+              loginId: :to_s,
+              totalKBsRecv: :to_f,
+              kbsPerSecRecv: :to_f,
+              avgKBsPerSecRecv: :to_f,
+              totalKBsSent: :to_f,
+              kbsPerSecSent: :to_f,
+              avgKBsPerSecSent: :to_f
+            }
+          end
+          # rubocop:enable Metrics/MethodLength
+        end
+      end
+    end
+  end
+end

data/lib/dtn/messages/system/symbol_not_found.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Messages
+    module System
+      # Not found symbol for streaming
+      class SymbolNotFound < MessageWithSimpleParser
+        class << self
+          def fields
+            @fields ||= {
+              _skip: :nil,
+              symbol: :to_s
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dtn/messages/system/timestamp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Messages
+    module System
+      # Parsed timestamp
+      class Timestamp < Message
+        class << self
+          def parse(line:, **)
+            new timestamp: line[2..].to_datetime
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dtn/messages/unknown.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Messages
+    # Just in case we got something unexpected.
+    # in the best world should be never executed.
+    class Unknown < Message
+      class << self
+        def parse(line:, **)
+          new(line: line)
+        end
+    end
+    end
+  end
+end

data/lib/dtn/registry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Dtn
+  # Abstract thread safe registry
+  class Registry
+    include Enumerable
+    extend Forwardable
+
+    delegate delete: :@items,
+             size: :@items,
+             clear: :@items
+
+    attr_reader :name
+
+    def initialize(name:)
+      @name  = name
+      @items = Concurrent::Map.new
+    end
+
+    def clear
+      @items.clear
+    end
+
+    def each(&block)
+      @items.values.uniq.each(&block)
+    end
+
+    def find(item_name)
+      @items.fetch(item_name)
+    rescue KeyError => e
+      raise key_error_with_custom_message(e, item_name)
+    end
+
+    alias [] find
+
+    def register(name, item)
+      return unless name
+
+      @items[name] = item
+    end
+
+    alias []= register
+
+    def registered?(name)
+      @items.key?(name)
+    end
+
+    private
+
+    def key_error_with_custom_message(key_error, item_name)
+      message = key_error.message.sub("key not found", %(#{@name} not registered: "#{item_name}"))
+      error = KeyError.new(message)
+      error.set_backtrace(key_error.backtrace)
+      error
+    end
+  end
+end

data/lib/dtn/streaming/client.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Streaming
+    # Top level client abstraction. Different streams are available on different
+    # ports, so we can use it and follow the same pattern
+    class Client
+      # Status helper methods
+      module Status
+        STATUSES = { run: :running, stop: :stopped, initializing: :initialized }.freeze
+
+        STATUSES.each do |k, v|
+          define_method(k) { self.status = v }
+          define_method("#{v}?") { status == v }
+        end
+
+        attr_reader :status
+
+        protected
+
+        attr_writer :status
+      end
+
+      include Status
+
+      PROTOCOL_VERSION = "6.1"
+
+      CLIENT_TERMINATION_SIGNALS = %w[TERM INT].freeze
+
+      COMMON_SUPPORTED_MESSAGES = {
+        "S" => Messages::System::Generic,
+        "T" => Messages::System::Timestamp,
+        "n" => Messages::System::SymbolNotFound,
+        "E" => Messages::System::Error
+      }.freeze
+
+      # @params name             Specify name for this client
+      # @params start_engine     auto start engine, which is processing messages
+      def initialize(name: nil, start_engine: true)
+        @name = name || SecureRandom.alphanumeric(10)
+
+        initializing
+
+        init_connection
+        setup_signals
+        engine if start_engine
+      end
+
+      attr_reader :name
+
+      # We are able to filer the incoming data with custom fields
+      # using
+      attr_accessor :quote_update_fields
+
+      def request
+        RequestBuilder.new(client: self)
+      end
+
+      def observers
+        @observers ||= Set.new
+      end
+
+      def to_s
+        "Client name: #{name}, status: #{status}"
+      end
+
+      def socket
+        @socket ||= TCPSocket.open(Dtn.host, self.class::PORT)
+      end
+
+      def engine
+        @engine ||= Thread.new do
+          run
+          while running? && (line = socket.gets)
+            process_line(line: line)
+          end
+        end
+      end
+
+      private
+
+      def process_line(line:)
+        message_class(line: line).parse(line: line, client: self).tap do |message|
+          observers.each do |obs|
+            obs.public_send(message.callback_name, message: message) if obs.respond_to?(message.callback_name)
+          end
+        end
+      end
+
+      def message_class(line:)
+        self.class::SUPPORTED_MESSAGES[line[0]] || Messages::Unknown
+      end
+
+      def init_connection
+        socket
+      end
+
+      def setup_signals
+        CLIENT_TERMINATION_SIGNALS.each do |signal|
+          Signal.trap(signal) { stop }
+        end
+      end
+    end
+  end
+end

data/lib/dtn/streaming/clients/admin.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Streaming
+    module Clients
+      # Provides a connection to IQFeed's Administrative socket.
+      #
+      # Is used to find out the health of the feed, figure out the
+      # status of each connection made to IQFeed, and also set various parameters
+      # to the feed.
+      #
+      # See www.iqfeed.net/dev/api/docs/AdminviaTCPIP.cfm
+      class Admin < Client
+        PORT = 9300
+
+        SUPPORTED_MESSAGES = COMMON_SUPPORTED_MESSAGES
+      end
+    end
+  end
+end

data/lib/dtn/streaming/clients/bar.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Streaming
+    module Clients
+      #   Let's you get live data as interval bar data.
+      #
+      #   If you are using interval bars for trading, use this class if you want
+      #   IQFeed to calculate the interval bars for you and send you interval bars
+      #   instead of (or in addition to) receiving every tick. For example, you may
+      #   want to get open, high, low, close data for each minute or every 50 trades.
+      #
+      #   The length of the interval can be in time units, number of trades units
+      #   or volume traded units as for bars from HistoryConn.
+      #   If you want historical bars, use HistoryConn instead. This class
+      #   allows you to get some history, for example if you want the past 5
+      #   days's bars to fill in a data structure before you start getting live
+      #   data updates. But if you want historical data for back-testing or some
+      #   such, you are better off using HistoryConn instead.
+      #
+      #   Since most historical data that IQFeed gives you is bar data, if you are
+      #   just getting started, it may be a good idea to save some live tick-data and
+      #   bar-data and compare them so you understand exactly how IQFeed is
+      #   filtering ticks and generating it's bars. Different data providers tend to
+      #   do this differently, dome better than others and the documentation usually
+      #   doesn't get updated when things are changed.
+      #
+      #   For more info, see:
+      #   www.iqfeed.net/dev/api/docs/Derivatives_Overview.cfm
+      #   and
+      #   www.iqfeed.net/dev/api/docs/Derivatives_StreamingIntervalBars_TCPIP.cfm
+      class Bar < Client
+        PORT = 9400
+
+        SUPPORTED_MESSAGES = COMMON_SUPPORTED_MESSAGES.merge(
+          "BH" => Messages::Bar::HistoricalBar,
+          "BC" => Messages::Bar::CurrentBar,
+          "BU" => Messages::Bar::UpdateBar
+        ).freeze
+
+        def message_class(line:)
+          self.class::SUPPORTED_MESSAGES[line[0]] ||
+            ((line =~ /\d+,(\w+),.+/) && self.class::SUPPORTED_MESSAGES[Regexp.last_match(1)]) ||
+            Messages::Unknown
+        end
+      end
+    end
+  end
+end

data/lib/dtn/streaming/clients/level2.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Streaming
+    module Clients
+      # Provides a connection to IQFeed's Level2 socket.
+      class Level2 < Client
+        PORT = 9200
+
+        SUPPORTED_MESSAGES = COMMON_SUPPORTED_MESSAGES.merge(
+          "Z" => Messages::Level2::Level2Update, # Summary message, but it's actually the same
+          "2" => Messages::Level2::Level2Update,
+          "U" => Messages::Level2::Level2Update,
+          "M" => Messages::Level2::MarketMakerName # A Market Maker name OR order book level query response message.
+        ).freeze
+
+        private
+
+        def init_connection
+          request.level2.connect
+        end
+      end
+    end
+  end
+end

data/lib/dtn/streaming/clients/quote.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Streaming
+    module Clients
+      # Quote provides real-time Level 1 data and real-time news.
+      #
+      # Quote provides access to top-of-book quotes, regional quotes
+      # (quotes from a single exchange), fundamentals (which includes
+      # reference) data, streaming real-time news.
+      #
+      # Quotes, Regional, Trades and Fundamental data is provided as a messages
+      # since you are likely going to do something fancy with it.
+      #
+      #
+      # READ THIS CAREFULLY: For quote updates (provided when the top of book
+      # quote changes or a trade happens) IQFeed.exe can send dynamic fieldsets.
+      # This means that you can ask for any fields (subset of the set available)
+      # you want. This map to `Messages::Quote::Level1::ALL_FIELDS` which lists
+      # all available fields which will be used as a field name by DTN.
+      # The values corresponding to each
+      # key a tuple of (FieldName used by DTN, FieldName used in Structured Array,
+      # numpy scalar type used for that field).
+      #
+      # We start with a default set of fields (same as default in the IQFeed
+      # docs. It will be fetch once client starts. If you want a different
+      # set of fields, call
+      # `client.request.quote.update_fields list: %i[Bid Ask]` with the
+      # fieldnames you want. If you want a different set of fieldnames for options
+      # and stocks, create two clients. Use one for all stock subscriptions and
+      # one for all options subscriptions. They can both use the same observer if
+      # that is what you want.
+      #
+      # If you don't understand the above two paragraphs, look at the code, look
+      # at the examples, run the examples and then read the above again.
+      class Quote < Client
+        PORT = 5009
+
+        SUPPORTED_MESSAGES = COMMON_SUPPORTED_MESSAGES.merge(
+          "F" => Messages::Quote::Level1Fundamental,
+          "P" => Messages::Quote::Level1Summary,
+          "Q" => Messages::Quote::Level1Update,
+          "R" => Messages::Quote::Level1Regional,
+          "N" => Messages::Quote::Level1News
+        ).freeze
+
+        private
+
+        def init_connection
+          request.quote.set_client_name(name: name)
+          request.quote.current_update_fieldnames
+          request.quote.set_protocol
+        end
+      end
+    end
+  end
+end

data/lib/dtn/streaming/messages_recorder_observer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Streaming
+    # A sample class, which will record all messages, which were
+    # invoked by the client.
+    # It will spy and record all invocations for simpler further analyses
+    #
+    # It's costly for production use, but very convenient for dev &
+    # testing purposes to quickly understand what you will get from the
+    # API
+    class MessagesRecorderObserver
+      def invoked_methods
+        @invoked_methods ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def method_missing(method_name, **opts)
+        invoked_methods[method_name] << opts[:message]
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+    end
+  end
+end