tupelo 0.10 → 0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 892628e201d400fa9592a01b1fd62c4bb8e09ab5
-  data.tar.gz: 2ca45f4f124ad6db32e2880557004f5c0553cf9f
+  metadata.gz: be780826d017e0ea442fa49d2a6403cc44cfe263
+  data.tar.gz: 133fa6c3218dd1fc4b06a8ea407a35ca3bdea0ac
 SHA512:
-  metadata.gz: 0b8bfcdbb7143f543372cd0bdad95feb49305a47e57e0368146e3c224f33e1fddb261f9f019ec4c4a503a4250d91ecc653a93e5792c27e4f47cfd7ca33727a76
-  data.tar.gz: 931b57069c7e06452429eb71e083c568be953a1e37de54cd1b9541107c6a79884e7d64645ed8765777c9ede5f18589e3c35d5057e946e82b8daa70c18180b49d
+  metadata.gz: 3327df2fc6fd2587dd244b99a4ed64827aeafd3314f7d3f34360e69f5598f294cd1c31010f8729c7ba913f1d1f489ce624735090074976de5aca19f88db5a646
+  data.tar.gz: 9b8c852daa50910f9c0823601a85618000404259893de1bc187393b8f0faeb99321ed06cbf78fb7ad488e9725326efa43202f201ae81c5a6d1e832cb9660cd3b

data/README.md

@@ -1,7 +1,8 @@
 tupelo
 ==
 
-A tuplespace that is fast, scalable, and language agnostic.
+A tuplespace that is fast, scalable, and language agnostic. It is designed for distribution of both computation and storage, 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. Planned implementation languages include C, Python, and Go.
 
@@ -191,7 +192,7 @@ A tuplespace is a service for coordination, configuration, and control of concur
 
 See https://en.wikipedia.org/wiki/Tuple_space for general information and history. This project is strongly influenced by Masatoshi Seki's Rinda implementation, part of the Ruby standard library. See http://pragprog.com/book/sidruby/the-druby-book for a good introduction to rinda and druby.
 
-See http://dbmsmusings.blogspot.com/2010/08/problems-with-acid-and-how-to-fix-them.html for an explanation of the imporance of determinism in distributed transaction systems.
+See http://dbmsmusings.blogspot.com/2010/08/problems-with-acid-and-how-to-fix-them.html for an explanation of the importance of determinism in distributed transaction systems.
 
 What is a tuple?
 ----------------
@@ -318,11 +319,11 @@ Another use of transactions: forcing a retry when something changes:
 
 This code waits on the existence of a value, but retries if the step changes while waiting. See example/pregel/distributed.rb for a use of this techinique.
 
-Tupelo transactions are ACID in the following sense. They are Atomic and Isolated -- this is enforced by the transaction processing in each client. Consistency is enforced by the underlying message sequencer: each client's copy of the space is the deterministic result of the same sequence of operations. Durability is optional, but can be provided by the persistent archiver or other clients.
+Tupelo transactions are ACID in the following sense. They are Atomic and Isolated -- this is enforced by the transaction processing in each client. Consistency is enforced by the underlying message sequencer: each client's copy of the space is the deterministic result of the same sequence of operations. This is also known as [sequential consistency] (https://en.wikipedia.org/wiki/Sequential_consistency). Durability is optional, but can be provided by the persistent archiver or other clients.
 
