tupelo 0.20 → 0.21

data/example/sqlite/poi-template.rb

@@ -0,0 +1,61 @@
+# Hard-coded to work with tuples belonging to the "poi" subspace
+# and with the PoiStore table.
+class PoiTemplate
+  attr_reader :lat, :lng
+  
+  # Template for matching all POI tuples.
+  attr_reader :poi_template
+
+  # lat and lng can be intervals or single values or nil to match any value
+  def initialize lat: nil, lng: nil, poi_template: nil
+    @lat = lat
+    @lng = lng
+    @poi_template = poi_template
+  end
+
+  # we only need to define this method if we plan to wait for poi tuples
+  # locally using this template, i.e. read(template) or take(template)
+  def === tuple
+    @poi_template === tuple and
+    !@lat || @lat === tuple[:lat] and
+    !@lng || @lng === tuple[:lng]
+  end
+
+  def find_in table, distinct_from: []
+    where_terms = {}
+    where_terms[:lat] = @lat if @lat
+    where_terms[:lng] = @lng if @lng
+
+    matches = table.
+      select(:lat, :lng, :desc).
+      where(where_terms).
+      limit(distinct_from.size + 1).all
+
+    # Note: everything in this method up to and including where(...) can
+    # be called once and reused as a sequel dataset.
+
+    distinct_from.each do |tuple|
+      if i=matches.index(tuple)
+        matches.delete_at i
+      end
+    end
+
+    matches.first
+  end
+
+  def find_all_in table, &bl
+    where_terms = {}
+    where_terms[:lat] = @lat if @lat
+    where_terms[:lng] = @lng if @lng
+
+    matches = table.
+      select(:lat, :lng, :desc).
+      where(where_terms)
+
+    if bl
+      matches.each(&bl)
+    else
+      matches.all
+    end
+  end
+end

data/example/sqlite/poi-v2.rb

@@ -1,58 +1,88 @@
-# POI -- Points Of Interest
-#
-# This example creates a sqlite db in memory with a table of locations and
-# descriptions of points of interest, and attaches the db to a subspace of the
-# tuplespace. The process which manages that subspace can now do two things:
-#
-# 1. accept inserts (via write)
-#
-# 2. custom queries, accessed by write to a different subspace
-#
-# You can have redundant instances of this, and that will distribute load
-# in #2 above.
-#
-# See example/subspaces/addr-book.rb for more comments on the command/response
-# subspace pattern.
-#
-# gem install sequel sqlite3
-
 require 'tupelo/app'
-require_relative 'poi-store'
+require_relative 'poi-client'
 
 Tupelo.application do
   local do
     POISPACE = PoiStore.define_poispace(self)
     define_subspace("cmd", {id: nil, cmd: String, arg: nil})
     define_subspace("rsp", {id: nil, result: nil})
+      # Note: this id is request id, not related to sqlite table id.
   end
 
-  child tuplespace: [PoiStore, POISPACE],
-        subscribe: ["poi", "cmd"], passive: true do
+  child PoiClient, poispace: POISPACE, subscribe: "cmd", passive: true do
     log.progname = "poi-store #{client_id}"
+    
+    poispace = subspace("poi")
+      # get local copy to replace poispace argument, which has wrong kind of
+      # keys (string, not symbol)
 
     # handle custom queries here, using poi template
     loop do
       req = take subspace("cmd")
-      case req["cmd"]
+      case req[:cmd]
       when "find box"
-        arg = req["arg"] ## validate this
-        lat = arg["lat"]; lng = arg["lng"]
-        template = PoiTemplate.new(poispace: subspace("poi"),
+        arg = req[:arg] ## should validate args
+        lat = arg[:lat]; lng = arg[:lng]
+        template = PoiTemplate.new(poi_template: poispace,
+          lat: lat[0]..lat[1], lng: lng[0]..lng[1])
+        write id: req[:id], result: read_all(template)
+
+      when "delete box"
+        arg = req[:arg]
+        lat = arg[:lat]; lng = arg[:lng]
+        template = PoiTemplate.new(poi_template: poispace,
           lat: lat[0]..lat[1], lng: lng[0]..lng[1])
-        write id: req["id"], result: read_all(template)
+
+        deleted = []
+        transaction do
+          while poi = take_nowait(template)
+            log "preparing to delete: #{poi}"
+            deleted << poi
+          end
+          # Wrapping this in a transaction not really necessary, but more
+          # efficient (only one round-trip to network). Watch out for huge sets
+          # of tuples, though.
+        end
+
+        write id: req[:id], result: deleted
       end
     end
   end
   
   child subscribe: "rsp" do
-    write lat: 12, lng: 34, desc: "foo"
-    write lat: 56, lng: 78, desc: "bar"
-    write lat: 12, lng: 34, desc: "foo" # dup is ok
-    write lat: 13, lng: 35, desc: "baz"
+    write lat: 1.2, lng: 3.4, desc: "foo"
+    write lat: 5.6, lng: 7.8, desc: "bar"
+    write lat: 1.2, lng: 3.4, desc: "foo" # dup is ok
+    write lat: 1.3, lng: 3.5, desc: "baz"
     
-    req_id = [client_id, 1]
-    write id: req_id, cmd: "find box", arg: {lat: [10, 14], lng: [30, 40]}
+    cmd_id = 0 # manually managing cmd id is a pain!
+
+    log "finding in box"
+    cmd_id += 1
+    req_id = [client_id, cmd_id]
+    write id: req_id, cmd: "find box", arg: {lat: [1.0, 1.4], lng: [3.0, 4.0]}
+    rsp = take id: req_id, result: nil
+    log "result: #{rsp["result"]}"
+
+    log "deleting in box"
+    cmd_id += 1
+    req_id = [client_id, cmd_id]
+    write id: req_id, cmd: "delete box", arg: {lat: [1.0, 1.4], lng: [3.0, 4.0]}
+    rsp = take id: req_id, result: nil
+    log "result: #{rsp["result"]}"
+
+    log "finding in box"
+    cmd_id += 1
+    req_id = [client_id, cmd_id]
+    write id: req_id, cmd: "find box", arg: {lat: [1.0, 1.4], lng: [3.0, 4.0]}
+    rsp = take id: req_id, result: nil
+    log "result: #{rsp["result"]}"
+
+    log "finding in BIGGER box"
+    cmd_id += 1
+    req_id = [client_id, cmd_id]
+    write id: req_id, cmd: "find box", arg: {lat: [0, 100], lng: [0, 100]}
     rsp = take id: req_id, result: nil
-    log rsp["result"]
+    log "result: #{rsp["result"]}"
   end
 end

data/example/sqlite/poi.rb

@@ -1,40 +1,28 @@
-# POI -- Points Of Interest
-#
-# This example creates a sqlite db in memory with a table of locations and
-# descriptions of points of interest, and attaches the db to a subspace of the
-# tuplespace. The process which manages that subspace can now do two things:
-#
-# 1. accept inserts (via write)
-#
-# 2. custom queries, accessed by write to a different subspace
-#
-# You can have redundant instances of this, and that will distribute load
-# in #2 above.
-#
-# gem install sequel sqlite3
-
 require 'tupelo/app'
-require_relative 'poi-store'
+require_relative 'poi-client'
 
 Tupelo.application do
   local do
     POISPACE = PoiStore.define_poispace(self)
   end
 
-  child tuplespace: [PoiStore, POISPACE], subscribe: "poi", passive: true do
+  child PoiClient, poispace: POISPACE, passive: true do
     log.progname = "poi-store"
-    # handle custom queries here, using poi template
+    
+    # At this point, the client already accepts writes in the space and stores
+    # them in a sqlite table. For the sake of a simple example, we add
+    # one feature to this mix: just show everything for each new tuple
     read do
-      log read_all # just show everything for each new tuple
+      log read_all
     end
   end
   
   child subscribe: nil do
-    write_wait lat: 12, lng: 34, desc: "foo"
-    sleep 0.5 # give poi store time to store and log
-    write_wait lat: 56, lng: 78, desc: "bar"
-    sleep 0.5 # give poi store time to store and log
-    write_wait lat: 12, lng: 34, desc: "foo" # dup is ok
-    sleep 0.5 # give poi store time to store and log
+    write lat: 1.2, lng: 3.4, desc: "foo"
+    sleep 0.5 # delay to make the demo interesting
+    write lat: 5.6, lng: 7.8, desc: "bar"
+    sleep 0.5
+    write lat: 1.2, lng: 3.4, desc: "foo" # dup is ok
+    sleep 0.5
   end
 end

data/example/sqlite/tmp/poi-sqlite.rb

@@ -13,13 +13,13 @@ end
 
 poi = db[:poi]
 
-#10.times do |i|
-#  poi << {
-#    lat:  rand,
-#    lng:  rand,
-#    desc: "point #{i}"
-#  }
-#end
+10.times do |i|
+  poi << {
+    lat:  rand,
+    lng:  rand,
+    desc: "point #{i}"
+  }
+end
 
 #p poi.all
 #exit
@@ -28,6 +28,8 @@ poi << {lat: 1, lng: 2, desc: "a"}
 poi << {lat: 1, lng: 2, desc: "b"}
 
 #p poi.count
-
+p poi.select(:lat, :lng, :desc).
+  where(lat: 0..1, lng: 0..1)
+  
 p poi.select(:lat, :lng, :desc).
   where(lat: 0..1, lng: 0..1).limit(5).all

data/example/subspaces/addr-book.rb

@@ -20,7 +20,7 @@
 # clients can each use their own data structure for these tuples.
 
 require 'tupelo/app'
-require_relative 'sorted-set-space'
+require_relative 'sorted-set-store'
 
 SHOW_HANDLERS = ARGV.delete("--show-handlers")
 
@@ -66,7 +66,7 @@ Tupelo.application do
   N_REPLICAS.times do |i|
     # Inserts are just writes, which are handled by Worker and SortedSetSpace,
     # so this child's app loop only needs to handle the special commands.
-    child tuplespace: [SortedSetSpace, ab_tag],
+    child tuplestore: [SortedSetStore, ab_tag],
           subscribe: [ab_tag, cmd_tag], passive: true do
 
       log.progname = "replica ##{i}"

data/example/subspaces/{sorted-set-space.rb → sorted-set-store.rb}

@@ -2,10 +2,10 @@ require 'rbtree'
 
 ## TODO
 ##
-## generalize SortedSetSpace to accept params that indicate which fields
+## generalize SortedSetStore to accept params that indicate which fields
 ##   are key and value
 ##
-## unify with space used in ../riemann v2, generalize
+## unify with store used in ../riemann v2, generalize
 
 # This is a template class, but it doesn't just match tuples. It can
 # be used to find the *next* tuple after a given one, using the rbtree
@@ -74,8 +74,8 @@ end
 # (See memo2.rb.)
 #
 # This store also manages command and meta tuples, which it keeps in an array,
-# just like the default Tuplespace class does.
-class SortedSetSpace
+# just like the default Tuplestore class does.
+class SortedSetStore
   include Enumerable
 
   attr_reader :tag, :tree, :metas

data/example/wip/complex-tags.rb

@@ -0,0 +1,45 @@
+# Tags can be any object that can be serialized by msgpack. Strings and
+# numbers are typical, but it can be useful to encode a bit more structure.
+# In this case we can use a complex tag to limit communication to particular
+# client groups (use groups of clients, so
+# that the lifespan of one process does not affect the system as a whole).
+
+require 'tupelo/app'
+
+Tupelo.application do
+  num_tag = "input numbers"#["input numbers", 1]
+  str_tag = "input strings"#["input strings", 2]
+  
+  local do
+    define_subspace num_tag, [Numeric]
+    define_subspace str_tag, [String]
+  end
+
+  child subscribe: num_tag, passive: true do
+    read subspace(num_tag) do |num, _|
+      write [num.to_s]
+    end
+  end
+  
+  child subscribe: str_tag, passive: true do
+    read subspace(str_tag) do |str, _|
+      begin
+        num = Integer(str) rescue Float(str)
+        write [num]
+      rescue 
+      end
+    end
+  end
+
+  local do # subscribed to everything
+    write [42]
+    write ["17.5"]
+
+    count = 0
+    read do |tuple|
+      log tuple
+      count += 1
+      break if count == 4
+    end
+  end
+end

data/lib/tupelo/app/trace.rb

@@ -18,7 +18,7 @@ class Tupelo::Client
   end
 
   def tracing?
-    !!@trace_thread
+    defined?(@trace_thread) && !!@trace_thread
   end
 
   private

data/lib/tupelo/app.rb

@@ -105,14 +105,14 @@ module Tupelo
         ez.service :arcd, **arcd_addr do |sv|
           require 'tupelo/archiver'
           if persist_dir
-            require 'tupelo/archiver/persistent-tuplespace'
+            require 'tupelo/archiver/persistent-tuplestore'
             arc = Archiver.new sv, seq: arc_to_seq_sock,
-                    tuplespace: Archiver::PersistentTuplespace,
+                    tuplestore: Archiver::PersistentTupleStore,
                     persist_dir: persist_dir,
                     cseq: arc_to_cseq_sock, log: log
           else
             arc = Archiver.new sv, seq: arc_to_seq_sock,
-                    tuplespace: Archiver::Tuplespace,
+                    tuplestore: Archiver::TupleStore,
                     cseq: arc_to_cseq_sock, log: log
           end
           arc.start

data/lib/tupelo/archiver/{persistent-tuplespace.rb → persistent-tuplestore.rb}

@@ -1,5 +1,5 @@
 class Tupelo::Archiver
-  class PersistentTuplespace
+  class PersistentTupleStore
     include Enumerable
     
     attr_reader :zero_tolerance

data/lib/tupelo/archiver/{tuplespace.rb → tuplestore.rb}

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

data/lib/tupelo/archiver/worker.rb

@@ -10,19 +10,19 @@ class Tupelo::Archiver
       @opts = opts
     end
 
-    def tuplespace
-      @tuplespace ||= begin
-        if client.tuplespace.respond_to? :new
-          client.tuplespace.new **@opts
+    def tuplestore
+      @tuplestore ||= begin
+        if client.tuplestore.respond_to? :new
+          client.tuplestore.new **@opts
         else
-          client.tuplespace
+          client.tuplestore
         end
       end
     end
 
     def stop
       super
-      tuplespace.flush global_tick
+      tuplestore.flush global_tick
     end
 
     def handle_client_request req
@@ -67,8 +67,8 @@ class Tupelo::Archiver
             raise "Unimplemented" ###
           when "get range" ### handle this in Funl::HistoryWorker
             raise "Unimplemented" ###
-          when GET_TUPLESPACE
-            send_tuplespace stream, sub_delta
+          when GET_TUPLESTORE
+            send_tuplestore stream, sub_delta
           else
             raise "Unknown operation: #{op.inspect}"
           end
@@ -94,9 +94,9 @@ class Tupelo::Archiver
       end
     end
 
-    def send_tuplespace stream, sub_delta
+    def send_tuplestore stream, sub_delta
       log.info {
-        "send_tuplespace to #{stream.peer_name} " +
+        "send_tuplestore to #{stream.peer_name} " +
         "at tick #{global_tick.inspect} " +
         (sub_delta ? " with sub_delta #{sub_delta.inspect}" : "")}
       
@@ -106,7 +106,7 @@ class Tupelo::Archiver
       ## has to be sent.
 
       if sub_delta["request_all"]
-        tuplespace.each do |tuple, count|
+        tuplestore.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
@@ -117,7 +117,7 @@ class Tupelo::Archiver
         tags = sub_delta["request_tags"] ## use set
         subs = subspaces.select {|sub| tags.include? sub.tag}
 
-        tuplespace.each do |tuple, count|
+        tuplestore.each do |tuple, count|
           ## alternately, store tags with tuples (risk if dynamic spaces)
           if subs.any? {|sub| sub === tuple}
             count.times do

data/lib/tupelo/archiver.rb

@@ -9,7 +9,7 @@ require 'funl/history-client'
 class Tupelo::Archiver < Tupelo::Client; end
 
 require 'tupelo/archiver/worker'
-require 'tupelo/archiver/tuplespace' ## unless persistent?
+require 'tupelo/archiver/tuplestore' ## unless persistent?
 
 module Tupelo
   class Archiver
@@ -23,11 +23,13 @@ module Tupelo
     ZERO_TOLERANCE = 1000
 
     def initialize server,
-        tuplespace: Tupelo::Archiver::Tuplespace,
+        tuplestore: Tupelo::Archiver::TupleStore,
         persist_dir: nil, **opts
+        ## when ruby does GC symbols, add this:
+        ## symbolize_keys: true
       @server = server
       @persist_dir = persist_dir
-      super arc: nil, tuplespace: tuplespace, **opts
+      super arc: nil, tuplestore: tuplestore, **opts
     end
 
     # three kinds of requests:
@@ -37,12 +39,12 @@ module Tupelo
     #
     # 2. accept tcp/unix socket connection and fork, and then:
     #
-    #   a. dump subspace matching given templates OR
+    #   a. dump tuples matching given templates OR
     #
     #   b. dump all ops in a given range of the global sequence
     #      matching given templates
     #
-    # the fork happens when tuplespace is consistent; we
+    # the fork happens when tuplestore is consistent; we
     # do this by passing cmd to worker thread, with conn
     class ForkRequest
       attr_reader :io

data/lib/tupelo/client/reader.rb

@@ -3,18 +3,21 @@ require 'tupelo/client/common'
 class Tupelo::Client
   # Include into class that defines #worker and #log.
   module Api
-    NOT_META = proc {|t| not defined? t.key? or not t.key? TUPELO_META_KEY}
+    def not_meta
+      k = tupelo_meta_key
+      @not_meta ||= proc {|t| not defined? t.key? or not t.key? k}
+    end
 
     # If no block given, return one matching tuple, blocking if necessary.
     # If block given, yield each matching tuple that is found
-    # locally and then yield each new match as it is written to the space.
+    # locally and then yield each new match as it is written to the store.
     # Guaranteed not to miss tuples, even if they arrive and are immediately
     # taken. (Note that simply doing read(template) in a loop would not
     # have this guarantee.)
-    # The template defaults to NOT_META, which matches any tuple except metas.
+    # The template defaults to not_meta, which matches any tuple except metas.
     # The first phase of this method, reading existing tuples, is essentially
     # the same as read_all, and subject to the same warnings.
-    def read_wait template = NOT_META
+    def read_wait template = not_meta
       waiter = Waiter.new(worker.make_template(template), self, !block_given?)
       worker << waiter
       if block_given?
@@ -31,15 +34,15 @@ class Tupelo::Client
     end
     alias read read_wait
 
-    # The template defaults to NOT_META, which matches any tuple except metas.
-    def read_nowait template = NOT_META
+    # The template defaults to not_meta, which matches any tuple except metas.
+    def read_nowait template = not_meta
       matcher = Matcher.new(worker.make_template(template), self)
       worker << matcher
       matcher.wait
     end
 
-    # Returns all matching tuples currently in the space. Does not wait for more
-    # tuples to arrive. The template defaults to NOT_META, which matches any
+    # Returns all matching tuples currently in the store. Does not wait for more
+    # tuples to arrive. The template defaults to not_meta, which matches any
     # tuple except metas. To read all matches of more than one template, use
     # the #or method from util/boolean.rb.
     # Matches are guaranteed to exist at the same tick (even if they no longer
@@ -47,11 +50,11 @@ class Tupelo::Client
     # blocked from all other activity for some time, so be careful about
     # using read_all when large numbers of tuples match. If a block is given,
     # it runs after the worker has unblocked.
-    def read_all template = NOT_META
+    def read_all template = not_meta
       matcher = Matcher.new(worker.make_template(template), self, :all => true)
       worker << matcher
       a = []
-      while tuple = matcher.wait ## inefficient?
+      while tuple = matcher.wait ## inefficient to wait one at a time?
         yield tuple if block_given?
         a << tuple
       end

data/lib/tupelo/client/subspace.rb

@@ -1,11 +1,19 @@
 class Tupelo::Client
   module Api
     TUPELO_SUBSPACE_TAG = "tupelo subspace".freeze
-    TUPELO_META_KEY = "__tupelo__".freeze
+
+    def tupelo_subspace_tag
+      @tupelo_subspace_tag ||=
+        symbolize_keys ? TUPELO_SUBSPACE_TAG.to_sym : TUPELO_SUBSPACE_TAG
+    end
+
+    def tupelo_meta_key
+      @tupelo_meta_key ||= symbolize_keys ? :__tupelo__ : "__tupelo__".freeze
+    end
 
     def define_subspace tag, template, addr: nil
       metatuple = {
-        TUPELO_META_KEY => "subspace",
+        tupelo_meta_key => "subspace",
         tag:        tag,
         template:   PortableObjectTemplate.spec_from(template),
         addr:       addr
@@ -19,7 +27,7 @@ class Tupelo::Client
     def use_subspaces!
       return if find_subspace_by_tag(TUPELO_SUBSPACE_TAG)
       define_subspace(TUPELO_SUBSPACE_TAG, {
-        TUPELO_META_KEY => "subspace",
+        tupelo_meta_key => "subspace",
         tag:        nil,
         template:   nil,
         addr:       nil
@@ -30,7 +38,7 @@ class Tupelo::Client
       tag = tag.to_s
       find_subspace_by_tag(tag) or begin
         if subscribed_tags.include? tag
-          read TUPELO_META_KEY => "subspace",
+          read tupelo_meta_key => "subspace",
             tag:      tag,
             template: nil,
             addr:     nil