fix-engine 0.0.24 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c91eff8188ecd2d2a756b520272008fe02b84eda
-  data.tar.gz: f8a6ca41d7b37da9f38811a869d03013a1f925f1
+  metadata.gz: 32ec2077ed212596bc692e4650be57c8a003a55c
+  data.tar.gz: e2ad9ef6e6824e8d06de895dd44747f01a10934f
 SHA512:
-  metadata.gz: a773023d43105871d71e3300ce97e9b8156e7412535f0a2867b2ec43bc826a7bd139c9e5cdb0a99c65f786ea5efced658bd1bd6b1cf590ccf03f6e8bbe72e0bd
-  data.tar.gz: bca29ee94ce994971a868db41c1fdb110b913923cd79d4e04b0a42633476d3c9d1b008921f669fee078d8e1edeb09b15e0adfd650313bbb22ebc5128e2ae73f1
+  metadata.gz: 3cced1625f0196a24a4006e1b9784fa5db83d9141167bca0286bab405fd0e6abefa5ebf0db81b6042ec66fd4824e48b5d5ad1d4e0dd0d561a2bd56e9e075b46c
+  data.tar.gz: 36a2e95f782491cd465c5bf81029a84956884d85180c2beb08dff94652f261a43490d2bdd86feff1ec4bc2c770c99b886fc133ded5fc68b126f59e09710e1642

data/README.md

@@ -1,4 +1,154 @@
 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.
