eodhd 0.19.12 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 530f57a120775f0c6624020d4f445306b4dfa33d7c12e9a7f67f2b44df33c9e7
-  data.tar.gz: 5e4888b2cbeb8f453e3c936062c292b872f440fc3cef7a6727a1b69f976127de
+  metadata.gz: 9ffb5b10a7b76ed5cbf348871d4a52e632928745e47be2da832025c190385f4e
+  data.tar.gz: 7c2b748ba0bbb9c9c10700a705d73540cf34e9cb02785bd52b78053d818cbcb0
 SHA512:
-  metadata.gz: ef65941abdbbbaf07a93107448f290ef8a14041de4eca5f802a48276f73e6c40c44dcf615e654397cfac72b9004f5a10dd53f7c9975933be5e94b98dc27d10aa
-  data.tar.gz: 51efb1a993e9d299a8f2308842fd81e5cd7e66fd8a0eca28330faf013577ad38847ff499672faea85858325d42c5b9334595db045634773c744a620b2295a3fe
+  metadata.gz: 275a4e69b3d081bbe5f680f7afb8ab4e63799753a13a386abdcf2f5431357e15c5c935acef513cc2c6266031843e194e72829a18d9381589ca349c7d2402a6e4
+  data.tar.gz: 96be2135eb222e8b0d3b006baf8633ffd12fc7639c44d7358c5f4edd1f050b7bedd8e626c57e92ab4d176354179d4c3acad01066a6d0a8892bc5fca642d797b4

data/CHANGELOG

@@ -1,5 +1,27 @@
 # eodhd/CHANGELOG
 
+## 20261024
+
+0.20.0: Replace iodine with websocket-driver, so as WebSocketClient sends SNI.
+
+1. ~ eodhd.gemspec and eodhd.rb.gemspec: spec.dependencies: - iodine, + websocket-driver. EODHD's WebSocket endpoints refuse a TLS handshake without SNI, which neither iodine 0.7.60 nor 0.8.2 sends, and 0.8.2 also leaves the API token's query string off the request.
+2. + Eodhd::WebSocketClient::Connection, the URL and socket for WebSocket::Driver.
+3. + Eodhd::WebSocketClient#tls_socket, #tls_context: naming the host (SNI) and verifying its certificate.
+4. + Eodhd::WebSocketClient#websocket_driver
+5. ~ Eodhd::WebSocketClient#run: reads into a WebSocket::Driver until it closes, or until EOFError, Errno::EPIPE or Errno::ECONNRESET. An exception from the consumer, or an Eodhd::Error for a frame which isn't JSON, now ends run, where iodine printed it and carried on.
+6. ~ Eodhd::WebSocketClient::Handler#on_open: subscribes with WebSocket::Driver#text.
+7. - Eodhd::WebSocketClient::Handler#on_close
+8. ~ test/Eodhd/WebSocketClient_test.rb: #run against a server on a socket pair, rather than with Iodine stubbed; + #tls_socket against a local TLS server; + Handler#on_open.
+9. ~ test/gemspec_test.rb: "declares its runtime dependencies": - iodine, + websocket-driver.
+10. ~ Eodhd::VERSION: /0.19.13/0.20.0/
+
+0.19.13: Fix WebSocketClient.us_trade, .us_quote, .forex and .crypto.
+
+1. ~ Eodhd::WebSocketClient.us_trade, .us_quote, .forex and .crypto: /self.class.new/new/. Within class << self, self.class is Class, so each raised TypeError.
+2. + test/Eodhd/WebSocketClient_test.rb: that .us_trade, .us, .us_quote, .forex and .crypto each make a client for their stream.
+3. ~ Eodhd::VERSION: /0.19.12/0.19.13/
+
+
 ## 20261021
 
 0.19.12: Require http.rb >= 1.7.0, for case-sensitive filesystems.

data/eodhd.gemspec

@@ -38,8 +38,8 @@ Gem::Specification.new do |spec|
 
   spec.dependencies = [
     ['http.rb', '>= 1.7.0'],
-    'iodine',
     'logger',
+    'websocket-driver',
   ]
 
   spec.development_dependencies = %w{

data/lib/Eodhd/VERSION.rb

@@ -1,3 +1,3 @@
 class Eodhd
-  VERSION = '0.19.12'
+  VERSION = '0.20.0'
 end

data/lib/Eodhd/WebSocketClient.rb

@@ -7,9 +7,12 @@
 #   ii.  US market quote data: wss://ws.eodhistoricaldata.com/ws/us-quote?api_token=XXX
 #   iii. Forex: wss://ws.eodhistoricaldata.com/ws/forex?api_token=XXX
 #   iv.  Crypto: wss://ws.eodhistoricaldata.com/ws/crypto?api_token=XXX
+# 2. The endpoints refuse a TLS handshake which doesn't name the host (SNI).
 
-require 'iodine'
 require 'json'
+require 'openssl'
+require 'socket'
+require 'websocket/driver'
 
 require_relative './DefaultLogger'
 require_relative './Error'
@@ -17,21 +20,35 @@ require_relative './Error'
 class Eodhd
   class WebSocketClient
     API_HOST = 'ws.eodhistoricaldata.com'
+    API_PORT = 443
+    READ_SIZE = 16384
+
+    # What WebSocket::Driver writes to: the URL it asks for and the socket to write to.
+    class Connection
+      attr_reader :url
+
+      def write(data)
+        @socket.write(data)
+      end
+
+      private
+
+      def initialize(url:, socket:)
+        @url = url
+        @socket = socket
+      end
+    end
 
     class Handler
-      def on_open(connection)
-        connection.write({action: 'subscribe', symbols: @symbols}.to_json)
+      def on_open(driver)
+        driver.text({action: 'subscribe', symbols: @symbols}.to_json)
       end
 
-      def on_message(connection, message)
+      def on_message(driver, message)
         dataframe = handle_response(message)
         @consumer.call(dataframe) if @consumer
       end
 
-      def on_close(connection)
-        Iodine.stop
-      end
-
       private
 
       def initialize(symbols:, consumer:, logger: nil)
@@ -63,20 +80,20 @@ class Eodhd
       end
 
       def us_trade(api_token:, symbols:, consumer:)
-        self.class.new(api_token: api_token, asset_class: 'us', symbols: symbols, consumer: consumer)
+        new(api_token: api_token, asset_class: 'us', symbols: symbols, consumer: consumer)
       end
       alias_method :us, :us_trade
 
       def us_quote(api_token:, symbols:, consumer:)
-        self.class.new(api_token: api_token, asset_class: 'us-quote', symbols: symbols, consumer: consumer)
+        new(api_token: api_token, asset_class: 'us-quote', symbols: symbols, consumer: consumer)
       end
 
       def forex(api_token:, symbols:, consumer:)
-        self.class.new(api_token: api_token, asset_class: 'forex', symbols: symbols, consumer: consumer)
+        new(api_token: api_token, asset_class: 'forex', symbols: symbols, consumer: consumer)
       end
 
       def crypto(api_token:, symbols:, consumer:)
-        self.class.new(api_token: api_token, asset_class: 'crypto', symbols: symbols, consumer: consumer)
+        new(api_token: api_token, asset_class: 'crypto', symbols: symbols, consumer: consumer)
       end
     end # class << self
 
@@ -94,11 +111,14 @@ class Eodhd
     end
 
     def run
-      Iodine.threads = 1
-      Iodine.connect(url: url, handler: Handler.new(symbols: @symbols, consumer: @consumer, logger: @logger))
-      Iodine.start
-    rescue SystemExit, Interrupt
+      socket = tls_socket
+      driver = websocket_driver(socket)
+      driver.start
+      driver.parse(socket.readpartial(READ_SIZE)) until driver.state == :closed
+    rescue EOFError, Errno::EPIPE, Errno::ECONNRESET, SystemExit, Interrupt
       return
+    ensure
+      socket&.close
     end
 
     private
@@ -126,5 +146,30 @@ class Eodhd
     def url
       "wss://#{API_HOST}#{self.class.path_prefix}/#{@asset_class}?api_token=#{@api_token}"
     end
+
+    def tls_context
+      context = OpenSSL::SSL::SSLContext.new
+      context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+      context
+    end
+
+    def tls_socket(host: API_HOST, port: API_PORT)
+      socket = OpenSSL::SSL::SSLSocket.new(TCPSocket.new(host, port), tls_context)
+      socket.hostname = host
+      socket.sync_close = true
+      socket.connect
+      socket
+    rescue OpenSSL::SSL::SSLError
+      socket.close
+      raise
+    end
+
+    def websocket_driver(socket)
+      driver = WebSocket::Driver.client(Connection.new(url: url, socket: socket))
+      handler = Handler.new(symbols: @symbols, consumer: @consumer, logger: @logger)
+      driver.on(:open){handler.on_open(driver)}
+      driver.on(:message){|event| handler.on_message(driver, event.data)}
+      driver
+    end
   end
 end

data/test/Eodhd/WebSocketClient_test.rb

@@ -6,6 +6,46 @@ describe Eodhd::WebSocketClient do
   let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
   let(:consumer){->(data){}}
 
+  describe ".us_trade" do
+    it "makes a client for the US trade stream" do
+      client = Eodhd::WebSocketClient.us_trade(api_token: api_token, symbols: 'AAPL', consumer: consumer)
+      _(client).must_be_instance_of(Eodhd::WebSocketClient)
+      _(client.asset_class).must_equal('us')
+    end
+  end
+
+  describe ".us" do
+    it "makes a client for the US trade stream" do
+      client = Eodhd::WebSocketClient.us(api_token: api_token, symbols: 'AAPL', consumer: consumer)
+      _(client).must_be_instance_of(Eodhd::WebSocketClient)
+      _(client.asset_class).must_equal('us')
+    end
+  end
+
+  describe ".us_quote" do
+    it "makes a client for the US quote stream" do
+      client = Eodhd::WebSocketClient.us_quote(api_token: api_token, symbols: 'AAPL', consumer: consumer)
+      _(client).must_be_instance_of(Eodhd::WebSocketClient)
+      _(client.asset_class).must_equal('us-quote')
+    end
+  end
+
+  describe ".forex" do
+    it "makes a client for the forex stream" do
+      client = Eodhd::WebSocketClient.forex(api_token: api_token, symbols: 'EURUSD', consumer: consumer)
+      _(client).must_be_instance_of(Eodhd::WebSocketClient)
+      _(client.asset_class).must_equal('forex')
+    end
+  end
+
+  describe ".crypto" do
+    it "makes a client for the crypto stream" do
+      client = Eodhd::WebSocketClient.crypto(api_token: api_token, symbols: 'BTC-USD', consumer: consumer)
+      _(client).must_be_instance_of(Eodhd::WebSocketClient)
+      _(client.asset_class).must_equal('crypto')
+    end
+  end
+
   describe "#initialize" do
     it "accepts array of symbols and formats to comma-separated string" do
       client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: ['AAPL', 'MSFT'], consumer: consumer)
@@ -53,26 +93,119 @@ describe Eodhd::WebSocketClient do
   end
 
   describe "#run" do
-    it "configures Iodine and starts connection" do
-      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL', consumer: consumer)
+    # The server's half of the opening handshake (RFC 6455, 4.2.2), answering with the request line.
+    def accept_handshake(socket)
+      request = []
+      request << socket.gets.chomp until request.last == ''
+      key = request.grep(/\ASec-WebSocket-Key:/i).first.split(':', 2).last.strip
+      accept = [OpenSSL::Digest.digest('SHA1', key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')].pack('m0')
+      socket.write("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: #{accept}\r\n\r\n")
+      request.first
+    end
+
+    # A masked client frame of under 126 bytes.
+    def read_client_frame(socket)
+      length = socket.read(2).bytes.last & 0x7f
+      mask = socket.read(4).bytes
+      socket.read(length).bytes.each_with_index.map{|byte, i| byte ^ mask[i % 4]}.pack('C*')
+    end
+
+    def text_frame(text)
+      [0x81, text.bytesize].pack('CC') + text
+    end
+
+    def close_frame
+      [0x88, 2, 1000].pack('CCn')
+    end
+
+    it "subscribes, hands each message to the consumer, and returns once the server closes" do
+      received = []
+      client = Eodhd::WebSocketClient.new(api_token: 'api_token', asset_class: 'crypto', symbols: 'BTC-USD', consumer: ->(data){received << data})
+      client_socket, server_socket = UNIXSocket.pair
+      server = Thread.new do
+        request_line = accept_handshake(server_socket)
+        subscription = read_client_frame(server_socket)
+        server_socket.write(text_frame('{"s":"BTC-USD","p":"81430.24"}'))
+        server_socket.write(close_frame)
+        [request_line, subscription]
+      end
+      client.stub(:tls_socket, client_socket){client.run}
+      request_line, subscription = server.value
+      _(request_line).must_equal('GET /ws/crypto?api_token=api_token HTTP/1.1')
+      _(JSON.parse(subscription)).must_equal({'action' => 'subscribe', 'symbols' => 'BTC-USD'})
+      _(received).must_equal([{'s' => 'BTC-USD', 'p' => '81430.24'}])
+    end
+
+    it "returns when the server drops the connection" do
+      received = []
+      client = Eodhd::WebSocketClient.new(api_token: 'api_token', asset_class: 'crypto', symbols: 'BTC-USD', consumer: ->(data){received << data})
+      client_socket, server_socket = UNIXSocket.pair
+      server = Thread.new do
+        accept_handshake(server_socket)
+        server_socket.close
+      end
+      client.stub(:tls_socket, client_socket){client.run}
+      server.join
+      _(received).must_equal([])
+    end
+  end
 
-      iodine_connect_called = false
-      iodine_start_called = false
+  describe "#tls_socket" do
+    def self_signed_certificate(key)
+      certificate = OpenSSL::X509::Certificate.new
+      certificate.version = 2
+      certificate.serial = 1
+      certificate.subject = certificate.issuer = OpenSSL::X509::Name.parse('/CN=localhost')
+      certificate.public_key = key.public_key
+      certificate.not_before = Time.now - 60
+      certificate.not_after = Time.now + 3600
+      certificate.sign(key, OpenSSL::Digest.new('SHA256'))
+    end
+
+    # Yields the port of a local TLS server with a self-signed certificate, and the host names its clients sent.
+    def with_tls_server
+      key = OpenSSL::PKey::RSA.new(2048)
+      context = OpenSSL::SSL::SSLContext.new
+      context.cert, context.key = self_signed_certificate(key), key
+      server_names = []
+      context.servername_cb = ->((socket, name)){server_names << name; nil}
+      tcp_server = TCPServer.new('localhost', 0)
+      ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, context)
+      server = Thread.new{ssl_server.accept rescue nil}
+      yield tcp_server.addr[1], server_names
+    ensure
+      server&.join(5)
+      ssl_server&.close
+    end
 
-      Iodine.stub(:threads=, nil) do
-        Iodine.stub(:connect, ->(opts){iodine_connect_called = true}) do
-          Iodine.stub(:start, ->{iodine_start_called = true}) do
-            client.run
-          end
-        end
+    it "names the host in the TLS handshake (SNI)" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'crypto', symbols: 'BTC-USD', consumer: consumer)
+      with_tls_server do |port, server_names|
+        _{client.send(:tls_socket, host: 'localhost', port: port)}.must_raise(OpenSSL::SSL::SSLError)
+        _(server_names).must_equal(['localhost'])
       end
