funl 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 015bd0c0d3e5537bb8beeda5ccd1aa7502dd66c5
+  data.tar.gz: c5ce417f5a23cfce7a9d9aa920b6a65cc405dfff
+SHA512:
+  metadata.gz: ccf71263bcda9155f8733c2a7f7adc0d23d526af9af16faa75ba0fed4fc4f59885444d2782550283aa52a7ec0e8c77435bb1aca9752d60ae349f00ebc73629dc
+  data.tar.gz: 10f240e8925c2aa63f21ac05f5ca12871d0df7f10d775e741019ecc1a889e927b57fdb183e211f4a4ce76b1c471883ec8b1f5222b57dd4b9ed899fe1b409268b

data/COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 2013, Joel VanderWerf, vjoel@users.sourceforge.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,4 @@
+funl
+====
+
+Sequences messages.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake'
+require 'rake/testtask'
+
+desc "Run tests"
+Rake::TestTask.new :test do |t|
+  t.libs << "lib"
+  t.libs << "ext"
+  t.test_files = FileList["test/**/*.rb"]
+end

data/lib/funl/blobber.rb

@@ -0,0 +1,31 @@
+require 'object-stream'
+
+module Funl
+  module Blobber
+    MARSHAL_TYPE  = ObjectStream::MARSHAL_TYPE
+    YAML_TYPE     = ObjectStream::YAML_TYPE
+    JSON_TYPE     = ObjectStream::JSON_TYPE
+    MSGPACK_TYPE  = ObjectStream::MSGPACK_TYPE
+    
+    # Returns something which responds to #dump(obj) and #load(str).
+    def self.for type
+      case type
+      when MARSHAL_TYPE
+        Marshal
+      when YAML_TYPE
+        require 'yaml'
+        YAML
+      when JSON_TYPE
+        require 'yajl'
+        require 'yajl/json_gem'
+        ## would 'json' conflict with yajl required from other libs?
+        JSON
+      when MSGPACK_TYPE
+        require 'msgpack'
+        MessagePack
+      else
+        raise ArgumentError, "unknown type: #{type.inspect}"
+      end
+    end
+  end
+end

data/lib/funl/client-sequencer.rb

@@ -0,0 +1,67 @@
+require 'logger'
+require 'object-stream'
+require 'funl/stream'
+
+module Funl
+  # Assigns unique ids to clients.
+  class ClientSequencer
+    attr_reader :server
+    attr_reader :server_thread
+    attr_reader :next_id
+    attr_reader :log
+    attr_reader :stream_type
+
+    def initialize server, *conns, log: Logger.new($stderr),
+        stream_type: ObjectStream::MSGPACK_TYPE,
+        next_id: 0
+
+      @server = server
+      @log = log
+      @stream_type = stream_type
+      @next_id = next_id
+
+      conns.each do |conn|
+        handle_conn conn
+      end
+    end
+
+    def start
+      @server_thread = Thread.new do
+        run
+      end
+    end
+
+    def stop
+      server_thread.kill if server_thread
+    end
+
+    def wait
+      server_thread.join
+    end
+
+    def run
+      loop do
+        conn = server.accept
+        log.debug {"accepted #{conn.inspect}"}
+        handle_conn conn
+      end
+    rescue => ex
+      log.error ex
+      raise
+    end
+
+    def handle_conn conn
+      stream = ObjectStream.new(conn, type: stream_type)
+      msg = {"client_id" => next_id}
+      @next_id += 1
+      stream << msg
+    rescue IOError, SystemCallError => ex
+      log.error "write error for client #{next_id}: #{ex}"
+    else
+      log.info "recognized client #{next_id}"
+    ensure
+      stream.close if stream and not stream.closed?
+    end
+    private :handle_conn
+  end
+end

data/lib/funl/client.rb

@@ -0,0 +1,74 @@
+require 'logger'
+require 'funl/stream'
+require 'funl/message'
+require 'funl/blobber'
+
+module Funl
+  # Generic client base class. Manages the setup and handshake on the streams
+  # to the client sequencer and the message sequencer.
+  class Client
+    include Funl::Stream
+
+    attr_reader :seq
+    attr_reader :cseq
+    attr_reader :arc
+    attr_reader :log
+    attr_reader :stream_type
+    attr_reader :message_class
+    attr_reader :client_id
+    attr_reader :greeting
+    attr_reader :start_tick
+    attr_reader :blob_type
+    attr_reader :blobber
+
+    def initialize(seq: seq!, cseq: cseq!, arc: nil,
+          log: Logger.new($stderr),
+          stream_type: ObjectStream::MSGPACK_TYPE,
+          message_class: Message)
+
+      @log = log
+      @stream_type = stream_type ## discover this thru connections
+      @message_class = message_class
+
+      @seq = client_stream_for(seq)
+      @cseq = client_stream_for(cseq)
+      @arcio = arc
+    end
+
+    # Handshake with both cseq and seq. Does not start any threads--that is left
+    # to subclasses. Yields after getting client id so that caller can set
+    # log.progname, for example.
+    def start
+      cseq_read_client_id
+      yield if block_given?
+      seq_read_greeting
+    end
+
+    def cseq_read_client_id
+      log.info "getting client_id from cseq"
+      @client_id = cseq.read["client_id"]
+      log.info "client_id = #{client_id}"
+      cseq.close rescue nil
+      @cseq = nil
+    end
+
+    def seq_read_greeting
+      log.info "getting greeting from seq"
+      @greeting = seq.read
+      @start_tick = greeting["tick"]
+      log.info "start_tick = #{start_tick}"
+      @blob_type = greeting["blob"]
+      log.info "blob_type = #{blob_type}"
+      @blobber = Blobber.for(blob_type)
+      seq.expect message_class
+
+      @arc = @arcio && client_stream_for(@arcio, type: blob_type)
+        # note: @arc is nil when client is the archiver itself
+    end
+
+    def arc_server_stream_for io
+      server_stream_for(io, type: blob_type)
+        # note: blob_type, not stream_type, since we are sending bare objects
+    end
+  end
+end

data/lib/funl/history-client.rb

@@ -0,0 +1,12 @@
+module Funl::HistoryClient
+  attr_reader :history_size
+
+  # The last N messages are kept.
+  HISTORY_SIZE = 1000
+  
+  def initialize *args, history_size: HISTORY_SIZE, **opts
+    super *args, **opts
+    @history_size = history_size
+  end
+end
+

data/lib/funl/history-worker.rb

@@ -0,0 +1,13 @@
+module Funl::HistoryWorker
+  attr_reader :history
+
+  def initialize client
+    super
+    @history = client.history_size && Array.new(client.history_size)
+      # nil in case of use without UDP
+  end
+
+  def record_history msg
+    history[global_tick % history.size] = msg if history
+  end
+end

data/lib/funl/message-sequencer.rb

@@ -0,0 +1,135 @@
+require 'logger'
+require 'funl/stream'
+require 'funl/message'
+require 'funl/blobber'
+
+module Funl
+  # Assigns a unique sequential ids to each message and relays it to its
+  # destinations.
+  class MessageSequencer
+    include Funl::Stream
+
+    attr_reader :server
+    attr_reader :server_thread
+    attr_reader :streams
+    attr_reader :tick
+    attr_reader :log
+    attr_reader :stream_type
+    attr_reader :message_class
+    attr_reader :blob_type
+    attr_reader :greeting
+    
+    def initialize server, *conns, log: Logger.new($stderr),
+        stream_type: ObjectStream::MSGPACK_TYPE,
+        message_class: Message,
+        blob_type: Blobber::MSGPACK_TYPE,
+        tick: 0
+
+      @server = server
+      @log = log
+      @stream_type = stream_type
+      @message_class = message_class
+      @blob_type = blob_type
+      @greeting = default_greeting
+      @tick = tick
+
+      @streams = []
+      conns.each do |conn|
+        try_conn conn
+      end
+    end
+
+    def default_greeting
+      {
+        "blob" => blob_type
+      }.freeze # can't change after initial conns read it
+    end
+
+    def try_conn conn
+      stream = message_server_stream_for(conn)
+      current_greeting = greeting.merge({"tick" => tick})
+      if write_succeeds?(current_greeting, stream)
+        log.info "connected #{stream.inspect}"
+        @streams << stream
+      end
+    end
+    private :try_conn
+
+    def start
+      @server_thread = Thread.new do
+        run
+      end
+    end
+
+    def stop
+      server_thread.kill if server_thread
+    end
+
+    def wait
+      server_thread.join
+    end
+
+    def run
+      loop do
+        readables, _ = select [server, *streams]
+
+        readables.each do |readable|
+          case readable
+          when server
+            begin
+              conn, addr = readable.accept_nonblock
+              log.info "accepted #{conn.inspect} from #{addr.inspect}"
+              try_conn conn
+            rescue IO::WaitReadable
+              next
+            end
+
+          else
+            log.debug {"readable = #{readable}"}
+            begin
+              msgs = []
+              readable.read do |msg|
+                msgs << msg
+              end
+            rescue IOError, SystemCallError => ex
+              log.debug {"closing #{readable}: #{ex}"}
+              @streams.delete readable
+              readable.close unless readable.closed?
+            else
+              log.debug {
+                "read #{msgs.size} messages from #{readable.peer_name}"}
+            end
+
+            msgs.each do |msg|
+              handle_message msg
+            end
+          end
+        end
+      end
+    rescue => ex
+      log.error ex
+      raise
+    end
+
+    def handle_message msg
+      log.debug {"handling message #{msg.inspect}"}
+      @tick += 1
+      msg.global_tick = tick
+      msg.delta = nil
+      @streams.keep_if do |stream|
+        write_succeeds? msg, stream
+      end
+    end
+    private :handle_message
+
+    def write_succeeds? data, stream
+      stream << data
+      true
+    rescue IOError, SystemCallError => ex
+      log.debug {"closing #{stream}: #{ex}"}
+      stream.close unless stream.closed?
+      false
+    end
+    private :write_succeeds?
+  end
+end

data/lib/funl/message.rb

@@ -0,0 +1,104 @@
+module Funl
+  class Message
+    # Unique (per funl instance) sequential id of client who sent message.
+    attr_accessor :client_id
+
+    # Client's sequential id of message, unique only in client scope.
+    attr_accessor :local_tick
+
+    # Global sequential id of message, unique in scope of funl instance.
+    # In client request to funl, this means last ack-ed global tick.
+    # Assummed to be 64 bits, to avoid rollover errors.
+    attr_accessor :global_tick
+
+    # In client request, how far ahead of ack this message is. When
+    # messages are pipelined, delta > 1.
+    attr_accessor :delta
+
+    # Application-defined metadata. May be used for filtering etc.
+    attr_accessor :tags
+
+    # Application-defined payload data. See blobber.rb.
+    attr_accessor :blob
+    
+    def initialize(*args)
+      @client_id, @local_tick, @global_tick, @delta, @tags, @blob = *args
+    end
+    
+    def self.[](
+      client: nil, local: nil, global: nil, delta: nil, tags: nil, blob: nil)
+      new client, local, global, delta, tags, blob
+    end
+
+    def inspect
+      d = delta ? "+#{delta}" : nil
+      t = tags ? " #{tags}" : nil
+      s = [
+        "client #{client_id}",
+        "local #{local_tick}",
+        "global #{global_tick}#{d}"
+      ].join(", ")
+      "<Message: #{s}#{t}>"
+    end
+    
+    def to_a
+      [@client_id, @local_tick, @global_tick, @delta, @tags, @blob]
+    end
+
+    def == other
+      other.kind_of? Message and
+        @client_id = other.client_id and
+        @local_tick = other.local_tick and
+        @global_tick = other.global_tick and
+        @delta = other.delta and
+        @tags = other.tags and
+        @blob = other.blob
+    end
+    alias eql? ==
+    
+    def hash
+      @client_id.hash ^ @local_tick.hash ^ @global_tick.hash
+    end
+    
+    # Call with Packer, nil, or IO. If +pk+ is nil, returns string. If +pk+ is
+    # a Packer, returns the Packer, which will need to be flushed. If +pk+ is
+    # IO, returns nil.
+    def to_msgpack(pk = nil)
+      case pk
+      when MessagePack::Packer
+        pk.write_array_header(6)
+        pk.write @client_id
+        pk.write @local_tick
+        pk.write @global_tick
+        pk.write @delta
+        pk.write @tags
+        pk.write @blob
+        return pk
+      
+      else # nil or IO
+        MessagePack.pack(self, pk)
+      end
+    end
+    
+    def to_json
+      to_a.to_json
+    end
+
+    def self.from_serialized ary
+      new *ary
+    end
+
+    def self.from_msgpack(src)
+      case src
+      when MessagePack::Unpacker
+        new(*src.read)
+      
+      when IO, StringIO
+        from_msgpack(MessagePack::Unpacker.new(src))
+      
+      else # String
+        from_msgpack(MessagePack::Unpacker.new.feed(src))
+      end
+    end
+  end
+end

data/lib/funl/stream.rb

@@ -0,0 +1,34 @@
+require 'object-stream-wrapper'
+
+module Funl
+  # Mixin depends on stream_type, log, client_id, message_class.
+  module Stream
+    def client_stream_for io, type: stream_type
+      ObjectStreamWrapper.new(io, type: type).tap do |stream|
+        stream.write_to_outbox {{"client_id" => client_id}}
+          # client_id will be nil in the case of cseq, but that's ok.
+      end
+    end
+
+    def server_stream_for io, type: stream_type
+      ObjectStreamWrapper.new(io, type: type).tap do |stream|
+        stream.consume do |h|
+          client_id = h["client_id"]
+          stream.peer_name = "client #{client_id}"
+          log.info "peer is #{stream.peer_name}"
+        end
+      end
+    end
+    
+    def message_server_stream_for io, type: stream_type
+      ObjectStreamWrapper.new(io, type: type).tap do |stream|
+        stream.consume do |h|
+          client_id = h["client_id"]
+          stream.peer_name = "client #{client_id}"
+          log.info "peer is #{stream.peer_name}"
+          stream.expect message_class
+        end
+      end
+    end
+  end
+end

data/test/test-client-sequencer.rb

@@ -0,0 +1,69 @@
+require 'funl/client-sequencer'
+require 'socket'
+require 'tmpdir'
+
+require 'minitest/autorun'
+
+class TestClientSequencer < Minitest::Test
+  attr_reader :log
+
+  def setup
+    @dir = Dir.mktmpdir "funl-test-cseq-"
+    @path = File.join(@dir, "sock")
+    @log = Logger.new($stderr)
+    log.level = Logger::WARN
+  end
+  
+  def teardown
+    FileUtils.remove_entry @dir
+  end
+  
+  def test_initial_conns
+    as = []; bs = []
+    3.times {a, b = UNIXSocket.pair; as << a; bs << b}
+    cseq = Funl::ClientSequencer.new nil, *as, log: log
+    bs.each_with_index do |b, i|
+      stream = ObjectStream.new(b, type: cseq.stream_type)
+      client_id = stream.read["client_id"]
+      assert_equal i, client_id
+    end
+  end
+  
+  def test_later_conns
+    svr = UNIXServer.new(@path)
+    cseq = Funl::ClientSequencer.new svr, log: log
+    cseq.start
+    3.times do |i|
+      conn = UNIXSocket.new(@path)
+      stream = ObjectStream.new(conn, type: cseq.stream_type)
+      client_id = stream.read["client_id"]
+      assert_equal i, client_id
+    end
+  ensure
+    cseq.stop rescue nil
+  end
+
+  def test_persist
+    saved_next_id = 0
+    3.times do |i|
+      assert_equal i, saved_next_id
+
+      path = "#{@path}-#{i}"
+      svr = UNIXServer.new(path)
+      cseq = Funl::ClientSequencer.new svr, log: log,
+        next_id: saved_next_id
+      cseq.start
+
+      conn = UNIXSocket.new(path)
+      stream = ObjectStream.new(conn, type: cseq.stream_type)
+      client_id = stream.read["client_id"]
+      assert_equal i, client_id
+
+      cseq.stop
+      cseq.wait
+      saved_next_id = cseq.next_id
+    end
+  ensure
+    cseq.stop rescue nil
+  end
+end

data/test/test-client.rb

@@ -0,0 +1,50 @@
+require 'funl/client'
+require 'funl/blobber'
+require 'funl/message-sequencer'
+require 'funl/client-sequencer'
+require 'socket'
+require 'tmpdir'
+
+include Funl
+
+require 'minitest/autorun'
+
+class TestClient < Minitest::Test
+  attr_reader :log
+
+  def setup
+    @dir = Dir.mktmpdir "funl-test-client-"
+    @cseq_path = File.join(@dir, "cseq")
+    @seq_path = File.join(@dir, "seq")
+    @log = Logger.new($stderr)
+    log.level = Logger::WARN
+  end
+  
+  def teardown
+    FileUtils.remove_entry @dir
+  end
+  
+  def test_client
+    cseq_sock = UNIXServer.new(@cseq_path)
+    cseq = ClientSequencer.new cseq_sock, log: log
+    cseq.start
+    
+    seq_sock = UNIXServer.new(@seq_path)
+    seq = MessageSequencer.new  seq_sock, log: log
+    seq.start
+    
+    client = Client.new(
+      seq: UNIXSocket.new(@seq_path),
+      cseq: UNIXSocket.new(@cseq_path),
+      log: log)
+    
+    client.start
+    
+    assert_equal(0, client.client_id)
+    assert_equal(0, client.start_tick)
+    assert_equal(Funl::Blobber::MSGPACK_TYPE, client.blob_type)
+  ensure
+    cseq.stop rescue nil
+    seq.stop rescue nil
+  end
+end

data/test/test-message-sequencer.rb

@@ -0,0 +1,122 @@
+require 'funl/message-sequencer'
+require 'socket'
+require 'tmpdir'
+
+include Funl
+
+require 'minitest/autorun'
+
+class TestMessageSequencer < Minitest::Test
+  attr_reader :log
+
+  def setup
+    @dir = Dir.mktmpdir "funl-test-mseq-"
+    @path = File.join(@dir, "sock")
+    @log = Logger.new($stderr)
+    log.level = Logger::WARN
+    @n_clients = 3
+  end
+  
+  def teardown
+    FileUtils.remove_entry @dir
+  end
+  
+  def test_initial_conns
+    as = []; bs = []
+    @n_clients.times {a, b = UNIXSocket.pair; as << a; bs << b}
+    mseq = MessageSequencer.new nil, *as, log: log
+    bs.each_with_index do |b, i|
+      stream = ObjectStreamWrapper.new(b, type: mseq.stream_type)
+      stream.write_to_outbox({"client_id" => "test_initial_conns #{i}"})
+      global_tick = stream.read["tick"]
+      assert_equal 0, global_tick
+    end
+  end
+  
+  def test_later_conns
+    stream_type = ObjectStream::MSGPACK_TYPE
+    svr = UNIXServer.new(@path)
+    pid = fork do
+      log.progname = "mseq"
+      mseq = MessageSequencer.new svr, log: log,  stream_type: stream_type
+      mseq.start
+      sleep
+    end
+    
+    log.progname = "client"
+    streams = (0...@n_clients).map do
+      conn = UNIXSocket.new(@path)
+      stream = ObjectStreamWrapper.new(conn, type: stream_type)
+      stream.write_to_outbox{{"client_id" => "test_later_conns"}}
+      global_tick = stream.read["tick"]
+      assert_equal 0, global_tick
+      stream
+    end
+    
+    m1 = Message[
+      client: 0, local: 12, global: 34,
+      delta: 1, tags: ["foo"], blob: "BLOB"]
+    send_msg(src: streams[0], message: m1, dst: streams, expected_tick: 1)
+    
+    if @n_clients > 1
+      m2 = Message[
+        client: 1, local: 23, global: 45,
+        delta: 4, tags: ["bar"], blob: "BLOB"]
+      send_msg(src: streams[1], message: m2, dst: streams, expected_tick: 2)
+    end
+    
+  ensure
+    Process.kill "TERM", pid if pid
+  end
+
+  def send_msg(src: nil, message: nil, dst: nil, expected_tick: nil)
+    src << message
+    
+    replies = dst.map do |stream|
+      stream.expect Message
+      stream.read
+    end
+    
+    assert_equal @n_clients, replies.size
+
+    replies.each do |r|
+      assert_equal(message.client_id, r.client_id)
+      assert_equal(message.local_tick, r.local_tick)
+      assert_equal(expected_tick, r.global_tick)
+      assert_equal(nil, r.delta)
+      assert_equal(message.tags, r.tags)
+      assert_equal(message.blob, r.blob)
+    end
+  end
+
+  def test_persist
+    saved_tick = 0
+    n_write = 0
+    3.times do |i|
+      assert_equal n_write, saved_tick
+
+      path = "#{@path}-#{i}"
+      svr = UNIXServer.new(path)
+      mseq = Funl::MessageSequencer.new svr, log: log,
+        tick: saved_tick
+      mseq.start
+
+      conn = UNIXSocket.new(path)
+      stream = ObjectStreamWrapper.new(conn, type: mseq.stream_type)
+      stream.write_to_outbox{{"client_id" => "test_persist"}} # not needed
+      tick = stream.read["tick"]
+      assert_equal n_write, tick
+
+      stream.write Message.new
+      stream.read
+      n_write += 1
+
+      mseq.stop
+      mseq.wait
+      saved_tick = mseq.tick
+    end
+
+  ensure
+    mseq.stop rescue nil
+  end
+end

data/test/test-message.rb

