tupelo 0.1

data/test/lib/testable-worker.rb

@@ -0,0 +1,24 @@
+require 'tupelo/client/worker'
+require 'tupelo/client/tuplespace'
+
+class TestableWorker < Tupelo::Client::Worker
+  def initialize client
+    super
+    
+    @cmd_queue = MockQueue.new
+    
+    observe_started_client
+    update_to_tick 0
+  end
+
+  def in_thread?
+    true
+  end
+  
+  def update
+    begin
+      handle_one_request unless cmd_queue.empty?
+      read_messages_from_seq # doesn't block; reads from seq to queue
+    end until cmd_queue.empty?
+  end
+end

data/test/stress/concurrent-transactions.rb

@@ -0,0 +1,42 @@
+require 'tupelo/app'
+
+N = 100
+
+Tupelo.application do |app|
+  app.child do |client|
+    N.times do
+      client.transaction do |t|
+        x, y = t.take [nil, nil]
+        sleep rand/100
+        t.write [x+1, y]
+      end
+    end
+    client.write ["done"]
+  end
+
+  app.child do |client|
+    N.times do
+      client.transaction do |t|
+        x, y = t.take [nil, nil]
+        sleep rand/100
+        t.write [x, y+1]
+      end
+    end
+    client.write ["done"]
+  end
+
+  app.local do |client|
+    client.write [0, 0]
+
+    2.times do
+      client.take ["done"]
+    end
+
+    x, y = client.read [nil, nil]
+    if x == N and y == N
+      puts "OK"
+    else
+      abort "FAIL: x=#{x}, y=#{y}"
+    end
+  end
+end

data/test/system/test-archiver.rb

@@ -0,0 +1,35 @@
+require 'tupelo/app'
+
+Tupelo.application do |app|
+  expected = [[1], [2], [3]]
+
+  app.local do |client|
+    client.write *expected
+  end
+      
+  child_pid = app.child do |client|
+    # Test that tuples written before this client started are readable.
+    a = client.read_all [Integer]
+    client.write result: a
+    sleep 0.1
+  end
+
+  # Normally we would wait using tuples, but in this case we want more
+  # isolation in the test case, so we wait in terms of the PID.
+  Process.waitpid child_pid
+
+  app.local do |client|
+    h = client.read_all result: Array
+    begin
+      a = h.first["result"]
+    rescue => ex
+      abort "FAIL: #{ex}, h=#{h.inspect}"
+    end
+
+    if a == expected
+      puts "OK"
+    else
+      abort "FAIL: a=#{a.inspect}, expected=#{expected.inspect}"
+    end
+  end
+end

data/test/unit/test-mock-queue.rb

@@ -0,0 +1,93 @@
+require 'minitest/autorun'
+
+require 'mock-queue.rb'
+
+class TestMockQueueWithPushPopYields < Minitest::Test
+  def setup
+    @q = MockQueue.new yield_on_push: true, yield_on_pop: true
+  end
+  
+  def test_push
+    f = Fiber.new do |val|
+      loop do
+        val = @q.push val
+      end
+    end
+    
+    a = []
+    assert_equal a, @q.entries
+    
+    3.times do |i|
+      op, val = f.resume i
+      assert_equal :push, op
+      assert_equal i, val
+      a << i
+      assert_equal a, @q.entries
+    end
+  end
+  
+  def test_pop
+    a = []
+    f = Fiber.new do
+      loop do
+        a << @q.pop
+      end
+    end
+    
+    3.times do
+      op = f.resume
+      assert_equal :block, op
+      assert_equal [], a
+    end
+    
+    @q.entries.concat (0...10).to_a
+    
+    10.times do |i|
+      op, val = f.resume
+      assert_equal :pop, op
+      assert_equal i, val
+    end
+    
+    op = f.resume
+    assert_equal :block, op
+    assert_equal a, (0...10).to_a
+  end
+end
+
+class TestMockQueueSimpler < Minitest::Test
+  def setup
+    @q = MockQueue.new
+  end
+  
+  def test_push
+    a = []
+    assert_equal a, @q.entries
+    
+    3.times do |i|
+      @q.push i
+      a << i
+      assert_equal a, @q.entries
+    end
+  end
+  
+  def test_pop
+    a = []
+    f = Fiber.new do
+      loop do
+        a << @q.pop
+      end
+    end
+    
+    3.times do
+      op = f.resume
+      assert_equal :block, op
+      assert_equal [], a
+    end
+    
+    @q.entries.concat (0...10).to_a
+    
+    op = f.resume
+    assert_equal :block, op
+    assert_equal a, (0...10).to_a
+  end
+end

data/test/unit/test-mock-seq.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+
+require 'mock-seq.rb'
+require 'mock-msg.rb'
+
+class TestMockSeq < Minitest::Test
+  def setup
+    @seq = MockSequencer.new
+  end
+  
+  def test_multiple_streams
+    clients = (0..1).map {|i| @seq.stream}
+    
+    count = 0
+    expected = []
+    clients.each_with_index do |c, i|
+      (0..2).each do |j|
+        c.write MockMessage[blob: [i,j]]
+        count += 1
+        expected << [count, i,j]
+      end
+    end
+
+    clients.each_with_index do |c, i|
+      assert_equal expected, c.map {|m| [m.global_tick, *m.blob]}
+    end
+  end
+  
+  def test_alternations_of_reads_and_writes
+    client = @seq.stream
+    client.write MockMessage[blob: 1]
+    client.write MockMessage[blob: 2]
+    assert_equal [1,2], client.map(&:blob)
+
+    client.write MockMessage[blob: "a"]
+    client.write MockMessage[blob: "b"]
+    assert_equal ["a","b"], client.map(&:blob)
+  end
+end

data/test/unit/test-ops.rb

@@ -0,0 +1,222 @@
+require 'minitest/autorun'
+require 'logger'
+
+require 'mock-seq.rb'
+require 'mock-msg.rb'
+require 'mock-client.rb'
+require 'testable-worker.rb'
+
+class TestOps < Minitest::Test
+  attr_reader :seq, :sio, :log
+
+  class MiniFormatter < Logger::Formatter # Based on EasyServe::EasyFormatter
+    Format = "%s: %s: %s\n"
+
+    def call(severity, time, progname, msg)
+      Format % [severity[0..0], progname, msg2str(msg)]
+    end
+  end
+
+  def setup
+    @seq = MockSequencer.new
+  end
+
+  def make_client cid
+    MockClient.new.tap do |c|
+      c.client_id = cid
+      c.log = Logger.new($stderr).tap do |log|
+        log.level = Logger::WARN
+        log.progname = cid
+        log.formatter = MiniFormatter.new
+      end
+      c.blobber = Marshal
+      c.tuplespace = Tupelo::Client::SimpleTuplespace
+      c.message_class = MockMessage
+      c.seq = seq.stream
+      c.worker = TestableWorker.new(c)
+    end
+  end
+
+  def make_clients n
+    n.times.map {|i| make_client i}
+  end
+  
+  def test_one_client
+    client = make_client "one"
+
+    client.update; writer = client.write_nowait [1]
+    client.update; writer.wait
+    client.update; assert_equal 1, writer.global_tick
+    
+    reader = Fiber.new do
+      client.read [nil]
+    end
+
+    client.update; reader.resume
+    client.update; assert_equal [1], reader.resume
+  end
+  
+  def test_two_clients
+    t = ["c0"]
+    cl = make_clients(2)
+
+    cl[0].write t
+
+    cl.each do |c|
+      reader = Fiber.new { c.read [nil] }; reader.resume
+      c.update; assert_equal t, reader.resume
+    end
+  end
+
+  def test_read_existing
+    t = ["foo"]
+    cl = make_clients(2)
+    
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+    
+    cl.each do |c|
+      reader = Fiber.new { c.read [nil] }; reader.resume
+      c.update; assert_equal t, reader.resume
+    end
+  end
+
+  def test_read_waiting
+    t = ["bar"]
+    cl = make_clients(2)
+
+    reader = Fiber.new { cl[1].read [nil] }; reader.resume
+
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+    cl[1].update; assert_equal t, reader.resume
+
+    cl.each do |c|
+      reader = Fiber.new { c.read [nil] }; reader.resume
+      c.update; assert_equal t, reader.resume
+    end
+  end
+
+  def test_take_existing
+    t = ["foo"]
+    cl = make_clients(2)
+
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+
+    taker = Fiber.new { cl[1].take [nil] }; taker.resume
+    cl[1].update; taker.resume
+    cl[1].update; assert_equal t, taker.resume
+    cl[0].update
+
+    cl.each do |c|
+      reader = Fiber.new { c.read_all [nil] }; reader.resume
+      c.update; assert_empty reader.resume
+    end
+  end
+
+  def test_take_waiting
+    t = ["bar"]
+    cl = make_clients(2)
+
+    taker = Fiber.new { cl[1].take [nil] }; taker.resume
+    cl[1].update; taker.resume
+    cl[1].update; assert_equal :block, taker.resume
+
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+    cl[1].update; taker.resume
+    cl[1].update; assert_equal t, taker.resume
+    cl[0].update
+
+    cl.each do |c|
+      reader = Fiber.new { c.read_all [nil] }; reader.resume
+      c.update; assert_empty reader.resume
+    end
+  end
+  
+  def test_transaction_existing
+    w = [1]; t = [2]
+    cl = make_clients(2)
+
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+    
+    trans = Fiber.new do
+      cl[1].transaction do |tr|
+        tr.write w
+        tr.take t
+      end
+    end
+    trans.resume
+
+    cl[1].update; trans.resume
+    cl[1].update; assert_equal t, trans.resume
+    cl[0].update
+
+    cl.each do |c|
+      reader = Fiber.new { c.read_all [nil] }; reader.resume
+      c.update; assert_equal [w], reader.resume
+    end
+  end
+  
+  def test_transaction_waiting
+    w = [1]; t = [2]
+    cl = make_clients(2)
+
+    trans = Fiber.new do
+      cl[1].transaction do |tr|
+        tr.write w
+        tr.take t
+      end
+    end
+    trans.resume
+
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+    
+    cl[1].update; trans.resume
+    cl[1].update; assert_equal t, trans.resume
+    cl[0].update
+
+    cl.each do |c|
+      reader = Fiber.new { c.read_all [nil] }; reader.resume
+      c.update; assert_equal [w], reader.resume
+    end
+  end
+  
+  def test_transaction_cancel
+    w = [1]; t = [2]
+    cl = make_clients(2)
+
+    tr = nil
+    trans = Fiber.new do
+      tr = cl[1].transaction
+      tr.write w
+      begin
+        tr.take t
+        tr.commit.wait
+      rescue Tupelo::Client::TransactionAbort
+        Fiber.yield :abort
+      end
+    end
+    cl[1].update; assert_equal :block, trans.resume
+    
+    tr.cancel
+    cl[1].update; assert_equal :abort, trans.resume
+
+    wr = cl[0].write t
+    cl[0].update; assert_equal 1, wr.global_tick
+    cl[1].update
+
+    cl.each do |c|
+      reader = Fiber.new { c.read_all [nil] }; reader.resume
+      c.update; assert_equal [t], reader.resume
+    end
+  end
+  
+  ## test Transaction#read
+  ## test failure
+  ## test pulse
+  ## test optimistic
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: tupelo
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Joel VanderWerf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-23 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: Distributed tuplespace.
+email: vjoel@users.sourceforge.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- README.md
+- COPYING
+- Rakefile
+- lib/tupelo/client.rb
+- lib/tupelo/app.rb
+- lib/tupelo/archiver.rb
+- lib/tupelo/client/worker.rb
+- lib/tupelo/client/common.rb
+- lib/tupelo/client/tuplespace.rb
+- lib/tupelo/client/transaction.rb
+- lib/tupelo/client/reader.rb
+- lib/tupelo/archiver/worker.rb
+- lib/tupelo/archiver/tuplespace.rb
+- lib/tupelo/version.rb
+- bench/pipeline.rb
+- bugs/write-read.rb
+- bugs/take-write.rb
+- example/timeout-trans.rb
+- example/tiny-client.rb
+- example/add.rb
+- example/app-and-tup.rb
+- example/small.rb
+- example/bounded-retry.rb
+- example/map-reduce-v2.rb
+- example/concurrent-transactions.rb
+- example/cancel.rb
+- example/tiny-server.rb
+- example/write-wait.rb
+- example/tcp.rb
+- example/timeout.rb
+- example/read-in-trans.rb
+- example/balance-xfer-retry.rb
+- example/lock-mgr-with-queue.rb
+- example/hash-tuples.rb
+- example/pulse.rb
+- example/transaction-logic.rb
+- example/map-reduce.rb
+- example/balance-xfer.rb
+- example/broker-optimistic-async.rb
+- example/lock-mgr.rb
+- example/broker-locking.rb
+- example/fail-and-retry.rb
+- example/optimist.rb
+- example/balance-xfer-locking.rb
+- example/increment.rb
+- example/custom-class.rb
+- example/matching.rb
+- example/custom-search.rb
+- example/broker-optimistic.rb
+- example/notify.rb
+- example/small-simplified.rb
+- example/broker-queue.rb
+- example/async-transaction.rb
+- example/boolean-match.rb
+- test/lib/testable-worker.rb
+- test/lib/mock-seq.rb
+- test/lib/mock-msg.rb
+- test/lib/mock-queue.rb
+- test/lib/mock-client.rb
+- test/system/test-archiver.rb
+- test/unit/test-ops.rb
+- test/unit/test-mock-seq.rb
+- test/unit/test-mock-queue.rb
+- test/stress/concurrent-transactions.rb
+homepage: https://github.com/vjoel/tupelo
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --quiet
+- --line-numbers
+- --inline-source
+- --title
+- tupelo
+- --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: Distributed tuplespace
+test_files:
+- test/unit/test-ops.rb
+- test/unit/test-mock-seq.rb
+- test/unit/test-mock-queue.rb
+has_rdoc: