tupelo 0.9 → 0.10

data/example/fail-and-retry.rb

@@ -1,29 +1,29 @@
 require 'tupelo/app'
 
-Tupelo.application do |app|
+Tupelo.application do
   2.times do
-    app.child do |client|
+    child do
       begin
         # the block is re-executed for the client that fails to take [1]
         # this is also true in the transaction do...end construct.
-        t = client.transaction
+        t = transaction
         r = t.take [Integer]
-        client.log "trying to take #{r.inspect}"
+        log "trying to take #{r.inspect}"
         t.commit.wait
-        client.log "took #{r.inspect}"
+        log "took #{r.inspect}"
       rescue Tupelo::Client::TransactionFailure => ex
-        client.log "#{ex} -- retrying"
+        log "#{ex} -- retrying"
         retry
         # manually emulate the effect of transaction do...end
       end
     end
   end
   
-  app.child do |client|
-    client.write [1]
-    client.log "wrote #{[1]}"
+  child do
+    write [1]
+    log "wrote #{[1]}"
     sleep 0.1
-    client.write [2]
-    client.log "wrote #{[2]}"
+    write [2]
+    log "wrote #{[2]}"
   end
 end

data/example/hash-tuples.rb

@@ -35,19 +35,21 @@
 
 require 'tupelo/app'
 
-Tupelo.application do |app|
-  app.child do |client|
-    client.write x: 1, y: 2
+Tupelo.application do
+  child do
+    write x: 1, y: 2
   end
   
-  app.child do |client|
-    t = client.take x: Numeric, y: Numeric
-    client.write x: t["x"], y: t["y"], sum: t["x"] + t["y"]
-    client.log "sum result: #{client.read x: nil, y: nil, sum: nil}"
+  child do
+    t = take x: Numeric, y: Numeric
+    write x: t["x"], y: t["y"], sum: t["x"] + t["y"]
+    log "sum result: #{read x: nil, y: nil, sum: nil}"
     
     # N.B.: these are all empty, for the reason given above.
-    client.log client.read_all x: nil
-    client.log client.read_all y: nil
-    client.log client.read_all x: nil, y: nil, z: nil
+    log read_all x: nil
+    log read_all y: nil
+    log read_all x: nil, y: nil, z: nil
+    
+    log read_all
   end
 end

data/example/increment.rb

@@ -2,20 +2,20 @@ require 'tupelo/app'
 
 N = 5
 
-Tupelo.application do |app|
+Tupelo.application do
   N.times do |i|
-    app.child do |client|
-      client.transaction do |t|
-        n, s = t.take [Numeric, String]
+    child do
+      transaction do
+        n, s = take [Numeric, String]
         #sleep rand # No race conditions here!
-        t.write [n + 1, s + "\n  incremented by client #{i}"]
+        write [n + 1, s + "\n  incremented by client #{i}"]
       end
     end
   end
 
-  app.child do |client|
-    client.write [0, "started with 0"]
-    n, s = client.take [N, String]
+  child do
+    write [0, "started with 0"]
+    n, s = take [N, String]
     puts s, "result is #{n}"
   end
 end

data/example/load-balancer.rb

@@ -33,7 +33,8 @@ Tupelo.application do
         req_id = nil
         transaction do
           # grouping the following ops in a transaction is not necessary for
-          # correctness, but it does reduce latency
+          # correctness, but it does reduce latency. Also, it's more robust
+          # in that a crash or network problem cannot cause a lost tuple.
           _, req_id = take ["next_req_id", Integer]
           write ["next_req_id", req_id + 1]
           write ["request", req_id, req_dat]

data/example/lock-mgr-with-queue.rb

@@ -9,36 +9,36 @@ require 'tupelo/app'
 
 N = 3
 
-Tupelo.application do |app|
-  app.child passive: true do |client| # the lock manager
-    client.log.progname << " (lock mgr)"
+Tupelo.application do
+  child passive: true do # the lock manager
+    log.progname << " (lock mgr)"
     waiters = Queue.new
 
     Thread.new do
       loop do
         _, _, client_id, duration =
-          client.take ["request", "resource", nil, nil]
+          take ["request", "resource", nil, nil]
         waiters << [client_id, duration]
       end
     end
 
     loop do
       client_id, duration = waiters.pop
-      client.write ["resource", client_id, duration]
+      write ["resource", client_id, duration]
       begin
-        client.take ["done", "resource", client_id], timeout: duration
+        take ["done", "resource", client_id], timeout: duration
       rescue TimeoutError
-        client.log "forcing client #{client_id} to stop using resource."
+        log "forcing client #{client_id} to stop using resource."
       end
-      client.take ["resource", client_id, duration]
+      take ["resource", client_id, duration]
     end
     # exercise for reader: make this work with 2 or more resources
     # exercise: rewrite this with hash tuples instead of array tuples
   end
   
   N.times do |i|
-    app.child do |client|
-      client.write ["request", "resource", client.client_id, 0.5]
+    child do
+      write ["request", "resource", client_id, 0.5]
       
       2.times do |j|
         # Now we are ouside of transaction, but still no other client may use
@@ -46,20 +46,20 @@ Tupelo.application do |app|
         # as all clients follow the read protocol below.
         sleep 0.2
 
-        client.transaction do |t|
-          t.read ["resource", client.client_id, nil]
-          t.write ["c#{client.client_id}##{j}"]
+        transaction do
+          read ["resource", client_id, nil]
+          write ["c#{client_id}##{j}"]
         end
       end
     end
   end
   
-  app.child passive: true do |client|
+  child passive: true do
     # This client never even tries to lock the resource, so it cannot write.
-    client.transaction do |t|
-      t.read ["resource", client.client_id, nil]
-      t.write ["c#{client.client_id}##{j}"]
+    transaction do
+      read ["resource", client_id, nil]
+      write ["c#{client_id}##{j}"]
     end
-    client.log.error "should never get here"
+    log.error "should never get here"
   end
 end

data/example/lock-mgr.rb

@@ -4,14 +4,14 @@ require 'tupelo/app'
 
 N = 3
 
-Tupelo.application do |app|
-  app.child passive: true do |client| # the lock manager
-    client.log.progname << " (lock mgr)"
+Tupelo.application do
+  child passive: true do # the lock manager
+    log.progname << " (lock mgr)"
     loop do
-      client.write ["resource", "none"]
-      lock_id, client_id, duration = client.read ["resource", nil, nil]
+      write ["resource", "none"]
+      lock_id, client_id, duration = read ["resource", nil, nil]
       sleep duration
-      client.take [lock_id, client_id, duration]
+      take [lock_id, client_id, duration]
         # optimization: combine take and write in a transaction, just to
         # reduce delay
     end
@@ -20,10 +20,10 @@ Tupelo.application do |app|
   end
   
   N.times do |i|
-    app.child do |client|
-      client.transaction do |t|
-        t.take ["resource", "none"]
-        t.write ["resource", client.client_id, 0.5]
+    child do
+      transaction do
+        take ["resource", "none"]
+        write ["resource", client_id, 0.5]
       end
       # Thundering herd -- all N clients can respond at the same time.
       # Can be avoided with a queue -- see lock-mgr-with-queue.rb.
@@ -34,20 +34,20 @@ Tupelo.application do |app|
         # as all clients follow the read protocol below.
         sleep 0.2
 
-        client.transaction do |t|
-          t.read ["resource", client.client_id, nil]
-          t.write ["c#{client.client_id}##{j}"]
+        transaction do
+          read ["resource", client_id, nil]
+          write ["c#{client_id}##{j}"]
         end
       end
     end
   end
   
-  app.child passive: true do |client|
+  child passive: true do
     # This client never even tries to lock the resource, so it cannot write.
-    client.transaction do |t|
-      t.read ["resource", client.client_id, nil]
-      t.write ["c#{client.client_id}##{j}"]
+    transaction do
+      read ["resource", client_id, nil]
+      write ["c#{client_id}##{j}"]
     end
-    client.log.error "should never get here"
+    log.error "should never get here"
   end
 end

data/example/map-reduce-v2.rb

@@ -3,13 +3,13 @@ require 'tupelo/util/boolean'
 
 N = 2 # how many cpus do you want to use for mappers?
 
-Tupelo.application do |app|
-  app.child do |client|
+Tupelo.application do
+  child do
     document = "I will not map reduce in class\n" * 10
     lineno = 0
     document.each_line do |line|
       lineno += 1
-      client.write line: line, lineno: lineno
+      write line: line, lineno: lineno
         # Note that tuples should be small, so if the data is large, the line
         # should be a reference, not the actual data.
         # Also, in a complex application you might want to add another
@@ -19,13 +19,13 @@ Tupelo.application do |app|
     results = Hash.new(0)
     lines_remaining = lineno
     results_remaining = 0
-    result_template = client.match_any(
+    result_template = match_any(
       {word: String, count: Integer},
       {lineno: Integer, result_count: Integer}
     )
 
     until lines_remaining == 0 and results_remaining == 0 do
-      result = client.take result_template
+      result = take result_template
 
       if result["word"]
         results[result["word"]] += result["count"]
@@ -38,15 +38,15 @@ Tupelo.application do |app|
       end
     end
 
-    client.log "results = #{results}"
+    log "results = #{results}"
   end
   
   N.times do |i|
-    app.child passive: true do |client|
-      client.log.progname = "mapper #{i}"
+    child passive: true do
+      log.progname = "mapper #{i}"
       
       loop do
-        input = client.take line: String, lineno: Integer
+        input = take line: String, lineno: Integer
 
         h = Hash.new(0)
         input["line"].split.each do |word|
@@ -54,9 +54,9 @@ Tupelo.application do |app|
         end
 
         h.each do |word, count|
-          client.write word: word, count: count
+          write word: word, count: count
         end
-        client.write lineno: input["lineno"], result_count: h.size
+        write lineno: input["lineno"], result_count: h.size
       end
     end
   end

data/example/map-reduce.rb

@@ -2,13 +2,13 @@ require 'tupelo/app'
 
 N = 2 # how many cpus do you want to use for mappers?
 
-Tupelo.application do |app|
-  app.child do |client|
+Tupelo.application do
+  child do
     document = "I will not map reduce in class\n" * 10
     lineno = 0
     document.each_line do |line|
       lineno += 1
-      client.write ["wc input", lineno, line]
+      write ["wc input", lineno, line]
         # Note that tuples should be small, so if the data is large, the line
         # should be a reference, not the actual data.
     end
@@ -17,9 +17,9 @@ Tupelo.application do |app|
     lines_remaining = lineno
     results_remaining = 0
     until lines_remaining == 0 and results_remaining == 0 do
-      event, *a = client.take [/wc (?:output|done)/, nil, nil]
+      event, *a = take [/wc (?:output|done)/, nil, nil]
         # Using a regex is hacky. Better to use an "or" template. See
-        # boolean-match.rb. That's not a standard feature yet.
+        # boolean-match.rb.
         # Also, in real use it might be better to use hash tuples rather than
         # arrays.
         # See map-reduce-v2.rb.
@@ -36,15 +36,15 @@ Tupelo.application do |app|
       end
     end
 
-    client.log "results = #{results}"
+    log "results = #{results}"
   end
   
   N.times do |i|
-    app.child passive: true do |client|
-      client.log.progname = "mapper #{i}"
+    child passive: true do
+      log.progname = "mapper #{i}"
       
       loop do
-        _, lineno, line = client.take ["wc input", Integer, String]
+        _, lineno, line = take ["wc input", Integer, String]
 
         h = Hash.new(0)
         line.split.each do |word|
@@ -52,9 +52,9 @@ Tupelo.application do |app|
         end
 
         h.each do |word, count|
-          client.write ["wc output", word, count]
+          write ["wc output", word, count]
         end
-        client.write ["wc done", lineno, h.size]
+        write ["wc done", lineno, h.size]
       end
     end
   end

data/example/matching.rb

@@ -1,9 +1,9 @@
 require 'tupelo/app'
 
-Tupelo.application do |app|
-  app.local do |client|
-    client.write_wait ["foo", 42.5]
-    p client.read_all [/oo/, nil]
-    p client.read_all [nil, 5..95]
+Tupelo.application do
+  local do
+    write_wait ["foo", 42.5]
+    p read_all [/oo/, nil]
+    p read_all [nil, 5..95]
   end
 end

data/example/message-bus.rb

@@ -24,7 +24,7 @@ Tupelo.application do
       sleep delay
       ch = channels[ pi % channels.size ]
       transaction do
-        take_nowait [ch, nil]
+        take [ch, nil]
         write [ch, "pub #{pi} slept for #{delay} sec"]
       end
     end
@@ -36,8 +36,7 @@ Tupelo.application do
       ch = channels[ si % channels.size ]
       loop do
         sleep 1
-        t = read_nowait [ch, nil]
-        log t if t
+        log read [ch, nil] # note asynchronous reads
       end
     end
   end
@@ -54,6 +53,10 @@ Tupelo.application do
   end
 
   local do
+    channels.each do |ch|
+      write [ch, nil]
+    end
+
     write ['start']
   end
 end

data/example/notify.rb

@@ -1,35 +1,35 @@
-# See also bin/tspy
+# See also bin/tspy and the --trace switch on all tupelo apps and examples.
 
 require 'tupelo/app'
 
-Tupelo.application do |app|
-  app.child do |client|
+Tupelo.application do
+  child do
     Thread.new do
-      note = client.notifier
-      client.write ["start"]
+      note = notifier
+      write ["start"]
 
-      client.log "%10s %10s %10s %s" % %w{ status tick client operation }
+      log "%10s %10s %10s %s" % %w{ status tick client operation }
       loop do
         status, global_tick, client_id, op = note.wait
-        client.log "%10s %10d %10d %p" % [status, global_tick, client_id, op]
+        log "%10s %10d %10d %p" % [status, global_tick, client_id, op]
       end
     end
 
-    client.take ["finish"]
+    take ["finish"]
   end
   
-  app.child do |client|
-    client.take ["start"]
+  child do
+    take ["start"]
 
-    client.write [1, 2]
-    client.write [3, 4]
-    client.write foo: "bar", baz: ["zap"]
+    write [1, 2]
+    write [3, 4]
+    write foo: "bar", baz: ["zap"]
     
-    client.transaction do |t|
-      x, y = t.take [Numeric, Numeric]
-      t.write [x, y, x + y]
+    transaction do
+      x, y = take [Numeric, Numeric]
+      write [x, y, x + y]
     end
     
-    client.write ["finish"]
+    write ["finish"]
   end
 end

data/example/optimist.rb

@@ -1,20 +1,20 @@
 require 'tupelo/app'
 
-Tupelo.application do |app|
-  app.child do |client|
-    client.write [1]
+Tupelo.application do
+  child do
+    write [1]
     sleep 0.1
-    client.take [1]
-    client.write [2]
+    take [1]
+    write [2]
   end
   
-  app.child do |client|
+  child do
     final_i =
-      client.take([Integer]) do |optimistic_i|
-        client.log "optimistic_i = #{optimistic_i}"
+      take([Integer]) do |optimistic_i|
+        log "optimistic_i = #{optimistic_i}"
         sleep 0.2
       end
     
-    client.log "final_i = #{final_i}"
+    log "final_i = #{final_i}"
   end
 end

data/example/parallel.rb

@@ -9,14 +9,18 @@ hosts = ARGV.shift
 map = ARGV.slice!(0,3)
 reduce = ARGV.slice!(0,4)
 
-abort <<END unless hosts and
-  map[0] == "map" and reduce[0] == "reduce" and reduce[3]
+args_ok = hosts && map[0] == "map" && reduce[0] == "reduce" && reduce[3]
+  
+abort <<END unless args_ok
 
-  usage: #$0 <ssh-host>,... map <var> <expr> reduce <var> <var> <expr> [<infile> ...]
+  usage: #$0 <ssh-host>,... map <var> <expr> reduce <var> <var> <expr>
+  
+  Input is provided on standard input
+  
+  Writes the result of the last reduction to standard output.
   
-  Input can be provided on standard input or as the contents of the files
-  specified in the infile arguments. Writes the result of the last
-  reduction to standard output.
+  If <ssh-host> is of the form host:<number> than <number> processes are
+  started on host.
   
   If --show-steps is set then intermediate reductions are printed as they
   are computed. If input is stdin at the terminal, then you can see these
@@ -28,12 +32,16 @@ abort <<END unless hosts and
   Example:
   
     ruby #$0 localhost,localhost map s s.length reduce l1 l2 l1+l2
-  
+    
   Use `s.split.length` to get word count instead of char count.
 
 END
 
-hosts = hosts.split(",")
+hosts = hosts.split(",").map do |s|
+  s.slice!(/:(\d+)\z/)
+  $1 ? [s] * Integer($1) : s
+end
+hosts.flatten!
 
 map_str = <<END
   proc do |#{map[1]}|