+This library provides an event-machine based FIX server and client connection implementation.
+
+# Usage as a FIX client
+
+## Implement a connection handler
+
+Create an `EM::Connection` subclass and include the `FE::ClientConnection` module. You will then have to implement
+the callbacks for the various message types you are interested in.
+
+````ruby
+require 'fix/engine'
+
+module Referee
+
+  class FixConnection < EM::Connection
+
+    include FE::ClientConnection
+
+    attr_accessor :exchange
+
+    #
+    # When a logon message is received we request a market snapshot
+    # and subscribe for continuous updates
+    #
+    def on_logon(msg)
+      mdr = FP::Messages::MarketDataRequest.new
+
+      mdr.md_req_id = 'foo'
+
+      mdr.subscription_request_type = :updates
+      mdr.market_depth              = :full
+      mdr.md_update_type            = :incremental
+
+      mdr.instruments.build do |i|
+        i.symbol = 'EUR/XBT'
+      end
+
+      [:bid, :ask, :trade, :open, :vwap, :close].each do |mdet|
+        mdr.md_entry_types.build do |m|
+          m.md_entry_type = mdet
+        end
+      end
+
+      send_msg(mdr)
+    end
+
+    # Called when a market data snapshot is received
+    def on_market_data_snapshot(msg)
+      update_book_with(msg)
+    end
+
+    # Called upon each subsequent update
+    def on_market_data_incremental_refresh(msg)
+      update_book_with(msg)
+    end
+
+    # Update the local order book copy with the new data
+    def update_book_with(msg)
+      msg.md_entries.each do |mde|
+        exchange.book[mde.md_entry_type].set_depth_at(BigDecimal(mde.md_entry_px), BigDecimal(mde.md_entry_size))
+      end
+    end
+
+  end
+end
+````
+
+## Use it to connect to a FIX acceptor
+
+Once your connection class has been created you can establish a connection in a running EventMachine reactor. 
+See the [referee gem](https://github.com/davout/referee) for the full code example.
+
+````ruby
+require 'referee/exchange'
+require 'referee/fix_connection'
+
+module Referee
+  module Exchanges
+    class Paymium < Referee::Exchange
+
+      FIX_SERVER  = 'fix.paymium.com'
+      FIX_PORT    = 8359
+
+      def symbol
+        'PAYM'
+      end
+
+      def currency
+        'EUR'
+      end
+
+      def connect
+        FE::Logger.logger.level = Logger::WARN
+
+        EM.connect(FIX_SERVER, FIX_PORT, FixConnection) do |conn|
+          conn.target_comp_id = 'PAYMIUM'
+          conn.comp_id        = 'BC-U458625'
+          conn.username       = 'BC-U458625'
+          conn.exchange       = self
+        end
+      end
+    end
+  end
+end
+````
+
+
+# Usage as a FIX acceptor
+
+You can start a simple FIX acceptor that will maintain a session by running the `fix-engine` executable.
+The basic FIX acceptor requires a `COMP_ID` environment variable to be set.
+
+````
+$ COMP_ID=MY_COMP_ID fix-engine
+
+> D, [2015-01-07T12:47:07.807867 #87486] DEBUG -- : Starting FIX engine v0.0.31, listening on <0.0.0.0:8359>, exit with <Ctrl-C>
+> D, [2015-01-07T12:47:12.379787 #87486] DEBUG -- : Client connected <127.0.0.1:54204>, expecting logon message in the next 10s
+> D, [2015-01-07T12:47:12.816626 #87486] DEBUG -- : Received a <Fix::Protocol::Messages::Logon> from <127.0.0.1:54204> with sequence number <1>
+> D, [2015-01-07T12:47:12.820093 #87486] DEBUG -- : Peer authenticated as <JAVA_TESTS> with heartbeat interval of <30s> and message sequence number start <1>
+> D, [2015-01-07T12:47:12.820259 #87486] DEBUG -- : Heartbeat interval for <127.0.0.1:54204> : <30s>
+> D, [2015-01-07T12:47:12.820899 #87486] DEBUG -- : Sending <Fix::Protocol::Messages::Logon> to <127.0.0.1:54204> with sequence number <1>
+````
+
+In order to handle business messages appropriately you need to implement a connection handler
+that includes the `FE::ServerConnection` module and use that as a connection handler.
+
+````ruby
+class MyHandler < EM::Connection
+
+  include FE::ServerConnection
+
+  def on_market_data_request
+    # Fetch market data and send the relevant response
+    #  ...
+  end
+
+end
+
+server = FE::Server.new('127.0.0.1', 8095, MyHandler) do |conn|
+  conn.comp_id = 'MY_COMP_ID'
+end
+
+# This will also start an EventMachine reactor
+server.run!
+
+# This would be used inside an already-running reactor
+EM.run do
+  server.start_server
+end
+````
+

data/bin/fix-engine

@@ -5,5 +5,11 @@ require 'fix/engine'
 ip    = ENV['FE_IP']   || FE::DEFAULT_IP
 port  = ENV['FE_PORT'] || FE::DEFAULT_PORT
 
-Fix::Engine.run!(ip, port)
+if ENV['COMP_ID']
+  Fix::Engine.run!(ip, port) do |conn|
+    conn.comp_id = ENV['COMP_ID']
+  end
+else
+  puts "The COMP_ID environment variable must be set to be able to start a basic acceptor."
+end
 

data/lib/fix/engine.rb

@@ -1,5 +1,6 @@
 require 'fix/engine/logger'
 require 'fix/engine/server'
+require 'fix/engine/client_connection'
 
 #
 # Main FIX namespace
@@ -20,8 +21,8 @@ module Fix
     #
     # Runs a FIX server engine
     #
-    def self.run!(ip = DEFAULT_IP, port = DEFAULT_PORT, handler = FE::Connection)
-      Server.new(ip, port, handler).run!
+    def self.run!(ip = DEFAULT_IP, port = DEFAULT_PORT, handler = FE::ServerConnection, &block)
+      Server.new(ip, port, handler, &block).run!
     end
 
     #

data/lib/fix/engine/client.rb

@@ -8,9 +8,9 @@ module Fix
     #
     class Client
 
-      @@clients = {}
+      @clients = {}
 
-      attr_accessor :ip, :port, :connection, :client_id
+      attr_accessor :ip, :port, :connection, :username
 
       include Logger
 
@@ -18,34 +18,65 @@ module Fix
         @ip         = ip
         @port       = port
         @connection = connection
+       
+        self.class.instance_variable_get(:@clients)[key] = self 
       end
 
       #
       # Returns a client instance from its connection IP
       #
       # @param ip [String] The connection IP
+      # @param port [Fixnum] The connection port
+      # @param connection [FE::Connection] Optionnally the connection which will used to create an instance if none exists 
       # @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)
+      def self.get(ip, port, connection = nil)
+        @clients[key(ip, port)] || Client.new(ip, port, connection)
       end
 
+      #
+      # Returns the count of currently connected clients
+      #
+      # @return [Fixnum] The client count
+      #
       def self.count
-        @@clients.count
+        @clients.count
       end
 
+      #
+      # Removes a client from the currently connected ones
+      #
+      # @param ip [String] The client's remote IP
+      # @param port [Fixnum] The client's port
+      #
       def self.delete(ip, port)
-        @@clients.delete(key(ip, port))
-      end
-
-      def has_session?
-        !!client_id
+        @clients.delete(key(ip, port))
       end
 
+      #
+      # Returns an identifier for the current client
+      #
+      # @return [String] An identifier
+      #
       def key
         self.class.key(ip, port)
       end
 
+      #
+      # Removes the current client from the array of connected ones
+      #
+      def delete
+        self.class.delete(ip, port)
+      end
+
+      #
+      # Returns an identifier for the given IP and port
+      #
+      # @param ip [String] The client's remote IP
+      # @param port [Fixnum] The client's port
+      #
+      # @return [String] An identifier
+      #
       def self.key(ip, port)
         "#{ip}:#{port}"
       end

data/lib/fix/engine/client_connection.rb

@@ -0,0 +1,50 @@
+require 'fix/engine/connection'
+
+module Fix
+  module Engine
+
+    #
+    # The client connection wrapper, used in order to connect a remote FIX server
+    #
+    module ClientConnection
+
+      include Connection
+
+      attr_accessor :username
+
+      #
+      # Run after we've connected to the server
+      #
+      def post_init
+        super
+
+        log("Connecting to server sending a logon message with our COMP_ID <#{@comp_id}>")
+
+        @logged_in = false
+
+        EM.next_tick { send_logon }
+      end
+
+      #
+      # Sends a logon message to the server we're connected to
+      #
+      def send_logon
+        logon = FP::Messages::Logon.new
+        logon.username            = @username
+        logon.target_comp_id      = @peer_comp_id
+        logon.sender_comp_id      = @comp_id 
+        logon.reset_seq_num_flag  = true
+        send_msg(logon)
+      end
+
+      #
+      # Consider ourselves logged-in if we receive on of these
+      #
+      def on_logon(msg)
+        @logged_in = true
+      end
+
+    end
+  end
+end
+

data/lib/fix/engine/connection.rb

@@ -1,7 +1,6 @@
 require 'eventmachine'
 
 require 'fix/engine/message_buffer'
-require 'fix/engine/client'
 
 module Fix
   module Engine
@@ -9,61 +8,52 @@ module Fix
     #
     # The client connection handling logic and method overrides
     #
-    class Connection < EM::Connection
+    module 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
+      attr_accessor :ip, :port, :msg_buf, :hrtbt_int, :last_request_at, :comp_id, :target_comp_id
 
       #
-      # Our own company ID
-      #
-      DEFAULT_COMP_ID = 'PYMBTC'
-
-      #
-      # Run after a client has connected
+      # Initialize the messages array, our comp_id, and the expected message sequence number
       #
       def post_init
-        @port, @ip            = Socket.unpack_sockaddr_in(get_peername)
-        @client               = Client.get(ip, port, self)
-        @expected_clt_seq_num = 1
+        @expected_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 = []
+      end
 
-        # TODO : How do we test this
-        # TODO : Do we cancel the periodic timeout when leaving ?
-        EM.add_timer(LOGON_TIMEOUT) { logon_timeout }
+      #
+      # The way we refer to our connection peer in various logs and messages
+      #
+      def peer
+        "server"
       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
+      #
+      # Sets the heartbeat interval and schedules the keep alive call
+      #
+      # @param interval [Fixnum] The frequency in seconds at which a heartbeat should be emitted
+      #
+      def set_heartbeat_interval(interval)
+        @hrtbt_int && raise("Can't set heartbeat interval twice")
+        @hrtbt_int = interval
+
+        log("Heartbeat interval for #{peer} : <#{hrtbt_int}s>")
+        @keep_alive_timer = EM.add_periodic_timer(1) { keep_alive }
       end
 
-      def manage_hrtbts
+      #
+      # Keeps the connection alive by sending regular heartbeats, and test request
+      # messages whenever the connection has been idl'ing for too long
+      #
+      def keep_alive
         @last_send_at     ||= 0
         @last_request_at  ||= 0
         @hrtbt_int        ||= 0
@@ -75,25 +65,48 @@ module Fix
 
         # 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
+          send_test_request
+        end
+      end
 
-          EM.add_timer(TEST_REQ_GRACE_TIME) do
-            @pending_test_req_id && kill!
-          end
+      #
+      # Sends a test request and expects an answer before +TEST_REQ_GRACE_TIME+
+      #
+      def send_test_request
+        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
 
+      #
+      # Sends a heartbeat message with an optional +test_req_id+ parameter
+      #
+      # @param test_req_id [String] Sets the test request ID if sent in response to a test request
+      #
+      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
+
+      #
+      # Sends a +Fix::Protocol::Message+ to the connected peer
+      #
+      # @param msg [Fix::Protocol::Message] The message to send
+      #
       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
+        msg.target_comp_id  = @target_comp_id
 
-        log("Sending <#{msg.class}> to <#{ip}:#{port}> with sequence number <#{msg.msg_seq_num}>")
+        log("Sending <#{msg.class}> to #{peer} with sequence number <#{msg.msg_seq_num}>")
 
         if msg.valid?
           @messages[msg.msg_seq_num] = msg
@@ -102,85 +115,71 @@ module Fix
           @last_send_at = Time.now.to_i
         else
           log(msg.errors.join(', '))
-          raise "Tried to send invalid message!"
+          raise "Tried to send invalid message! <#{msg.errors.join(', ')}>"
         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
-
+      #
+      # Kills the connection after sending a logout message, if applicable
+      #
       def kill!
-        if @client_comp_id
-          log("Logging out client <#{ip}:#{port}>")
+        if @target_comp_id
+          log("Logging out #{peer}")
+
           logout = FP::Messages::Logout.new
           logout.text = 'Bye!'
+
           send_msg(logout)
         end
 
         close_connection_after_writing
       end
 
+      #
+      # Cleans up after we're done
+      #
       def unbind
-        log("Terminating client <#{ip}:#{port}>")
-        Client.delete(ip, port)
-        @hrtbt_monitor && @hrtbt_monitor.cancel
+        log("Terminating connection to #{peer}")
+        @keep_alive_timer && @keep_alive_timer.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]
+      #
+      # Notifies the connected peer it fucked up somehow and kill the connection
+      #
+      # @param error_msg [String] The reason to embed in the reject message
+      # @param msg_seq_num [Fixnum] The message sequence number this error pertains to
+      #
+      def peer_error(error_msg, msg_seq_num)
+        log("Notifying #{peer} of error: <#{error_msg}> and terminating")
+
+        rjct              = FP::Messages::Reject.new
+        rjct.text         = error_msg
+        rjct.ref_seq_num  = msg_seq_num
+
         send_msg(rjct)
         kill!
       end
 
-      def handle_msg(msg)
+      #
+      # Maintains the message sequence consistency before handing off the message to +#handle_msg+
+      #
+      def process_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)
+        log("Received a <#{msg.class}> from #{peer} with sequence number <#{msg.msg_seq_num}>")
 
+        # If sequence number == expected, then process it normally
+        if (@expected_seq_num == @recv_seq_num)
           if @comp_id && msg.target_comp_id != @comp_id
-            @client_comp_id = msg.sender_comp_id
+            @target_comp_id = msg.sender_comp_id
 
+            # Whoops, incorrect COMP_ID received, kill it with fire
             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)
+              peer_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 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)
@@ -195,36 +194,40 @@ module Fix
 
             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|
+              @messages[msg.begin_seq_no - 1, (msg.end_seq_no.zero? ? @messages.length : (msg.end_seq_no - msg.begin_seq_no + 1))].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)
+              run_message_handler(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)
+          @expected_seq_num += 1
 
-        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_seq_num > @recv_seq_num)
+          log("Ignoring message <#{msg}> with stale sequence number <#{msg.msg_seq_num}>, expecting <#{@expected_seq_num}>")
 
-        elsif (@expected_clt_seq_num < @recv_seq_num) && @client_comp_id
+        elsif (@expected_seq_num < @recv_seq_num) && @target_comp_id
           # Request missing range when detect a gap
           rr = FP::Messages::ResendRequest.new
-          rr.begin_seq_no = @expected_clt_seq_num
+          rr.begin_seq_no = @expected_seq_num
           send_msg(rr)
         end
 
         self.last_request_at = Time.now.to_i
       end
 
-      def on_message(msg)
+      #
+      # Runs the defined message handler for the message's class
+      #
+      # @param msg [FP::Message] The message to handle
+      #
+      def run_message_handler(msg)
+        m = "on_#{msg.class.to_s.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase}".to_sym
+        send(m, msg) if respond_to?(m)
       end
 
       #
@@ -234,58 +237,27 @@ module Fix
       # @param data [String] The received data chunk
       #
       def receive_data(data)
-        data_chunk = data.chomp
-        msg_buf << data_chunk
+        @buf ||= MessageBuffer.new do |parsed|
+          if (parsed.class == FP::ParseFailure) || !parsed.errors.count.zero?
+            peer_error("#{parsed.message} -- #{parsed.errors.join(", ")}", @expected_seq_num)
+            log("Failed to parse message <#{parsed.message}>")
+            parsed.errors.each { |err| log(" >>> #{err}") }
+
+          else
+            process_msg(parsed)
+
+          end
+        end
 
         begin
-          parse_messages_from_buffer
+          @buf.add_data(data)
         rescue
-          log("Client <#{@client.key}> raised exception when parsing data <#{data.gsub(/\x01/, '|')}>, terminating.")
+          log("Raised exception by #{peer} when parsing data <#{@buf.msg_buf.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

@@ -24,8 +24,14 @@ module Fix
       # running specs
       #
       def self.log(msg)
+        logger.debug(msg)
+      end
+
+      #
+      # Returns the current logger
+      #
+      def self.logger
         @logger ||= ::Logger.new(STDOUT)
-        @logger.debug(msg)
       end
 
     end

data/lib/fix/engine/message_buffer.rb

@@ -13,9 +13,21 @@ module Fix
 
       attr_accessor :fields, :client
 
-      def initialize(client)
+      def initialize(&block)
         @fields = []
-        @client = client
+
+        raise "A block accepting a FP::Message as single parameter must be provided" unless (block && (block.arity == 1))
+        @msg_handler = block
+      end
+
+      #
+      # Adds received bytes to the message buffer and attempt to process them
+      #
+      # @param data [String] The received FIX message bits, as they come
+      #
+      def add_data(data)
+        msg_buf << data.chomp
+        parse_messages
       end
 
       #
@@ -41,42 +53,48 @@ module Fix
       end
 
       #
-      # Parses the message into a FP::Message instance
+      # Attempts to parse fields from the message buffer, if the fields that get parsed
+      # complete the temporary message, it is processed
       #
-      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)
+      def parse_messages(&block)
+        while idx = msg_buf.index("\x01")
+          field = msg_buf.slice!(0, idx + 1).gsub(/\x01\Z/, '')
+          append(field)
+
+          if complete?
+            parsed = FP.parse(to_s)
+            @fields = []
+            @msg_handler.call(parsed)
+          end
         end
-
-        msg
       end
 
       #
-      # Parses the message and empties the fields array so a new message
-      # can start to get buffered right away
+      # The data buffer string
       #
-      def parse!
-        parsed = parse
-        @fields = []
-        parsed
+      def msg_buf
+        @msg_buf ||= ''
       end
 
+      #
+      # Returns a human-friendly string of the currently handled data
+      #
+      # @return [String] The parsed fields and the temporary buffer
+      #
       def debug
-        to_s('|')
+        "#{to_s('|')}#{@msg_buf}"
       end
 
+      #
+      # Returns the current fields as a string joined by a given separator
+      #
+      # @param sep [String] The separator
+      # @return [String] The fields joined by the separator
+      #
       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

@@ -2,7 +2,7 @@ require 'eventmachine'
 
 require 'fix/protocol'
 require 'fix/engine/version'
-require 'fix/engine/connection'
+require 'fix/engine/server_connection'
 
 module Fix
   module Engine
@@ -14,14 +14,18 @@ module Fix
 
       include Logger
 
+      #
+      # Periodicity in seconds of logged status reports
+      #
       REPORT_INTERVAL = 10
 
       attr_accessor :ip, :port
 
-      def initialize(ip, port, handler)
+      def initialize(ip, port, handler, &block)
         @ip       = ip
         @port     = port
         @handler  = handler
+        @block    = block
       end
 
       #
@@ -38,10 +42,15 @@ module Fix
       #
       def start_server
         raise "EventMachine must be running to start a server" unless EM.reactor_running?
-        EM.start_server(ip, port, @handler)
+
+        EM.start_server(ip, port, @handler) { |conn| @block && @block.call(conn) }
+
         REPORT_INTERVAL && EM.add_periodic_timer(REPORT_INTERVAL) { report_status }
       end
 
+      #
+      # Logs a short summary of the current server status
+      #
       def report_status
         log("#{Client.count} client(s) currently connected")
       end

data/lib/fix/engine/server_connection.rb

@@ -0,0 +1,103 @@
+require 'fix/engine/connection'
+require 'fix/engine/client'
+
+module Fix
+  module Engine
+
+    #
+    # The server connection wrapper, used when accepting a connection
+    #
+    module ServerConnection
+
+      include Connection
+
+      #
+      # Timespan during which a client must send a logon message after connecting
+      #
+      LOGON_TIMEOUT = 10
+
+      #
+      # Run after a client has connected
+      #
+      def post_init
+        super
+
+        @port, @ip  = Socket.unpack_sockaddr_in(get_peername)
+        @client     = Client.get(ip, port, self)
+
+        log("Client connected #{peer}, expecting logon message in the next #{LOGON_TIMEOUT}s")
+
+        EM.add_timer(LOGON_TIMEOUT) { logon_timeout }
+      end
+
+      #
+      # Logs the client out should he fail to authenticate before +LOGON_TIMEOUT+ seconds
+      #
+      def logon_timeout
+        unless @target_comp_id
+        log("Client #{peer} failed to authenticate before timeout, closing connection")
+        close_connection_after_writing
+        client.delete
+        end
+      end
+
+      #
+      # Returns the currently connected client
+      #
+      def client
+        Client.get(ip, port, self)
+      end
+
+      #
+      # The way we refer to our connection peer in various logs and messages
+      #
+      def peer
+        "<#{client.key}>"
+      end
+
+      #
+      # Deletes the +FE::Client+ instance after the connection is terminated
+      #
+      def unbind
+        super
+        client.delete
+      end
+
+      #
+      # We override +FE::Connection#run_message_handlers+ to add some session-related logic
+      #
+      def run_message_handler(msg)
+        if !@target_comp_id && msg.is_a?(FP::Messages::Logon)
+          log("Peer authenticated as <#{msg.username}> with heartbeat interval of <#{msg.heart_bt_int}s> and message sequence number start <#{msg.msg_seq_num}>")
+          client.username = msg.username
+          @target_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 @target_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 !@target_comp_id
+          peer_error("The session must be started with a logon message", msg.msg_seq_num, target_comp_id: msg.sender_comp_id)
+
+        else
+          super(msg)
+
+        end
+      end
+
+    end
+  end
+end
+

data/lib/fix/engine/version.rb

@@ -4,7 +4,7 @@ module Fix
   #
   # The fix-engine gem version string
   #   
-  VERSION = '0.0.24'
+  VERSION = '1.0.0'
 
   end
 end

metadata

@@ -1,128 +1,120 @@
 --- !ruby/object:Gem::Specification
 name: fix-engine
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 1.0.0
 platform: ruby
 authors:
 - David François
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-05 00:00:00.000000000 Z
+date: 2015-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   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'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: fix-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.64
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.64
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.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
+        version: '1.0'
+description: "  The FIX engine library allows one to easily connect to a FIX acceptor
+  and establish\n  a session, it will handle the administrative messages such as logons,
+  hearbeats, gap fills and\n  allow custom handling of business level messages.\n\n
+  \ Likewise, an acceptor may be easily implemented by defining callbacks for business
+  level messages.\n\n  FIX protocol message parsing capabilities are provided by the
+  fix-protocol gem, which\n  currently supports the administrative subset (and a few
+  business level messages) of the FIX 4.4\n  message specification. \n"
 email:
 - david.francois@paymium.com
 executables: []
@@ -134,13 +126,16 @@ files:
 - bin/fix-engine
 - lib/fix/engine.rb
 - lib/fix/engine/client.rb
+- lib/fix/engine/client_connection.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/server_connection.rb
 - lib/fix/engine/version.rb
 homepage: https://github.com/paymium/fix-engine
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []