tupelo 0.14 → 0.15

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/example/tcp.rb

@@ -13,8 +13,7 @@
 #
 #   ../bin/tup tcp.yaml
 #
-# Copy tcp.yaml to a remote host, and in the remote copy edit the
-# addr field to a hostname (or ip addr) isntead of 0.0.0.0.
+# Copy tcp.yaml to a remote host.
 #
 # Then run a client like this:
 #
@@ -22,21 +21,21 @@
 
 require 'tupelo/app'
 
-svr = "tcp.yaml" # copy this file to remote clients, setting host as needed
+sv = "tcp.yaml" # copy this file to remote clients, setting host as needed
 port = 9901 # Use 0 to let system choose free port
 
-Tupelo.application servers_file: svr,
-            seqd_addr:  [:tcp, '0.0.0.0', port],
-            cseqd_addr: [:tcp, '0.0.0.0', port + 1],
-            arcd_addr:  [:tcp, '0.0.0.0', port + 2] do
-  if owns_servers
-    puts "server started; ^C to stop"
+Tupelo.application services_file: sv,
+            seqd_addr:  {proto: :tcp, bind_host: '0.0.0.0', port: port},
+            cseqd_addr: {proto: :tcp, bind_host: '0.0.0.0', port: port + 1},
+            arcd_addr:  {proto: :tcp, bind_host: '0.0.0.0', port: port + 2} do
+  if owns_services
+    puts "service started; ^C to stop"
     puts "run in another terminal: ../bin/tup tcp.yaml"
     if log.level > Logger::INFO
       puts "(run with --info or --trace to see events)"
     end
     sleep
   else
-    abort "server seems to be running already; check file #{svr.inspect}"
+    abort "service seems to be running already; check file #{sv.inspect}"
   end
 end

data/example/tiny-client.rb

@@ -1,10 +1,10 @@
 require 'tupelo/app'
 
-svr = "tiny-server.yaml"
+sv = "tiny-service.yaml"
 
-Tupelo.application servers_file: svr do
-  if owns_servers
-    abort "server not running"
+Tupelo.application services_file: sv do
+  if owns_services
+    abort "service not running"
   end
 
   child do

data/example/tiny-service.rb

@@ -0,0 +1,12 @@
+require 'tupelo/app'
+
+sv = "tiny-service.yaml"
+
+Tupelo.application services_file: sv do
+  if owns_services
+    puts "service started"
+    sleep
+  else
+    abort "service seems to be running already; check file #{sv.inspect}"
+  end
+end

data/lib/tupelo/app/builder.rb

@@ -4,16 +4,16 @@ module Tupelo
   class AppBuilder
     attr_reader :ez
 
-    # Does this app own (as child processes) the seq, cseq, and arc servers?
-    attr_reader :owns_servers
+    # Does this app own (as child processes) the seq, cseq, and arc services?
+    attr_reader :owns_services
 
     # Arguments available to application after tupelo has parsed out switches
     # and args that it recognizes.
     attr_reader :argv
 
-    def initialize ez, owns_servers: nil, argv: argv
+    def initialize ez, owns_services: nil, argv: argv
       @ez = ez
-      @owns_servers = owns_servers
+      @owns_services = owns_services
       @argv = argv
     end
 

data/lib/tupelo/app.rb

@@ -38,12 +38,10 @@ module Tupelo
   end
 
   # same as application, but with tcp sockets the default
-  def self.tcp_application argv: nil,
-        servers_file: nil, blob_type: nil,
-        seqd_addr:  [:tcp, nil, 0],
-        cseqd_addr: [:tcp, nil, 0],
-        arcd_addr:  [:tcp, nil, 0], **opts, &block
-    application argv: argv, servers_file: servers_file, blob_type: blob_type,
+  def self.tcp_application argv: nil, services_file: nil, blob_type: nil,
+        seqd_addr: {}, cseqd_addr: {}, arcd_addr: {}, **opts, &block
+    seqd_addr[:proto] = cseqd_addr[:proto] = arcd_addr[:proto] = :tcp
+    application argv: argv, services_file: services_file, blob_type: blob_type,
       seqd_addr: seqd_addr, cseqd_addr: cseqd_addr, arcd_addr: arcd_addr, &block
   end
 
@@ -53,8 +51,8 @@ module Tupelo
   #blob_type: 'json' # more portable than yaml, but more restrictive
 
   def self.application argv: nil,
-        servers_file: nil, blob_type: nil,
-        seqd_addr: [], cseqd_addr: [], arcd_addr: [], **opts, &block
+        services_file: nil, blob_type: nil,
+        seqd_addr: {}, cseqd_addr: {}, arcd_addr: {}, **opts, &block
   
     unless argv
       argv, h = parse_args(ARGV)
@@ -68,7 +66,7 @@ module Tupelo
     persist_dir = opts[:persist_dir]
 
     ez_opts = {
-      servers_file: servers_file || argv.shift,
+      services_file: services_file || argv.shift,
       interactive: $stdin.isatty
     }
 
@@ -77,37 +75,37 @@ module Tupelo
       log.level = log_level
       log.formatter = nil if verbose
       log.progname = File.basename($0)
-      owns_servers = false
+      owns_services = false
 
-      ez.start_servers do
-        owns_servers = true
+      ez.start_services do
+        owns_services = true
 
         arc_to_seq_sock, seq_to_arc_sock = UNIXSocket.pair
         arc_to_cseq_sock, cseq_to_arc_sock = UNIXSocket.pair
 
-        ez.server :seqd, *seqd_addr do |svr|
+        ez.service :seqd, **seqd_addr do |sv|
           require 'funl/message-sequencer'
-          seq = Funl::MessageSequencer.new svr, seq_to_arc_sock, log: log,
+          seq = Funl::MessageSequencer.new sv, seq_to_arc_sock, log: log,
             blob_type: blob_type
           seq.start
         end
 
-        ez.server :cseqd, *cseqd_addr do |svr|
+        ez.service :cseqd, **cseqd_addr do |sv|
           require 'funl/client-sequencer'
-          cseq = Funl::ClientSequencer.new svr, cseq_to_arc_sock, log: log
+          cseq = Funl::ClientSequencer.new sv, cseq_to_arc_sock, log: log
           cseq.start
         end
 
-        ez.server :arcd, *arcd_addr do |svr|
+        ez.service :arcd, **arcd_addr do |sv|
           require 'tupelo/archiver'
           if persist_dir
             require 'tupelo/archiver/persistent-tuplespace'
-            arc = Archiver.new svr, seq: arc_to_seq_sock,
+            arc = Archiver.new sv, seq: arc_to_seq_sock,
                     tuplespace: Archiver::PersistentTuplespace,
                     persist_dir: persist_dir,
                     cseq: arc_to_cseq_sock, log: log
           else
-            arc = Archiver.new svr, seq: arc_to_seq_sock,
+            arc = Archiver.new sv, seq: arc_to_seq_sock,
                     tuplespace: Archiver::Tuplespace,
                     cseq: arc_to_cseq_sock, log: log
           end
@@ -115,7 +113,7 @@ module Tupelo
         end
       end
 
-      app = AppBuilder.new(ez, owns_servers: owns_servers, argv: argv.dup)
+      app = AppBuilder.new(ez, owns_services: owns_services, argv: argv.dup)
       
       if enable_trace
         require 'tupelo/app/trace'

data/lib/tupelo/client/transaction.rb

@@ -13,13 +13,12 @@ class Tupelo::Client
       Transaction
     end
 
-    # Transactions are atomic by default, and are always isolated. In the
-    # non-atomic case, a "transaction" is really a batch op. Without a block,
-    # returns the Transaction. In the block form, transaction automatically
-    # waits for successful completion and returns the value of the block.
-    def transaction atomic: true, timeout: nil, &block
+    # Transactions are atomic and isolated. Without a block, returns the
+    # Transaction. In the block form, transaction automatically waits for
+    # successful completion and returns the value of the block.
+    def transaction timeout: nil, &block
       deadline = timeout && Time.now + timeout
-      t = trans_class.new self, atomic: atomic, deadline: deadline
+      t = trans_class.new self, deadline: deadline
       return t unless block_given?
 
       val =
@@ -41,17 +40,13 @@ class Tupelo::Client
       t.cancel if t and t.open? and block_given?
     end
     
-    def batch &bl
-      transaction atomic: false, &bl
-    end
-    
     def abort
       raise TransactionAbort
     end
 
     # returns an object whose #wait method waits for write to be ack-ed
     def write_nowait *tuples
-      t = transaction atomic: false
+      t = transaction
       t.write *tuples
       t.commit
     end
@@ -63,7 +58,7 @@ class Tupelo::Client
     end
 
     def pulse_nowait *tuples
-      t = transaction atomic: false
+      t = transaction
       t.pulse *tuples
       t.commit
     end
@@ -94,7 +89,6 @@ class Tupelo::Client
   class Transaction
     attr_reader :client
     attr_reader :worker
-    attr_reader :atomic
     attr_reader :deadline
     attr_reader :status
     attr_reader :global_tick
@@ -129,11 +123,10 @@ class Tupelo::Client
       }
     end
 
-    def initialize client, atomic: true, deadline: nil
+    def initialize client, deadline: nil
       @client = client
       @worker = client.worker
       @log = client.log
-      @atomic = atomic
       @deadline = deadline
       @global_tick = nil
       @exception = nil
@@ -197,15 +190,13 @@ class Tupelo::Client
         ["#{label} #{tuples.map(&:inspect).join(", ")}"] unless tuples.empty?
       end
       ops.compact!
-      
-      b = atomic ? "atomic" : "batch"
       ops << "missing: #{missing}" if missing
 
       ## show take/read tuples too?
       ## show current tick, if open or closed
       ## show nowait
       
-      "<#{self.class} #{stat} #{b} #{ops.join('; ')}>"
+      "<#{self.class} #{stat} #{ops.join('; ')}>"
     end
     
     # :section: Client methods
@@ -240,7 +231,6 @@ class Tupelo::Client
     
     # raises TransactionFailure
     def take template_spec
-      raise "cannot take in batch" unless atomic
       raise exception if failed?
       raise TransactionStateError, "not open: #{inspect}" unless open? or
         failed?
@@ -253,7 +243,6 @@ class Tupelo::Client
     end
     
     def take_nowait template_spec
-      raise "cannot take in batch" unless atomic
       raise exception if failed?
       raise TransactionStateError, "not open: #{inspect}" unless open? or
         failed?
@@ -270,7 +259,6 @@ class Tupelo::Client
     
     # transaction applies only if template has a match
     def read template_spec
-      raise "cannot read in batch" unless atomic
       raise exception if failed?
       raise TransactionStateError, "not open: #{inspect}" unless open? or
         failed?
@@ -283,7 +271,6 @@ class Tupelo::Client
     end
 
     def read_nowait template_spec
-      raise "cannot read in batch" unless atomic
       raise exception if failed?
       raise TransactionStateError, "not open: #{inspect}" unless open? or
         failed?
@@ -486,7 +473,6 @@ class Tupelo::Client
       
       ## convert cancelling write/take to pulse
       ## convert cancelling take/write to read
-      ## check that remaining take/read tuples do not cross a space boundary
       
       if take_tuples_for_local.all? and read_tuples_for_local.all?
         @queue << true

data/lib/tupelo/client/worker.rb

@@ -29,16 +29,13 @@ class Tupelo::Client
     GET_TUPLESPACE = "get tuplespace"
 
     class Operation
-      attr_reader :atomic, :writes, :pulses, :takes, :reads
-      ## "put" or "set" operation to ensure that at least one
-      ## copy of a tuple exists?
+      attr_reader :writes, :pulses, :takes, :reads
 
-      def initialize atomic, writes, pulses, takes, reads
-        @atomic, @writes, @pulses, @takes, @reads =
-          atomic, writes, pulses, takes, reads
+      def initialize writes, pulses, takes, reads
+        @writes, @pulses, @takes, @reads = writes, pulses, takes, reads
       end
       
-      NOOP = new([], [], [], [], [])
+      NOOP = new([].freeze, [].freeze, [].freeze, [].freeze).freeze
 
       def to_s
         ops = [ ["write", writes], ["pulse", pulses],
@@ -47,8 +44,7 @@ class Tupelo::Client
           ["#{label} #{tuples.map(&:inspect).join(", ")}"] unless tuples.empty?
         end
         ops.compact!
-
-        [atomic ? "atomic" : "batch", ops.join("; ")].join(" ")
+        ops.join("; ")
       end
       alias inspect to_s
     end
@@ -331,11 +327,9 @@ class Tupelo::Client
         waiter << [:attempt, msg.global_tick, msg.client_id, op, msg.tags]
       end
 
-      granted_tuples = tuplespace.find_distinct_matches_for(op.takes)
+      take_tuples = tuplespace.find_distinct_matches_for(op.takes)
       read_tuples = op.reads.map {|t| tuplespace.find_match_for(t)}
-
-      succeeded = !op.atomic || (granted_tuples.all? && read_tuples.all?)
-      take_tuples = granted_tuples.compact
+      succeeded = take_tuples.all? && read_tuples.all?
 
       if client.subscribed_all
         write_tuples = op.writes
@@ -395,12 +389,15 @@ class Tupelo::Client
             end
           end
 
-          log.debug {trans ? "taking #{granted_tuples}" :
-            "client #{msg.client_id} takes #{granted_tuples}"}
+          log.debug {trans ? "taking #{take_tuples}" :
+            "client #{msg.client_id} takes #{take_tuples}"}
 
         else
           log.debug {
-            missing = op.takes - take_tuples
+            missing = []
+            take_tuples.each_with_index do |tuple, i|
+              missing << op.takes[i] unless tuple
+            end
             trans ? "failed to take #{missing}" :
             "client #{msg.client_id} failed to take #{missing}"}
         end
@@ -431,7 +428,7 @@ class Tupelo::Client
         trans_waiters.delete trans
 
         if succeeded
-          trans.done msg.global_tick, granted_tuples # note: tuples not frozen
+          trans.done msg.global_tick, take_tuples # note: tuples not frozen
         else
           trans.fail (op.takes - take_tuples) + (op.reads - read_tuples)
         end
@@ -598,12 +595,9 @@ class Tupelo::Client
       end
 
       begin
-        msg.blob = blobber.dump([
-          transaction.atomic,
-          writes, pulses, takes, reads
-        ])
+        msg.blob = blobber.dump([writes, pulses, takes, reads])
         ## optimization: use bitfields to identify which ops are present
-        ## (instead of nils), and combine this with atomic flag in one int
+        ## (instead of nils), in one int
       rescue => ex
         raise ex, "cannot serialize #{transaction.inspect}: #{ex}"
       end

data/lib/tupelo/client.rb

@@ -19,6 +19,10 @@ module Tupelo
       @initial_subscriptions = subscribe
     end
 
+    def inspect
+      "#<#{self.class} #{client_id} (#{log.progname}) at tick #{worker.global_tick}>"
+    end
+
     def make_worker
       Worker.new self
     end

data/lib/tupelo/version.rb

@@ -1,3 +1,3 @@
 module Tupelo
-  VERSION = "0.14"
+  VERSION = "0.15"
 end