fwd 0.3.0

data/.gitignore

@@ -0,0 +1,2 @@
+tmp/
+log/

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    fwd (0.3.0)
+      connection_pool
+      eventmachine-le
+      servolux
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    connection_pool (1.0.0)
+    diff-lcs (1.1.3)
+    eventmachine-le (1.1.4)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.2)
+    servolux (0.10.0)
+    yard (0.8.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  fwd!
+  rake
+  rspec
+  yard

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake'
+
+require 'rspec/mocks/version'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+desc 'Default: run specs.'
+task :default => :spec

data/benchmark/performance.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'bundler/setup'
+require 'benchmark'
+require 'tempfile'
+require 'fwd'
+
+root = Pathname.new(File.expand_path('../..', __FILE__))
+FileUtils.rm_rf root.join("tmp/benchmark")
+FileUtils.mkdir_p root.join("tmp/benchmark")
+
+EVENTS = 10_000_000
+DATA   = "A" * 64
+OUTF   = root.join('tmp/benchmark/out.txt')
+
+COLL   = fork do
+  `nc -vlp 7291 > #{OUTF}`
+  sleep
+end
+EMIT   = fork do
+  sock = TCPSocket.new "127.0.0.1", 7289
+  EVENTS.times { sock.write DATA }
+  sock.close
+end
+
+at_exit do
+  Process.kill(:TERM, COLL)
+  Process.kill(:TERM, EMIT)
+end
+
+until OUTF.exist?
+  sleep(1)
+end
+
+while OUTF.size < EVENTS * DATA.size
+  sleep(1)
+  puts "Written #{(OUTF.size / 1024.0 / 1024.0).round(1)}M"
+end

data/bin/fwd-rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require "fwd/cli"
+Fwd::CLI.run!

data/fwd.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.required_ruby_version = '>= 1.9.1'
+  s.required_rubygems_version = ">= 1.8.0"
+
+  s.name        = File.basename(__FILE__, '.gemspec')
+  s.summary     = "fwd >>"
+  s.description = "The minimalistic stream forwarder"
+  s.version     = "0.3.0"
+
+  s.authors     = ["Black Square Media"]
+  s.email       = "info@blacksquaremedia.com"
+  s.homepage    = "https://github.com/bsm/fwd"
+
+  s.require_path = 'lib'
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.add_dependency "eventmachine-le"
+  s.add_dependency "servolux"
+  s.add_dependency "connection_pool"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "yard"
+end

data/lib/fwd/backend.rb

@@ -0,0 +1,27 @@
+class Fwd::Backend
+  attr_reader :url
+
+  def initialize(url)
+    @url = URI(url)
+  end
+
+  def write(data)
+    sock.write(data)
+  end
+
+  def close
+    @sock.close if @sock
+    @sock = nil
+  end
+
+  def to_s
+    url.to_s
+  end
+
+  protected
+
+    def sock
+      @sock ||= TCPSocket.new @url.host, @url.port
+    end
+
+end

data/lib/fwd/buffer.rb

@@ -0,0 +1,79 @@
+class Fwd::Buffer
+  extend Forwardable
+  def_delegators :core, :root, :prefix, :logger
+
+  MAX_SIZE = 64 * 1024 * 1024 # 64M
+  attr_reader :core, :interval, :rate, :count, :limit, :timer, :fd, :path
+
+  # Constructor
+  # @param [Fwd] core
+  def initialize(core)
+    @core     = core
+    @interval = (core.opts[:flush_interval] || 60).to_i
+    @rate     = (core.opts[:flush_rate] || 10_000).to_i
+    @limit    = (core.opts[:flush_limit] || 0).to_i
+    @count    = 0
+
+    reschedule!
+    rotate!
+  end
+
+  # @param [String] data binary data
+  def concat(data)
+    rotate! if rotate?
+    @fd.write(data)
+    @count += 1
+    flush! if flush?
+  end
+
+  # (Force) flush buffer
+  def flush!
+    @count = 0
+    rotate!
+    core.flush!
+  ensure
+    reschedule!
+  end
+
+  # @return [Boolean] true if flush is due
+  def flush?
+    (@rate > 0 && @count >= @rate) || (@limit > 0 && @path.size >= @limit)
+  end
+
+  # (Force) rotate buffer file
+  def rotate!
+    FileUtils.mv(@path.to_s, @path.to_s.sub(/\.open$/, ".closed")) if @path
+    @fd, @path = new_file
+  rescue Errno::ENOENT
+  end
+
+  # @return [Boolean] true if rotation is due
+  def rotate?
+    !@fd || @path.size > MAX_SIZE
+  end
+
+  private
+
+    def new_file
+      path = nil
+      until path && !path.exist?
+        path = root.join("#{generate_name}.open")
+      end
+      FileUtils.mkdir_p root.to_s
+      file = File.open(path, "wb")
+      file.sync = true
+      [file, path]
+    end
+
+    def reschedule!
+      return unless @interval > 0
+
+      @timer.cancel if @timer
+      @timer = EM.add_periodic_timer(@interval) { flush! }
+    end
+
+    def generate_name
+      [prefix, Time.now.utc.strftime("%Y%m%d%H%m%s"), SecureRandom.hex(4)].join(".")
+    end
+
+end

data/lib/fwd/cli.rb

@@ -0,0 +1,60 @@
+require 'optparse'
+require 'fwd'
+
+class Fwd::CLI < Hash
+
+  def self.run!(argv = ARGV)
+    new(argv).run!
+  end
+
+  attr_reader :core
+
+  def initialize(argv)
+    super()
+    parser.parse!(argv)
+    @core = Fwd.new(self)
+  end
+
+  def run!
+    @core.run!
+  end
+
+  def parser
+    @parser ||= OptionParser.new do |o|
+      o.banner = "Usage: fwd-rb [options]"
+      o.separator ""
+
+      o.on("-B", "--bind URI", "Listen on this address. Default: tcp://0.0.0.0:7289") do |uri|
+        update bind: URI.parse(uri).to_s
+      end
+
+      o.on("-F", "--forward U1,[..,Un]", Array, "Forward to these URIs") do |uris|
+        update forward: uris.map {|uri| URI.parse(uri).to_s }
+      end
+
+      o.on("-f", "--flush L:M:N",
+        "Flush after an interval of N seconds, " <<
+        "or after receiving M messages, " <<
+        "or after the limit of L bytes was reached. " <<
+        "Default: 0:10000:60") do |values|
+        l,m,n = values.split(":").map(&:to_i)
+        update flush_limit: l.to_i, flush_rate: m.to_i, flush_interval: n.to_i
+      end
+
+      o.on("--path PATH", "Root path for storage. Default: ./tmp") do |path|
+        update path: path
+      end
+
+      o.on("--prefix STRING", "Custom prefix for buffer files. Default: buffer") do |prefix|
+        update prefix: prefix
+      end
+
+      o.separator ""
+      o.on_tail("-h", "--help", "Show this message") do
+        puts o
+        exit
+      end
+    end
+  end
+
+end

data/lib/fwd/input.rb

@@ -0,0 +1,22 @@
+class Fwd::Input < EM::Connection
+  extend Forwardable
+  def_delegators :core, :logger
+
+  attr_reader :core, :buffer
+
+  # @param [Fwd] core
+  # @param [Hash] opts additional opts
+  def initialize(core)
+    @core = core
+  end
+
+  def post_init
+    @buffer = Fwd::Buffer.new(core)
+  end
+
+  # When receiving data, concat it to the buffer
+  def receive_data(data)
+    buffer.concat(data)
+  end
+
+end

data/lib/fwd/output.rb

@@ -0,0 +1,66 @@
+class Fwd::Output
+  extend Forwardable
+  def_delegators :core, :logger, :root, :prefix
+
+  RESCUABLE = [
+    Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::EPIPE,
+    Errno::ENETUNREACH, Errno::ENETDOWN, Errno::EINVAL, Errno::ETIMEDOUT,
+    IOError, EOFError
+  ].freeze
+
+  attr_reader :pool, :core
+
+  # Constructor
+  # @param [Fwd] core
+  def initialize(core)
+    backends = Array(core.opts[:forward]).compact.map do |s|
+      Fwd::Backend.new(s)
+    end
+    @core = core
+    @pool = Fwd::Pool.new(backends)
+  end
+
+  # Callback
+  def forward!
+    Dir[root.join("#{prefix}.*.closed")].each do |file|
+      reserve(file) do |data|
+        logger.debug { "Flushing #{File.basename(file)}, #{data.size.fdiv(1024).round} kB" }
+        write(data)
+      end
+    end
+  end
+
+  # @param [String] binary data
+  def write(data)
+    pool.any? do |backend|
+      forward(backend, data)
+    end
+  end
+
+  private
+
+    def reserve(file)
+      return if File.size(file) < 1
+
+      target = Pathname.new(file.sub(/\.closed$/, ".reserved"))
+      FileUtils.mv file, target.to_s
+
+      if yield(target.read)
+        target.unlink
+      else
+        logger.error "Flushing of #{target} failed."
+        FileUtils.mv target.to_s, target.to_s.sub(/\.reserved$/, ".closed")
+      end
+    rescue Errno::ENOENT
+      # Ignore if file was alread flushed by another process
+    end
+
+    def forward(backend, data)
+      backend.write(data) && true
+    rescue *RESCUABLE => e
+      logger.error "Backend #{backend} failed: #{e.class.name} #{e.message}"
+      backend.close
+      false
+    end
+
+end

data/lib/fwd/pool.rb

@@ -0,0 +1,35 @@
+# "Clone" of normal ConnectionPool but tweaked for round-robin
+class Fwd::Pool
+  include Enumerable
+
+  class IdleStack < ConnectionPool::TimedStack
+    def unshift(obj)
+      @mutex.synchronize do
+        @que.unshift obj
+        @resource.broadcast
+      end
+    end
+  end
+
+  def initialize(items)
+    @idle = IdleStack.new(0) {}
+    @size = items.size
+    @key  = :"io-proxy-pool-#{@idle.object_id}"
+
+    items.each do |item|
+      @idle.push(item)
+    end
+  end
+
+  def each(&block)
+    @size.times { checkout(&block) }
+  end
+
+  def checkout
+    conn = @idle.pop(30)
+    yield conn
+  ensure
+    @idle.unshift(conn) if conn
+  end
+
+end

data/lib/fwd/worker.rb

@@ -0,0 +1,43 @@
+class Fwd::Worker
+
+  class << self
+    private :new
+
+    def fork(opts)
+      GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+
+      child_read, parent_write = IO.pipe
+      parent_read, child_write = IO.pipe
+
+      pid = Process.fork do
+        begin
+          parent_write.close
+          parent_read.close
+          output = Fwd::Output.new(opts)
+          process(output, child_read, child_write)
+        ensure
+          child_read.close
+          child_write.close
+        end
+      end
+
+      child_read.close
+      child_write.close
+
+      new(pid, parent_read, parent_write)
+    end
+
+    def process(output, read, write)
+      while !read.eof?
+        path = Marshal.load(read)
+        begin
+          result = call_with_index(items, index, options, &block)
+          result = nil if options[:preserve_results] == false
+        rescue Exception => e
+          result = ExceptionWrapper.new(e)
+        end
+        Marshal.dump(result, write)
+      end
+    end
+
+  end

data/lib/fwd.rb

@@ -0,0 +1,107 @@
+require 'eventmachine-le'
+require 'forwardable'
+require 'uri'
+require 'logger'
+require 'fileutils'
+require 'pathname'
+require 'securerandom'
+require 'connection_pool'
+require 'servolux'
+
+class Fwd
+  FLUSH = "\000>>"
+
+  class << self
+
+    attr_writer :logger
+
+    # [Logger] logger instance
+    def logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+  end
+
+  # @attr_reader [URI] uri to bind to
+  attr_reader :bind
+
+  # @attr_reader [Pathname] root path
+  attr_reader :root
+
+  # @attr_reader [String] custom buffer file prefix
+  attr_reader :prefix
+
+  # @attr_reader [Fwd::Output] output
+  attr_reader :output
+
+  # @attr_reader [Hash] opts
+  attr_reader :opts
+
+  # Constructor
+  # @param [Hash] opts
+  # @option opts [String]  path path where buffer files are stored
+  # @option opts [String]  prefix buffer file prefix
+  # @option opts [URI] bind the endpoint to listen to
+  # @option opts [Array<URI>] forward the endpoints to forward to
+  # @option opts [Integer] flush_limit flush after L messages
+  # @option opts [Integer] flush_rate flush after M messages
+  # @option opts [Integer] flush_interval flush after N seconds
+  def initialize(opts = {})
+    @bind   = URI.parse(opts[:bind] || "tcp://0.0.0.0:7289")
+    @root   = Pathname.new(opts[:path] || "tmp")
+    @prefix = opts[:prefix] || "buffer"
+    @opts   = opts
+    @output = Fwd::Output.new(self)
+  end
+
+  # Starts the loop
+  def run!
+    $0 = "fwd-rb (output)"
+
+    @piper = ::Servolux::Piper.new('rw')
+    at_exit do
+      @piper.signal("TERM")
+    end
+
+    @piper.child do
+      $0 = "fwd-rb (input)"
+      EM.run { listen! }
+    end
+
+    @piper.parent do
+      loop do
+        sleep(0.1)
+        case val = @piper.gets()
+        when FLUSH
+          output.forward!
+        else
+          logger.error "Received unknown message #{val.class.name} "
+          exit
+        end
+      end
+    end
+  end
+
+  # Starts the server
+  def listen!
+    logger.info "Starting server on #{@bind}"
+    EM.start_server @bind.host, @bind.port, Fwd::Input, self
+  end
+
+  # Initiates flush
+  def flush!
+    @piper.child do
+      @piper.puts(FLUSH)
+    end
+  end
+
+  # [Logger] logger instance
+  def logger
+    self.class.logger
+  end
+
+end
+
+%w|buffer output backend input pool cli|.each do |name|
+  require "fwd/#{name}"
+end

data/spec/fwd/backend_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Fwd::Backend do
+
+  subject do
+    described_class.new "tcp://127.0.0.1:7289"
+  end
+
+  before do
+    TCPSocket.any_instance.stub write: true
+  end
+
+  its(:url)  { should be_instance_of(URI::Generic) }
+  its(:to_s) { should == "tcp://127.0.0.1:7289" }
+
+end

data/spec/fwd/buffer_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Fwd::Buffer do
+
+  def files(glob = "*")
+    Dir[root.join(glob)]
+  end
+
+  let(:buffer) { described_class.new core }
+  let(:timer)  { mock("Timer", cancel: true) }
+  subject      { buffer }
+  before do
+    EM.stub add_periodic_timer: timer
+  end
+
+  its(:root)     { should == root }
+  its(:root)     { should be_exist }
+  its(:prefix)   { should == "buffer" }
+  its(:core)     { should be(core) }
+  its(:count)    { should be(0) }
+  its(:interval) { should be(60) }
+  its(:rate)     { should be(20) }
+  its(:limit)    { should be(2048) }
+  its(:timer)    { should be(timer) }
+  its(:fd)       { should be_instance_of(File) }
+  its(:path)     { should be_instance_of(Pathname) }
+  its(:logger)   { should be(Fwd.logger) }
+
+  describe "concat" do
+    it 'should concat data' do
+      lambda {
+        subject.concat("x" * 1024)
+      }.should change {
+        subject.path.size
+      }.by(1024)
+    end
+  end
+
+  describe "rotate" do
+    before  { buffer }
+    subject { lambda { buffer.rotate! } }
+
+    it { should change { buffer.path } }
+    it { should change { buffer.fd } }
+    it { should change { files.size }.by(1) }
+
+    it 'should archive previous file' do
+      previous = buffer.path
+      subject.call
+      files.should include(previous.sub("open", "closed").to_s)
+    end
+  end
+
+  describe "flush" do
+
+    before { core.stub flush!: true }
+
+    it 'should trigger when flush rate is reached' do
+      19.times { subject.concat("x") }
+      lambda { subject.concat("x") }.should change { subject.count }.from(19).to(0)
+    end
+
+    it 'should trigger when flush limit is reached' do
+      subject.concat("x" * 1024)
+      lambda { subject.concat("x" * 1024) }.should change { subject.count }.from(1).to(0)
+    end
+
+    it 'should reset count' do
+      3.times { subject.concat("x") }
+      lambda { subject.flush! }.should change { subject.count }.from(3).to(0)
+    end
+
+    it 'should rotate file' do
+      lambda { subject.flush! }.should change { subject.path }
+      files.size.should == 2
+    end
+
+    it 'should reset timer' do
+      subject.timer.should_receive(:cancel)
+      subject.flush!
+    end
+
+    it 'should forward data' do
+      3.times { subject.concat("x") }
+      subject.core.should_receive(:flush!).and_return(true)
+      subject.flush!
+      sleep(0.1)
+    end
+
+  end
+end

data/spec/fwd/cli_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Fwd::CLI do
+
+  subject do
+    described_class.new [
+      "--path", root.to_s,
+      "--prefix", "prefix",
+      "--bind", "tcp://127.0.0.1:7289",
+      "--forward", "tcp://1.2.3.4:1234,tcp://1.2.3.5:1235",
+      "--flush", "30:1200:90",
+    ]
+  end
+
+  it { should be_a(Hash) }
+  its([:path]) { should == root.to_s }
+  its([:prefix]) { should == "prefix" }
+  its([:bind]) { should == "tcp://127.0.0.1:7289" }
+  its([:forward]) { should == ["tcp://1.2.3.4:1234", "tcp://1.2.3.5:1235"] }
+  its([:flush_limit]) { should == 30 }
+  its([:flush_rate]) { should == 1200 }
+  its([:flush_interval]) { should == 90 }
+  its(:core) { should be_instance_of(Fwd) }
+
+end

data/spec/fwd/input_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Fwd::Input do
+
+  subject do
+    input = described_class.allocate
+    input.send(:initialize, core)
+    input
+  end
+  before { EM.stub :add_periodic_timer }
+
+  it { should be_a(EM::Connection) }
+  its(:buffer) { should be_nil }
+  its(:logger) { should be(Fwd.logger) }
+
+  describe "post init" do
+    before { subject.post_init }
+    its(:buffer) { should be_instance_of(Fwd::Buffer) }
+  end
+
+end

data/spec/fwd/output_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Fwd::Output do
+
+  let(:output) { described_class.new core }
+  subject { output }
+
+  class MockServer
+    attr_reader :port, :data
+
+    def initialize(port)
+      @port   = port
+      @data   = ""
+      @server = ::TCPServer.new("127.0.0.1", port)
+      @thread = Thread.new do
+        loop do
+          conn = @server.accept
+          loop { @data << conn.readpartial(1024) }
+        end
+      end
+      sleep(0.001) until @thread.alive?
+    end
+
+    def stop
+      if @thread.alive?
+        @thread.kill
+        sleep(0.001) while @thread.alive?
+      end
+
+      unless @server.closed?
+        @server.close
+      end
+    end
+  end
+
+  def servers(*ports)
+    svs = ports.map {|port| MockServer.new(port) }
+    yield(*svs)
+    sleep(0.01)
+    svs.each(&:stop)
+    Hash[svs.map{|s| [s.port, s.data] }]
+  end
+
+  it 'should have a pool of backends' do
+    subject.pool.should be_instance_of(Fwd::Pool)
+    subject.pool.should have(2).items
+    subject.pool.checkout {|c| c.should be_instance_of(Fwd::Backend) }
+  end
+
+  describe "writing" do
+
+    it 'should forward data to backends' do
+      servers(7291, 7292) do
+        subject.write("A").should be(true)
+        subject.write("B").should be(true)
+        subject.write("C").should be(true)
+        subject.write("D").should be(true)
+      end.should == { 7291=>"BD", 7292=>"AC" }
+    end
+
+    it 'should handle partial fallouts' do
+      servers(7291) do
+        subject.write("A").should be(true)
+        subject.write("B").should be(true)
+        subject.write("C").should be(true)
+        subject.write("D").should be(true)
+      end.should == { 7291=>"ABCD" }
+    end
+
+    it 'should handle full fallouts' do
+      subject.write("A").should be(false)
+      subject.write("B").should be(false)
+      subject.write("C").should be(false)
+      subject.write("D").should be(false)
+    end
+
+  end
+
+  describe "forwarding" do
+
+    def write(file)
+      file.open("w") {|f| f << "x" }
+      file
+    end
+
+    def files(glob = "*")
+      Dir[root.join(glob)].map {|f| File.basename f }.sort
+    end
+
+    before    { subject.stub! write: true }
+    before    { FileUtils.mkdir_p root.to_s }
+    let!(:f1) { write root.join("buffer.1.closed") }
+    let!(:f2) { write root.join("buffer.2.open") }
+    let!(:f3) { write root.join("buffer.3.closed") }
+
+    it 'should write the data' do
+      subject.should_receive(:write).twice
+      subject.forward!
+    end
+
+    it 'should unlink written files' do
+      lambda { subject.forward! }.should change {
+        files
+      }.to(["buffer.2.open"])
+    end
+
+    it 'should handle failures files' do
+      subject.should_receive(:write).and_return(true)
+      subject.should_receive(:write).and_return(false)
+
+      lambda { subject.forward! }.should change {
+        files
+      }.to(["buffer.2.open", "buffer.3.closed"])
+    end
+
+  end
+end

data/spec/fwd/pool_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Fwd::Pool do
+
+  subject do
+    described_class.new ["A", "B", "C"]
+  end
+
+  it { should be_a(Enumerable) }
+  its(:to_a) { should == ["C", "B", "A"] }
+
+  it "should round-robin" do
+    subject.checkout {|c| c.should == "C" }
+    subject.checkout {|c| c.should == "B" }
+    subject.checkout {|c| c.should == "A" }
+    subject.checkout {|c| c.should == "C" }
+    subject.checkout {|c| c.should == "B" }
+    subject.checkout {|c| c.should == "A" }
+  end
+
+end
+

data/spec/fwd_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Fwd do
+
+  subject      { core }
+
+  its(:logger) { should be_instance_of(::Logger) }
+  its(:root)   { should be_instance_of(::Pathname) }
+  its(:root)   { should == root }
+  its(:bind)   { should be_instance_of(URI::Generic) }
+  its(:bind)   { should == URI("tcp://0.0.0.0:7289") }
+  its(:prefix) { should == "buffer" }
+  its(:opts)   { should be_instance_of(Hash) }
+  its(:logger) { should be_instance_of(Logger) }
+  its(:output) { should be_instance_of(Fwd::Output) }
+
+  it "should listen the server" do
+    with_em do
+      subject.logger.should_receive(:info)
+      subject.listen!.should be_instance_of(Fixnum)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'bundler/setup'
+require 'rspec'
+require 'fwd'
+
+module Fwd::TestHelper
+
+  def with_em
+    EM.run do
+      begin
+        yield
+      ensure
+        EM.stop
+      end
+    end
+  end
+
+  def root
+    @_root ||= Pathname.new File.expand_path("../../tmp", __FILE__)
+  end
+
+  def core
+    @_core ||= Fwd.new \
+      path: root,
+      flush_rate: 20,
+      flush_limit: 2048,
+      forward: ["tcp://127.0.0.1:7291", "tcp://127.0.0.1:7292"]
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include(Fwd::TestHelper)
+  c.before(:suite) do
+    Fwd.logger = Logger.new("/dev/null")
+  end
+  c.before(:each) do
+    FileUtils.rm_rf root.to_s
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: fwd
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Black Square Media
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine-le
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: servolux
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The minimalistic stream forwarder
+email: info@blacksquaremedia.com
+executables:
+- fwd-rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- benchmark/performance.rb
+- bin/fwd-rb
+- fwd.gemspec
+- lib/fwd.rb
+- lib/fwd/backend.rb
+- lib/fwd/buffer.rb
+- lib/fwd/cli.rb
+- lib/fwd/input.rb
+- lib/fwd/output.rb
+- lib/fwd/pool.rb
+- lib/fwd/worker.rb
+- spec/fwd/backend_spec.rb
+- spec/fwd/buffer_spec.rb
+- spec/fwd/cli_spec.rb
+- spec/fwd/input_spec.rb
+- spec/fwd/output_spec.rb
+- spec/fwd/pool_spec.rb
+- spec/fwd_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bsm/fwd
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: fwd >>
+test_files: []
+has_rdoc: