agent_fix 0.1.0

data/features/support/env.rb

@@ -0,0 +1,29 @@
+$: << File.expand_path("../../../lib", __FILE__)
+
+require 'agent_fix/cucumber'
+require 'agent_fix/cucumber/report'
+require 'fix_spec/cucumber'
+require 'rspec'
+require 'anticipate'
+
+Around('@inspect_all') do |scenario, block|
+  old_scope = AgentFIX.include_session_level?
+  AgentFIX::include_session_level = true
+
+  #hard reset, forces logout/logon
+  AgentFIX.hard_reset
+  block.call
+  AgentFIX::include_session_level = old_scope
+end
+
+Before('~@inspect_all') do
+  AgentFIX.reset
+end
+
+FIXSpec::data_dictionary= quickfix.DataDictionary.new "features/support/FIX42.xml"
+
+World(Anticipate)
+
+AgentFIX.start
+at_exit {AgentFIX.stop}
+

data/lib/agent_fix/agent.rb

@@ -0,0 +1,157 @@
+require 'thread'
+require 'agent_fix/message_cache'
+
+module AgentFIX
+  class Agent
+    include quickfix.Application
+
+    attr_reader :name, :connection_type
+    attr_accessor :default, :session
+
+    attr_accessor :bookmark
+
+    def initialize name, connection_type
+      @name = name
+      @connection_type = connection_type
+      @logged_on = false
+      @bookmark = 0
+      @all_messages = MessageCache.new
+      @logger = Java::org.slf4j.LoggerFactory.getLogger("AgentFIX.Agent")
+    end
+
+    def init
+      parse_settings
+      @connector = case @connection_type
+        when :acceptor then quickfix.SocketAcceptor.new(self, @storeFactory, @settings, @logFactory, @messageFactory)
+        when :initiator then quickfix.SocketInitiator.new(self, @storeFactory, @settings, @logFactory, @messageFactory)
+        else nil
+      end
+    end
+
+    def onCreate(sessionId)
+      @default_session = sessionId
+    end
+
+    def onLogon(sessionId)
+      @logger.debug "#{@name} onLogon: #{sessionId.to_s}"
+
+      lock.synchronize do
+        @logged_on = true
+      end
+    end
+
+    def onLogout(sessionId)
+      @logger.debug "#{@name} onLogout: #{sessionId.to_s}"
+
+      lock.synchronize do
+        @logged_on = false
+      end
+    end
+
+    def toApp(message, sessionId) 
+      @logger.debug "#{@name} toApp #{sessionId.to_s}: #{message.to_s.gsub("
","|")}"
+      @all_messages.add_message(message:message,sent:true,admin:false)
+    end
+
+    def fromApp(message, sessionId)
+      @logger.debug "#{@name} fromApp #{sessionId.to_s}: #{message.to_s.gsub("
","|")}"
+      @all_messages.add_message(message:message,sent:false,admin:false)
+    end
+
+    def toAdmin(message, sessionId)
+      @logger.debug "#{@name} toAdmin #{sessionId.to_s}: #{message.to_s.gsub("
","|")}"
+      @all_messages.add_message(message:message,sent:true,admin:true)
+    end
+
+    def fromAdmin(message, sessionId)
+      @logger.debug "#{@name} fromAdmin #{sessionId.to_s}: #{message.to_s.gsub("
","|")}"
+      @all_messages.add_message(message:message,sent:false,admin:true)
+    end
+
+    def loggedOn?
+      lock.synchronize do
+        return @logged_on
+      end
+    end
+
+    def sendToTarget msg
+      msg.getHeader.setField(quickfix.field.BeginString.new(@default_session.getBeginString))
+      msg.getHeader.setField(quickfix.field.TargetCompID.new(@default_session.getTargetCompID))
+      msg.getHeader.setField(quickfix.field.SenderCompID.new(@default_session.getSenderCompID))
+
+      quickfix.Session.sendToTarget(msg)
+    end
+
+    def reset
+      clear_state!
+    end
+
+    def start
+      @connector.start
+    end
+
+    def stop
+      @connector.stop
+      clear_state!
+    end
+
+    def history opts={}
+      opts[:since] ||= 0
+      opts[:received_only] ||= false
+      opts[:include_session]||= AgentFIX::include_session_level?
+
+      indexed_msgs = []
+      @all_messages.messages.each_with_index { |m,i| indexed_msgs << m.merge(index:i) }
+      indexed_msgs = indexed_msgs.slice(opts[:since], indexed_msgs.length)
+
+      if opts[:received_only]
+        indexed_msgs = indexed_msgs.find_all {|m| !m[:sent]}
+      end
+
+      unless opts[:include_session]
+        indexed_msgs = indexed_msgs.find_all {|m| !m[:admin]}
+      end
+
+      indexed_msgs
+    end
+
+    def messages_received opts = {}
+      history opts.merge(:received_only=>true)
+    end
+
+    protected
+
+    def clear_state!
+      @all_messages.clear!
+      @bookmark = 0
+    end
+
+    def parse_settings
+      session_settings = "[DEFAULT]\n"
+      session_settings << "ConnectionType=#{@connection_type}\n"
+
+      @default ||= {}
+      AgentFIX::session_defaults.merge(@default).each do |k,v|
+        session_settings << "#{k}=#{v}\n"
+      end
+    
+      unless @session.nil?
+        session_settings << "[SESSION]\n"
+        @session.each { |k,v| session_settings << "#{k}=#{v}\n"}
+      end
+
+      @logger.info "Settings for #{@name}: #{session_settings}"
+
+      @storeFactory = quickfix.MemoryStoreFactory.new()
+      @messageFactory = quickfix.DefaultMessageFactory.new()
+      @settings = quickfix.SessionSettings.new( Java::java.io.ByteArrayInputStream.new(session_settings.to_java_bytes) )
+      @logFactory = quickfix.FileLogFactory.new(@settings)
+    end
+
+    private
+
+    def lock
+      @lock||=Mutex.new
+    end
+  end
+end

