tupelo 0.9 → 0.10

data/example/tiny-client.rb

@@ -2,13 +2,13 @@ require 'tupelo/app'
 
 svr = "tiny-server.yaml"
 
-Tupelo.application servers_file: svr do |app|
-  if app.owns_servers
+Tupelo.application servers_file: svr do
+  if owns_servers
     abort "server not running"
   end
 
-  app.child do |client|
-    client.write ["Hello", "world!"]
-    p client.take [nil, nil]
+  child do
+    write ["Hello", "world!"]
+    p take [nil, nil]
   end
 end

data/example/tiny-server.rb

@@ -2,8 +2,8 @@ require 'tupelo/app'
 
 svr = "tiny-server.yaml"
 
-Tupelo.application servers_file: svr do |app|
-  if app.owns_servers
+Tupelo.application servers_file: svr do
+  if owns_servers
     puts "server started"
     sleep
   else

data/example/transaction-logic.rb

@@ -1,21 +1,21 @@
 require 'tupelo/app'
 
-Tupelo.application do |app|
-  app.child do |client|
+Tupelo.application do
+  child do
     done = false
     until done do
-      client.transaction do |t|
-        op, x, y = t.take [String, Numeric, Numeric]
+      transaction do
+        op, x, y = take [String, Numeric, Numeric]
         # further operations within this transaction can depend on the above.
         
         case op
         when "+"
-          t.write [op, x, y, x + y]
+          write [op, x, y, x + y]
         when "*"
-          t.write [op, x, y, x * y]
+          write [op, x, y, x * y]
         when "select"
-          _, _, _, z = t.take [nil, nil, nil, x..y]
-          t.write [op, x, y, z]
+          _, _, _, z = take [nil, nil, nil, x..y]
+          write [op, x, y, z]
         when "stop"
           done = true
         end
@@ -23,18 +23,18 @@ Tupelo.application do |app|
     end
   end
 
-  app.child do |client|
-    client.write ["+", 1, 2]
-    results = client.read ["+", 1, 2, nil]
+  child do
+    write ["+", 1, 2]
+    results = read ["+", 1, 2, nil]
     p results
 
-    client.write ["*", 3, 4]
-    results = client.read ["*", 3, 4, nil]
+    write ["*", 3, 4]
+    results = read ["*", 3, 4, nil]
     p results
 
-    client.write ["select", 10, 20]
-    p client.read ["select", 10, 20, nil]
+    write ["select", 10, 20]
+    p read ["select", 10, 20, nil]
     
-    client.write ["stop", 0, 0]
+    write ["stop", 0, 0]
   end
 end

data/example/wait-interrupt.rb

@@ -0,0 +1,38 @@
+# This example shows how a transaction can be used to wait for some event,
+# but interrupt the wait when some other event happens.
+
+require 'tupelo/app'
+
+Tupelo.application do
+  child do
+    log.progname = "host"
+
+    transaction do
+      mode = read(mode: nil)["mode"]
+      log "waiting for visitor to arrive by #{mode}"
+      read ["visitor arrives"]
+    end
+
+    log "welcome!"
+  end
+  
+  child do
+    log.progname = "visitor"
+
+    log "I think I am coming by train"
+    write_wait mode: "train"
+    sleep 1
+
+    log "changing my mind, coming by plane"
+    transaction {take mode: nil; write mode: "plane"}
+    sleep 1
+
+    log "changing my mind again, coming by car"
+    transaction {take mode: nil; write mode: "car"}
+    sleep 1
+
+    log "hello!"
+    write_wait ["visitor arrives"]
+  end
+end
+

data/example/write-wait.rb

@@ -1,17 +1,17 @@
 require 'tupelo/app'
 
-Tupelo.application do |app|
-  app.local do |client|
-    client.write [1]
-    client.write [2]
-    w = client.write [3]
-    p client.read_all [nil]
+Tupelo.application do
+  local do
+    write [1]
+    write [2]
+    w = write [3]
+    p read_all
     w.wait # wait for the write to come back and be applied to the client
-    p client.read_all [nil]
+    p read_all
 
-    client.write [4]
-    client.write [5]
-    client.write_wait [6]
-    p client.read_all [nil]
+    write [4]
+    write [5]
+    write_wait [6]
+    p read_all
   end
 end

data/lib/tupelo/archiver/tuplespace.rb

@@ -5,9 +5,13 @@ class Tupelo::Archiver
     attr_reader :zero_tolerance
 
     def initialize(zero_tolerance: Tupelo::Archiver::ZERO_TOLERANCE)
+      @zero_tolerance = zero_tolerance
+      clear
+    end
+    
+    def clear
       @counts = Hash.new(0) # tuple => count
       @nzero = 0
-      @zero_tolerance = zero_tolerance
     end
     
     # note: multiple equal tuples are yielded once

data/lib/tupelo/archiver/worker.rb

@@ -38,7 +38,7 @@ class Tupelo::Archiver
       stream = client.arc_server_stream_for req.io
 
       begin
-        op, tags, tick = stream.read
+        op, sub_delta, tick = stream.read
       rescue EOFError
         log.debug {"#{stream.peer_name} disconnected from archiver"}
         return
@@ -48,18 +48,18 @@ class Tupelo::Archiver
 
       log.info {
         "#{stream.peer_name} requested #{op.inspect} at tick=#{tick}" +
-          (tags ? " on #{tags}" : "")}
+          (sub_delta ? " for #{sub_delta}" : "")}
 
       if tick <= global_tick
-        fork_for_op op, tags, tick, stream, req
+        fork_for_op op, sub_delta, tick, stream, req
       else
         at_tick tick do
-          fork_for_op op, tags, tick, stream, req
+          fork_for_op op, sub_delta, tick, stream, req
         end
       end
     end
 
-    def fork_for_op op, tags, tick, stream, req
+    def fork_for_op op, sub_delta, tick, stream, req
       fork do
         begin
           case op
@@ -68,7 +68,7 @@ class Tupelo::Archiver
           when "get range" ### handle this in Funl::HistoryWorker
             raise "Unimplemented" ###
           when GET_TUPLESPACE
-            send_tuplespace stream, tags
+            send_tuplespace stream, sub_delta
           else
             raise "Unknown operation: #{op.inspect}"
           end
@@ -94,18 +94,32 @@ class Tupelo::Archiver
       end
     end
 
-    def send_tuplespace stream, templates
+    def send_tuplespace stream, sub_delta
       log.info {
         "send_tuplespace to #{stream.peer_name} " +
         "at tick #{global_tick.inspect} " +
-        (templates ? " with templates #{templates.inspect}" : "")}
+        (sub_delta ? " with sub_delta #{sub_delta.inspect}" : "")}
       
       stream << [global_tick]
 
-      if templates
-        templates = templates.map {|t| Tupelo::Client::Template.new t}
+      ## better: make use of sub_delta["subscribed_*"] to reduce what
+      ## has to be sent.
+
+      if sub_delta["request_all"]
         tuplespace.each do |tuple, count|
-          if templates.any? {|template| template === tuple}
+          count.times do ## just dump and send str * count?
+            stream << tuple ## optimize this, and cache the serial
+            ## optimization: use stream.write_to_buffer
+          end
+        end
+
+      else
+        tags = sub_delta["request_tags"] ## use set
+        subs = subspaces.select {|sub| tags.include? sub.tag}
+
+        tuplespace.each do |tuple, count|
+          ## alternately, store tags with tuples (risk if dynamic spaces)
+          if subs.any? {|sub| sub === tuple}
             count.times do
               stream << tuple
               ## optimization: use stream.write_to_buffer
@@ -114,13 +128,6 @@ class Tupelo::Archiver
           ## optimize this if templates have simple form, such as
           ##   [ [str1, nil, ...], [str2, nil, ...], ...]
         end
-      else
-        tuplespace.each do |tuple, count|
-          count.times do ## just dump and send str * count?
-            stream << tuple ## optimize this, and cache the serial
-            ## optimization: use stream.write_to_buffer
-          end
-        end
       end
 
       stream << nil # terminator

data/lib/tupelo/client/reader.rb

@@ -61,9 +61,9 @@ class Tupelo::Client
     end
 
     def wait
-      @client.log.debug {"waiting for #{self}"}
+      @client.log.debug {"waiting for #{inspect}"}
       r = queue.pop
-      @client.log.debug {"finished waiting for #{self}"}
+      @client.log.debug {"finished waiting for #{inspect}"}
       r
     end
 

data/lib/tupelo/client/transaction.rb

@@ -103,10 +103,13 @@ class Tupelo::Client
     attr_reader :pulses
     attr_reader :take_templates
     attr_reader :read_templates
-    attr_reader :take_tuples
-    attr_reader :read_tuples
+    attr_reader :take_tuples_for_remote
+    attr_reader :take_tuples_for_local
+    attr_reader :read_tuples_for_remote
+    attr_reader :read_tuples_for_local
     attr_reader :granted_tuples
     attr_reader :missing
+    attr_reader :tags
     
     STATES = [
       OPEN      = :open,    # initial state
@@ -140,10 +143,13 @@ class Tupelo::Client
       @pulses = []
       @take_templates = []
       @read_templates = []
-      @take_tuples = []
-      @read_tuples = []
+      @take_tuples_for_remote = []
+      @take_tuples_for_local = []
+      @read_tuples_for_remote = []
+      @read_tuples_for_local = []
       @granted_tuples = nil
       @missing = nil
+      @tags = nil
       @_take_nowait = nil
       @_read_nowait = nil
       
@@ -181,6 +187,7 @@ class Tupelo::Client
       
       ops = [ ["write", writes], ["pulse", pulses],
             ["take", take_templates], ["read", read_templates] ]
+            ## exclude templates that were satisfied locally by writes
       ops.map! do |label, tuples|
         ["#{label} #{tuples.map(&:inspect).join(", ")}"] unless tuples.empty?
       end
@@ -209,7 +216,10 @@ class Tupelo::Client
       raise TransactionStateError, "not open: #{inspect}" unless open? or
         failed?
       check_tuples tuples
-      @writes.concat tuples
+      blobber = worker.blobber
+      @writes.concat tuples.map {|t| blobber.load(blobber.dump(t))}
+        # this is both to de-alias (esp. in case of marshal or yaml) and
+        # to convert symbols to strings (in case of msgpack or json)
       nil
     end
     
@@ -218,7 +228,8 @@ class Tupelo::Client
       raise TransactionStateError, "not open: #{inspect}" unless open? or
         failed?
       check_tuples tuples
-      @pulses.concat tuples
+      blobber = worker.blobber
+      @pulses.concat tuples.map {|t| blobber.load(blobber.dump(t))}
       nil
     end
     
@@ -233,7 +244,7 @@ class Tupelo::Client
       log.debug {"asking worker to take #{template_spec.inspect}"}
       worker_push self
       wait
-      return take_tuples.last
+      return take_tuples_for_local.last
     end
     
     def take_nowait template_spec
@@ -249,7 +260,7 @@ class Tupelo::Client
       log.debug {"asking worker to take_nowait #{template_spec.inspect}"}
       worker_push self
       wait
-      return take_tuples[i]
+      return take_tuples_for_local[i]
     end
     
     # transaction applies only if template has a match
@@ -263,7 +274,7 @@ class Tupelo::Client
       log.debug {"asking worker to read #{template_spec.inspect}"}
       worker_push self
       wait
-      return read_tuples.last
+      return read_tuples_for_local.last
     end
 
     def read_nowait template_spec
@@ -279,7 +290,7 @@ class Tupelo::Client
       log.debug {"asking worker to read #{template_spec.inspect}"}
       worker_push self
       wait
-      return read_tuples[i]
+      return read_tuples_for_local[i]
     end
 
     def abort
@@ -299,8 +310,9 @@ class Tupelo::Client
     def commit
       if open?
         if @writes.empty? and @pulses.empty? and
-           @take_tuples.empty? and @read_tuples.empty?
-          @global_tick = global_tick
+           @take_tuples_for_remote.all? {|t| t.nil?} and
+           @read_tuples_for_remote.all? {|t| t.nil?}
+          @global_tick = worker.global_tick ## ok?
           done!
           log.info {"not committing empty transaction"}
         else
@@ -352,11 +364,16 @@ class Tupelo::Client
       end
     end
 
-    def async
-      raise ArgumentError, "must provide block" unless block_given?
+    def async &block
+      raise ArgumentError, "must provide block" unless block
       TransactionThread.new(self) do ## Fiber?
         begin
-          val = yield self
+          val =
+            if block.arity == 0
+              instance_eval &block
+            else
+              yield self
+            end
           commit.wait
           val
         rescue TransactionFailure => ex
@@ -379,19 +396,21 @@ class Tupelo::Client
       raise unless in_worker_thread?
 
       if new_tuple
-        return true if take_tuples.all? and read_tuples.all?
+        return true if take_tuples_for_local.all? and read_tuples_for_local.all?
 
-        take_tuples.each_with_index do |tuple, i|
+        take_tuples_for_local.each_with_index do |tuple, i|
           if not tuple and take_templates[i] === new_tuple
-            take_tuples[i] = new_tuple
+            take_tuples_for_local[i] = new_tuple
+            take_tuples_for_remote[i] = new_tuple
             log.debug {"prepared #{inspect} with #{new_tuple}"}
             break
           end
         end
 
-        read_tuples.each_with_index do |tuple, i|
+        read_tuples_for_local.each_with_index do |tuple, i|
           if not tuple and read_templates[i] === new_tuple
-            read_tuples[i] = new_tuple
+            read_tuples_for_local[i] = new_tuple
+            read_tuples_for_remote[i] = new_tuple
             log.debug {"prepared #{inspect} with #{new_tuple}"}
           end
         end
@@ -399,11 +418,22 @@ class Tupelo::Client
       else
         ## optimization: use tuple cache
         skip = nil
-        (take_tuples.size...take_templates.size).each do |i|
-          take_tuples[i] = worker.tuplespace.find_match_for(
-            take_templates[i], distinct_from: take_tuples)
-          if take_tuples[i]
-            log.debug {"prepared #{inspect} with #{take_tuples[i]}"}
+        (take_tuples_for_local.size...take_templates.size).each do |i|
+          template = take_templates[i]
+          
+          if wt = @writes.find {|tuple| template === tuple}
+            take_tuples_for_remote[i] = nil
+            take_tuples_for_local[i] = wt.dup
+            @writes.delete wt
+            next
+          end
+
+          take_tuples_for_local[i] = take_tuples_for_remote[i] =
+            worker.tuplespace.find_match_for(template,
+              distinct_from: take_tuples_for_local)
+          
+          if take_tuples_for_local[i]
+            log.debug {"prepared #{inspect} with #{take_tuples_for_local[i]}"}
           else
             if @_take_nowait and @_take_nowait[i]
               (skip ||= []) << i
@@ -412,17 +442,28 @@ class Tupelo::Client
         end
 
         skip and skip.reverse_each do |i|
-          take_tuples.delete_at i
+          take_tuples_for_local.delete_at i
+          take_tuples_for_remote.delete_at i
           take_templates.delete_at i
           @_take_nowait.delete i
         end
         
         skip = nil
-        (read_tuples.size...read_templates.size).each do |i|
-          read_tuples[i] = worker.tuplespace.find_match_for(
-            read_templates[i])
-          if read_tuples[i]
-            log.debug {"prepared #{inspect} with #{read_tuples[i]}"}
+        (read_tuples_for_local.size...read_templates.size).each do |i|
+          template = read_templates[i]
+
+          if wt = @writes.find {|tuple| template === tuple}
+            read_tuples_for_remote[i] = nil
+            read_tuples_for_local[i] = wt.dup
+            next
+          end
+
+          read_tuples_for_local[i] = read_tuples_for_remote[i] =
+            worker.tuplespace.find_match_for(template,
+              distinct_from: take_tuples_for_local)
+          
+          if read_tuples_for_local[i]
+            log.debug {"prepared #{inspect} with #{read_tuples_for_local[i]}"}
           else
             if @_read_nowait and @_read_nowait[i]
               (skip ||= []) << i
@@ -431,7 +472,8 @@ class Tupelo::Client
         end
 
         skip and skip.reverse_each do |i|
-          read_tuples.delete_at i
+          read_tuples_for_local.delete_at i
+          read_tuples_for_remote.delete_at i
           read_templates.delete_at i
           @_read_nowait.delete i
         end
@@ -441,11 +483,12 @@ class Tupelo::Client
       ## convert cancelling take/write to read
       ## check that remaining take/read tuples do not cross a space boundary
       
-      if take_tuples.all? and read_tuples.all?
+      if take_tuples_for_local.all? and read_tuples_for_local.all?
         @queue << true
         log.debug {
           "prepared #{inspect}, " +
-          "take tuples: #{take_tuples}, read tuples: #{read_tuples}"}
+          "take tuples: #{take_tuples_for_local}, " +
+          "read tuples: #{read_tuples_for_local}"}
       end
       
       return true
@@ -455,7 +498,7 @@ class Tupelo::Client
       return false if closed? or failed? # might change during this method
       raise unless in_worker_thread?
 
-      @take_tuples.each do |tuple|
+      @take_tuples_for_remote.each do |tuple|
         if tuple == missing_tuple ## might be false positive, but ok
           fail [missing_tuple]
             ## optimization: manage tuple cache
@@ -463,7 +506,7 @@ class Tupelo::Client
         end
       end
 
-      @read_tuples.each do |tuple|
+      @read_tuples_for_remote.each do |tuple|
         if tuple == missing_tuple ## might be false positive, but ok
           fail [missing_tuple]
           return false

data/lib/tupelo/client/tuplespace.rb

@@ -44,6 +44,7 @@ class Tupelo::Client
     def insert(*); self; end
     def find_distinct_matches_for(*); raise; end ##?
     def find_match_for(*); raise; end ##?
+    def clear; end
     
     ## should store space metadata, so outgoing writes can be tagged
   end