tupelo 0.20 → 0.21

data/lib/tupelo/client/transaction.rb

@@ -108,6 +108,7 @@ class Tupelo::Client
     attr_reader :granted_tuples
     attr_reader :missing
     attr_reader :tags
+    attr_reader :read_only
     
     STATES = [
       OPEN      = :open,    # initial state
@@ -149,14 +150,15 @@ class Tupelo::Client
       @tags = nil
       @_take_nowait = nil
       @_read_nowait = nil
+      @read_only = false
       
+      open!
+
       if deadline
         worker.at deadline do
           cancel(TimeoutError) if open?
         end
       end
-      
-      open!
     end
     
     def client_id
@@ -175,10 +177,6 @@ class Tupelo::Client
       end
     end
 
-    def read_only?
-      @writes.empty? && @pulses.empty? && @take_templates.empty?
-    end
-
     def inspect
       stat_extra =
         case
@@ -304,7 +302,7 @@ class Tupelo::Client
     # this causes transaction to be re-executed.
     def fail!
       raise if in_worker_thread?
-      raise unless open?
+      check_open
       failed!
       raise TransactionFailure
     end
@@ -312,17 +310,11 @@ class Tupelo::Client
     # idempotent
     def commit
       if open?
-        if @writes.empty? and @pulses.empty? and
-           @take_tuples_for_remote.all? {|t| t.nil?} and
-           @read_tuples_for_remote.all? {|t| t.nil?}
-          @global_tick = worker.global_tick ## ok?
-          done!
-          log.info {"not committing empty transaction"}
-        else
-          closed!
-          log.info {"committing #{inspect}"}
-          worker_push self
-        end
+        closed!
+        @read_only = @writes.empty? && @pulses.empty? &&
+           @take_tuples_for_remote.all? {|t| t.nil?}
+        log.info {"committing #{inspect}"}
+        worker_push self
       else
         raise exception if failed?
       end
@@ -369,7 +361,7 @@ class Tupelo::Client
 
     def async &block
       raise ArgumentError, "must provide block" unless block
-      TransactionThread.new(self) do ## Fiber?
+      TransactionThread.new(self) do
         begin
           val =
             if block.arity == 0
@@ -394,100 +386,112 @@ class Tupelo::Client
       worker.in_thread?
     end
 
-    def prepare new_tuple = nil
-      return false if closed? or failed? # might change during this method
+    # Further prepare this open transaction after the arrival of a new tuple.
+    def prepare new_tuple
+      return false if closed? or failed?
       raise unless in_worker_thread?
 
-      if new_tuple
-        return true if take_tuples_for_local.all? and read_tuples_for_local.all?
+      return true if take_tuples_for_local.all? and read_tuples_for_local.all?
 
-        take_tuples_for_local.each_with_index do |tuple, i|
-          if not tuple and take_templates[i] === new_tuple
-            take_tuples_for_local[i] = new_tuple
-            take_tuples_for_remote[i] = new_tuple
-            log.debug {"prepared #{inspect} with #{new_tuple}"}
-            break
-          end
+      take_tuples_for_local.each_with_index do |tuple, i|
+        if not tuple and take_templates[i] === new_tuple
+          take_tuples_for_local[i] = new_tuple
+          take_tuples_for_remote[i] = new_tuple
+          log.debug {"prepared #{inspect} with #{new_tuple}"}
+          break
         end
+      end
 
-        read_tuples_for_local.each_with_index do |tuple, i|
-          if not tuple and read_templates[i] === new_tuple
-            read_tuples_for_local[i] = new_tuple
-            read_tuples_for_remote[i] = new_tuple
-            log.debug {"prepared #{inspect} with #{new_tuple}"}
-          end
+      read_tuples_for_local.each_with_index do |tuple, i|
+        if not tuple and read_templates[i] === new_tuple
+          read_tuples_for_local[i] = new_tuple
+          read_tuples_for_remote[i] = new_tuple
+          log.debug {"prepared #{inspect} with #{new_tuple}"}
         end
+      end
 
-      else
-        ## optimization: use tuple cache
-        skip = nil
-        (take_tuples_for_local.size...take_templates.size).each do |i|
-          template = take_templates[i]
-          
-          if wt = @writes.find {|tuple| template === tuple}
-            take_tuples_for_remote[i] = nil
-            take_tuples_for_local[i] = wt.dup
-            @writes.delete wt
-            next
-          end
+      wake_client_if_ready
+      return true
+    end
 
-          take_tuples_for_local[i] = take_tuples_for_remote[i] =
-            worker.tuplespace.find_match_for(template,
-              distinct_from: take_tuples_for_local)
-          
-          if take_tuples_for_local[i]
-            log.debug {"prepared #{inspect} with #{take_tuples_for_local[i]}"}
-          else
-            if @_take_nowait and @_take_nowait[i]
-              (skip ||= []) << i
-            end
+    # Further prepare this open transaction after new operations are added.
+    def prepare_ops
+      return false if closed? or failed?
+      raise unless in_worker_thread?
+
+      ## optimization: use tuple cache
+      skip = nil
+      (take_tuples_for_local.size...take_templates.size).each do |i|
+        template = take_templates[i]
+
+        if wt = @writes.find {|tuple| template === tuple}
+          take_tuples_for_remote[i] = nil
+          take_tuples_for_local[i] = wt.dup
+          @writes.delete wt
+          next
+        end
+
+        take_tuples_for_local[i] = take_tuples_for_remote[i] =
+          worker.tuplestore.find_match_for(template,
+            distinct_from: take_tuples_for_local)
+
+        if take_tuples_for_local[i]
+          log.debug {"prepared #{inspect} with #{take_tuples_for_local[i]}"}
+        else
+          if @_take_nowait and @_take_nowait[i]
+            (skip ||= []) << i
           end
         end
+      end
+
+      skip and skip.reverse_each do |i|
+        take_tuples_for_local.delete_at i
+        take_tuples_for_remote.delete_at i
+        take_templates.delete_at i
+        @_take_nowait.delete i
+      end
 
-        skip and skip.reverse_each do |i|
-          take_tuples_for_local.delete_at i
-          take_tuples_for_remote.delete_at i
-          take_templates.delete_at i
-          @_take_nowait.delete i
+      skip = nil
+      (read_tuples_for_local.size...read_templates.size).each do |i|
+        template = read_templates[i]
+
+        if wt = @writes.find {|tuple| template === tuple}
+          read_tuples_for_remote[i] = nil
+          read_tuples_for_local[i] = wt.dup
+          next
         end
-        
-        skip = nil
-        (read_tuples_for_local.size...read_templates.size).each do |i|
-          template = read_templates[i]
-
-          if wt = @writes.find {|tuple| template === tuple}
-            read_tuples_for_remote[i] = nil
-            read_tuples_for_local[i] = wt.dup
-            next
-          end
 
-          read_tuples_for_local[i] = read_tuples_for_remote[i] =
-            worker.tuplespace.find_match_for(template,
-              distinct_from: take_tuples_for_local)
-          
-          if read_tuples_for_local[i]
-            log.debug {"prepared #{inspect} with #{read_tuples_for_local[i]}"}
-          else
-            if @_read_nowait and @_read_nowait[i]
-              (skip ||= []) << i
-            end
+        read_tuples_for_local[i] = read_tuples_for_remote[i] =
+          worker.tuplestore.find_match_for(template,
+            distinct_from: take_tuples_for_local)
+
+        if read_tuples_for_local[i]
+          log.debug {"prepared #{inspect} with #{read_tuples_for_local[i]}"}
+        else
+          if @_read_nowait and @_read_nowait[i]
+            (skip ||= []) << i
           end
         end
+      end
 
-        skip and skip.reverse_each do |i|
-          read_tuples_for_local.delete_at i
-          read_tuples_for_remote.delete_at i
-          read_templates.delete_at i
-          @_read_nowait.delete i
-        end
+      skip and skip.reverse_each do |i|
+        read_tuples_for_local.delete_at i
+        read_tuples_for_remote.delete_at i
+        read_templates.delete_at i
+        @_read_nowait.delete i
       end
-      
+
       ## convert cancelling write/take to pulse
       ## convert cancelling take/write to read
       ## remove redundant pulse after read
       ## remove redundant read before take
       ## remove redundant read after write
-      
+
+      wake_client_if_ready
+      return true
+    end
+
+    def wake_client_if_ready
       if take_tuples_for_local.all? and read_tuples_for_local.all?
         @queue << true
         log.debug {
@@ -495,8 +499,6 @@ class Tupelo::Client
           "take tuples: #{take_tuples_for_local}, " +
           "read tuples: #{read_tuples_for_local}"}
       end
-      
-      return true
     end
 
     def unprepare missing_tuple
@@ -531,8 +533,9 @@ class Tupelo::Client
     end
     
     def done global_tick, granted_tuples
-      raise TransactionStateError, "must be pending or read_only" unless
-        pending? or (closed? and read_only?)
+      unless pending? or (closed? and read_only)
+        raise TransactionStateError, "must be pending or closed+read_only"
+      end
       raise unless in_worker_thread?
       raise if @global_tick or @exception
 

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

@@ -1,6 +1,6 @@
 class Tupelo::Client
-  # Simplest fully functional tuplespace. Not efficient for large spaces.
-  class SimpleTuplespace < Array
+  # Simplest fully functional tuplestore. Not efficient for large stores.
+  class SimpleTupleStore < Array
     alias insert <<
 
     def delete_once elt
@@ -32,12 +32,12 @@ class Tupelo::Client
     end
   end
   
-  # Tuplespace that stores nothing. Very efficient for large spaces!
+  # Tuplestore that stores nothing. Very efficient for large stores!
   # Useful for clients that don't need to take or read the stored tuples.
   # The write, pulse, and blocking read operations all work correctly.
   # The client is essentially a pub/sub client, then. See the
   # --pubsub switch in tup for an example.
-  class NullTuplespace
+  class NullTupleStore
     include Enumerable
     def each(*); end
     def delete_once(*); end

data/lib/tupelo/client/worker.rb

@@ -17,7 +17,7 @@ class Tupelo::Client
     attr_reader :msg_reader_thread
     attr_reader :worker_thread
     attr_reader :cmd_queue
-    attr_reader :tuplespace
+    attr_reader :tuplestore
     attr_reader :message_class
     attr_reader :blobber
     attr_reader :read_waiters
@@ -26,7 +26,7 @@ class Tupelo::Client
     attr_reader :notify_waiters
     attr_reader :subspaces
 
-    GET_TUPLESPACE = "get tuplespace"
+    GET_TUPLESTORE = "get tuplestore"
 
     class Operation
       attr_reader :writes, :pulses, :takes, :reads
@@ -50,14 +50,16 @@ class Tupelo::Client
     end
     
     class Subspace
-      attr_reader :tag
+      attr_reader :tag, :spec, :pot
+      alias template pot
       
       def initialize metatuple, worker
         @metatuple = metatuple
-        @tag = metatuple["tag"]
+        @tag = metatuple["tag"] || metatuple[:tag]
 
-        spec = Marshal.load(Marshal.dump(metatuple["template"]))
-        @pot = worker.pot_for(spec).optimize!
+        template = metatuple["template"] || metatuple[:template]
+        @spec = Marshal.load(Marshal.dump(template)).freeze
+        @pot = worker.pot_for(spec).optimize!.freeze
       end
       
       def === tuple
@@ -79,7 +81,7 @@ class Tupelo::Client
       @delta = 0
 
       @cmd_queue = client.make_queue
-      @tuplespace = nil
+      @tuplestore = nil
       @message_class = client.message_class
       @blobber = nil
 
@@ -99,15 +101,15 @@ class Tupelo::Client
       end
     end
     
-    def tuplespace
-      @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)
+    def tuplestore
+      @tuplestore ||= begin
+        if client.tuplestore.respond_to? :new
+          client.tuplestore.new
+        elsif client.tuplestore.class == Array # but not subclass of Array
+          tsclass, *args = client.tuplestore
+          tsclass.new(*args, client: client)
         else
-          client.tuplespace
+          client.tuplestore
         end
       end
     end
@@ -239,17 +241,17 @@ class Tupelo::Client
         return
       end
 
-      log.info "requesting tuplespace from arc"
+      log.info "requesting tuplestore from arc"
       subscription_delta = {
         request_all: all,
         request_tags: tags,
         subscribed_all: client.subscribed_all,
         subscribed_tags: client.subscribed_tags
       }
-      arc << [GET_TUPLESPACE, subscription_delta, tick]
+      arc << [GET_TUPLESTORE, subscription_delta, tick]
 
       begin
-        tuplespace.clear
+        tuplestore.clear
           ## 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.
@@ -265,15 +267,15 @@ class Tupelo::Client
           else
             raise "bad object stream from archiver" if done
             sniff_meta_tuple tuple
-            tuplespace.insert tuple
+            tuplestore.insert tuple
             count += 1
           end
         end
         unless done
-          raise "did not get all of tuplespace from archiver" ## roll back?
+          raise "did not get all of tuplestore from archiver" ## roll back?
         end
 
-        log.info "received tuplespace from arc: #{count} tuples"
+        log.info "received tuplestore from arc: #{count} tuples"
 
         @global_tick = arc_tick
         log.info "global_tick = #{global_tick}"
@@ -332,8 +334,8 @@ class Tupelo::Client
         waiter << [:attempt, msg.global_tick, msg.client_id, op, msg.tags]
       end
 
-      take_tuples = tuplespace.find_distinct_matches_for(op.takes)
-      read_tuples = op.reads.map {|t| tuplespace.find_match_for(t,
+      take_tuples = tuplestore.find_distinct_matches_for(op.takes)
+      read_tuples = op.reads.map {|t| tuplestore.find_match_for(t,
         distinct_from: take_tuples)}
       succeeded = take_tuples.all? && read_tuples.all?
 
@@ -349,7 +351,7 @@ class Tupelo::Client
 
       if succeeded
         log.debug {"inserting #{op.writes}; deleting #{take_tuples}"}
-        tuplespace.transaction inserts: write_tuples, deletes: take_tuples,
+        tuplestore.transaction inserts: write_tuples, deletes: take_tuples,
           tick: @global_tick
       
         op.writes.each do |tuple|
@@ -359,7 +361,8 @@ class Tupelo::Client
         take_tuples.each do |tuple|
           if is_meta_tuple? tuple
             ## do some error checking
-            subspaces.delete_if {|sp| sp.tag == tuple["tag"]}
+            tag = tuple["tag"] || tuple[:tag]
+            subspaces.delete_if {|sp| sp.tag == tag}
           end
         end
       end
@@ -452,8 +455,8 @@ class Tupelo::Client
         meta_subspace === tuple
       else
         # meta_subspace hasn't arrived yet, so use approximation
-        tuple.kind_of? Hash and tuple.key? Api::TUPELO_META_KEY and
-          tuple[Api::TUPELO_META_KEY] == "subspace"
+        tuple.kind_of? Hash and tuple.key? client.tupelo_meta_key and
+          tuple[client.tupelo_meta_key] == "subspace"
       end
     end
 
@@ -504,10 +507,10 @@ class Tupelo::Client
     def handle_transaction t
       case
       when t.open?
-        t.prepare
+        t.prepare_ops
         prep_waiters << t unless prep_waiters.include? t
       when t.closed?
-        if t.read_only?
+        if t.read_only
           t.done global_tick, nil
         else
           t.submit
@@ -529,26 +532,32 @@ class Tupelo::Client
 
     def handle_waiter waiter
       if waiter.once
-        tuple = tuplespace.find_match_for waiter.template
+        tuple = tuplestore.find_match_for waiter.template
         if tuple
           waiter.peek tuple
         else
           read_waiters << waiter
         end
       else
-        tuplespace.each {|tuple| waiter.gloms tuple}
+        tuplestore.each {|tuple| waiter.gloms tuple}
         read_waiters << waiter
       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
+        if defined? tuplestore.find_all_matches_for
+          tuplestore.find_all_matches_for matcher.template do |tuple|
+            matcher.peek tuple
+          end
+        else
+          tuplestore.each do |tuple|
+            matcher.gloms tuple
+          end
+        end
         matcher.fails
       else
-        tuple = tuplespace.find_match_for matcher.template
+        tuple = tuplestore.find_match_for matcher.template
         if tuple
           matcher.peek tuple
         else

data/lib/tupelo/client.rb

@@ -7,14 +7,14 @@ module Tupelo
     include Api
 
     require 'tupelo/client/worker'
-    require 'tupelo/client/tuplespace'
+    require 'tupelo/client/tuplestore'
 
     attr_reader :worker
-    attr_reader :tuplespace
+    attr_reader :tuplestore
 
-    def initialize(tuplespace: SimpleTuplespace, subscribe: :all, **opts)
+    def initialize(tuplestore: SimpleTupleStore, subscribe: :all, **opts)
       super **opts
-      @tuplespace = tuplespace
+      @tuplestore = tuplestore
       @worker = make_worker
       @initial_subscriptions = subscribe || []
     end

data/lib/tupelo/version.rb

@@ -1,3 +1,3 @@
 module Tupelo
-  VERSION = "0.20"
+  VERSION = "0.21"
 end

data/test/lib/mock-client.rb

@@ -14,7 +14,7 @@ class MockClient
   attr_accessor :client_id
   attr_accessor :blobber
   attr_accessor :message_class
-  attr_accessor :tuplespace
+  attr_accessor :tuplestore
   attr_accessor :seq
   attr_accessor :arc
   attr_accessor :start_tick

data/test/lib/testable-worker.rb

@@ -1,5 +1,5 @@
 require 'tupelo/client/worker'
-require 'tupelo/client/tuplespace'
+require 'tupelo/client/tuplestore'
 
 class TestableWorker < Tupelo::Client::Worker
   def initialize client

data/test/unit/test-ops.rb

@@ -30,7 +30,7 @@ class TestOps < Minitest::Test
         log.formatter = MiniFormatter.new
       end
       c.blobber = Marshal
-      c.tuplespace = Tupelo::Client::SimpleTuplespace
+      c.tuplestore = Tupelo::Client::SimpleTupleStore
       c.message_class = MockMessage
       c.seq = seq.stream
       c.worker = TestableWorker.new(c)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tupelo
 version: !ruby/object:Gem::Version
-  version: '0.20'
+  version: '0.21'
 platform: ruby
 authors:
 - Joel VanderWerf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-11 00:00:00.000000000 Z
+date: 2014-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atdo
@@ -81,7 +81,7 @@ files:
 - README.md
 - Rakefile
 - bench/pipeline.rb
-- bench/tuplespace.rb
+- bench/tuplestore.rb
 - bin/tspy
 - bin/tup
 - bugs/read-take.rb
@@ -126,7 +126,6 @@ files:
 - example/load-balancer.rb
 - example/lock-mgr-with-queue.rb
 - example/lock-mgr.rb
-- example/map-reduce/ex.rb
 - example/map-reduce/map-reduce-v2.rb
 - example/map-reduce/map-reduce.rb
 - example/map-reduce/prime-factor-balanced.rb
@@ -136,7 +135,7 @@ files:
 - example/message-bus.rb
 - example/multi-tier/drb.rb
 - example/multi-tier/http.rb
-- example/multi-tier/kvspace.rb
+- example/multi-tier/kvstore.rb
 - example/multi-tier/memo.rb
 - example/multi-tier/memo2.rb
 - example/multi-tier/multi-sinatras.rb
@@ -160,15 +159,19 @@ files:
 - example/riemann/producer.rb
 - example/riemann/v1/expirer.rb
 - example/riemann/v1/riemann.rb
+- example/riemann/v2/event-sql.rb
 - example/riemann/v2/expirer.rb
 - example/riemann/v2/hash-store.rb
 - example/riemann/v2/http-mode.rb
 - example/riemann/v2/ordered-event-store.rb
 - example/riemann/v2/riemann.rb
+- example/riemann/v2/sqlite-event-store.rb
 - example/small-simplified.rb
 - example/small.rb
 - example/socket-broker.rb
+- example/sqlite/poi-client.rb
 - example/sqlite/poi-store.rb
+- example/sqlite/poi-template.rb
 - example/sqlite/poi-v2.rb
 - example/sqlite/poi.rb
 - example/sqlite/tmp/poi-sqlite.rb
@@ -181,7 +184,7 @@ files:
 - example/subspaces/shop/shop-v2.rb
 - example/subspaces/simple.rb
 - example/subspaces/sorted-set-space-OLD.rb
-- example/subspaces/sorted-set-space.rb
+- example/subspaces/sorted-set-store.rb
 - example/take-many.rb
 - example/take-nowait-caution.rb
 - example/take-nowait.rb
@@ -193,6 +196,7 @@ files:
 - example/transaction-logic.rb
 - example/uniq-id.rb
 - example/wait-interrupt.rb
+- example/wip/complex-tags.rb
 - example/wip/fish.rb
 - example/wip/fish1.rb
 - example/wip/fish2.rb
@@ -204,9 +208,9 @@ files:
 - lib/tupelo/app/remote.rb
 - lib/tupelo/app/trace.rb
 - lib/tupelo/archiver.rb
-- lib/tupelo/archiver/persistent-tuplespace.rb
+- lib/tupelo/archiver/persistent-tuplestore.rb
 - lib/tupelo/archiver/persister.rb
-- lib/tupelo/archiver/tuplespace.rb
+- lib/tupelo/archiver/tuplestore.rb
 - lib/tupelo/archiver/worker.rb
 - lib/tupelo/client.rb
 - lib/tupelo/client/common.rb
@@ -214,7 +218,7 @@ files:
 - lib/tupelo/client/scheduler.rb
 - lib/tupelo/client/subspace.rb
 - lib/tupelo/client/transaction.rb
-- lib/tupelo/client/tuplespace.rb
+- lib/tupelo/client/tuplestore.rb
 - lib/tupelo/client/worker.rb
 - lib/tupelo/tuplets/persistent-archiver.rb
 - lib/tupelo/tuplets/persistent-archiver/tuplespace.rb