data/lib/agent_fix/configuration.rb

@@ -0,0 +1,46 @@
+module AgentFIX
+  module Configuration
+    REASONABLE_SESSION_DEFAULTS = {
+      StartTime: "00:00:00",
+      EndTime: "00:00:00",
+      FileLogPath: "fixlog",
+      HeartBtInt: 60
+    }
+    
+    def include_session_level=(opt)
+      @include_session_level = opt
+    end
+    
+    def include_session_level?
+      @include_session_level ||=false
+    end
+
+    def cucumber_sleep_seconds=(secs)
+      @cucumber_sleep_seconds = secs
+    end
+
+    def cucumber_sleep_seconds
+      @cucumber_sleep_seconds ||= 0.5
+    end
+
+    def cucumber_retries=(retries)
+      @cucumber_retries = retries
+    end
+
+    def cucumber_retries
+      @cucumber_retries ||= 10
+    end
+
+    def session_defaults=(defaults)
+      @session_defaults = defaults
+    end
+
+    def session_defaults
+      @session_defaults ||= REASONABLE_SESSION_DEFAULTS
+    end
+
+    def reset_config
+      instance_variables.each{|ivar| remove_instance_variable(ivar) }
+    end
+  end
+end

data/lib/agent_fix/cucumber/report.rb

@@ -0,0 +1,79 @@
+class String
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def pink
+    colorize(35)
+  end
+  
+  def white
+    colorize(37)
+  end
+  
+  def blue
+    colorize(34)
+  end
+  
+  def magenta
+    colorize(35)
+  end
+  
+  def cyan
+    colorize(36)
+  end
+end
+
+def print_results agent
+  STDERR.puts "\nMessages for ".yellow + agent.name.to_s.white + ": ".yellow
+  
+  agent.history(:include_session=>true).each do |msg|
+    if msg[:sent]
+      STDERR.puts "\tsent >>\t #{msg[:message].to_s.gsub!(/\001/, '|')}".green
+    else
+      outbound = "\trecv <<\t #{msg[:message].to_s.gsub!(/\001/, '|')}"
+
+      if @message!=nil and msg[:message] == @message
+        STDERR.puts outbound.red
+      else
+        if msg[:index] >= @agent.bookmark
+          STDERR.puts outbound.blue
+        else
+
+          if @message_scope.include? msg[:message]
+            STDERR.puts outbound.pink
+          else
+            STDERR.puts outbound.green
+          end
+        end
+      end
+    end
+  end
+end
+
+After do |scenario|
+  if scenario.failed? then
+    #last selected agent gets priority
+    unless @agent.nil?
+      print_results(@agent)
+    end
+
+    AgentFIX.agents_hash.values.each do |agent|
+      next if agent == @agent
+      print_results(agent)
+    end
+  end
+end

data/lib/agent_fix/cucumber.rb

@@ -0,0 +1,146 @@
+require File.expand_path("../../agent_fix", __FILE__)
+
+require 'fix_spec/builder'
+require 'fix_spec/cucumber'
+
+module FIXMessageCache
+  # accessor for fix_spec
+  def last_fix
+    @message
+  end
+
+  def recall_agent agent
+    agent = AgentFIX.agents_hash[agent.to_sym]
+    throw "Unknown agent #{agent}" if agent.nil?
+
+    agent
+  end
+end
+
+World(FIXMessageCache)
+
+def anticipate_fix
+  sleeping(AgentFIX.cucumber_sleep_seconds).seconds.between_tries.failing_after(AgentFIX.cucumber_retries).tries do
+    yield
+  end
+end
+
+When(/^I send the following FIX message(?:s)? from agent "(.*?)":$/) do |agent, fix|
+  messages = fix.split("\n")
+
+  messages.each do |msg|
+    steps %Q{
+Given the following fix message:
+"""
+#{msg}  
+"""
+}
+    
+    AgentFIX.agents_hash[agent.to_sym].sendToTarget(FIXSpec::Builder.message)
+  end
+end
+
+Then(/^I should receive (exactly )?(\d+)(?: FIX|fix)? messages(?: (?:on|over) FIX)?(?: of type "(.*?)")? with agent "(.*?)"$/) do |exact, count, type, agent|
+  @agent = recall_agent(agent)
+  count = count.to_i
+
+  scope = []
+  anticipate_fix do
+    messages = @agent.messages_received :since=>@agent.bookmark
+
+    if exact
+      (messages.length).should be == count, "Expected exactly #{count} messages, but got #{messages.length}"
+    else
+      (messages.length).should be >= count, "Expected #{count} messages, but got #{messages.length}"
+    end
+    
+    scope=messages.slice(0, count)
+
+    unless type.nil?
+      unless FIXSpec::data_dictionary.nil?
+        type = FIXSpec::data_dictionary.get_msg_type(type)
+      end
+
+      @scope.each do |msg|
+        msg[:message].header.get_string(35).should == type
+      end
+    end
+  end
+
+  unless scope.empty?
+    @agent.bookmark = scope.last[:index]+1
+  end
+
+  @message_scope=scope.collect {|m| m[:message]}
+
+  #if we only requested one message for the scope, inspect that message
+  if count == 1
+    @message = @message_scope.first
+  else
+    @message = nil
+  end
+end
+
+Then(/^I should not receive any(?: more)?(?: FIX| fix)? messages with agent "(.*?)"$/) do |agent|
+  steps %Q{Then I should receive exactly 0 FIX messages with agent "#{agent}"}
+end
+
+Then(/^I should receive a(?: FIX| fix)? message(?: (?:on|over) FIX)?(?: of type "(.*?)")? with agent "(.*?)"$/) do |type, agent|
+  if type.nil?
+    steps %Q{Then I should receive 1 FIX messages with agent "#{agent}"}
+  else
+    steps %Q{Then I should receive 1 FIX messages of type "#{type}" with agent "#{agent}"}
+  end
+end
+
+When(/^I inspect the (\d+)(?:.*?)(?: FIX| fix)? message$/) do |index|
+  index = index.to_i-1
+
+  @message_scope.should_not be_nil, "No message scope defined"
+  @message_scope.length.should be >index, "There are only #{@message_scope.length} messages in the scope"
+  @message = @message_scope[index]
+end
+
+
+Then(/^the (\d+)(?:.*?)(?: FIX| fix)? message should have the following:$/) do |index, table|
+  table_raw ="" 
+  table.raw.each do |path, val|
+    table_raw << "|#{path}|#{val}|\n"
+  end
+
+  steps %Q{
+When I inspect the #{index}th FIX message
+Then the FIX message should have the following:
+#{table_raw}
+  }
+end
+
+Then(/^the(?: FIX|fix)? messages should include(?: a message with)? the following:$/) do |table|
+  @message_scope.should_not be_nil, "No message scope defined"
+  
+  table_raw ="" 
+  table.raw.each do |path, val|
+    table_raw << "|#{path}|#{val}|\n"
+  end
+  
+  found = false
+  error_accum = ""
+  index = 1
+  @message_scope.each do |m|
+    @message = m
+    begin
+      steps %Q{
+When I inspect the #{index}th FIX message
+Then the FIX message should have the following:
+#{table_raw}
+      }
+      found = true
+    rescue Exception => e
+      error_accum << "\n#{m.to_s.gsub!(/\001/, '|')}\n #{e}"
+    end
+    index += 1
+  end
+  
+  found.should be_true, "Message not included in FIX messages\n #{error_accum}"
+
+end

data/lib/agent_fix/message_cache.rb

@@ -0,0 +1,31 @@
+require 'thread'
+module AgentFIX
+  class MessageCache
+    def messages
+      lock.synchronize do
+        return msgs.dup
+      end
+    end
+    
+    def add_message msg
+      lock.synchronize do
+        msgs << msg
+      end
+    end
+    
+    def clear!
+      lock.synchronize do
+        msgs.clear
+      end
+    end
+    
+  private
+    def msgs
+      @messages||=[]
+    end
+    
+    def lock
+      @lock||=Mutex.new
+    end
+  end
+end

data/lib/agent_fix.rb

@@ -0,0 +1,75 @@
+require 'quickfix'
+require 'agent_fix/configuration'
+require 'agent_fix/agent'
+
+module AgentFIX
+  extend Configuration
+  extend self
+
+  def agent_path
+    "./config/fix_agents.rb"
+  end
+
+  def agents
+    return @agents if @agents
+
+    (@agents=[]).tap do
+      load_agents if agent_files_loaded.empty?
+    end
+  end
+
+  def agent_files_loaded
+    @agent_files_loaded ||=[]
+  end
+  
+  def load_agents path=nil
+    path = File.expand_path(path || agent_path, Dir.pwd)
+    return if agent_files_loaded.include? path
+    agent_files_loaded << path
+    load path
+
+    agents.each {|a| a.init}
+  end
+
+  def define_agent(agent, &blk)
+    yield agent
+    agents << agent
+  end
+
+  def define_acceptor(name, &blk)
+    define_agent(Agent.new(name, :acceptor), &blk)
+  end
+
+  def define_initiator(name, &blk)
+    define_agent(Agent.new(name, :initiator), &blk)
+  end
+  
+  #starts all configured agents
+  def start
+    raise RuntimeError, "No FIX Agents Defined" if agents.empty?
+
+    agents.each do |a|
+      a.start
+    end
+  end
+
+  def stop
+    agents.each {|a| a.stop}
+  end
+
+  def reset
+    agents.each {|a| a.reset}
+  end
+
+  def hard_reset
+    stop
+    sleep 0.5
+    start
+  end
+
+  def agents_hash
+    Hash[agents.map { |a| [a.name.to_sym, a]}]
+  end
+end
+
+

data/spec/agent_fix/configuration_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe AgentFIX::Configuration do
+  it "inspects just app messages by default" do
+    AgentFIX.include_session_level?.should be_false
+  end
+
+  it "can inspect both app and session level messages" do
+    AgentFIX.include_session_level = true
+    AgentFIX.include_session_level?.should be_true
+  end
+end

data/spec/agent_fix/message_cache_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe AgentFIX::MessageCache do
+  it "is basically a read-only queue"  do
+    cache = AgentFIX::MessageCache.new
+    cache.add_message "1"
+    cache.add_message "2"
+    cache.add_message "3"
+
+    msgs = cache.messages
+    msgs.should == ["1","2","3"]
+
+    cache.clear!
+    msgs.should == ["1","2","3"]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'agent_fix'
+
+RSpec.configure do |config|
+  config.before do
+    AgentFIX.reset_config
+  end
+end
+