-On the CAP spectrum, tupelo tends towards consistency: for all clients, write and take operations are applied in the same order, so the state of the entire system up through a given tick of discrete time is universally agreed upon. Of course, because of the difficulties of distributed systems, one client may not yet have seen the same range of ticks as another.
+On the CAP spectrum, tupelo tends towards consistency: for all clients, write and take operations are applied in the same order, so the state of the entire system up through a given tick of discrete time is universally agreed upon. This is known as [state machine replication] (http://en.wikipedia.org/wiki/State%20machine%20replication). Of course, because of the difficulties of distributed systems, one client may not yet have seen the same range of ticks as another. Tupelo's replication model (especially in the use of subspaces) can also be described as [virtual synchrony](https://en.wikipedia.org/wiki/Virtual_synchrony).
 
-Tupelo transactions do not require two-phase commit, because they are less powerful than general transactions. Each client has enough information to decide (in the same way as all other clients) whether the transaction succeeds or fails. This has performance advantages, but imposes some limitations on transactions over subspaces that are known to one client but not another.
+Tupelo transactions do not require two-phase commit, because they are less powerful than general transactions. Each client has enough information to decide (in the same way as all other clients) whether the transaction succeeds or fails. This has performance advantages, but imposes some limitations on transactions over subspaces that are known to one client but not another. [Subspaces](doc/subspace.md).
 
 
 Syntax
@@ -532,11 +533,14 @@ Other gems:
 
 * yajl-ruby (only used to support --json option)
 
+Optional gems for some of the examples:
+
+* sinatra, http, sequel, sqlite, rbtree, leveldb-native
 
 Contact
 =======
 
-Joel VanderWerf, vjoel@users.sourceforge.net.
+Joel VanderWerf, vjoel@users.sourceforge.net, @JoelVanderWerf.
 
 License and Copyright
 ========

data/bin/tup

@@ -63,6 +63,12 @@ if ARGV.delete("-h") or ARGV.delete("--help")
       --persist-dir DIR
                   load and save tuplespace to DIR
 
+      --use-subspaces
+                  enable subspaces for this tupelo server
+                    (only needs to be set on first tup invocation)
+      --subscribe TAG,TAG,...
+                  subscribe to specified subspaces; use "" for none
+
   END
   exit
 end
@@ -73,6 +79,13 @@ argv, tupelo_opts = Tupelo.parse_args(ARGV)
 
 pubsub = argv.delete("--pubsub") # not a standard tupelo opt
 
+use_subspaces = argv.delete("--use-subspaces") # not a standard tupelo opt
+
+if i=argv.index("--subscribe") # default is to subscribe to all
+  argv.delete("--subscribe")
+  subscribed_tags = argv.delete_at(i).split(",")
+end
+
 servers_file = argv.shift
 addr = argv.shift(3)
 
@@ -100,8 +113,14 @@ Tupelo.application(
     client_opts[:arc] = nil
     client_opts[:tuplespace] = TupClient::NullTuplespace
   end
+  
+  if subscribed_tags
+    client_opts[:subscribe] = subscribed_tags
+  end
 
   local TupClient, **client_opts do
+    use_subspaces! if use_subspaces
+
     log.info {"cpu time: %.2fs" % Process.times.inject {|s,x|s+x}}
     log.info {"starting shell. Commands: #{TupClient::CMD_ALIASES.join(", ")}"}
 

data/example/{remote-map-reduce.rb → map-reduce/remote-map-reduce.rb}

@@ -1,4 +1,4 @@
-# see also parallel.rb
+# see also ../parallel.rb and ../remote.rb
 
 require 'tupelo/app/remote'
 

data/example/message-bus.rb

@@ -19,6 +19,7 @@ Tupelo.application do
   
   N_PUBS.times do |pi|
     child do
+      log.progname = "pub #{pi}"
       read ['start']
       delay = pi
       sleep delay

data/example/multi-tier/drb.rb

@@ -0,0 +1,49 @@
+# A tupelo cluster may expose its services using some other protocol so that
+# process need not be tupelo-aware to use them. This example uses drb to expose
+# services, but http or plain sockets would work too.
+
+require 'drb'
+
+rd, wr = IO.pipe # just for sharing the drb uri (or we could hardcode it)
+
+fork do
+  rd.close
+  require 'tupelo/app'
+  
+  Tupelo.application do
+    child do
+      DRb.start_service("druby://localhost:0", self)
+      wr.puts DRb.uri; wr.close
+      read ["done"]
+    end
+    
+    child passive: true do
+      loop do
+        transaction do
+          _, x, y = take ["request", nil, nil]
+          write ["response", x, y, x + y]
+        end
+      end
+    end
+  end
+end
+
+fork do # No tupelo in this process.
+  wr.close
+  uri = rd.gets.chomp; rd.close
+  DRb.start_service(nil, nil)
+  tup_client = DRbObject.new(nil, uri)
+
+  tup_client.write ["request", 3, 4]
+  p tup_client.take ["response", 3, 4, nil]
+
+  tup_client.write ["request", "foo", "bar"]
+  p tup_client.take ["response", "foo", "bar", nil]
+
+  tup_client.write ["request", ["a", "b"], ["c", "d"]]
+  p tup_client.take ["response", ["a", "b"], ["c", "d"], nil]
+
+  tup_client.write ["done"]
+end
+
+Process.waitall

data/example/multi-tier/http.rb

@@ -0,0 +1,67 @@
+# A tupelo cluster may expose its services using some other protocol so that
+# process need not be tupelo-aware to use them. This example uses http to expose
+# services.
+#
+# Depends on the sinatra and http gems.
+
+fork do
+  require 'tupelo/app'
+  
+  Tupelo.application do
+    child do |client|
+      require 'sinatra/base'
+
+      Class.new(Sinatra::Base).class_eval do
+        get '/' do
+          "hello, world\n"
+        end
+        
+        get '/add' do
+          x = Float(params["x"])
+          y = Float(params["y"])
+          client.write ["request", x, y]
+          resp = client.take ["response", x, y, nil]
+          resp.inspect + "\n"
+        end
+
+        get '/exit' do
+          Thread.new {sleep 1; exit}
+          "bye\n"
+        end
+        
+        run!
+      end
+    end
+    
+    child passive: true do
+      loop do
+        transaction do
+          _, x, y = take ["request", nil, nil]
+          write ["response", x, y, x + y]
+        end
+      end
+    end
+  end
+end
+
+fork do # No tupelo in this process.
+  require 'http'
+
+  url = 'http://localhost:4567'
+
+  print "trying server at #{url}"
+  begin
+    print "."
+    HTTP.get url
+  rescue Errno::ECONNREFUSED
+    sleep 0.2
+    retry
+  end
+
+  puts
+  puts HTTP.get "#{url}/add?x=1&y=2"
+  puts HTTP.get "#{url}/add?x=3.14&y=10"
+  HTTP.get "#{url}/exit"
+end
+
+Process.waitall

data/example/multi-tier/kvspace.rb

@@ -0,0 +1,113 @@
+# 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 KVSpace
+  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: []
+    # try to optimize if template can be satisfied by hash lookup
+    if template.kind_of? RubyObjectTemplate
+      spec = template.spec
+      if spec.kind_of? Array
+        key = spec[1]
+        if key.kind_of? String and spec[2] == nil
+          if hash.key? key
+            value = hash[key].last # most recently written
+            return [tag, key, value]
+          else
+            return nil
+          end
+        end
+      end
+    end
+    
+    # fall back to linear search
+    find do |tuple|
+      template === tuple and not distinct_from.any? {|t| t.equal? tuple}
+    end
+  end
+end

data/example/multi-tier/memo.rb

@@ -0,0 +1,78 @@
+# A tupelo cluster may expose its services using some other protocol so that
+# process need not be tupelo-aware to use them. This example uses http to expose
+# a memcache-like service. See also memo2.rb.
+#
+# Depends on the sinatra, json, and http gems.
+
+require 'json'
+
+fork do
+  require 'tupelo/app'
+  
+  Tupelo.application do
+    child do |client|
+      require 'sinatra/base'
+
+      Class.new(Sinatra::Base).class_eval do
+        get '/' do
+          "hello, world\n"
+        end
+        
+        get '/read' do
+          key = params["k"]
+          resp = client.read ["memo", key, nil]
+          resp.to_json + "\n"
+        end
+
+        get '/exit' do
+          Thread.new {sleep 1; exit}
+          "bye\n"
+        end
+        
+        run!
+      end
+    end
+    
+    # this process does some imaginary super-important work whose results
+    # need to be cached.
+    child passive: true do
+      100.times do |i|
+        sleep 1
+        write ["memo", i.to_s, Time.now.to_s]
+      end
+    end
+  end
+end
+
+fork do # No tupelo in this process.
+  require 'http'
+
+  url = 'http://localhost:4567'
+
+  print "trying server at #{url}"
+  begin
+    print "."
+    HTTP.get url
+  rescue Errno::ECONNREFUSED
+    sleep 0.2
+    retry
+  end
+
+  puts
+  puts "Getting cached data as soon as available:"
+  5.times do |i|
+    resp = HTTP.get "#{url}/read?k=#{i}"
+    p JSON.parse(resp)
+  end
+
+  puts
+  puts "Reviewing already cached data:"
+  5.times do |i|
+    resp = HTTP.get "#{url}/read?k=#{i}"
+    p JSON.parse(resp)
+  end
+
+  HTTP.get "#{url}/exit"
+end
+
+Process.waitall

data/example/multi-tier/memo2.rb

@@ -0,0 +1,94 @@
+# Better, but more complex, implementation of memo.rb. Uses a custom tuplespace
+# that is optimized for storing key-value data, rather than general tuples.
+# Also, subscribes to just the relevant subspace. Consequently, this example
+# should scale up to large memo spaces much better than memo.rb, which uses
+# linear search.
+#
+# Depends on the sinatra, json, and http gems.
+
+require 'json'
+
+fork do
+  require 'tupelo/app'
+  require_relative 'kvspace.rb'
+
+  Tupelo.application do
+    local do
+      use_subspaces!
+
+      define_subspace(
+        tag:          "memo",
+        template:     [
+          {value: "memo"},    # tag is encoded in each tuple, for recognizing
+          {type:  "string"},  # key in the cache, must be string
+          nil                 # value, can be any object (e.g. JSON object)
+        ]
+      )
+    end
+
+    child tuplespace: [KVSpace, "memo"], subscribe: ["memo"] do |client|
+      require 'sinatra/base'
+
+      Class.new(Sinatra::Base).class_eval do
+        get '/' do
+          "hello, world\n"
+        end
+        
+        get '/read' do
+          key = params["k"]
+          resp = client.read ["memo", key, nil]
+          resp.to_json + "\n"
+        end
+
+        get '/exit' do
+          Thread.new {sleep 1; exit}
+          "bye\n"
+        end
+        
+        run!
+      end
+    end
+    
+    # this process does some imaginary super-important work whose results
+    # need to be cached.
+    child passive: true do
+      100.times do |i|
+        sleep 1
+        write ["memo", i.to_s, Time.now.to_s]
+      end
+    end
+  end
+end
+
+fork do # No tupelo in this process.
+  require 'http'
+
+  url = 'http://localhost:4567'
+
+  print "trying server at #{url}"
+  begin
+    print "."
+    HTTP.get url
+  rescue Errno::ECONNREFUSED
+    sleep 0.2
+    retry
+  end
+
+  puts
+  puts "Getting cached data as soon as available:"
+  5.times do |i|
+    resp = HTTP.get "#{url}/read?k=#{i}"
+    p JSON.parse(resp)
+  end
+
+  puts
+  puts "Reviewing already cached data:"
+  5.times do |i|
+    resp = HTTP.get "#{url}/read?k=#{i}"
+    p JSON.parse(resp)
+  end
+
+  HTTP.get "#{url}/exit"
+end
+
+Process.waitall

data/example/pubsub.rb

@@ -1,6 +1,6 @@
 # Synchronously deliver published messages to subscribers. Subscriber gets the
 # message only if waiting while the message is sent.
-# Compare message-bus.rb.
+# Compare message-bus.rb. Also: subspaces/pubsub.rb.
 #
 # Run with the --show-final-state switch to verify that published tuples
 # don't stay in the space.
@@ -18,6 +18,7 @@ Tupelo.application do
   
   N_PUBS.times do |pi|
     child do
+      log.progname = "pub #{pi}"
       read ['start']
       delay = pi/10.0
       sleep delay

data/example/subspace.rb

@@ -2,6 +2,7 @@ require 'tupelo/app'
 
 Tupelo.application do
   local do
+    log.progname = "before"
     log [subscribed_all, subscribed_tags]
 
     use_subspaces!
@@ -18,7 +19,13 @@ Tupelo.application do
     log read_all(Object)
   end
   
+  child subscribe: [], passive: true do
+    log.progname = "not a subscriber"
+    log "should never see this: #{read(subspace "foo")}"
+  end
+  
   cid = child subscribe: ["foo"] do
+    log.progname = "foo subscriber"
     log [subscribed_all, subscribed_tags]
     write [1]
     write_wait ["abc"]
@@ -27,6 +34,7 @@ Tupelo.application do
   Process.wait cid
 
   local do
+    log.progname = "after"
     log [subscribed_all, subscribed_tags]
     log read_all(Object)
     log read_all(subspace "foo")

data/example/subspaces/pubsub.rb

@@ -0,0 +1,77 @@
+# Synchronously deliver published messages to subscribers. Subscriber gets the
+# message only if waiting while the message is sent. Use subspaces to reduce
+# total message traffic.
+# Compare ../pubsub.rb.
+#
+# Run with the --show-final-state switch to verify that published tuples
+# don't stay in the space.
+
+require 'tupelo/app'
+
+show_final_state = ARGV.delete "--show-final-state"
+
+N_PUBS = 6
+N_SUBS = 6
+N_CHAN = 3
+
+Tupelo.application do
+  local do
+    use_subspaces!
+
+    N_CHAN.times do |i|
+      define_subspace(
+        tag:          i,
+        template:     [
+          {value: i},
+          {type: "string"}
+        ]
+      )
+    end
+
+    define_subspace(
+      tag:          "control",
+      template:     [
+        {value: "control"},
+        nil
+      ]
+    )
+  end
+  
+  N_PUBS.times do |pi|
+    child subscribe: ["control"] do
+      log.progname = "pub #{pi}"
+      read [nil, 'start'] # first elt can only be 'control'
+      delay = pi/10.0
+      sleep delay
+      tag = pi % N_CHAN
+      pulse [tag, "pub #{pi} slept for #{delay} sec"]
+    end
+  end
+
+  N_SUBS.times do |si|
+    tag = si % N_CHAN
+    child subscribe: [tag], passive: true do
+      log.progname = "sub #{si} on tag #{tag}"
+      loop do
+        log read [nil, nil]
+          # Note: match any pair, but in fact will only get [tag, ....]
+          # because of subspaces.
+      end
+    end
+  end
+  
+  if show_final_state
+    child passive: true do
+      log.progname = "final"
+      def self.stop
+        log read_all
+        super
+      end
+      sleep
+    end
+  end
+
+  local do
+    write ['control', 'start']
+  end
+end

data/lib/tupelo/app.rb

@@ -95,7 +95,7 @@ module Tupelo
 
     %w{--marshal --yaml --json --msgpack}.each do |switch|
       s = argv.delete(switch) and
-        otps[:blob_type] = s.delete("--")
+        opts[:blob_type] = s.delete("--")
     end
 
     opts[:trace] = argv.delete("--trace")

data/lib/tupelo/archiver/tuplespace.rb

@@ -1,4 +1,6 @@
 class Tupelo::Archiver
+  # Faster than the default tuplespace, but does not support some things
+  # that are not needed in the Archiver: template searches, for example.
   class Tuplespace
     include Enumerable
     

data/lib/tupelo/client/worker.rb

@@ -106,6 +106,9 @@ class Tupelo::Client
       @tuplespace ||= begin
         if client.tuplespace.respond_to? :new
           client.tuplespace.new
+        elsif client.tuplespace.class == Array # but not subclass of Array
+          tsclass, *args = client.tuplespace
+          tsclass.new(*args)
         else
           client.tuplespace
         end
@@ -294,7 +297,7 @@ class Tupelo::Client
           update_to_tick tick: msg.global_tick, all: true
         when Funl::SUBSCRIBE
           update_to_tick tick: msg.global_tick,
-            tags: (client.subscribed_tags + tags)
+            tags: (client.subscribed_tags | tags)
         when Funl::UNSUBSCRIBE_ALL
           update_to_tick tick: msg.global_tick, all: false
         when Funl::UNSUBSCRIBE
@@ -332,18 +335,28 @@ class Tupelo::Client
       read_tuples = op.reads.map {|t| tuplespace.find_match_for(t)}
 
       succeeded = !op.atomic || (granted_tuples.all? && read_tuples.all?)
-      actual_tuples = granted_tuples.compact
+      take_tuples = granted_tuples.compact
+
+      if client.subscribed_all
+        write_tuples = op.writes
+      else
+        write_tuples = op.writes.select do |tuple|
+          subspaces.any? {|subspace| subspace === tuple}
+        end
+      end
+      ## This is duplicated effort: the sender has already done this.
+      ## So maybe the result could be transmitted in the msg protocol?
 
       if succeeded
-        log.debug {"inserting #{op.writes}; deleting #{actual_tuples}"}
-        tuplespace.transaction inserts: op.writes, deletes: actual_tuples,
+        log.debug {"inserting #{op.writes}; deleting #{take_tuples}"}
+        tuplespace.transaction inserts: write_tuples, deletes: take_tuples,
           tick: @global_tick
       
         op.writes.each do |tuple|
           sniff_meta_tuple tuple
         end
 
-        actual_tuples.each do |tuple|
+        take_tuples.each do |tuple|
           ### abstract this out
           if tuple.kind_of? Hash and tuple.key? "__tupelo__"
             if tuple["__tupelo__"] == "subspace" # tuple is subspace metatdata
@@ -372,9 +385,9 @@ class Tupelo::Client
         log.debug {"operation belongs to this client: #{trans.inspect}"}
       end
 
-      if not actual_tuples.empty?
+      if not take_tuples.empty?
         if succeeded
-          actual_tuples.each do |tuple|
+          take_tuples.each do |tuple|
             prep_waiters.keep_if do |waiter|
               waiter.unprepare tuple
               ## optimization: track number of instances of tuple, to avoid
@@ -387,7 +400,7 @@ class Tupelo::Client
 
         else
           log.debug {
-            missing = op.takes - actual_tuples
+            missing = op.takes - take_tuples
             trans ? "failed to take #{missing}" :
             "client #{msg.client_id} failed to take #{missing}"}
         end
@@ -420,7 +433,7 @@ class Tupelo::Client
         if succeeded
           trans.done msg.global_tick, granted_tuples # note: tuples not frozen
         else
-          trans.fail (op.takes - actual_tuples) + (op.reads - read_tuples)
+          trans.fail (op.takes - take_tuples) + (op.reads - read_tuples)
         end
       end
     end
@@ -494,19 +507,27 @@ class Tupelo::Client
     end
 
     def handle_waiter waiter
-      tuplespace.find {|tuple| waiter.gloms tuple} or
+      tuple = tuplespace.find_match_for waiter.template
+      if tuple
+        waiter.peek tuple
+      else
         read_waiters << waiter
-        ## optimize: if template is just a tuple, use hashing,
-        ## but will need to expose waiter.tuple
+      end
     end
 
     def handle_matcher matcher
       if matcher.all
         tuplespace.each {|tuple| matcher.gloms tuple}
+          ## maybe should have tuplespace.find_all_matches_for ...
+          ## in case there is an optimization
         matcher.fails
       else
-        tuplespace.find {|tuple| matcher.gloms tuple} or
+        tuple = tuplespace.find_match_for waiter.template
+        if tuple
+          waiter.peek tuple
+        else
           matcher.fails
+        end
       end
     end
 

data/lib/tupelo/client.rb

@@ -36,6 +36,12 @@ module Tupelo
         subscribe_all
       when Array
         subscribe @initial_subscriptions | [Tupelo::Client::TUPELO_SUBSPACE_TAG]
+      when String
+        @initial_subscriptions = [@initial_subscriptions]
+        subscribe @initial_subscriptions | [Tupelo::Client::TUPELO_SUBSPACE_TAG]
+      else
+        raise ArgumentError,
+          "bad subscription specifier: #{@initial_subscriptions}"
       end
     end
 
@@ -60,6 +66,7 @@ module Tupelo
     # call this just once at start of first client (it's optional to
     # preserve behavior of non-subspace-aware code)
     def use_subspaces!
+      return if subspace(TUPELO_SUBSPACE_TAG)
       define_subspace(
         tag:          TUPELO_SUBSPACE_TAG,
         template:     {
@@ -73,7 +80,7 @@ module Tupelo
 
     def subspace tag
       tag = tag.to_s
-      worker.subspaces.find {|sp| sp.tag == tag}
+      worker.subspaces.find {|sp| sp.tag == tag} ## should go thru worker queue
     end
   end
 end

data/lib/tupelo/version.rb

@@ -1,3 +1,3 @@
 module Tupelo
-  VERSION = "0.10"
+  VERSION = "0.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tupelo
 version: !ruby/object:Gem::Version
-  version: '0.10'
+  version: '0.11'
 platform: ruby
 authors:
 - Joel VanderWerf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-07 00:00:00.000000000 Z
+date: 2013-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atdo
@@ -113,7 +113,6 @@ files:
 - example/fail-and-retry.rb
 - example/load-balancer.rb
 - example/read-in-trans.rb
-- example/map-reduce.rb
 - example/bounded-retry.rb
 - example/pregel/remote.rb
 - example/pregel/pagerank.rb
@@ -122,7 +121,6 @@ files:
 - example/take-nowait.rb
 - example/boolean-match.rb
 - example/lease.rb
-- example/remote-map-reduce.rb
 - example/broker-locking.rb
 - example/transaction-logic.rb
 - example/message-bus.rb
@@ -138,18 +136,26 @@ files:
 - example/balance-xfer-retry.rb
 - example/custom-search.rb
 - example/app-and-tup.rb
+- example/multi-tier/memo2.rb
+- example/multi-tier/http.rb
+- example/multi-tier/kvspace.rb
+- example/multi-tier/memo.rb
+- example/multi-tier/drb.rb
 - example/take-many.rb
+- example/subspaces/pubsub.rb
 - example/dphil-optimistic.rb
 - example/async-transaction.rb
 - example/wait-interrupt.rb
 - example/zk/lock.rb
 - example/subspace.rb
-- example/map-reduce-v2.rb
 - example/deadlock.rb
 - example/add.rb
 - example/dphil-optimistic-v2.rb
 - example/parallel.rb
 - example/tiny-client.rb
+- example/map-reduce/map-reduce.rb
+- example/map-reduce/remote-map-reduce.rb
+- example/map-reduce/map-reduce-v2.rb
 - example/lock-mgr-with-queue.rb
 - example/balance-xfer.rb
 - example/cancel.rb
@@ -202,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.10
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Distributed tuplespace