spinoza 0.1 → 0.2

data/test/test-link.rb

@@ -0,0 +1,43 @@
+require 'minitest/autorun'
+require 'spinoza/system/link'
+
+class TestLink < Minitest::Test
+  include Spinoza
+
+  class MockNode
+    attr_reader :msgs
+    
+    def initialize
+      @msgs = []
+    end
+    
+    def recv msg: nil
+      @msgs << msg
+    end
+  end
+
+  def setup
+    @timeline = Timeline.new
+    @node1 = MockNode.new
+    @node2 = MockNode.new
+    @link = Link[timeline: @timeline,
+      src: @node1, dst: @node2, latency: 1.0
+    ]
+  end
+  
+  def test_link
+    @link.send_message "hello"
+    assert_equal [], @node2.msgs
+    @timeline.evolve 0.9
+    assert_equal [], @node2.msgs
+    @timeline.evolve 0.2
+    assert_equal ["hello"], @node2.msgs
+  end
+  
+  def test_fifo
+    @link.send_message "foo"
+    @link.send_message "bar"
+    @timeline.evolve 1.0
+    assert_equal ["foo", "bar"], @node2.msgs
+  end
+end

data/test/test-log.rb

@@ -0,0 +1,47 @@
+require 'minitest/autorun'
+require 'spinoza/system/log'
+
+class TestLog < Minitest::Test
+  include Spinoza
+
+  class MockNode
+    attr_reader :time_now
+
+    def initialize time_now
+      @time_now = time_now
+    end
+
+    def evolve dt
+      @time_now += dt
+    end
+  end
+  
+  def setup
+    @log = Log.new dt_durable: 0.300, dt_replicated: 0.500
+    @sender = MockNode.new 0.0
+    @recver = MockNode.new 0.0
+  end
+  
+  def test_log
+    @log.write "a", 1, node: @sender
+    assert_raises Log::KeyConflictError do
+      @log.write "a", 1, node: @sender
+    end
+
+    assert_equal 0.300, @log.time_durable("a")
+    assert_equal 0.500, @log.time_replicated("a")
+    
+    assert_equal 1, @log.read("a", node: @sender)
+    assert_equal nil, @log.read("a", node: @recver)
+    
+    @sender.evolve 0.200
+    refute @log.durable? "a"
+    @sender.evolve 0.200
+    assert @log.durable? "a"
+    
+    @recver.evolve 0.400
+    assert_equal nil, @log.read("a", node: @recver)
+    @recver.evolve 0.200
+    assert_equal 1, @log.read("a", node: @recver)
+  end
+end

data/test/test-meta-log.rb

@@ -0,0 +1,63 @@
+require 'minitest/autorun'
+require 'spinoza/system/meta-log'
+
+class TestMetaLog < Minitest::Test
+  include Spinoza
+
+  class MockNode
+    attr_reader :time_now, :timeline
+
+    def initialize time_now
+      @time_now = time_now
+      @timeline = [] # note: history and future
+    end
+
+    def evolve dt
+      @time_now += dt
+    end
+  end
+  
+  def setup
+    @meta_log = MetaLog.new dt_quorum: 0.300, dt_replicated: 0.500
+    @sender = MockNode.new 0.0
+    @recver = MockNode.new 0.0
+  end
+  
+  def test_meta_log
+    id = @meta_log.append "a", node: @sender
+
+    assert_equal 0.300, @meta_log.time_quorum(id)
+    assert_equal 0.500, @meta_log.time_replicated(id)
+    
+    assert_equal "a", @meta_log.get(id, node: @sender)
+    assert_equal nil, @meta_log.get(id, node: @recver)
+    
+    @sender.evolve 0.200
+    refute @meta_log.quorum? id
+    @sender.evolve 0.200
+    assert @meta_log.quorum? id
+    
+    @recver.evolve 0.400
+    assert_equal nil, @meta_log.get(id, node: @recver)
+    @recver.evolve 0.200
+    assert_equal "a", @meta_log.get(id, node: @recver)
+  end
+  
+  def test_listeners
+    listener = []
+    @meta_log.on_entry_available listener, :push
+    
+    @meta_log.append "a", node: @sender
+    @meta_log.append "b", node: @sender
+    
+    assert_equal 2, @sender.timeline.size
+
+    e = @sender.timeline[0]
+    assert_equal @sender.time_now + 0.500, e.time
+    assert_equal "a", e.data[:value]
+
+    e = @sender.timeline[1]
+    assert_equal @sender.time_now + 0.500, e.time
+    assert_equal "b", e.data[:value]
+  end
+end

data/test/test-node.rb

@@ -1,17 +1,18 @@
 require 'minitest/autorun'
 require 'spinoza/system/node'
 
-include Spinoza
-
 class TestNode < Minitest::Test
+  include Spinoza
+
   def setup
-    @node = Node.new(
-      TableSpec.new :foos, id: "integer", name: "string", len: "float"
-    )
+    @node = Node[
+      Table[:foos, id: "integer", name: "string", len: "float"],
+      timeline: nil
+    ]
   end
   
   def test_store
-    assert_equal [:foos], @node.store.tables
+    assert_equal Set[:foos], @node.store.tables
   end
   
   def test_ops
@@ -22,23 +23,18 @@ class TestNode < Minitest::Test
     rslt = store.execute op_i, op_r
     
     assert_equal(1, rslt.size)
-    r_tuples = rslt[0].val
-    assert_equal(1, r_tuples.size)
-    assert_equal({id: 1, name: "a", len: 1.2}, r_tuples[0])
+    assert_equal({id: 1, name: "a", len: 1.2}, rslt[0].val)
     
     op_u = UpdateOperation.new(table: :foos, key: {id: 1}, row: {name: "b"})
     rslt = store.execute op_u, op_r
     
     assert_equal(1, rslt.size)
-    r_tuples = rslt[0].val
-    assert_equal(1, r_tuples.size)
-    assert_equal({id: 1, name: "b", len: 1.2}, r_tuples[0])
+    assert_equal({id: 1, name: "b", len: 1.2}, rslt[0].val)
 
     op_d = DeleteOperation.new(table: :foos, key: {id: 1})
     rslt = store.execute op_d, op_r
     assert_equal(1, rslt.size)
-    r_tuples = rslt[0].val
-    assert_equal(0, r_tuples.size)
+    refute rslt[0].val
   end
   
   def test_locks
@@ -50,6 +46,7 @@ class TestNode < Minitest::Test
     lm.lock_read rs1, :t1
     assert lm.has_read_lock?(rs1, :t1)
     refute lm.has_read_lock?(rs1, :t2)
+    refute lm.has_read_lock?([:bars, 3], :t1)
 
     lm.lock_read rs1, :t2
     assert lm.has_read_lock?(rs1, :t1)
@@ -76,6 +73,8 @@ class TestNode < Minitest::Test
       lm.lock_read rs2, :t2
     end
     assert lm.has_write_lock?(rs2, :t1)
+    refute lm.has_write_lock?(rs2, :t3)
+    refute lm.has_write_lock?([:bars, 3], :t1)
 
     lm.lock_write rs2, :t1
     assert lm.has_write_lock?(rs2, :t1)
@@ -84,4 +83,26 @@ class TestNode < Minitest::Test
     lm.unlock_write rs2, :t1
     refute lm.has_write_lock?(rs2, :t1)
   end
+    
+  def test_unlock_all
+    lm = @node.lock_manager
+    
+    rs1 = [:foos, 1]
+    rs2 = [:foos, 2]
+
+    lm.lock_read rs1, :t1
+    lm.lock_write rs2, :t2
+
+    lm.unlock_all :t1
+    refute lm.has_write_lock?(rs1, :t1)
+    refute lm.has_write_lock?(rs2, :t1)
+    refute lm.has_write_lock?(rs1, :t2)
+    assert lm.has_write_lock?(rs2, :t2)
+
+    lm.unlock_all :t2
+    refute lm.has_write_lock?(rs1, :t1)
+    refute lm.has_write_lock?(rs2, :t1)
+    refute lm.has_write_lock?(rs1, :t2)
+    refute lm.has_write_lock?(rs2, :t2)
+  end
 end

data/test/test-readcaster.rb

