dtn 0.0.0 → 0.1.0

data/Rakefile

@@ -5,6 +5,8 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
+Dir.glob("lib/tasks/*.rake").each { |r| load r }
+
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new

data/docker-compose.yml

@@ -0,0 +1,34 @@
+version: "3.9"
+services:
+  iqfeed:
+    image: kvokka/iqfeed
+    container_name: iqfeed
+    ports:
+      - "5009:5009"
+      - "9100:9100"
+      - "9200:9200"
+      - "9300:9300"
+      - "9400:9400"
+      - "8088:8080"
+      - "5901:5900"
+    volumes:
+      - ./logs/iqfeed:/root/DTN/IQFeed
+      - ./logs/distdnnd:/var/log/distdnnd
+    healthcheck:
+      test: ["CMD", "python3", "/root/is_iqfeed_running.py"]
+      interval: 30s
+      timeout: 15s
+      retries: 3
+      start_period: 1m
+    env_file:
+      - .env
+
+  autoheal:
+    image: willfarrell/autoheal:latest
+    container_name: autoheal
+    restart: always
+    environment:
+      AUTOHEAL_CONTAINER_LABEL: all
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    hostname: autoheal

data/dtn.gemspec

@@ -27,6 +27,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "dry-configurable", "~> 0.12.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.0"
   spec.add_dependency "zeitwerk", "~> 2.4.0"
 end

data/lib/dtn.rb

@@ -4,8 +4,25 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.setup # ready!
 
-require "dry-configurable"
+require "forwardable"
+require "concurrent/atomic/atomic_fixnum"
+require "concurrent/map"
+require "active_support/concern"
+require "active_support/inflector"
+require "active_support/core_ext/string"
+require "active_support/time_with_zone"
+require "socket"
+require "securerandom"
+require "ostruct"
+require "date"
 
+# Top level API methods only
 module Dtn
   class Error < StandardError; end
+
+  class ValidationError < Error; end
+
+  extend Helpers::Catalog
+
+  mattr_accessor :host, instance_accessor: false, default: ENV.fetch("DTN_HOST", "localhost")
 end

data/lib/dtn/concerns/id.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Concerns
+    # Id creation and management methods
+    module Id
+      extend ActiveSupport::Concern
+
+      included do
+        extend Forwardable
+        delegate next_id: :"self.class"
+      end
+
+      class_methods do
+        def next_id
+          _id_tvar.increment
+          last_id
+        end
+
+        def last_id
+          _id_tvar.value
+        end
+
+        private
+
+        def _id_tvar
+          @_id_tvar ||= Concurrent::AtomicFixnum.new
+        end
+      end
+
+      def id
+        @id ||= next_id
+      end
+    end
+  end
+end

data/lib/dtn/concerns/validation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Concerns
+    # Collection of common validations
+    # This gem too small for ActiveModel, so manual approach should be just ok
+    module Validation
+      # Ruby 2.6 support
+      class ::Date
+        class Error < ArgumentError; end
+      end
+
+      DATE_TIME_FORMAT = "%Y%m%d %H%M%S"
+      DATE_FORMAT = "%Y%m%d"
+      MAX_INT16 = 2**16 - 1
+
+      DEFAULT_INTERVAL_TYPE = "s"
+
+      private
+
+      def validate_interval_type(value)
+        return DEFAULT_INTERVAL_TYPE unless value
+
+        it = value.to_s.downcase
+        return it if %w[s v t].include?(it)
+
+        raise ValidationError,
+              "Got #{value}, but interval_type can be only 's' for seconds, 'v' for volume or 't' for ticks"
+      end
+
+      def validate_datetime(value)
+        _general_date_validation(value: value, converter: :to_datetime, format: DATE_TIME_FORMAT)
+      end
+
+      def validate_date(value)
+        _general_date_validation(value: value, converter: :to_date, format: DATE_FORMAT)
+      end
+
+      def validate_short_int(value)
+        validate_int(value).yield_self do |v|
+          v > MAX_INT16 ? MAX_INT16 : v
+        end
+      end
+
+      def validate_int(value)
+        Integer(value)
+      rescue TypeError, ArgumentError
+        raise ValidationError, "Value '#{value}' is not an integer"
+      end
+
+      def validate_float(value)
+        Float(value)
+      rescue TypeError, ArgumentError
+        raise ValidationError, "Value '#{value}' is not a float"
+      end
+
+      def _general_date_validation(value:, converter:, format:)
+        return if value.blank?
+
+        _convert_date(value: value, converter: converter, format: format)
+      rescue ArgumentError
+        raise ValidationError, "Value '#{value}' is not a date"
+      end
+
+      def _convert_date(value:, converter:, format:)
+        base = value.is_a?(Date) ? value : value.to_s.public_send(converter)
+        base.strftime(format)
+      end
+    end
+  end
+end

data/lib/dtn/helpers/catalog.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Helpers
+    # Global catalog helpers
+    module Catalog
+      def method_missing(method_name, *, **)
+        return super unless method_name.to_s.end_with?("_catalog")
+
+        get_catalog(catalog: method_name.to_s.sub(/_catalog$/, ""))
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.end_with?("_catalog") || super
+      end
+
+      private
+
+      def get_catalog(catalog:)
+        v = instance_variable_get("@#{catalog}")
+        return v if v
+
+        result = Registry.new(name: catalog).tap do |registry|
+          "Dtn::Lookups::Catalog::#{catalog.camelcase}".constantize.call.each do |message|
+            registry[message.id] = message
+          end
+        end
+        instance_variable_set("@#{catalog}", result)
+      end
+    end
+  end
+end

data/lib/dtn/lookups/catalog/listed_markets.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Catalog
+      # Listed markets
+      class ListedMarkets < Request
+        TEMPLATE = "SLM"
+      end
+    end
+  end
+end

data/lib/dtn/lookups/catalog/naic_codes.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Catalog
+      # Naic codes
+      class NaicCodes < Request
+        TEMPLATE = "SNC"
+      end
+    end
+  end
+end

data/lib/dtn/lookups/catalog/security_types.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Catalog
+      # Security types
+      class SecurityTypes < Request
+        TEMPLATE = "SST"
+      end
+    end
+  end
+end

data/lib/dtn/lookups/catalog/sic_codes.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Catalog
+      # Sic codes
+      class SicCodes < Request
+        TEMPLATE = "SSC"
+      end
+    end
+  end
+end

data/lib/dtn/lookups/catalog/trade_conditions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Catalog
+      # Trade conditions
+      class TradeConditions < Request
+        TEMPLATE = "STC"
+      end
+    end
+  end
+end

data/lib/dtn/lookups/historical/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Historical
+      # User historical requests
+      class Base < Request
+        # Maximum data allowed per 1 request and per 1 batch
+        DEFAULT_MAX_DATAPOINTS = 1_000_000
+        DEFAULT_DATAPOINTS_PER_SEND = 500
+
+        # In case we are fetching the data for a few days we can filter all the days
+        # from and to. The pattern means %H%M%S
+        DEFAULT_BEGIN_FILTER_TIME = "093000"
+        DEFAULT_END_FILTER_TIME = "160000"
+
+        # Returned data order
+        DEFAULT_DATA_DIRECTION = 1
+
+        include Dtn::Concerns::Validation
+
+        private
+
+        def defaults(**options)
+          super.merge({
+                        max_datapoints: DEFAULT_MAX_DATAPOINTS,
+                        begin_filter_time: DEFAULT_BEGIN_FILTER_TIME,
+                        data_direction: DEFAULT_DATA_DIRECTION,
+                        end_filter_time: DEFAULT_END_FILTER_TIME,
+                        datapoints_per_send: DEFAULT_DATAPOINTS_PER_SEND
+                      }).merge(options)
+        end
+
+        def validate_symbol(value)
+          v = value.to_s
+          return v.upcase if v.length.positive?
+
+          raise ValidationError, "Symbol must be present"
+        end
+      end
+    end
+  end
+end

data/lib/dtn/lookups/historical/daily_datapoint.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Historical
+      # Daily datapoint requests
+      class DailyDatapoint < Datapoint
+        TEMPLATE =
+          "HDX,%<symbol>s,%<max_datapoints>d,%<data_direction>d,%<id>d,%<datapoints_per_send>d"
+      end
+    end
+  end
+end

data/lib/dtn/lookups/historical/daily_timeframe.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Historical
+      # Daily timeframe requests
+      class DailyTimeframe < Interval
+        TEMPLATE =
+          "HDT,%<symbol>s,%<begin_date>s,%<end_date>s,%<max_datapoints>d,%<data_direction>d,%<id>d"
+
+        # HDT - Retrieves [Days] days of interval data for the specified [Symbol].
+        #
+        # Example message
+        #
+        #   HDT,[Symbol],[BeginDate],[EndDate],[MaxDatapoints],[DataDirection],[RequestID],\
+        #   [DatapointsPerSend]<CR><LF>
+        def call(symbol:, begin_date:, end_date:, **options)
+          self.combined_options = defaults(**options).merge(
+            {
+              symbol: validate_symbol(symbol),
+              begin_date: validate_date(begin_date),
+              end_date: validate_date(end_date)
+            }
+          )
+          super
+        end
+
+        def expected_messages_class
+          Messages::Historical::DailyWeeklyMonthly
+        end
+      end
+    end
+  end
+end

data/lib/dtn/lookups/historical/datapoint.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Historical
+      # Weekly datapoint requests
+      class Datapoint < Base
+        # Retrieves up to [maxDatapoints] datapoints of composite daily/weekly/monthly datapoints
+        # for the specified [Symbol].
+        #
+        # Example messages
+        #
+        #   HDX,[Symbol],[MaxDatapoints],[DataDirection],[RequestID],[DatapointsPerSend]<CR><LF>
+        #   HWX,[Symbol],[MaxDatapoints],[DataDirection],[RequestID],[DatapointsPerSend]<CR><LF>
+        #   HMX,[Symbol],[MaxDatapoints],[DataDirection],[RequestID],[DatapointsPerSend]<CR><LF>
+        def call(symbol:, **options)
+          self.combined_options = defaults(**options).merge(symbol: validate_symbol(symbol))
+          super
+        end
+
+        def expected_messages_class
+          Messages::Historical::DailyWeeklyMonthly
+        end
+      end
+    end
+  end
+end

data/lib/dtn/lookups/historical/interval.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Historical
+      # Interval requests
+      class Interval < Base
+        def expected_messages_class
+          Messages::Historical::Interval
+        end
+      end
+    end
+  end
+end

data/lib/dtn/lookups/historical/interval_datapoint.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dtn
+  module Lookups
+    module Historical
+      # Interval datapoint requests
+      class IntervalDatapoint < Interval
+        TEMPLATE =
+          "HIX,%<symbol>s,%<interval>d,%<max_datapoints>d,%<data_direction>d,%<id>d,"\
+          "%<datapoints_per_send>d,%<interval_type>s"
+
+        # HIX - Retrieves [maxDatapoints] number of Intervals of data for the specified [Symbol].
+        #
+        # Example message
+        #
+        #   HIX,[Symbol],[Interval],[MaxDatapoints],[DataDirection],[RequestID],[DatapointsPerSend],\
+        #   [IntervalType]<CR><LF>
+        def call(symbol:, interval:, **options)
+          self.combined_options = defaults(**options).merge(
+            {
+              symbol: validate_symbol(symbol),
+              interval: validate_int(interval),
+              interval_type: validate_interval_type(options[:interval_type])
+            }
+          )
+          super
+        end
+      end
+    end
+  end
+end