tupelo 0.17 → 0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5703dd8bef3eca3c30fc208f1ff5fe291b19b4a
-  data.tar.gz: c84e02596fc16e71dce360a8ba67b7033194d15b
+  metadata.gz: 60516b564c0329a1544a913f4ec1680bd8308de8
+  data.tar.gz: 6aadbcc4c96e57d762d072e266ff921972f58578
 SHA512:
-  metadata.gz: f6e2afa9ccf4cea0e12497ae4b8d98d169d2b8b6b46dcf92ff13d46f44d111080331fc80aa637f9234ef41d3727cd7e591d7e861bf2492bce5fda9ab258e6e32
-  data.tar.gz: afb4669e2bdf49294eda7423b250ea62f0e4efedd7f9ea250658ee531e76871d27d027b456492680d0fa920ffd9d5045fb6f7df569bdc52945f7677b86ffb325
+  metadata.gz: 75b24e537a78c831be55b389457a41fd527bf3fc88cb7e4dd358d03ecc492d439157ce28a3191ae86946c2df12a5ee5f74b5b388aebd8a9da57e0e1cc0af8386
+  data.tar.gz: 53a0848f5b3c30e091fc0bd0d58fced4703b77561099866b032e1d9f7c312a85da01d2a4066c2979f2632caa31a6c97466b21cf4319acca99308f4beddaa25d5

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2013, Joel VanderWerf
+Copyright (c) 2013-2014, Joel VanderWerf
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -1,7 +1,7 @@
 Tupelo
 ==
 
-A tuplespace that is fast, scalable, and language agnostic. It is designed for distribution of both computation and storage (disk and memory), in a unified language that has both transactional and tuple-operation (read/write/take) semantics.
+A tuplespace that is fast, scalable, and language agnostic. Tupelo is designed for distribution of both computation and storage (disk and memory), in a unified language that has both transactional and tuple-operation (read/write/take) semantics.
 
 This is the reference implementation in ruby. It should be able to communicate with implementations in other languages.
 
@@ -12,7 +12,10 @@ Documentation
 * [FAQ](doc/faq.md)
 * [Comparisons](doc/compare.md)
 * [Transactions](doc/transactions.md)
+* [Replication](doc/replication.md)
 * [Subspaces](doc/subspace.md)
+* [Causality](doc/causality.md)
+* [Concurrency](doc/concurrency.md)
 * [Examples](example/)
 
 Internals
@@ -41,14 +44,13 @@ Getting started
         >> t [nil, nil]
         => ["hello", "world"]
 
-4. Take a look at the [FAQ](doc/faq.md), [tutorial](doc/tutorial.md), and many (examples)(example/).
+4. Take a look at the [FAQ](doc/faq.md), [tutorial](doc/tutorial.md), and the many [examples](example/).
 
 
 Applications
 =======
 
-Tupelo is a flexible base layer for various distributed programming paradigms: job queues, dataflow, map-reduce, etc.
-
+Tupelo is a flexible base layer for various distributed programming paradigms: job queues, dataflow, map-reduce, etc. Using subspaces, it's also a transactional, replicated datastore with pluggable storage providers.
 
 
 Advantages
@@ -148,6 +150,6 @@ Joel VanderWerf, vjoel@users.sourceforge.net, @JoelVanderWerf.
 License and Copyright
 ========
 
-Copyright (c) 2013, Joel VanderWerf
+Copyright (c) 2013-2014, Joel VanderWerf
 
 License for this project is BSD. See the COPYING file for the standard BSD license. The supporting gems developed for this project are similarly licensed.

data/bench/tuplespace.rb

@@ -0,0 +1,30 @@
+# Benchmark the default tuplespace (which is not intended to be fast).
+
+module Tupelo
+  class Client; end
+end
+
+require 'tupelo/client/tuplespace'
+require 'benchmark'
+
+N_TUPLES = 100_000
+N_DELETES = 10_000
+
+Benchmark.bm(20) do |b|
+  ts = Tupelo::Client::SimpleTuplespace.new
+
+  b.report('insert') do
+    N_TUPLES.times do |i|
+      ts.insert i
+    end
+  end
+  
+  b.report('delete') do
+    N_DELETES.times do
+      i = rand(N_TUPLES)
+      if ts.delete_once i
+        ts.insert i
+      end
+    end
+  end
+end

data/bin/tup

@@ -119,12 +119,28 @@ Tupelo.application(
     CMD_ALIASES = %w{ w pl t r ra tr }
     private *CMD_ALIASES
 
+    def trace *args
+      require 'tupelo/app/trace'
+      if args.empty?
+        if tracing? then stop_trace else start_trace end
+      elsif args.first
+        start_trace
+      else
+        stop_trace
+      end
+      tracing?
+    end
+
     def help
       puts "Command aliases:"
       CMD_ALIASES.each do |m_name|
         m = method(m_name)
         printf "%8s -> %s\n", m.name, m.original_name
       end
+      puts
+      puts "Extra commands:"
+      puts "  trace [true|false]  # turn on or off tracing"
+      puts "  trace               # toggle tracing"
       nil
     end
   end

data/example/barrier.rb

@@ -0,0 +1,29 @@
+# Unlike MPI barriers, does not use token ring. This is better for loosely
+# coupled systems -- a failed process doesn't break the ring, the state is in
+# the distributed tuplespace rather than just one process, and a replacement
+# process can be swapped in. Run with --trace to see what's happening.
+
+require 'tupelo/app'
+
+N_WORKERS = 5
+N_STEPS = 3
+
+Tupelo.application do
+  pids = []
+  N_WORKERS.times do |wi|
+    pids << child do
+      N_STEPS.times do |si|
+        sleep 0.1 # do some work
+        
+        write step: si, worker: wi
+
+        N_WORKERS.times do |i|
+          read step: si, worker: i
+        end
+      end
+    end
+  end
+  
+  pids.each {|pid| Process.wait pid}
+  puts "done"
+end

data/example/bingo/bingo-v1.rb

@@ -0,0 +1,42 @@
+require 'tupelo/app'
+
+N_BUYERS = 3
+MAX_PER_BUYER = 4
+
+Tupelo.application do
+  child do
+    # stock up on cards to sell
+    10.times do |i|
+      write ["card", i] # todo add card details
+    end
+    
+    # start selling
+    write ["selling", true]
+    sleep 1
+    
+    # stop selling
+    take ["selling", true]
+    write ["selling", false]
+
+    # run the game
+    p read_all ["player", nil, "card", nil]
+  end
+
+  N_BUYERS.times do
+    child do
+      catch :done_buying do
+        MAX_PER_BUYER.times do
+          transaction do
+            _, selling = read ["selling", nil]
+            if selling
+              _, card_id = take ["card", nil]
+              write ["player", client_id, "card", card_id]
+            else
+              throw :done_buying
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/example/dphil-optimistic-v2.rb

@@ -15,7 +15,8 @@ Tupelo.application do
 
       N_ITER.times do
         transaction do
-          # lock the resource (in transaction, so optimistically):
+          # lock the resource (in transaction, so optimistically)
+          # this is really just an assertion of facts:
           read ["chopstick", i]
           read ["chopstick", (i+1)%N_PHIL]
 

data/example/map-reduce/prime-factor-balanced.rb

@@ -1,7 +1,10 @@
 # Modified prime-factor.rb attempts to balance load better. Improvement
 # varies--typically around 50% faster with 12 remote hosts.
+# The key to balancing load in this case is that all tuples can be
+# read in each worker, so the worker doesn't have to guess so much.
 
 require 'tupelo/app/remote'
+require 'set'
 
 hosts = ARGV.shift or abort "usage: #$0 <ssh-hostname>,<ssh-hostname>,..."
 hosts = hosts.split(",")
@@ -13,7 +16,7 @@ Tupelo.tcp_application do
       class M
         def initialize nh, hi, excl = []
           @nh, @hi = nh, hi
-          @excl = excl
+          @excl = Set.new(excl)
         end
         def === x
           Array === x and
@@ -37,7 +40,7 @@ Tupelo.tcp_application do
 
         if input
           begin
-            txn.commit
+            txn.commit # but don't wait yet. Optimistically start working...
             output = input.prime_division
             Thread.new do
               begin
@@ -51,6 +54,9 @@ Tupelo.tcp_application do
           rescue TransactionFailure
           end
           my_pref = my_pref.exclude input
+            # Some other worker is optimistically working on this item
+            # (stolen from this worker), so don't try to take it again.
+            # Reduces contention.
           next
         end
 
@@ -60,27 +66,18 @@ Tupelo.tcp_application do
         end
         break
       end
-        
+
+      # No more preferred items, so fall back to dumb (and contentious) algo.
       loop do
         _, input = take(["input", Integer])
         write ["output", input, input.prime_division]
       end
-        
-
-#        _, input =
-#          begin
-#            take(my_pref, timeout: 1.0) # fewer fails (5.0 -> none at all)
-#          rescue TimeoutError
-#            take(["input", Integer])
-#          end
-#        write ["output", input, input.prime_division]
-#      end
     }
   end
 
   local do
     t0 = Time.now
-    inputs = 1_000_000_000_000 .. 1_000_000_000_050
+    inputs = 1_000_000_000_000 .. 1_000_000_000_200
 
     inputs.each do |input|
       write ["input", input]

data/example/map-reduce/prime-factor.rb

@@ -20,7 +20,7 @@ Tupelo.tcp_application do
 
   local do
     t0 = Time.now
-    inputs = 1_000_000_000_000 .. 1_000_000_000_050
+    inputs = 1_000_000_000_000 .. 1_000_000_000_200
 
     inputs.each do |input|
       write ["input", input]

data/example/nest.rb

@@ -0,0 +1,27 @@
+require 'tupelo/app'
+
+Tupelo.application do
+
+  child do
+    write [1]
+    
+    transaction timeout: 1 do |outer|
+      x, _ = outer.read [1]
+      
+      transaction do
+        write [x+1]
+          # This is a programming error. The outer txn assumes that [1] exists.
+          # The inner txn assumes that the outer txn executes. But in fact the
+          # outer txn never executes (it times out), and the inner txn does
+          # execute, leaving an unexpected [2] in the space.
+      end
+      
+      outer.read ["barrier"]
+    end
+  end
+
+  child do
+    take [1]
+    write ["barrier"]
+  end
+end

data/example/observer.rb

@@ -0,0 +1,55 @@
+# An implementation of the observer pattern using transaction failure.
+# Note that the failures happen in the pre-commit phase of the transactions,
+# so they will not be shown with the --trace switch.
+# Run with `--stream` to show the optional observer implemented using
+# streaming reads instead of transaction failure.
+
+require 'tupelo/app'
+
+Tupelo.application do
+
+  child do
+    log.progname = "counting client"
+
+    write count: 0
+
+    3.times do
+      sleep 1
+      transaction do
+        count = take(count: Numeric)["count"]
+        write count: count + 1
+        log "incrementing counter"
+      end
+    end
+  end
+
+  child passive: true do
+    log.progname = "observing client"
+
+    loop do
+      begin
+        t = transaction
+        counter = t.read count: Numeric
+        log "entering new state: #{counter}"
+        t.wait
+      rescue Tupelo::Client::TransactionFailure => ex
+        log "leaving old state: #{counter}"
+      end
+    end
+  end
+
+  if argv.include?("--stream")
+    # If you only care about seeing each new values as it arrives, this client
+    # is enough. But it doesn't alert you when a tuple is deleted. In this
+    # example, the delete and insert happen atomically in a transaction, so
+    # it doesn't matter.
+    child passive: true do
+      log.progname = "stream client"
+
+      read count: Numeric do |counter|
+        log "entering new state: #{counter}"
+      end
+    end
+  end
+
+end

data/example/subspaces/addr-book-v1.rb

@@ -0,0 +1,106 @@
+## TODO
+##
+## scaling params
+
+require 'tupelo/app'
+
+ab_tag = "my address book"
+ab_sort_field = 1
+ab_val_field = 2
+cmd_tag = "#{ab_tag} commands"
+resp_tag = "#{ab_tag} responses"
+
+Tupelo.application do
+  local do
+    use_subspaces!
+
+    # Subspace for tuples belonging to the addr book.
+    define_subspace(
+      tag:          ab_tag,
+      template:     [
+        {value: ab_tag},
+        {type:  "string"},  # name <-- ab_sort_field references this field
+        nil                 # address; can be any object <-- ab_val_field
+      ]
+    )
+    
+    # Subspace for commands for fetch and delete.
+    # We can't use #read and #take because then the requesting client
+    # would have to subscribe to the ab_tag subspace.
+    define_subspace(
+      tag:          cmd_tag,
+      template:     [
+        {value: cmd_tag},
+        {type:  "string"},  # cmd name
+        {type:  "list"}     # arguments
+      ]
+    )
+
+    # Subspace for responses to commands. Identify the command this is in
+    # response to by copying it (alternately, could use ids).
+    define_subspace(
+      tag:          resp_tag,
+      template:     [
+        {value: resp_tag},
+        {type:  "string"},  # cmd name
+        {type:  "list"},    # arguments
+        nil                 # result of query -- type depends on command
+      ]
+    )
+  end
+
+  ## Could set N_SORTED_SET_SPACE > 1, but lookups are so fast it would
+  ## just lead to contention and redundant computation. Redundancy is useful
+  ## though.
+
+  # Inserts are just writes, which are handled by Worker and SortedSetSpace,
+  # so this child's app loop only needs to handle special commands: fetch and
+  # delete, which are delegated to the SortedSetSpace.
+  child tuplespace: [SortedSetSpace, ab_tag, ab_sort_field, ab_val_field],
+        subscribe: [ab_tag, cmd_tag], passive: true do
+    loop do
+      transaction do
+        _, cmd, args = take(subspace cmd_tag)
+
+        case cmd
+        when "delete"
+          args.each do |name|
+            take [ab_tag, name, nil]
+          end
+
+        when "fetch"
+          name = args[0]
+          _, _, addr = read [ab_tag, name, nil]
+          write [resp_tag, name, args, addr]
+
+        when "next", "prev"
+          name = args[0]
+          _, name2, addr = read SortedSetTemplate[ab_tag, cmd, name]
+          write [resp_tag, name, args, name2, addr]
+
+        when "first", "last"
+          _, name, addr = read SortedSetTemplate[ab_tag, cmd]
+          write [resp_tag, name, args, name, addr]
+
+        else # maybe write an error message in a tuple
+          log.error "bad command: #{cmd}"
+        end
+      end
+    end
+  end
+  
+  child subscribe: resp_tag do
+    # write some ab entries
+    write [ab_tag, "McFirst, Firsty", "123 W. Crescent Terrace"]
+    write [ab_tag, "Secondismus, Deuce", "456 S. West Way"]
+
+    # make some queries
+    write [cmd_tag, "first", []]
+    *, name, addr = take [resp_tag, "first", [], nil, nil]
+    log "first entry: #{name} => #{addr}"
+    
+    write [cmd_tag, "next", [name]]
+    *, name, addr = take [resp_tag, "next", [name], nil, nil]
+    log "next entry: #{name} => #{addr}"
+  end
+end

data/example/subspaces/addr-book.rb

@@ -119,7 +119,7 @@ Tupelo.application do
     name = "Daisy"
     write [cmd_tag, rqid, "fetch", [name]]
     addr = take( [resp_tag, rqid, nil, nil, nil] ).last
-    log "found: #{name} => #{addr}"
+    log "Looked up #{name} and found: #{name} => #{addr}"
     
     rqid = next_rqid.call
     write [cmd_tag, rqid, "first", []]

data/example/subspaces/riemann.rb

@@ -0,0 +1,103 @@
+# A toy implementation of Riemann (http://riemann.io)
+#
+# Also, this is an example of storing a subspace using different data
+# structures in different clients, depending on needs: some clients (generic
+# consumers) need to index by host and service, and others (expiration manager)
+# need to sort by expiration time.
+
+require 'tupelo/app'
+
+N_PRODUCERS = 3
+N_CONSUMERS = 2
+
+Tupelo.application do
+
+  local do
+    use_subspaces!
+
+    define_subspace("event", {
+    # field         type        description
+    #                           (from http://riemann.io/concepts.html)
+
+      host:         String,   # A hostname, e.g. "api1", "foo.com"
+
+      service:      String,   # e.g. "API port 8000 reqs/sec"
+
+      state:        String,   # Any string less than 255 bytes, e.g. "ok",
+                              # "warning", "critical"
+
+      time:         Numeric,  # The time of the event, in unix epoch seconds
+
+      description:  String,   # Freeform text
+
+      tags:         Array,    # Freeform list of strings,
+                              # e.g. ["rate", "fooproduct", "transient"]
+
+      metric:       Numeric,  # A number associated with this event,
+                              # e.g. the number of reqs/sec.
+
+      ttl:          Numeric   # A floating-point time, in seconds, that this
+                              # event is considered valid for. Expired states
+                              # may be removed from the index.
+    })
+  end
+
+  N_PRODUCERS.times do
+    child subscribe: [] do # N.b., no subscriptions
+      event = {
+        host:         `hostname`.chomp,
+        service:      "service #{client_id}", # placeholder
+        state:        "",
+        time:         0,
+        description:  "",
+        tags:         [],
+        metric:       0,
+        ttl:          0
+      }.freeze
+
+      e_ok = event.merge(
+        state:    "ok",
+        time:     Time.now.to_f,
+        ttl:      1.0
+      )
+
+      if e_ok[:ttl] == 0.0
+        pulse e_ok # no need to bother with expiration
+      else
+        write e_ok
+      end
+    end
+  end
+
+  N_CONSUMERS.times do
+    # stores events indexed by host, service
+    child subscribe: "event", passive: true do ### tuplespace: sqlite
+      read subspace("event") do |event|
+        log event ### need filtering, actions, etc.
+      end
+    end
+  end
+  
+  # This could be a subspace of the event subspace.
+  critical_event = {
+    host:        nil,
+    service:     nil,
+    state:       /critical|fatal/i,
+    time:        nil,
+    description: nil,
+    tags:        nil,
+    metric:      nil,
+    ttl:         nil
+  }
+  
+  child subscribe: "event", passive: true do
+    read critical_event do |event|
+      log.error event
+    end
+  end
+
+  # expirer: stores current events in expiration order
+  child subscribe: "event", passive: true do
+    ### use rbtree
+  end
+end

data/example/subspaces/sorted-set-space-OLD.rb

@@ -0,0 +1,130 @@
+require 'rbtree'
+
+class SortedSetTemplate
+  class << self
+    alias [] new
+  end
+  
+  # cmd can be "next", "prev", "first", "last"
+  # for next/prev, args is ["name"]
+  # for first/last, args is empty
+  def initialize tag, cmd, *args
+    @tag = tag
+    @cmd = cmd
+    @args = args
+  end
+  
+  def === other
+    raise ### should not need this?
+  end
+  
+  def find_in rbtree
+    case @cmd
+    when "first"
+      rbtree.first
+    ###
+  end
+end
+
+# A tuple store (in-memory) that is optimized for (key_string, object) pairs.
+# The object may be any serializable object (built up from numbers, booleans,
+# nil, strings, hashes and arrays).
+#
+# Unlike in a key-value store, a given key_string may occur more than once.
+# It is up to the application to decide whether to enforce key uniqueness or
+# not (for example, by taking (k,...) before writing (k,v).
+#
+# This store should be used only by clients that subscribe to a subspace
+# that can be represented as pairs. (See memo2.rb.)
+#
+# This store also manages meta tuples, which it keeps in an array, just like
+# the default Tuplespace class does.
+class SortedSetSpace
+  include Enumerable
+
+  attr_reader :tag, :hash, :metas
+
+  def initialize tag
+    @tag = tag
+    clear
+  end
+
+  def clear
+    @hash = Hash.new {|h,k| h[k] = []}
+      # It's up to the application to enforce that these arrays have size <=1.
+    @metas = []
+      # We are automatically subscribed to tupelo metadata (subspace defs), so
+      # we need to keep them somewhere.
+  end
+
+  def each
+    hash.each do |k, vs|
+      vs.each do |v|
+        yield tag, k, v
+      end
+    end
+    metas.each do |tuple|
+      yield tuple
+    end
+  end
+
+  def insert tuple
+    if tuple.kind_of? Array
+        # and tuple.size == 3 and tuple[0] == tag and tuple[1].kind_of? String
+        # This is redundant, because of subscribe.
+      t, k, v = tuple
+      hash[k] << v
+
+    else
+      metas << tuple
+    end
+  end
+
+  def delete_once tuple
+    if tuple.kind_of? Array
+        # and tuple.size == 3 and tuple[0] == tag and tuple[1].kind_of? String
+        # This is redundant, because of subscribe.
+      t, k, v = tuple
+      if hash.key?(k) and hash[k].include? v
+        hash[k].delete v
+        hash.delete k if hash[k].empty?
+        true
+      else
+        false
+      end
+
+    else
+      if i=metas.index(tuple)
+        delete_at i
+      end
+    end
+  end
+
+  def transaction inserts: [], deletes: [], tick: nil
+    deletes.each do |tuple|
+      delete_once tuple or raise "bug"
+    end
+
+    inserts.each do |tuple|
+      insert tuple.freeze ## should be deep_freeze
+    end
+  end
+
+  def find_distinct_matches_for templates
+    templates.inject([]) do |tuples, template|
+      tuples << find_match_for(template, distinct_from: tuples)
+    end
+  end
+
+  def find_match_for template, distinct_from: []
+    case template
+    when SortedSetTemplate
+      template.find_in rbtree, distinct_from: distinct_from ###
+    else
+      # fall back to linear search
+      find do |tuple|
+        template === tuple and not distinct_from.any? {|t| t.equal? tuple}
+      end
+    end
+  end
+end

data/lib/tupelo/app/trace.rb

@@ -1,27 +1,58 @@
 require 'tupelo/app'
 
+class Tupelo::Client
+  def trace_loop
+    note = notifier
+    log << ( "%6s %6s %6s %s\n" % %w{ tick cid status operation } )
+    loop do
+      status, tick, cid, op, tags = note.wait
+      unless status == :attempt
+        s = status == :failure ? "FAIL" : ""
+        if tags and not tags.empty?
+          log << ( "%6d %6d %6s %p to %p\n" % [tick, cid, s, op, tags] )
+        else
+          log << ( "%6d %6d %6s %p\n" % [tick, cid, s, op] )
+        end
+      end
+    end
+  end
+
+  def tracing?
+    !!@trace_thread
+  end
+
+  private
+
+  # Turn on tracing in this client (performed by a thread).
+  def start_trace
+    @trace_thread ||= Thread.new do
+      begin
+        trace_loop
+      rescue => ex
+        log "trace thread: #{ex}"
+      end
+    end
+  end
+
+  # Turn off tracing in this client.
+  def stop_trace
+    if @trace_thread
+      @trace_thread.kill
+      @trace_thread = nil
+    end
+  end
+end
+
 # displays every transaction in sequence, specially marking failed ones,
 # until INT signal
 class Tupelo::AppBuilder
   def start_trace
-    child passive: true do |client|
+    child passive: true do
       trap :INT do
         exit!
       end
 
-      note = client.notifier
-      log << ( "%6s %6s %6s %s\n" % %w{ tick cid status operation } )
-      loop do
-        status, tick, cid, op, tags = note.wait
-        unless status == :attempt
-          s = status == :failure ? "FAIL" : ""
-          if tags and not tags.empty?
-            log << ( "%6d %6d %6s %p to %p\n" % [tick, cid, s, op, tags] )
-          else
-            log << ( "%6d %6d %6s %p\n" % [tick, cid, s, op] )
-          end
-        end
-      end
+      trace_loop
     end
   end
 end

data/lib/tupelo/app.rb

@@ -67,8 +67,12 @@ module Tupelo
     tunnel_default = !!opts[:tunnel]
     persist_dir = opts[:persist_dir]
 
+    if not services_file and argv[0] !~ /^-/ ## hacky
+      services_file = argv.shift
+    end
+
     ez_opts = {
-      services_file: services_file || argv.shift,
+      services_file: services_file,
       interactive: $stdin.isatty
     }
 

data/lib/tupelo/client/subspace.rb

@@ -2,7 +2,7 @@ class Tupelo::Client
   module Api
     def define_subspace tag, template, addr: nil
       metatuple = {
-        __tupelo__: "subspace",
+        TUPELO_META_KEY => "subspace",
         tag:        tag,
         template:   PortableObjectTemplate.spec_from(template),
         addr:       addr
@@ -15,7 +15,7 @@ class Tupelo::Client
     def use_subspaces!
       return if subspace(TUPELO_SUBSPACE_TAG)
       define_subspace(TUPELO_SUBSPACE_TAG, {
-        __tupelo__: "subspace",
+        TUPELO_META_KEY => "subspace",
         tag:        nil,
         template:   nil,
         addr:       nil
@@ -26,7 +26,10 @@ class Tupelo::Client
       tag = tag.to_s
       worker.subspaces.find {|sp| sp.tag == tag} or begin
         if subscribed_tags.include? tag
-          read __tupelo__: "subspace", tag: tag, addr: nil, template: nil
+          read TUPELO_META_KEY => "subspace",
+            tag:      tag,
+            template: nil,
+            addr:     nil
           worker.subspaces.find {|sp| sp.tag == tag}
         end
       end

data/lib/tupelo/client/transaction.rb

@@ -211,9 +211,19 @@ class Tupelo::Client
       end
     end
 
+    def check_open
+      if failed?
+        # checking this here is mostly a courtesy to client code; it is possible
+        # (a benign race condition) for the failure flag to be set later,
+        # even while a #write or #take method still has not returned.
+        raise exception
+      elsif not open?
+        raise TransactionStateError, "not open: #{inspect}"
+      end
+    end
+
     def write *tuples
-      raise TransactionStateError, "not open: #{inspect}" unless open? or
-        failed?
+      check_open
       check_tuples tuples
       blobber = worker.blobber
       @writes.concat tuples.map {|t| blobber.load(blobber.dump(t))}
@@ -223,9 +233,7 @@ class Tupelo::Client
     end
     
     def pulse *tuples
-      raise exception if failed?
-      raise TransactionStateError, "not open: #{inspect}" unless open? or
-        failed?
+      check_open
       check_tuples tuples
       blobber = worker.blobber
       @pulses.concat tuples.map {|t| blobber.load(blobber.dump(t))}
@@ -234,9 +242,7 @@ class Tupelo::Client
     
     # raises TransactionFailure
     def take template_spec
-      raise exception if failed?
-      raise TransactionStateError, "not open: #{inspect}" unless open? or
-        failed?
+      check_open
       template = worker.make_template(template_spec)
       @take_templates << template
       log.debug {"asking worker to take #{template_spec.inspect}"}
@@ -246,9 +252,7 @@ class Tupelo::Client
     end
     
     def take_nowait template_spec
-      raise exception if failed?
-      raise TransactionStateError, "not open: #{inspect}" unless open? or
-        failed?
+      check_open
       template = worker.make_template(template_spec)
       @_take_nowait ||= {}
       i = @take_templates.size
@@ -262,9 +266,7 @@ class Tupelo::Client
     
     # transaction applies only if template has a match
     def read template_spec
-      raise exception if failed?
-      raise TransactionStateError, "not open: #{inspect}" unless open? or
-        failed?
+      check_open
       template = worker.make_template(template_spec)
       @read_templates << template
       log.debug {"asking worker to read #{template_spec.inspect}"}
@@ -274,9 +276,7 @@ class Tupelo::Client
     end
 
     def read_nowait template_spec
-      raise exception if failed?
-      raise TransactionStateError, "not open: #{inspect}" unless open? or
-        failed?
+      check_open
       template = worker.make_template(template_spec)
       @_read_nowait ||= {}
       i = @read_templates.size

data/lib/tupelo/client/worker.rb

@@ -249,9 +249,9 @@ class Tupelo::Client
 
       begin
         tuplespace.clear
-          ## in some cases, we can keep some of it, but the current
-          ## archiver is not smart enough to send exactly the delta
-          ### abort all current transactions???
+          ## In some cases, we can keep some of it, but the current
+          ## archiver is not smart enough to send exactly the delta.
+          ## Also, might need to abort some current transactions.
 
         arc_tick = arc.read[0]
         log.info "arc says global_tick = #{arc_tick}"
@@ -434,8 +434,8 @@ class Tupelo::Client
 
     # Returns true if tuple is subspace metadata.
     def is_meta_tuple? tuple
-      tuple.kind_of? Hash and tuple.key? "__tupelo__" and
-        tuple["__tupelo__"] == "subspace"
+      tuple.kind_of? Hash and tuple.key? TUPELO_META_KEY and
+        tuple[TUPELO_META_KEY] == "subspace"
     end
 
     def sniff_meta_tuple tuple

data/lib/tupelo/client.rb

@@ -11,13 +11,14 @@ module Tupelo
     attr_reader :worker
     attr_reader :tuplespace
 
-    TUPELO_SUBSPACE_TAG = "tupelo subspace"
+    TUPELO_SUBSPACE_TAG = "tupelo subspace".freeze
+    TUPELO_META_KEY = "__tupelo__".freeze
 
     def initialize(tuplespace: SimpleTuplespace, subscribe: :all, **opts)
       super **opts
       @tuplespace = tuplespace
       @worker = make_worker
-      @initial_subscriptions = subscribe
+      @initial_subscriptions = subscribe || []
     end
 
     def inspect

data/lib/tupelo/version.rb

@@ -1,3 +1,3 @@
 module Tupelo
-  VERSION = "0.17"
+  VERSION = "0.18"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tupelo
 version: !ruby/object:Gem::Version
-  version: '0.17'
+  version: '0.18'
 platform: ruby
 authors:
 - Joel VanderWerf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-18 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atdo
@@ -81,6 +81,7 @@ files:
 - README.md
 - Rakefile
 - bench/pipeline.rb
+- bench/tuplespace.rb
 - bin/tspy
 - bin/tup
 - bugs/read-take.rb
@@ -92,6 +93,8 @@ files:
 - example/balance-xfer-locking.rb
 - example/balance-xfer-retry.rb
 - example/balance-xfer.rb
+- example/barrier.rb
+- example/bingo/bingo-v1.rb
 - example/boolean-match.rb
 - example/bounded-retry.rb
 - example/broker-locking.rb
@@ -128,7 +131,9 @@ files:
 - example/multi-tier/memo.rb
 - example/multi-tier/memo2.rb
 - example/multi-tier/multi-sinatras.rb
+- example/nest.rb
 - example/notify.rb
+- example/observer.rb
 - example/optimist.rb
 - example/parallel.rb
 - example/pregel/distributed.rb
@@ -143,13 +148,16 @@ files:
 - example/small-simplified.rb
 - example/small.rb
 - example/socket-broker.rb
+- example/subspaces/addr-book-v1.rb
 - example/subspaces/addr-book-v2.rb
 - example/subspaces/addr-book.rb
 - example/subspaces/pubsub.rb
 - example/subspaces/ramp.rb
+- example/subspaces/riemann.rb
 - example/subspaces/shop/shop-v1.rb
 - example/subspaces/shop/shop-v2.rb
 - example/subspaces/simple.rb
+- example/subspaces/sorted-set-space-OLD.rb
 - example/subspaces/sorted-set-space.rb
 - example/take-many.rb
 - example/take-nowait-caution.rb
@@ -231,7 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Distributed tuplespace