+    end
 
-      _(iodine_connect_called).must_equal(true)
-      _(iodine_start_called).must_equal(true)
+    it "refuses a certificate it can't verify" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'crypto', symbols: 'BTC-USD', consumer: consumer)
+      with_tls_server do |port, server_names|
+        error = _{client.send(:tls_socket, host: 'localhost', port: port)}.must_raise(OpenSSL::SSL::SSLError)
+        _(error.message).must_match(/certificate verify failed/)
+      end
     end
   end
 
   describe "Handler" do
+    describe "#on_open" do
+      it "subscribes to its symbols" do
+        sent = []
+        driver = Struct.new(:sent){def text(message) = sent << message}.new(sent)
+        handler = Eodhd::WebSocketClient::Handler.new(symbols: 'AAPL,MSFT', consumer: consumer, logger: nil)
+        handler.on_open(driver)
+        _(sent.collect{|message| JSON.parse(message)}).must_equal([{'action' => 'subscribe', 'symbols' => 'AAPL,MSFT'}])
+      end
+    end
+
     describe "#on_message" do
       it "parses JSON and calls consumer" do
         received_data = nil

data/test/gemspec_test.rb

@@ -23,7 +23,7 @@ require_relative './helper'
     end
 
     it "declares its runtime dependencies" do
-      _(spec.runtime_dependencies.collect(&:name).sort).must_equal(%w{http.rb iodine logger})
+      _(spec.runtime_dependencies.collect(&:name).sort).must_equal(%w{http.rb logger websocket-driver})
     end
 
     it "requires http.rb 1.7.0 or later, whose load file is lib/http.rb" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eodhd
 version: !ruby/object:Gem::Version
-  version: 0.19.12
+  version: 0.20.0
 platform: ruby
 authors:
 - thoran
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.7.0
 - !ruby/object:Gem::Dependency
-  name: iodine
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: logger
+  name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="