@@ -0,0 +1,75 @@
+require 'funl/message'
+require 'socket'
+require 'stringio'
+require 'msgpack'
+
+require 'minitest/autorun'
+
+class TestMessage < Minitest::Test
+  attr_reader :m, :sio
+  
+  def setup
+    @m = Funl::Message.new
+    m.client_id = 12
+    m.local_tick = 34
+    m.global_tick = 56
+    m.delta = 78
+    m.tags = [ "aaa", "bbb" ]
+    m.blob = "BLOB"
+  end
+  
+  def test_from_serialized
+    a = m.to_a
+    m2 = Funl::Message.from_serialized a
+    assert_equal(m, m2)
+  end
+  
+  def test_to_msgpack
+    assert_kind_of(String, m.to_msgpack(nil))
+    assert_kind_of(String, m.to_msgpack)
+    assert_equal(MessagePack.pack(m), m.to_msgpack(nil))
+    assert_equal(MessagePack.pack(m), m.to_msgpack)
+  end
+  
+  def test_to_msgpack_packer
+    pk = MessagePack::Packer.new
+    assert_kind_of(MessagePack::Packer, m.to_msgpack(pk))
+    assert_equal(pk, m.to_msgpack(pk))
+  end
+  
+  def test_to_msgpack_io
+    src, dst = UNIXSocket.pair
+    assert_nil(m.to_msgpack(src))
+    src.close
+    assert_equal(MessagePack.pack(m), dst.read)
+  end
+  
+  def test_pack_io
+    src, dst = UNIXSocket.pair
+    MessagePack.pack(m, src)
+    src.close
+    assert_equal(MessagePack.pack(m), dst.read)
+  end
+  
+  def test_pack_unpack
+    assert_equal(m.to_a, MessagePack.unpack(MessagePack.pack(m)))
+  end
+  
+  def test_from_msgpack_str
+    assert_equal(m, Funl::Message.from_msgpack(MessagePack.pack(m)))
+  end
+  
+  def test_from_msgpack_stringio
+    sio = StringIO.new
+    MessagePack.pack(m, sio)
+    sio.rewind
+    assert_equal(m, Funl::Message.from_msgpack(sio))
+  end
+  
+  def test_from_msgpack_io
+    src, dst = UNIXSocket.pair
+    MessagePack.pack(m, src)
+    src.close
+    assert_equal(m, Funl::Message.from_msgpack(dst))
+  end
+end

data/test/test-stream.rb

@@ -0,0 +1,53 @@
+require 'funl/stream'
+require 'funl/message'
+require 'stringio'
+require 'logger'
+
+require 'minitest/autorun'
+
+class TestStream < Minitest::Test
+  include Funl::Stream
+  
+  attr_reader :client_id
+  attr_reader :stream_type
+  attr_reader :message_class
+  attr_reader :log
+
+  def setup
+    # for the Stream mixin:
+    @client_id = 42
+    @stream_type = ObjectStream::MSGPACK_TYPE
+    @message_class = Funl::Message
+    @log = Logger.new($stderr)
+    log.level = Logger::WARN
+
+    @sio = StringIO.new
+  end
+  
+  def test_greeting
+    client = client_stream_for @sio
+    client.write "message"
+    
+    @sio.rewind
+
+    server = server_stream_for @sio
+    m = server.read
+    
+    assert_equal "message", m
+    assert_equal "client #{client_id}", server.peer_name
+  end
+
+  def test_message_server_stream
+    client = client_stream_for @sio
+    client.write Funl::Message[client: client_id]
+
+    @sio.rewind
+
+    server = message_server_stream_for @sio
+    m = server.read
+
+    assert_kind_of Funl::Message, m
+    assert_equal client_id, m.client_id
+    assert_equal "client #{client_id}", server.peer_name
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: funl
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Joel VanderWerf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: object-stream
+  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: Sequences messages.
+email: vjoel@users.sourceforge.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- README.md
+- COPYING
+- Rakefile
+- lib/funl/stream.rb
+- lib/funl/blobber.rb
+- lib/funl/history-client.rb
+- lib/funl/history-worker.rb
+- lib/funl/client.rb
+- lib/funl/message-sequencer.rb
+- lib/funl/client-sequencer.rb
+- lib/funl/message.rb
+- test/test-message-sequencer.rb
+- test/test-client-sequencer.rb
+- test/test-message.rb
+- test/test-stream.rb
+- test/test-client.rb
+homepage: https://github.com/vjoel/funl
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --quiet
+- --line-numbers
+- --inline-source
+- --title
+- funl
+- --main
+- README.md
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: Sequences messages
+test_files:
+- test/test-message-sequencer.rb
+- test/test-client-sequencer.rb
+- test/test-message.rb
+- test/test-stream.rb
+- test/test-client.rb
+has_rdoc: