tupelo 0.7 → 0.8

data/example/zk/lock.rb

@@ -0,0 +1,70 @@
+# A lock using a distributed queue, like the zookeeper lock:
+#
+# http://zookeeper.apache.org/doc/r3.3.1/recipes.html#sc_recipes_Locks
+#
+# Like the zk example:
+#
+# - there is no specialized lock manager process
+#
+# - there is no thundering herd effect when the head of the queue advances
+#
+# - queue state is globally visible (and you could add tuples that record
+#   which client_id is holding the lock or waiting for it)
+#
+# Unlike the zk example:
+#
+# - there is no mechanism for dealing with clients that disappear, either while
+#   holding the lock, or while waiting. See example/lease.rb for a solution.
+
+require 'tupelo/app'
+
+N_CLIENT = 3
+N_ITER = 3
+
+Tupelo.application do
+  local do
+    write ["head", nil]
+    write ["tail", nil]
+  end
+  
+  N_CLIENT.times do
+    child do
+      N_ITER.times do |iter|
+        my_wait_pos = nil
+
+        transaction do
+          _, head = take ["head", nil]
+          _, tail = take ["tail", nil]
+          if head
+            write ["head", head]
+            write ["tail", tail + 1]
+            my_wait_pos = tail + 1
+          else
+            write ["head", 0]
+            write ["tail", 0]
+          end
+        end
+
+        if my_wait_pos
+          read ["head", my_wait_pos]
+        end
+
+        log "working on iteration #{iter}..."
+        sleep 0.2
+        log "done"
+
+        transaction do
+          _, head = take ["head", nil]
+          _, tail = take ["tail", nil]
+          if head == tail
+            write ["head", nil]
+            write ["tail", nil]
+          else
+            write ["head", head + 1]
+            write ["tail", tail]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tupelo/app.rb

@@ -1,8 +1,6 @@
 require 'easy-serve'
 require 'tupelo/client'
 
-## this could be unified with the implementation of bin/tup, which is similar
-
 module Tupelo
   # Not an essential part of the library, but used to build up groups of
   # processes for use in examples, tests, benchmarks, etc.
@@ -22,18 +20,16 @@ module Tupelo
     end
 
     # Yields a client that runs in this process.
-    def local client_class = Client, &block
+    def local client_class = Client, **opts, &block
       ez.local :seqd, :cseqd, :arcd do |seqd, cseqd, arcd|
-        run_client client_class,
-                   seq: seqd, cseq: cseqd, arc: arcd, log: log do |client|
+        opts = {seq: seqd, cseq: cseqd, arc: arcd, log: log}.merge(opts)
+        run_client client_class, **opts do |client|
           if block
             if block.arity == 0
               client.instance_eval &block
             else
               yield client
             end
-          else
-            client
           end
         end
       end
@@ -45,18 +41,16 @@ module Tupelo
     # the passive flag for processes that wait for tuples and respond in some
     # way. Then you do not have to manually interrupt the whole application when
     # the active processes are done. See examples.
-    def child client_class = Client, passive: false, &block
+    def child client_class = Client, passive: false, **opts, &block
       ez.child :seqd, :cseqd, :arcd, passive: passive do |seqd, cseqd, arcd|
-        run_client client_class,
-                   seq: seqd, cseq: cseqd, arc: arcd, log: log do |client|
+        opts = {seq: seqd, cseq: cseqd, arc: arcd, log: log}.merge(opts)
+        run_client client_class, **opts do |client|
           if block
             if block.arity == 0
               client.instance_eval &block
             else
               yield client
             end
-          else
-            client
           end
         end
       end
@@ -74,14 +68,48 @@ module Tupelo
       client.stop if client # gracefully exit the tuplespace management thread
     end
   end
+  
+  # Returns [argv, opts], leaving orig_argv unmodified. The opts hash contains
+  # switches (and their arguments, if any) recognized by tupelo. The argv array
+  # contains all unrecognized arguments.
+  def self.parse_args orig_argv
+    argv = orig_argv.dup
+    opts = {}
+
+    opts[:log_level] =
+      case
+      when argv.delete("--debug"); Logger::DEBUG
+      when argv.delete("--info");  Logger::INFO
+      when argv.delete("--warn");  Logger::WARN
+      when argv.delete("--error"); Logger::ERROR
+      when argv.delete("--fatal"); Logger::FATAL
+      else Logger::WARN
+      end
+
+    opts[:verbose] = argv.delete("-v")
+
+    if i = argv.index("--persist-dir")
+      argv.delete_at(i)
+      opts[:persist_dir] = argv.delete_at(i)
+    end
+
+    %w{--marshal --yaml --json --msgpack}.each do |switch|
+      s = argv.delete(switch) and
+        otps[:blob_type] = s.delete("--")
+    end
+
+    opts[:trace] = argv.delete("--trace")
+    
+    [argv, opts]
+  end
 
   # same as application, but with tcp sockets the default
-  def self.tcp_application argv: ARGV,
+  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], &block
-    application argv: ARGV, servers_file: servers_file, blob_type: blob_type,
+        arcd_addr:  [:tcp, nil, 0], **opts, &block
+    application argv: argv, servers_file: servers_file, blob_type: blob_type,
       seqd_addr: seqd_addr, cseqd_addr: cseqd_addr, arcd_addr: arcd_addr, &block
   end
 
@@ -90,35 +118,31 @@ module Tupelo
   #blob_type: 'yaml' # less general ruby objects, but cross-language
   #blob_type: 'json' # more portable than yaml, but more restrictive
 
-  def self.application argv: ARGV,
+  def self.application argv: nil,
         servers_file: nil, blob_type: nil,
-        seqd_addr: [], cseqd_addr: [], arcd_addr: [], &block
-
-    log_level = case
-      when argv.delete("--debug"); Logger::DEBUG
-      when argv.delete("--info");  Logger::INFO
-      when argv.delete("--warn");  Logger::WARN
-      when argv.delete("--error"); Logger::ERROR
-      when argv.delete("--fatal"); Logger::FATAL
-      else Logger::WARN
+        seqd_addr: [], cseqd_addr: [], arcd_addr: [], **opts, &block
+  
+    unless argv
+      argv, h = parse_args(ARGV)
+      opts.merge! h
     end
 
-    unless blob_type
-      %w{--marshal --yaml --json --msgpack}.each do |switch|
-        s = argv.delete(switch) and
-          blob_type ||= s.delete("--")
-      end
-      blob_type ||= "msgpack"
-    end
-    
-    enable_trace = ARGV.delete("--trace")
+    log_level = opts[:log_level]
+    verbose = opts[:verbose]
+    blob_type = blob_type || "msgpack"
+    enable_trace = opts[:trace]
+    persist_dir = opts[:persist_dir]
 
-    svrs = servers_file || argv.shift || "servers-#$$.yaml"
+    ez_opts = {
+      servers_file: servers_file || argv.shift,
+      interactive: $stdin.isatty
+    }
 
-    EasyServe.start(servers_file: svrs) do |ez|
+    EasyServe.start ez_opts do |ez|
       log = ez.log
       log.level = log_level
-      log.progname = "parent"
+      log.formatter = nil if verbose
+      log.progname = File.basename($0)
       owns_servers = false
 
       ez.start_servers do
@@ -142,8 +166,17 @@ module Tupelo
 
         ez.server :arcd, *arcd_addr do |svr|
           require 'tupelo/archiver'
-          arc = Archiver.new svr, seq: arc_to_seq_sock,
-            cseq: arc_to_cseq_sock, log: log
+          if persist_dir
+            require 'tupelo/archiver/persistent-tuplespace'
+            arc = Archiver.new svr, 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,
+                    tuplespace: Archiver::Tuplespace,
+                    cseq: arc_to_cseq_sock, log: log
+          end
           arc.start
         end
       end

data/lib/tupelo/archiver/persistent-tuplespace.rb

@@ -0,0 +1,142 @@
+class Tupelo::Archiver
+  class PersistentTuplespace
+    include Enumerable
+    
+    attr_reader :zero_tolerance
+    
+    class Rec
+      attr_accessor :id
+      attr_accessor :count
+      attr_accessor :packed
+      
+      # linked list of recs to update to db
+      attr_accessor :next_rec_to_save
+      
+      def initialize ts, obj
+        @id = ts.next_id
+        @count = 0
+        @packed = MessagePack.pack(obj)
+        @next_rec_to_save = nil
+      end
+      
+      def unmark_to_save
+        @next_rec_to_save = nil
+      end
+    end
+
+    def initialize(
+        persist_dir: nil,
+        zero_tolerance: Tupelo::Archiver::ZERO_TOLERANCE)
+
+      @next_id = 0
+      @tuple_rec = Hash.new {|h,k| h[k] = Rec.new(self, k)}
+      @nzero = 0
+      @zero_tolerance = zero_tolerance
+      @next_rec_to_save = nil
+
+      if persist_dir
+        require 'tupelo/archiver/persister.rb'
+        @persister = Persister.new persist_dir
+        read_from_persister
+      else
+        @persister = nil
+      end
+    end
+
+    def read_from_persister
+      @persister.each do |tuple_row|
+        packed = tuple_row[:packed]
+        tuple = MessagePack.unpack(packed)
+        rec = @tuple_rec[tuple]
+        rec.count = tuple_row[:count]
+        rec.id = tuple_row[:id]
+        rec.packed = packed
+      end
+      @next_id = @persister.next_id
+      ## @persister.tick # how to send this back to worker? do we need to?
+    end
+
+    def next_id
+      @next_id += 1
+    end
+    
+    # note: multiple equal tuples are yielded once
+    def each
+      @tuple_rec.each do |tuple, rec|
+        yield tuple, rec.count if rec.count > 0
+      end
+    end
+    
+    def mark_to_save rec
+      unless rec.next_rec_to_save
+        rec.next_rec_to_save = @next_rec_to_save
+        @next_rec_to_save = rec
+        nil
+      end
+    end
+
+    def insert tuple
+      rec = @tuple_rec[tuple]
+      rec.count += 1
+      mark_to_save rec if @persister
+    end
+    
+    def delete_once tuple
+      rec = @tuple_rec[tuple]
+      if rec.count > 0
+        rec.count -= 1
+        if rec.count == 0
+          @nzero += 1
+          clear_excess_zeros if @nzero > zero_tolerance
+        end
+        mark_to_save rec if @persister
+        true
+      else
+        false
+      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 ## freeze recursively
+      end
+      
+      flush tick
+    end
+
+    def flush tick
+      if @persister
+        @persister.flush(@next_rec_to_save, @next_id, tick)
+      end
+    end
+
+    def clear_excess_zeros
+      nd = (@nzero - zero_tolerance / 2)
+      @nzero -= nd
+      @tuple_rec.delete_if {|tuple, rec| rec.count == 0 && (nd-=1) >= 0}
+      @nzero += nd
+      
+      @persister.clear_excess_zeros if @persister
+    end
+
+    def find_distinct_matches_for tuples
+      h = Hash.new(0)
+      tuples.map do |tuple|
+        if @tuple_rec[tuple].count > h[tuple]
+          h[tuple] += 1
+          tuple
+        else
+          nil
+        end
+      end
+    end
+
+    def find_match_for tuple
+      @tuple_rec[tuple].count > 0 && tuple
+    end
+  end
+end

data/lib/tupelo/archiver/persister.rb

@@ -0,0 +1,94 @@
+require 'sequel'
+
+class Tupelo::Archiver
+  class Persister
+    include Enumerable
+
+    attr_reader :dir
+
+    ## options:
+    ## time and size thresholds
+    ## sync wal
+    ## run in fork, at end of pipe, for parallel case
+    ### how to read old wal file in recovery case?
+    def initialize dir
+      @dir = dir
+      unless File.directory?(dir)
+        raise "not a dir: #{dir.inspect} -- cannot set up persister"
+      end
+      ### raise unless blobber is msgpack (or json)?
+    end
+    
+    def wal
+      @wal ||= begin
+        File.open File.join(dir, "wal"), "w"
+      end
+    end
+    
+    def db
+      @db ||= begin
+        db = Sequel.sqlite(:database => File.join(dir, "db"))
+        #db.loggers << Logger.new($stderr) ## client.log ?
+
+        db.create_table? :tuples do
+          primary_key   :id
+          String        :packed,  null: false
+          Integer       :count,   null: false
+        end
+
+        db.create_table? :subspaces do
+          foreign_key   :tuple_id, :tuples, index: true, null: false
+          Integer       :tag,     null: false
+        end
+
+        db.create_table? :global do # one row
+          Integer       :tick
+            # starts from 0 when system starts, but
+            # we persist it in case of crash while 2 arcs running, to
+            # determine which is more correct
+          Integer       :next_id
+            # internal state to a single arc worker
+        end
+        
+        if db[:global].count == 0
+          db[:global] << {tick: 0, next_id: 0}
+        end
+
+        db
+      end
+    end
+    
+    def each
+      db[:tuples].each do |tuple|
+        yield tuple
+      end
+    end
+    
+    # rec points to linked list (via next_rec_to_save) of
+    # recs to flush to db but we don't have to do that for every transaction
+    # (configurable)
+    def flush rec, next_id, tick
+      ## if threshold etc.
+      db.transaction do
+        while rec
+          n = db[:tuples].filter(id: rec.id).update(count: rec.count)
+          if n == 0
+            db[:tuples].insert(id: rec.id, count: rec.count, packed: rec.packed)
+          end
+          rec.unmark_to_save
+          rec = rec.next_rec_to_save
+        end
+        db[:global].update(next_id: next_id, tick: tick)
+      end
+    ## rescue ???
+    end
+    
+    def next_id
+      db[:global].first[:next_id]
+    end
+    
+    def clear_excess_zeros
+      db[:tuples].filter(count: 0).delete ## limit rows to delete? threshold?
+    end
+  end
+end

data/lib/tupelo/archiver/tuplespace.rb

@@ -34,7 +34,7 @@ class Tupelo::Archiver
       end
     end
 
-    def transaction inserts: [], deletes: []
+    def transaction inserts: [], deletes: [], tick: nil
       deletes.each do |tuple|
         delete_once tuple or raise "bug"
       end
@@ -46,7 +46,9 @@ class Tupelo::Archiver
 
     def clear_excess_zeros
       nd = (@nzero - zero_tolerance / 2)
+      @nzero -= nd
       @counts.delete_if {|tuple, count| count == 0 && (nd-=1) >= 0}
+      @nzero += nd
     end
 
     def find_distinct_matches_for tuples

data/lib/tupelo/archiver/worker.rb

@@ -4,9 +4,25 @@ class Tupelo::Archiver
   class Worker < Tupelo::Client::Worker
     include Funl::HistoryWorker
     
-    def initialize *args
-      super
+    def initialize *args, **opts
+      super *args
       @scheduled_actions = Hash.new {|h,k| h[k] = []}
+      @opts = opts
+    end
+
+    def tuplespace
+      @tuplespace ||= begin
+        if client.tuplespace.respond_to? :new
+          client.tuplespace.new **@opts
+        else
+          client.tuplespace
+        end
+      end
+    end
+
+    def stop
+      super
+      tuplespace.flush global_tick
     end
 
     def handle_client_request req

data/lib/tupelo/archiver.rb

@@ -1,24 +1,33 @@
 require 'tupelo/client'
 require 'funl/history-client'
 
+## move to tuplet and make optional (there is a use case: static set of clients)
+
+## should manipulate tuples as strings (at least in msgpack/json cases) instead
+## of objects -- use msgpack extension for #hash and #== on packed objects
+
 class Tupelo::Archiver < Tupelo::Client; end
 
 require 'tupelo/archiver/worker'
-require 'tupelo/archiver/tuplespace'
+require 'tupelo/archiver/tuplespace' ## unless persistent?
 
 module Tupelo
   class Archiver
     include Funl::HistoryClient
 
     attr_reader :server
+    attr_reader :persist_dir
     attr_reader :server_thread
 
     # How many tuples with count=0 do we permit before cleaning up?
     ZERO_TOLERANCE = 1000
 
-    def initialize server, **opts
-      super arc: nil, tuplespace: Tupelo::Archiver::Tuplespace, **opts
+    def initialize server,
+        tuplespace: Tupelo::Archiver::Tuplespace,
+        persist_dir: nil, **opts
       @server = server
+      @persist_dir = persist_dir
+      super arc: nil, tuplespace: tuplespace, **opts
     end
 
     # three kinds of requests:
@@ -43,11 +52,14 @@ module Tupelo
     end
 
     def make_worker
-      Tupelo::Archiver::Worker.new self
+      if persist_dir ## ???
+        Tupelo::Archiver::Worker.new self, persist_dir: persist_dir
+      else
+        Tupelo::Archiver::Worker.new self
+      end
     end
 
     def start
-      ## load from file?
       super # start worker thread
       @server_thread = Thread.new do
         run
@@ -65,8 +77,6 @@ module Tupelo
         Thread.new(server.accept) do |conn|
           handle_conn conn
         end
-
-        ## periodically send worker request to dump space to file?
       end
     rescue => ex
       log.error ex

data/lib/tupelo/client/atdo.rb

@@ -0,0 +1,31 @@
+require 'tupelo/client'
+require 'atdo'
+
+module Tupelo
+  class Client
+    class AtDo < ::AtDo
+      def initialize client, **opts
+        @client = client
+        super **opts
+      end
+
+      # Accepts numeric +time+. Logs errors in +action+. Otherwise, same
+      # as ::AtDo.
+      def at time, &action
+        time = Time.at(time) if time.kind_of? Numeric
+        super time do
+          begin
+            action.call
+          rescue => ex
+            @client.log.error "error in action scheduled for #{time}:" +
+              " #{ex.class}: #{ex}\n  #{ex.backtrace.join("\n  ")}"
+          end
+        end
+      end
+    end
+    
+    def make_scheduler **opts
+      AtDo.new self, **opts
+    end
+  end
+end

data/lib/tupelo/client/transaction.rb

@@ -35,6 +35,7 @@ class Tupelo::Client
       retry
     rescue TransactionAbort
       log.info {"aborting #{t.inspect}"}
+      :abort
     ensure
       t.cancel if t and t.open? and block_given?
     end
@@ -155,6 +156,10 @@ class Tupelo::Client
       open!
     end
     
+    def client_id
+      client.client_id
+    end
+    
     def log *args
       if args.empty?
         @log
@@ -277,6 +282,10 @@ class Tupelo::Client
       return read_tuples[i]
     end
 
+    def abort
+      client.abort
+    end
+
     # Client may call this before commit. In transaction do...end block,
     # this causes transaction to be re-executed.
     def fail!
@@ -289,9 +298,16 @@ class Tupelo::Client
     # idempotent
     def commit
       if open?
-        closed!
-        log.info {"committing #{inspect}"}
-        worker_push self
+        if @writes.empty? and @pulses.empty? and
+           @take_tuples.empty? and @read_tuples.empty?
+          @global_tick = global_tick
+          done!
+          log.info {"not committing empty transaction"}
+        else
+          closed!
+          log.info {"committing #{inspect}"}
+          worker_push self
+        end
       else
         raise exception if failed?
       end
@@ -318,7 +334,7 @@ class Tupelo::Client
     rescue TransactionAbort, Interrupt, TimeoutError => ex ## others?
       worker_push Unwaiter.new(self)
       raise ex.class,
-        "#{ex.message}: client #{client.client_id} waiting for #{inspect}"
+        "#{ex.message}: client #{client_id} waiting for #{inspect}"
     end
 
     def value

data/lib/tupelo/client/tuplespace.rb

@@ -9,7 +9,7 @@ class Tupelo::Client
       end
     end
 
-    def transaction inserts: [], deletes: []
+    def transaction inserts: [], deletes: [], tick: nil
       deletes.each do |tuple|
         delete_once tuple or raise "bug"
       end