fix-engine 0.0.24

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c91eff8188ecd2d2a756b520272008fe02b84eda
+  data.tar.gz: f8a6ca41d7b37da9f38811a869d03013a1f925f1
+SHA512:
+  metadata.gz: a773023d43105871d71e3300ce97e9b8156e7412535f0a2867b2ec43bc826a7bd139c9e5cdb0a99c65f786ea5efced658bd1bd6b1cf590ccf03f6e8bbe72e0bd
+  data.tar.gz: bca29ee94ce994971a868db41c1fdb110b913923cd79d4e04b0a42633476d3c9d1b008921f669fee078d8e1edeb09b15e0adfd650313bbb22ebc5128e2ae73f1

data/LICENSE

@@ -0,0 +1,17 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+FIX Engine [![Build Status](https://secure.travis-ci.org/Paymium/fix-engine.png?branch=master)](http://travis-ci.org/Paymium/fix-engine)
+=
+
+This library provides an event-machine based FIX server.

data/bin/fix-engine

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'fix/engine'
+
+ip    = ENV['FE_IP']   || FE::DEFAULT_IP
+port  = ENV['FE_PORT'] || FE::DEFAULT_PORT
+
+Fix::Engine.run!(ip, port)
+

data/lib/fix/engine.rb

@@ -0,0 +1,38 @@
+require 'fix/engine/logger'
+require 'fix/engine/server'
+
+#
+# Main FIX namespace
+#
+module Fix
+
+  #
+  # Main Fix::Engine namespace
+  #
+  module Engine
+
+    # The default IP on which the server will listen    
+    DEFAULT_IP    = '0.0.0.0'
+
+    # The default port on which the server will listen
+    DEFAULT_PORT  = 8359
+
+    #
+    # Runs a FIX server engine
+    #
+    def self.run!(ip = DEFAULT_IP, port = DEFAULT_PORT, handler = FE::Connection)
+      Server.new(ip, port, handler).run!
+    end
+
+    #
+    # Alias the +Fix::Engine+ namespace to +FE+ if possible, because lazy is not necessarily dirty
+    #
+    def self.alias_namespace!
+      Object.const_set(:FE, Engine) unless Object.const_defined?(:FE)
+    end
+
+  end
+end
+
+Fix::Engine.alias_namespace!
+

data/lib/fix/engine/client.rb

@@ -0,0 +1,56 @@
+require 'fix/engine/logger'
+
+module Fix
+  module Engine
+
+    #
+    # Represents a connected client
+    #
+    class Client
+
+      @@clients = {}
+
+      attr_accessor :ip, :port, :connection, :client_id
+
+      include Logger
+
+      def initialize(ip, port, connection)
+        @ip         = ip
+        @port       = port
+        @connection = connection
+      end
+
+      #
+      # Returns a client instance from its connection IP
+      #
+      # @param ip [String] The connection IP
+      # @return [Fix::Engine::Client] The client connected for this IP
+      # 
+      def self.get(ip, port, connection)
+        @@clients[key(ip, port)] ||= Client.new(ip, port, connection)
+      end
+
+      def self.count
+        @@clients.count
+      end
+
+      def self.delete(ip, port)
+        @@clients.delete(key(ip, port))
+      end
+
+      def has_session?
+        !!client_id
+      end
+
+      def key
+        self.class.key(ip, port)
+      end
+
+      def self.key(ip, port)
+        "#{ip}:#{port}"
+      end
+
+    end
+  end
+end
+

data/lib/fix/engine/connection.rb

@@ -0,0 +1,292 @@
+require 'eventmachine'
+
+require 'fix/engine/message_buffer'
+require 'fix/engine/client'
+
+module Fix
+  module Engine
+
+    #
+    # The client connection handling logic and method overrides
+    #
+    class Connection < EM::Connection
+
+      include Logger
+
+      #
+      # Timespan during which a client must send a logon message after connecting
+      #
+      LOGON_TIMEOUT = 10
+
+      #
+      # Timespan during which we will wait for a heartbeat response from the client
+      #
+      HRTBT_TIMEOUT = 10
+
+      #
+      # Grace time before we disconnect a client that doesn't reply to a test request
+      #
+      TEST_REQ_GRACE_TIME = 15
+
+      attr_accessor :ip, :port, :client, :msg_buf, :hrtbt_int, :last_request_at
+
+      #
+      # Our own company ID
+      #
+      DEFAULT_COMP_ID = 'PYMBTC'
+
+      #
+      # Run after a client has connected
+      #
+      def post_init
+        @port, @ip            = Socket.unpack_sockaddr_in(get_peername)
+        @client               = Client.get(ip, port, self)
+        @expected_clt_seq_num = 1
+
+        log("Client connected from <#{@client.key}>, expecting logon message in the next #{LOGON_TIMEOUT}s")
+
+        @comp_id ||= DEFAULT_COMP_ID
+        
+        # The sent messages
+        @messages = []
+
+        # TODO : How do we test this
+        # TODO : Do we cancel the periodic timeout when leaving ?
+        EM.add_timer(LOGON_TIMEOUT) { logon_timeout }
+      end
+
+      def logon_timeout
+        unless client.has_session?
+          log("Client <#{client.key}> failed to authenticate before timeout, closing connection")
+          close_connection_after_writing
+          Client.delete(ip, port)
+        end
+      end
+
+      def manage_hrtbts
+        @last_send_at     ||= 0
+        @last_request_at  ||= 0
+        @hrtbt_int        ||= 0
+
+        # Send a regular heartbeat when we don't send anything down the line for a while
+        if @hrtbt_int > 0 && (@last_send_at < (Time.now.to_i - @hrtbt_int))
+          send_heartbeat
+        end
+
+        # Trigger a test req message when we haven't received anything for a while
+        if !@pending_test_req_id && (last_request_at < (Time.now.to_i - @hrtbt_int))
+          tr = FP::Messages::TestRequest.new
+          tr.test_req_id = SecureRandom.hex(6)
+          send_msg(tr)
+          @pending_test_req_id = tr.test_req_id
+
+          EM.add_timer(TEST_REQ_GRACE_TIME) do
+            @pending_test_req_id && kill!
+          end
+        end
+      end
+
+      def send_msg(msg)
+        @send_seq_num ||= 1
+
+        msg.msg_seq_num     = @send_seq_num
+        msg.sender_comp_id  = @comp_id
+        msg.target_comp_id  ||= @client_comp_id
+
+        log("Sending <#{msg.class}> to <#{ip}:#{port}> with sequence number <#{msg.msg_seq_num}>")
+
+        if msg.valid?
+          @messages[msg.msg_seq_num] = msg
+          send_data(msg.dump)
+          @send_seq_num += 1
+          @last_send_at = Time.now.to_i
+        else
+          log(msg.errors.join(', '))
+          raise "Tried to send invalid message!"
+        end
+      end
+
+      def set_heartbeat_interval(interval)
+        @hrtbt_int && raise("Can't set heartbeat interval twice")
+        @hrtbt_int = interval
+
+        log("Heartbeat interval for <#{ip}:#{port}> : <#{hrtbt_int}s>")
+        @hrtbt_monitor  = EM.add_periodic_timer(1) { manage_hrtbts }
+      end
+
+      def kill!
+        if @client_comp_id
+          log("Logging out client <#{ip}:#{port}>")
+          logout = FP::Messages::Logout.new
+          logout.text = 'Bye!'
+          send_msg(logout)
+        end
+
+        close_connection_after_writing
+      end
+
+      def unbind
+        log("Terminating client <#{ip}:#{port}>")
+        Client.delete(ip, port)
+        @hrtbt_monitor && @hrtbt_monitor.cancel
+      end
+
+      def client_error(error_msg, msg_seq_num, opts = {})
+        log("Client error: \"#{error_msg}\"")
+        rjct = FP::Messages::Reject.new
+        rjct.text = error_msg
+        rjct.ref_seq_num = msg_seq_num
+        rjct.target_comp_id = opts[:target_comp_id] if opts[:target_comp_id]
+        send_msg(rjct)
+        kill!
+      end
+
+      def handle_msg(msg)
+        @recv_seq_num = msg.msg_seq_num
+       
+        log("Received a <#{msg.class}> from <#{ip}:#{port}> with sequence number <#{msg.msg_seq_num}>")
+
+        # If sequence number == expected, then process it normally
+        if (@expected_clt_seq_num == @recv_seq_num)
+
+          if @comp_id && msg.target_comp_id != @comp_id
+            @client_comp_id = msg.sender_comp_id
+
+            if (msg.target_comp_id != @comp_id)
+              client_error("Incorrect TARGET_COMP_ID in message, expected <#{@comp_id}>, got <#{msg.target_comp_id}>", msg.header.msg_seq_num)
+            end
+
+          else
+            if !@client_comp_id && msg.is_a?(FP::Messages::Logon)
+              log("Client authenticated as <#{msg.username}> with heartbeat interval of <#{msg.heart_bt_int}s> and message sequence number start <#{msg.msg_seq_num}>")
+              client.client_id  = msg.username
+              @client_comp_id   = msg.sender_comp_id
+              set_heartbeat_interval(msg.heart_bt_int)
+
+              logon = FP::Messages::Logon.new
+              logon.username            = msg.username
+              logon.target_comp_id      = msg.sender_comp_id
+              logon.sender_comp_id      = msg.target_comp_id 
+              logon.reset_seq_num_flag  = true
+              send_msg(logon)
+
+            elsif @client_comp_id && msg.is_a?(FP::Messages::Logon)
+              log("Received second logon message, reset_seq_num_flag <#{msg.reset_seq_num_flag}>")
+              if msg.reset_seq_num_flag = 'Y'
+                @send_seq_num = 1
+                @messages = []
+              end
+
+            elsif !@client_comp_id
+              client_error("The session must be started with a logon message", msg.msg_seq_num, target_comp_id: msg.sender_comp_id)
+
+            elsif msg.is_a?(FP::Messages::Heartbeat)
+              # If we were expecting an answer to a test request we can sign it off and
+              # cancel the scheduled connection termination
+              if @pending_test_req_id && msg.test_req_id && (@pending_test_req_id == msg.test_req_id)
+                @pending_test_req_id = nil
+              end
+
+            elsif msg.is_a?(FP::Messages::TestRequest)
+              # Answer test requests with a matching heartbeat
+              hb = FP::Messages::Heartbeat.new
+              hb.test_req_id = msg.test_req_id
+              send_msg(hb)
+
+            elsif msg.is_a?(FP::Messages::ResendRequest)
+              # Re-send requested message range
+              @messages[msg.begin_seq_no, msg.end_seq_no.zero? ? @messages.length : msg.end_seq_no].each do |m|
+                log("Re-sending <#{m.class}> to <#{ip}:#{port}> with sequence number <#{m.msg_seq_num}>")
+                send_data(m.dump)
+                @last_send_at = Time.now.to_i
+              end
+
+            elsif msg.is_a?(FP::Message)
+              on_message(msg)
+            end
+          end
+
+          @expected_clt_seq_num += 1
+
+        elsif msg.is_a?(FP::Messages::Logon)
+          client_error("Expected logon message to have msg_seq_num = <1>, received <#{msg.msg_seq_num}>", msg.msg_seq_num, target_comp_id: msg.sender_comp_id)
+
+        elsif (@expected_clt_seq_num > @recv_seq_num)
+          log("Ignoring message <#{msg}> with stale sequence number <#{msg.msg_seq_num}>, expecting <#{@expected_clt_seq_num}>")
+
+        elsif (@expected_clt_seq_num < @recv_seq_num) && @client_comp_id
+          # Request missing range when detect a gap
+          rr = FP::Messages::ResendRequest.new
+          rr.begin_seq_no = @expected_clt_seq_num
+          send_msg(rr)
+        end
+
+        self.last_request_at = Time.now.to_i
+      end
+
+      def on_message(msg)
+      end
+
+      #
+      # Run when a client has sent a chunk of data, it gets appended to a buffer
+      # and a parsing attempt is made at the buffered data
+      #
+      # @param data [String] The received data chunk
+      #
+      def receive_data(data)
+        data_chunk = data.chomp
+        msg_buf << data_chunk
+
+        begin
+          parse_messages_from_buffer
+        rescue
+          log("Client <#{@client.key}> raised exception when parsing data <#{data.gsub(/\x01/, '|')}>, terminating.")
+          log($!.message + $!.backtrace.join("\n"))
+          kill!
+        end
+      end
+
+      #
+      # Attempts to parse fields from the message buffer, if the fields that get parsed
+      # complete the temporary message, it is handled
+      #
+      def parse_messages_from_buffer
+        while idx = msg_buf.index("\x01")
+          field = msg_buf.slice!(0, idx + 1).gsub(/\x01\Z/, '')
+          msg.append(field)
+
+          if msg.complete?
+            parsed = msg.parse!
+            if parsed.is_a?(FP::Message)
+              handle_msg(parsed)
+            elsif parsed.is_a?(FP::ParseFailure)
+              client_error(parsed.errors.join(", "), @expected_clt_seq_num, target_comp_id: (@client_comp_id || 'UNKNOWN'))
+            end
+          end
+        end
+      end
+
+      #
+      # The data buffer string
+      #
+      def msg_buf
+        @msg_buf ||= ''
+      end
+
+      #
+      # The temporary message to which fields get appended
+      #
+      def msg
+        @msg ||= MessageBuffer.new(@client)
+      end
+
+      def send_heartbeat(test_req_id = nil)
+        msg = FP::Messages::Heartbeat.new
+        test_req_id && msg.test_req_id = test_req_id
+        send_msg(msg)
+      end
+
+    end
+  end
+end
+

data/lib/fix/engine/logger.rb

@@ -0,0 +1,33 @@
+require 'logger'
+
+module Fix
+  module Engine
+
+    #
+    # Naive logger implementation used in development
+    #
+    module Logger
+
+      @@logger = nil
+
+      #
+      # Logs a message to the standard output
+      #
+      # @param msg [String] The message to log
+      #
+      def log(msg)
+        FE::Logger.log(msg)
+      end
+
+      #
+      # Class-methods are easier to stub to disable logging while
+      # running specs
+      #
+      def self.log(msg)
+        @logger ||= ::Logger.new(STDOUT)
+        @logger.debug(msg)
+      end
+
+    end
+  end
+end

data/lib/fix/engine/message_buffer.rb

@@ -0,0 +1,83 @@
+require 'fix/protocol'
+
+module Fix
+  module Engine
+
+    #
+    # A FIX message to which fields get appended, once it is completed by a
+    # proper terminator it is handled
+    #
+    class MessageBuffer
+
+      include Logger
+
+      attr_accessor :fields, :client
+
+      def initialize(client)
+        @fields = []
+        @client = client
+      end
+
+      #
+      # Append a single FIX field to the message
+      #
+      # @param fld [String] A FIX formatted field, such as "35=0\x01"
+      #
+      def append(fld)
+        raise "Cannot append to complete message" if complete?
+        field = fld.split('=')
+        field[0] = field[0].to_i
+        field[1] = field[1].gsub(/\x01\Z/, '')
+        @fields << field
+      end
+
+      #
+      # Returns true if the last field of the collection is a FIX checksum
+      #
+      # @return [Boolean] Whether the message is complete
+      #
+      def complete?
+        (@fields.count > 0) && (@fields.last[0] == 10)
+      end
+
+      #
+      # Parses the message into a FP::Message instance
+      #
+      def parse
+        msg = FP.parse(to_s)
+        if (msg.class == FP::ParseFailure) || !msg.errors.count.zero?
+          log("Failed to parse message <#{debug}>")
+          log_errors(msg)
+        end
+
+        msg
+      end
+
+      #
+      # Parses the message and empties the fields array so a new message
+      # can start to get buffered right away
+      #
+      def parse!
+        parsed = parse
+        @fields = []
+        parsed
+      end
+
+      def debug
+        to_s('|')
+      end
+
+      def to_s(sep = "\x01")
+        fields.map { |f| f.join('=') }.join(sep) + sep
+      end
+
+      def log_errors(msg)
+        log("Invalid message received <#{debug}>")
+        msg.errors.each { |e| log(" >>> #{e}") }
+      end
+
+
+    end
+  end
+end
+

data/lib/fix/engine/server.rb

@@ -0,0 +1,51 @@
+require 'eventmachine'
+
+require 'fix/protocol'
+require 'fix/engine/version'
+require 'fix/engine/connection'
+
+module Fix
+  module Engine
+
+    #
+    # Main FIX engine server class
+    #
+    class Server
+
+      include Logger
+
+      REPORT_INTERVAL = 10
+
+      attr_accessor :ip, :port
+
+      def initialize(ip, port, handler)
+        @ip       = ip
+        @port     = port
+        @handler  = handler
+      end
+
+      #
+      # Starts running the server engine
+      #
+      def run!
+        trap('INT') { EM.stop }
+        log("Starting FIX engine v#{FE::VERSION}, listening on <#{ip}:#{port}>, exit with <Ctrl-C>")
+        EM.run { start_server }
+      end
+
+      #
+      # Starts a listener inside a running reactor
+      #
+      def start_server
+        raise "EventMachine must be running to start a server" unless EM.reactor_running?
+        EM.start_server(ip, port, @handler)
+        REPORT_INTERVAL && EM.add_periodic_timer(REPORT_INTERVAL) { report_status }
+      end
+
+      def report_status
+        log("#{Client.count} client(s) currently connected")
+      end
+
+    end
+  end
+end

data/lib/fix/engine/version.rb

@@ -0,0 +1,10 @@
+module Fix
+  module Engine
+
+  #
+  # The fix-engine gem version string
+  #   
+  VERSION = '0.0.24'
+
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: fix-engine
+version: !ruby/object:Gem::Version
+  version: 0.0.24
+platform: ruby
+authors:
+- David François
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fix-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: FIX engine handling connections, sessions, and message callbacks
+email:
+- david.francois@paymium.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/fix-engine
+- lib/fix/engine.rb
+- lib/fix/engine/client.rb
+- lib/fix/engine/connection.rb
+- lib/fix/engine/logger.rb
+- lib/fix/engine/message_buffer.rb
+- lib/fix/engine/server.rb
+- lib/fix/engine/version.rb
+homepage: https://github.com/paymium/fix-engine
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: FIX engine handling connections, sessions, and message callbacks
+test_files: []
+has_rdoc: