cotcube-helpers 0.2.2.5 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7496f5774fbcb9b661dac0f9315081a4b5f4d30a8c89334ef13d0639b789ba73
-  data.tar.gz: 596ab3ed0cc578c6321beb1b07b6400e109f4537d91cf0903a0c0542b9a962df
+  metadata.gz: 1d08ed5fa831283b0934d2ce7f86f9da0f1be5430d0d3164ee503b0aa7bac74f
+  data.tar.gz: ac59b5558432299e6906c8a93b4ddab8b7a57a7cac4b2c11239a8f41a8c05f4e
 SHA512:
-  metadata.gz: 7447d4f4d2297c60eb37a815b8cd0c91ddd70d1c4af0d2f8bab89ada65c2ac0c328da6e6dd2e99f46d39d75cc765ee4d724598c3d9fdbf42cd15b6a7f30a22fc
-  data.tar.gz: 348426b27122a2be123f93f4db63b7d57e032cf2451f6822a10fce94124d9d0f2cf6c9d3621b920daa651e80ec1b69a5e777d4d94a169cb03f6067f13d1d693f
+  metadata.gz: 8b3ce7871cbc2068523994caa155a2291512c0cce8c72398f51de275e56c6e1a75a94402327118f27ae0376ccbf70b148be3fb17d0f66326e019d21a639ae485
+  data.tar.gz: e17fe32e700a3441e5e54a4b521c0c3d20acedbfb45606cd8f3da6edb5041a7cbcab522729da6d9d0e784f739730972af1ad1210b5542e06cd879f70587d7b1e

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.2.3 (December 30, 2021)
+  - merging conflict
+  - added bare josch_ and order_client s
+  - added bare js_ and order_client s
+
 ## 0.2.2.5 (December 23, 2021)
   - hash_ext: reworked keys_to_sym!
   - minor changes

data/VERSION

@@ -1 +1 @@
-0.2.2.5
+0.2.3

data/lib/cotcube-helpers/data_client.rb

@@ -227,4 +227,4 @@ begin
   } 
 ensure
   client.stop
-  e,nd
+  end

data/lib/cotcube-helpers/josch_client.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bunny'
+require 'json'
+
+module Cotcube
+  module Helpers
+    class JoSchClient
+      SECRETS_DEFAULT = {
+        'josch_mq_proto' => 'http',
+        'josch_mq_user' => 'guest',
+        'josch_mq_password' => 'guest',
+        'josch_mq_host' => 'localhost',
+        'josch_mq_port' => '15672',
+        'josch_mq_vhost' => '%2F'
+      }.freeze
+
+      SECRETS = SECRETS_DEFAULT.merge(
+        lambda {
+          begin
+            YAML.safe_load(File.read(Cotcube::Helpers.init[:secrets_file]))
+          rescue StandardError
+            {}
+          end
+        }.call
+      )
+
+      def initialize
+        @connection = Bunny.new(user:     SECRETS['josch_mq_user'],
+                                password: SECRETS['josch_mq_password'],
+                                vhost:    SECRETS['josch_mq_vhost'])
+        @connection.start
+
+        @commands  = connection.create_channel
+        @exchange  = commands.direct('josch_commands')
+        @requests  = {}
+        @debug     = false
+        setup_reply_queue
+      end
+
+      # command acts a synchronizer: it sends the command and waits for the response
+      #     otherwise times out --- the counterpart here is the subscription within 
+      #     setup_reply_queue
+      #
+      def command(command, timeout: 10)
+        command = { command: command.to_s } unless command.is_a? Hash
+        command[:timestamp] ||= (Time.now.to_f * 1000).to_i
+        request_id = Digest::SHA256.hexdigest(command.to_json)[..6]
+        requests[request_id] = {
+          request: command,
+          id: request_id,
+          lock: Mutex.new,
+          condition: ConditionVariable.new
+        }
+
+        exchange.publish(command.to_json,
+                         routing_key: 'josch_commands',
+                         correlation_id: request_id,
+                         reply_to: reply_queue.name)
+
+        # wait for the signal to continue the execution
+        #
+        requests[request_id][:lock].synchronize do
+          requests[request_id][:condition].wait(requests[request_id][:lock], timeout)
+        end
+
+        # if we reached timeout, we will return nil, just for explicity
+        response = requests[request_id][:response].dup
+        requests.delete(request_id)
+        response
+      end
+
+      alias_method :send_command, :command
+
+      attr_accessor :response
+      attr_reader   :lock, :condition
+
+      private
+
+      attr_reader :call_id, :connection, :requests, :persistent,
+                  :commands, :server_queue_name, :reply_queue, :exchange
+
+      def setup_reply_queue
+        @reply_queue = commands.queue('', exclusive: true, auto_delete: true)
+        @reply_queue.bind(commands.exchange('josch_replies'), routing_key: @reply_queue.name)
+
+        reply_queue.subscribe do |delivery_info, properties, payload|
+          __id__ = properties[:correlation_id]
+
+          if __id__.nil?
+            puts "Received without __id__: #{delivery_info.map       { |k, v| "#{k}\t#{v}" }.join("\n")
+                                      }\n\n#{properties.map          { |k, v| "#{k}\t#{v}" }.join("\n")
+                                      }\n\n#{JSON.parse(payload).map { |k, v| "#{k}\t#{v}" }.join("\n")}" if @debug
+
+          elsif requests[__id__].nil?
+            puts "Received non-matching response, maybe previously timed out: \n\n#{delivery_info}\n\n#{properties}\n\n#{payload}\n."[..620].scan(/.{1,120}/).join(' '*30 + "\n") if @debug
+          else
+            # save the payload and send the signal to continue the execution of #command
+            # need to rescue the rare case, where lock and condition are destroyed right in parallel by timeout
+            begin 
+              puts "Received result for #{__id__}" if @debug
+              requests[__id__][:response] = payload
+              requests[__id__][:lock].synchronize { requests[__id__][:condition].signal }
+            rescue nil
+            end
+          end
+        end
+      end
+    end
+    JoschClient = JoSchClient
+  end
+end
+
+__END__

data/lib/cotcube-helpers/order_client.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bunny'
+require 'json'
+
+module Cotcube
+  module Helpers
+    class OrderClient
+      SECRETS_DEFAULT = {
+        'orderproxy_mq_proto'    => 'http',
+        'orderproxy_mq_user'     => 'guest',
+        'orderproxy_mq_password' => 'guest',
+        'orderproxy_mq_host'     => 'localhost',
+        'orderproxy_mq_port'     => '15672',
+        'orderproxy_mq_vhost'    => '%2F'
+      }.freeze
+
+      SECRETS = SECRETS_DEFAULT.merge(
+        lambda {
+          begin
+            YAML.safe_load(File.read(Cotcube::Helpers.init[:secrets_file]))
+          rescue StandardError
+            {}
+          end
+        }.call
+      )
+
+      def initialize
+        @connection = Bunny.new(user:     SECRETS['orderproxy_mq_user'],
+                                password: SECRETS['orderproxy_mq_password'],
+                                vhost:    SECRETS['orderproxy_mq_vhost'])
+        @connection.start
+
+        @commands  = connection.create_channel
+        @exchange  = commands.direct('orderproxy_commands')
+        @requests  = {}
+        @persistent = { depth: {}, realtimebars: {}, ticks: {} }
+        @debug     = false
+        setup_reply_queue
+      end
+
+      # command acts a synchronizer: it sends the command and waits for the response
+      #     otherwise times out --- the counterpart here is the subscription within 
+      #     setup_reply_queue
+      #
+      def command(command, timeout: 10)
+        command = { command: command.to_s } unless command.is_a? Hash
+        command[:timestamp] ||= (Time.now.to_f * 1000).to_i
+        request_id = Digest::SHA256.hexdigest(command.to_json)[..6]
+        requests[request_id] = {
+          request: command,
+          id: request_id,
+          lock: Mutex.new,
+          condition: ConditionVariable.new
+        }
+
+        exchange.publish(command.to_json,
+                         routing_key: 'orderproxy_commands',
+                         correlation_id: request_id,
+                         reply_to: reply_queue.name)
+
+        # wait for the signal to continue the execution
+        #
+        requests[request_id][:lock].synchronize do
+          requests[request_id][:condition].wait(requests[request_id][:lock], timeout)
+        end
+
+        # if we reached timeout, we will return nil, just for explicity
+        response = requests[request_id][:response].dup
+        requests.delete(request_id)
+        response
+      end
+
+      alias_method :send_command, :command
+
+      def stop
+        commands.close
+        connection.close
+      end
+
+      def get_contracts(symbol:)
+        send_command({ command: :get_contracts, symbol: symbol })
+      end
+
+      attr_accessor :response
+      attr_reader   :lock, :condition
+
+      private
+
+      attr_reader :call_id, :connection, :requests, :persistent,
+                  :commands, :server_queue_name, :reply_queue, :exchange
+
+      def setup_reply_queue
+        @reply_queue = commands.queue('', exclusive: true, auto_delete: true)
+        @reply_queue.bind(commands.exchange('orderproxy_replies'), routing_key: @reply_queue.name)
+
+        reply_queue.subscribe do |delivery_info, properties, payload|
+          __id__ = properties[:correlation_id]
+
+          if __id__.nil?
+            puts "Received without __id__: #{delivery_info.map       { |k, v| "#{k}\t#{v}" }.join("\n")
+                                      }\n\n#{properties.map          { |k, v| "#{k}\t#{v}" }.join("\n")
+                                      }\n\n#{JSON.parse(payload).map { |k, v| "#{k}\t#{v}" }.join("\n")}" if @debug
+
+          elsif requests[__id__].nil?
+            puts "Received non-matching response, maybe previously timed out: \n\n#{delivery_info}\n\n#{properties}\n\n#{payload}\n."[..620].scan(/.{1,120}/).join(' '*30 + "\n") if @debug
+          else
+            # save the payload and send the signal to continue the execution of #command
+            # need to rescue the rare case, where lock and condition are destroyed right in parallel by timeout
+            begin 
+              puts "Received result for #{__id__}" if @debug
+              requests[__id__][:response] = payload
+              requests[__id__][:lock].synchronize { requests[__id__][:condition].signal }
+            rescue nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+begin 
+  client = OrderClient.new
+  reply = client.send_command( { command: 'ping' } ) 
+  puts reply.nil? ? 'nil' : JSON.parse(reply)
+ensure
+  client.stop
+end

data/lib/cotcube-helpers.rb

@@ -53,5 +53,6 @@ module Cotcube
   end
 end
 
-require_relative 'cotcube-helpers/data_client'
-require_relative 'cotcube-helpers/cache_client'
+%w[ data cache order josch ].each do |part| 
+  require_relative "cotcube-helpers/#{part}_client"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-helpers
 version: !ruby/object:Gem::Version
-  version: 0.2.2.5
+  version: 0.2.3
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-23 00:00:00.000000000 Z
+date: 2021-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,7 +108,9 @@ files:
 - lib/cotcube-helpers/ib_contracts.rb
 - lib/cotcube-helpers/init.rb
 - lib/cotcube-helpers/input.rb
+- lib/cotcube-helpers/josch_client.rb
 - lib/cotcube-helpers/numeric_ext.rb
+- lib/cotcube-helpers/order_client.rb
 - lib/cotcube-helpers/orderclient.rb
 - lib/cotcube-helpers/output.rb
 - lib/cotcube-helpers/parallelize.rb