Initial commit

app/workers/amqp/matching.rb

@@ -0,0 +1,160 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Workers
+  module AMQP
+    class Matching < Base
+
+      class DryrunError < StandardError
+        attr :engine
+
+        def initialize(engine)
+          @engine = engine
+        end
+      end
+
+      def initialize(options={})
+        @options = options
+        reload 'all'
+      end
+
+      def process(payload, metadata, delivery_info)
+        payload.symbolize_keys!
+
+        case payload[:action]
+        when 'submit'
+          submit build_order(payload[:order])
+        when 'cancel'
+          cancel build_order(payload[:order])
+        when 'reload'
+          reload payload[:market]
+        when 'new'
+          initialize_engine Market.find(payload[:market])
+        else
+          Rails.logger.fatal { "Unknown action: #{payload[:action]}" }
+        end
+      end
+
+      def submit(order)
+        engines[order.market].submit(order)
+      end
+
+      def cancel(order)
+        engines[order.market].cancel(order)
+      end
+
+      def reload(market)
+        if market == 'all'
+          # NOTE: Run matching engine for disabled markets.
+          Market.find_each(&method(:initialize_engine))
+          Rails.logger.info { "All engines reloaded." }
+        else
+          initialize_engine Market.find(market)
+          Rails.logger.info { "#{market} engine reloaded." }
+        end
+      rescue DryrunError => e
+        # stop started engines
+        engines.each {|id, engine| engine.shift_gears(:dryrun) unless engine == e.engine }
+
+        Rails.logger.fatal { "#{market} engine failed to start. Matched during dryrun:" }
+        e.engine.queue.each do |trade|
+          Rails.logger.info { trade[1].inspect }
+        end
+      end
+
+      def build_order(attrs)
+        ::Matching::OrderBookManager.build_order attrs
+      end
+
+      def initialize_engine(market)
+        engine = create_engine(market)
+        load_orders(market)
+        engine.initializing = false
+        engine.publish_snapshot
+        start_engine(market)
+      end
+
+      def create_engine(market)
+        engines[market.id] = ::Matching::Engine.new(market, @options)
+      end
+
+      def load_orders(market)
+        ::Order.active.with_market(market.id).order('id asc').each do |order|
+          submit build_order(order.to_matching_attributes)
+        end
+      end
+
+      def start_engine(market)
+        engine = engines[market.id]
+        if engine.mode == :dryrun
+          if engine.queue.empty?
+            engine.shift_gears :run
+          else
+            accept = ENV['ACCEPT_MINUTES'] ? ENV['ACCEPT_MINUTES'].to_i : 30
+            order_ids = engine.queue
+              .map {|args| [args[1][:trade][:maker_order_id], args[1][:trade][:taker_order_id]] }
+              .flatten.uniq
+
+            orders = Order.where('created_at < ?', accept.minutes.ago).where(id: order_ids)
+            if orders.exists?
+              # there're very old orders matched, need human intervention
+              raise DryrunError, engine
+            else
+              # only buffered orders matched, just publish trades and continue
+              engine.queue.each {|args| ::AMQP::Queue.enqueue(*args) }
+              engine.shift_gears :run
+            end
+          end
+        else
+          Rails.logger.info { "#{market.id} engine already started. mode=#{engine.mode}" }
+        end
+      end
+
+      def engines
+        @engines ||= {}
+      end
+
+      # dump limit orderbook
+      def on_usr1
+        engines.each do |id, eng|
+          dump_file = File.join('/', 'tmp', "limit_orderbook_#{id}")
+          limit_orders = eng.limit_orders
+
+          File.open(dump_file, 'w') do |f|
+            f.puts "ASK"
+            limit_orders[:ask].keys.reverse.each do |k|
+              f.puts k.to_s('F')
+              limit_orders[:ask][k].each {|o| f.puts "\t#{o.label}" }
+            end
+            f.puts "-"*40
+            limit_orders[:bid].keys.reverse.each do |k|
+              f.puts k.to_s('F')
+              limit_orders[:bid][k].each {|o| f.puts "\t#{o.label}" }
+            end
+            f.puts "BID"
+          end
+
+          puts "#{id} limit orderbook dumped to #{dump_file}."
+        end
+      end
+
+      # dump market orderbook
+      def on_usr2
+        engines.each do |id, eng|
+          dump_file = File.join('/', 'tmp', "market_orderbook_#{id}")
+          market_orders = eng.market_orders
+
+          File.open(dump_file, 'w') do |f|
+            f.puts "ASK"
+            market_orders[:ask].each {|o| f.puts "\t#{o.label}" }
+            f.puts "-"*40
+            market_orders[:bid].each {|o| f.puts "\t#{o.label}" }
+            f.puts "BID"
+          end
+
+          puts "#{id} market orderbook dumped to #{dump_file}."
+        end
+      end
+    end
+  end
+end