@@ -0,0 +1,87 @@
+require 'minitest/autorun'
+require 'spinoza/calvin/readcaster'
+require 'spinoza/system/node'
+require 'spinoza/system/link'
+require 'spinoza/system/timeline'
+require 'spinoza/transaction'
+
+class TestReadcaster < Minitest::Test
+  include Spinoza
+
+  def setup
+    @timeline = Spinoza::Timeline.new
+
+    @node = Node[
+      Table[:as, id: "integer", name: "string"],
+      Table[:bs, id: "integer", name: "string"],
+      timeline: @timeline
+    ]
+    
+    @na = Node[
+      Table[:as, id: "integer", name: "string"],
+      timeline: @timeline
+    ]
+
+    @nb = Node[
+      Table[:bs, id: "integer", name: "string"],
+      timeline: @timeline
+    ]
+    
+    @node.link @na, latency: 1.0
+    @node.link @nb, latency: 1.0
+    
+    store = @node.store
+    
+    op_ia = InsertOperation.new(table: :as, row: {id: 2, name: "a2"})
+    op_ib = InsertOperation.new(table: :bs, row: {id: 2, name: "b2"})
+    store.execute op_ia, op_ib
+
+    # normally this is part of a Calvin::Node, but here we have a System::Node
+    @readcaster = Calvin::Readcaster.new(node: @node)
+
+    @txn = transaction do
+      at(:as).insert id: 1, name: "a1"
+      at(:as, id: 2).read
+      at(:bs, id: 2).read
+    end
+  end
+  
+  def test_readcaster
+    local_read_results = @readcaster.execute_local_reads @txn
+    assert_equal 2, local_read_results.size
+    assert_equal "a2", local_read_results[0].val[:name]
+    assert_equal "b2", local_read_results[1].val[:name]
+  end
+  
+  def test_serve_reads
+    results = []
+    class << @readcaster; self; end.send :define_method,
+       :send_read do |link, **opts|
+      results << [link, opts]
+    end
+    
+    local_read_results = @readcaster.execute_local_reads @txn
+    @readcaster.serve_reads @txn, local_read_results
+
+    assert_equal 1, results.size
+    link, opts = results.first
+
+    assert_equal @node.links[@na], link
+    table, read_results = opts.values_at(:table, :read_results)
+    assert_equal :bs, table
+    assert_equal 1, read_results.size
+    assert_equal "b2", read_results[0].val[:name]
+  end
+  
+  def test_all_reads_local
+    assert @txn.all_reads_are_local? @node
+    refute @txn.all_reads_are_local? @na
+    refute @txn.all_reads_are_local? @nb
+  end
+  
+  def test_remote_read_tables
+    assert_equal Set[], @txn.remote_read_tables(@node)
+    assert_equal Set[:bs], @txn.remote_read_tables(@na)
+    assert_equal Set[:as], @txn.remote_read_tables(@nb)
+  end
+end

data/test/test-scheduler.rb

@@ -0,0 +1,163 @@
+require 'minitest/autorun'
+require 'spinoza/transaction'
+require 'spinoza/system/timeline'
+require 'spinoza/system/log'
+require 'spinoza/system/meta-log'
+require 'spinoza/calvin/node'
+
+#===========#
+# DEBUGGING #
+#===========#
+#
+# require 'pp'
+# pp @results
+# pp @timeline.history.select {|time, event| event.action != :step_epoch}
+
+class TestScheduler < Minitest::Test
+  include Spinoza
+  
+  def mkresults node, txn, rslt
+    {
+      transaction:  txn,
+      time:         node.timeline.now,
+      values:       rslt.map {|rr| rr.val}
+    }
+  end
+  
+  FOOS = Table[:foos, id: "integer", name: "string"]
+  BARS = Table[:bars, id: "integer", name: "string"]
+
+  # spec is an array of arrays of Tables, such as [ [FOOS], [FOOS, BARS] ]
+  def mknodes spec
+    @nodes = spec.map.with_index do |tables, i|
+      Calvin::Node[
+        *tables,
+        name: i,
+        timeline: @timeline,
+        log: @log,
+        meta_log: @meta_log,
+        sequencer: nil, # so the default will get created
+        scheduler: nil ## TODO dependency injection
+      ]
+    end
+
+    @results = {}
+    @nodes.each do |node|
+      rs = @results[node] = []
+      node.on_transaction_finish do |txn, rslt|
+        rs << mkresults(node, txn, rslt)
+        #@node.default_output txn, rslt
+      end
+    end
+  end
+
+  def setup
+    @timeline = Timeline.new
+    @log = Log.new dt_durable: 0.300, dt_replicated: 0.500
+    @meta_log = MetaLog.new dt_quorum: 0.300, dt_replicated: 0.500
+  end
+
+  def test_one_node
+    mknodes [ [FOOS] ]
+
+    txn1 = transaction do
+      at(:foos).insert id: 1, name: "a"
+      at(:foos).insert id: 2, name: "b"
+      at(:foos).insert id: 3, name: "c"
+    end
+
+    txn2 = transaction do
+      at(:foos, id: 1).read
+      at(:foos, id: 2).delete
+      at(:foos, id: 3).update name: "cc"
+    end
+
+    txn3 = transaction do
+      at(:foos, id: 1).read
+      at(:foos, id: 2).read
+      at(:foos, id: 3).read
+    end
+
+    @nodes[0].sequencer.accept_transaction txn1
+    @nodes[0].sequencer.accept_transaction txn2
+    @nodes[0].sequencer.accept_transaction txn3
+
+    @timeline.evolve 1.0
+    
+    rs = @results[@nodes[0]]
+    assert_equal [0.81, 0.81, 0.81], rs.map{|r| r[:time]}
+    
+    assert_empty rs[0][:values]
+    assert_equal [{id: 1, name: "a"}], rs[1][:values]
+    assert_equal [{id: 1, name: "a"}, nil, {id: 3, name: "cc"}],
+      rs[2][:values]
+  end
+
+  def test_two_nodes_same_tables
+    mknodes [ [FOOS], [FOOS] ]
+
+    txn1 = transaction do
+      at(:foos).insert id: 1, name: "a"
+      at(:foos).insert id: 2, name: "b"
+      at(:foos).insert id: 3, name: "c"
+    end
+
+    txn2 = transaction do
+      at(:foos, id: 1).read
+      at(:foos, id: 2).delete
+      at(:foos, id: 3).update name: "cc"
+    end
+
+    txn3 = transaction do
+      at(:foos, id: 1).read
+      at(:foos, id: 2).read
+      at(:foos, id: 3).read
+    end
+
+    @nodes[0].sequencer.accept_transaction txn1
+    @nodes[0].sequencer.accept_transaction txn2
+    @nodes[0].sequencer.accept_transaction txn3
+
+    @timeline.evolve 1.0
+    
+    @results.each do |node, rs|
+      desc = node.inspect
+      assert_equal [0.81, 0.81, 0.81], rs.map{|r| r[:time]}, desc
+    
+      assert_empty rs[0][:values], desc
+      assert_equal [{id: 1, name: "a"}], rs[1][:values], desc
+      assert_equal [{id: 1, name: "a"}, nil, {id: 3, name: "cc"}],
+        rs[2][:values], desc
+    end
+  end
+
+  def test_remote_reads
+    mknodes [ [FOOS], [BARS] ]
+
+    @nodes[0].link @nodes[1], latency: 0.010
+
+    txn1 = transaction do
+      at(:foos).insert id: 1, name: "a"
+      at(:bars).insert id: 2, name: "b"
+    end
+
+    txn2 = transaction do
+      at(:foos, id: 1).read
+      at(:bars, id: 2).update name: "bb"
+        # write must be present or else msg to inactive node is optimized away
+    end
+
+    @nodes[0].sequencer.accept_transaction txn1
+    @nodes[0].sequencer.accept_transaction txn2
+
+    @timeline.evolve 2.0
+
+    rs = @results[@nodes[1]]
+
+    assert_equal 0.81, rs[0][:time]
+    assert_empty rs[0][:values]
+
+    assert_equal 0.81 + 0.010, rs[1][:time]
+    assert_equal [{id: 1, name: "a"}], rs[1][:values]
+  end
+end