tupelo 0.1

data/lib/tupelo/client/worker.rb

@@ -0,0 +1,493 @@
+require 'thread'
+require 'tupelo/client/reader'
+require 'tupelo/client/transaction'
+require 'object-template'
+require 'atdo'
+
+class Tupelo::Client
+  class Worker
+    attr_reader :client
+    attr_reader :seq
+    attr_reader :arc
+    attr_reader :log
+    attr_reader :client_id
+    attr_reader :local_tick
+    attr_reader :global_tick
+    attr_reader :start_tick
+    attr_reader :delta
+    attr_reader :msg_reader_thread
+    attr_reader :worker_thread
+    attr_reader :cmd_queue
+    attr_reader :tuplespace
+    attr_reader :message_class
+    attr_reader :blobber
+    attr_reader :read_waiters
+    attr_reader :prep_waiters
+    attr_reader :trans_waiters
+    attr_reader :notify_waiters
+
+    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?
+
+      def initialize atomic, writes, pulses, takes, reads
+        @atomic, @writes, @pulses, @takes, @reads =
+          atomic, writes, pulses, takes, reads
+      end
+
+      def to_s
+        ops = [ ["write", writes], ["pulse", pulses],
+              ["take", takes], ["read", reads] ]
+        ops.map! do |label, tuples|
+          ["#{label} #{tuples.map(&:inspect).join(", ")}"] unless tuples.empty?
+        end
+        ops.compact!
+
+        [atomic ? "atomic" : "batch", ops.join("; ")].join(" ")
+      end
+      alias inspect to_s
+    end
+
+    def initialize client
+      @client = client
+      @seq = nil
+      @arc = nil
+      @log = client.log
+
+      @client_id = nil
+      @global_tick = nil
+      @start_tick = nil
+      @local_tick = 0
+      @delta = 0
+
+      @cmd_queue = client.make_queue
+      @tuplespace =
+        begin
+          client.tuplespace.new
+        rescue NoMethodError
+          client.tuplespace
+        end
+      @message_class = client.message_class
+      @blobber = nil
+
+      @read_waiters = []
+      @prep_waiters = []
+      @trans_waiters = []
+      @notify_waiters = []
+      @stopping = false
+    end
+
+    def start
+      return if @worker_thread
+
+      log.info "worker starting"
+      observe_started_client
+
+      @msg_reader_thread = Thread.new do
+        run_msg_reader_thread
+      end
+
+      @worker_thread = Thread.new do
+        run_worker_thread
+      end
+    end
+
+    def in_thread?
+      Thread.current == worker_thread
+    end
+
+    def observe_started_client
+      @client_id = client.client_id
+      @blobber = client.blobber
+      @seq = client.seq
+      @arc = client.arc
+      @start_tick = client.start_tick
+    end
+
+    def stop
+      cmd_queue << :stop
+      worker_thread.join if worker_thread ## join(limit)?
+      msg_reader_thread.kill if msg_reader_thread
+      @atdo.stop if @atdo
+      ## optionally write final state (including global_tick) to disk
+    end
+
+    # stop without any remote handshaking
+    def stop!
+      @msg_reader_thread.kill if msg_reader_thread
+      @worker_thread.kill if worker_thread
+      @atdo.stop if @atdo
+    end
+
+    def at time, &action
+      @atdo ||= AtDo.new
+      @atdo.at time do
+        cmd_queue << action
+      end
+    end
+
+    def << cmd
+      cmd_queue << cmd
+    end
+
+    def run_msg_reader_thread
+      read_messages_from_seq
+      log.warn "connection to seq closed"
+      handle_seq_closed
+    rescue => ex
+      log.error ex
+      raise
+    end
+
+    def handle_seq_closed
+      ## what to do here in general?
+      ## for each waiter, push :stop into queue ?
+    end
+
+    def read_messages_from_seq
+      seq.each do |msg|
+        ## skip msg if tags not relevant
+        ## (and client must apply tags--i.e. not using multicast)
+        self << msg
+      end
+    end
+
+    def run_worker_thread
+      update_to_tick @start_tick
+      run_request_loop
+    rescue => ex
+      log.error ex
+      raise
+    end
+
+    def run_request_loop
+      catch :done do
+        loop do
+          handle_one_request
+        end
+      end
+    end
+
+    def handle_one_request
+      case cmd = cmd_queue.pop
+      when :stop
+        @stopping = true
+        if trans_waiters.empty?
+          throw :done
+        else
+          log.info {"stopping; waiting for #{trans_waiters}"}
+        end
+      when message_class
+        handle_message cmd
+        if @stopping
+          if trans_waiters.empty?
+            throw :done
+          else
+            log.info {"stopping; waiting for #{trans_waiters}"}
+          end
+        end
+      else
+        handle_client_request cmd unless @stopping
+      end
+    end
+
+    def update_to_tick tick
+      # at this point we know that the seq messages now accumulating in
+      # cmd_queue are tick+1, tick+2, .... In particular, if tick==0, we don't
+      # need to get state from archiver.
+      log.debug {"update_to_tick #{tick}"}
+
+      if tick == 0
+        @global_tick = 0
+        return
+      end
+
+      if false
+        ## load from file, update @global_tick, and see if equal to tick
+        if @global_tick == tick
+          return
+        elsif @global_tick > tick
+          raise "bad tick: #{@global_tick} > #{tick}"
+        end
+      end
+
+      unless arc
+        log.warn "no archiver provided; assuming pubsub mode; " +
+          "some client ops (take and local read) will not work"
+        @global_tick = tick
+        log.info "global_tick = #{global_tick}"
+        return
+      end
+
+      log.info "requesting tuplespace from arc"
+      arc << [GET_TUPLESPACE, nil]
+        ## replace nil with template tuples, if any
+
+      begin
+        arc_tick = arc.read[0]
+        log.info "arc says global_tick = #{arc_tick}"
+
+        done = false
+        arc.each do |tuple|
+          if tuple.nil?
+            done = true
+          else
+            raise "bad object stream from archiver" if done
+            tuplespace.insert tuple
+          end
+        end
+        unless done
+          raise "did not get all of tuplespace from archiver" ## roll back?
+        end
+
+        log.info "received tuplespace from arc"
+
+        @global_tick = arc_tick
+        log.info "global_tick = #{global_tick}"
+      end
+
+    ensure
+      arc.close if arc and not arc.closed?
+    end
+
+    def handle_message msg
+      log.debug {"seq sent #{msg.inspect}"}
+
+      if msg.global_tick != global_tick + 1
+        if msg.global_tick < global_tick + 1
+          log.debug {"discarding redundant message at #{msg.global_tick}"}
+            # due to archiver timing, for example
+          return
+        elsif msg.global_tick > global_tick + 1
+          log.error "message out of order: #{msg.inspect}, " +
+            "received at global_tick=#{global_tick}"
+          ## exit? wait? in udp case, get history
+        end
+      end
+
+      @global_tick += 1
+      @delta = 0
+
+      record_history msg
+      op = Operation.new(*blobber.load(msg.blob)) ## op.freeze_deeply
+      log.debug {"applying #{op} from client #{msg.client_id}"}
+
+      notify_waiters.each do |waiter|
+        waiter << [:attempt, msg.global_tick, msg.client_id, op]
+      end
+
+      granted_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?)
+      actual_tuples = granted_tuples.compact
+
+      if succeeded
+        log.debug {"inserting #{op.writes}; deleting #{actual_tuples}"}
+        tuplespace.transaction inserts: op.writes, deletes: actual_tuples
+      end
+
+      notify_waiters.each do |waiter|
+        waiter << [
+          succeeded ?  :success : :failure,
+          msg.global_tick, msg.client_id, op]
+      end
+
+      trans = nil
+      if msg.client_id == client_id
+        trans = trans_waiters.first
+        unless trans and trans.local_tick == msg.local_tick
+          log.error "transaction #{op} out of order in sequence " +
+            trans_waiters.inspect
+          ## exit? wait?
+        end
+        trans_waiters.shift
+        log.debug {"operation belongs to this client: #{trans.inspect}"}
+      end
+
+      if not actual_tuples.empty?
+        if succeeded
+          actual_tuples.each do |tuple|
+            prep_waiters.keep_if do |waiter|
+              waiter.unprepare tuple
+              ## optimization: track number of instances of tuple, to avoid
+              ## false positive in #unprepare
+            end
+          end
+
+          log.debug {trans ? "taking #{granted_tuples}" :
+            "client #{msg.client_id} takes #{granted_tuples}"}
+
+        else
+          log.debug {
+            missing = op.takes - actual_tuples
+            trans ? "failed to take #{missing}" :
+            "client #{msg.client_id} failed to take #{missing}"}
+        end
+      end
+
+      if succeeded
+        op.writes.each do |tuple|
+          read_waiters.delete_if do |waiter|
+            waiter.gloms tuple
+          end
+        end
+
+        op.pulses.each do |tuple|
+          log.debug {"pulsing #{tuple}"}
+          read_waiters.delete_if do |waiter|
+            waiter.gloms tuple
+          end
+        end
+
+        op.writes.each do |tuple|
+          prep_waiters.keep_if do |waiter|
+            waiter.prepare tuple
+          end
+        end
+      end
+
+      if trans
+        trans_waiters.delete trans
+
+        if succeeded
+          trans.done msg.global_tick, granted_tuples # note: tuples not frozen
+        else
+          trans.fail (op.takes - actual_tuples) + (op.reads - read_tuples)
+        end
+      end
+    end
+
+    def record_history msg; end
+
+    def handle_client_request req
+      log.debug {"client requested #{req.inspect}"}
+
+      case req
+      when message_class
+        raise "only seq can send messages"
+
+      when Waiter
+        handle_waiter req
+
+      when Matcher
+        handle_matcher req
+
+      when Unwaiter
+        handle_unwaiter req
+
+      when Transaction
+        handle_transaction req
+
+      when NotifyWaiter
+        notify_waiters.delete req or notify_waiters.push req
+
+      when Proc
+        req.call
+
+      else
+        raise "unknown request from client: #{req}"
+      end
+    rescue => ex
+      log.error "error while handling #{req.inspect}: #{ex}"
+      ## Raise an error in the waiter? Need to generalize the mechanism in
+      ## Transaction.
+    end
+
+    def handle_transaction t
+      case
+      when t.open?
+        t.prepare
+        prep_waiters << t unless prep_waiters.include? t
+      when t.closed?
+        t.submit
+        prep_waiters.delete t
+      when t.failed?
+      else
+        log.warn "not open or closed or failed: #{t.inspect}"
+      end
+    rescue => ex
+      log.error "error while handling #{t.inspect}: #{ex}"
+      t.error ex
+    end
+
+    def handle_unwaiter unwaiter
+      waiter = unwaiter.waiter
+      read_waiters.delete waiter or prep_waiters.delete waiter
+    end
+
+    def handle_waiter waiter
+      tuplespace.find {|tuple| waiter.gloms tuple} or
+        read_waiters << waiter
+        ## optimize: if template is just a tuple, use hashing,
+        ## but will need to expose waiter.tuple
+    end
+
+    def handle_matcher matcher
+      if matcher.all
+        tuplespace.each {|tuple| matcher.gloms tuple}
+        matcher.fails
+      else
+        tuplespace.find {|tuple| matcher.gloms tuple} or
+          matcher.fails
+      end
+    end
+
+    def send_transaction transaction
+      msg = message_class.new
+      msg.client_id = client_id
+      msg.local_tick = local_tick + 1
+      msg.global_tick = global_tick
+      msg.delta = delta + 1 # pipelined write/take
+      ##msg.tags = nil
+
+      begin
+        msg.blob = blobber.dump([
+          transaction.atomic,
+          transaction.writes,
+          transaction.pulses,
+          transaction.take_tuples,
+          transaction.read_tuples
+        ])
+        ## optimization: use bitfields to identify which ops are present
+        ## (instead of nils), and combine this with atomic flag in one int
+      rescue => ex
+        raise ex, "cannot serialize #{transaction.inspect}: #{ex}"
+      end
+
+      begin
+        seq << msg
+      rescue => ex
+        raise ex, "cannot send request for #{transaction.inspect}: #{ex}"
+      end
+
+      @local_tick += 1
+      @delta += 1
+
+      trans_waiters << transaction
+
+      return msg.local_tick
+    end
+
+    # Used by api to protect worker's copy from client changes.
+    # Also, for serialization types that don't represent symbols,
+    # this converts a template so that it works correctly regardless.
+    # So keyword args are very natural: read(k1: val, k2: val)
+    def make_template obj
+      return obj unless obj.respond_to? :to_ary or obj.respond_to? :to_hash
+      spec = Marshal.load(Marshal.dump(obj))
+      rot_for(spec).optimize!
+    end
+
+    def rot_for spec
+      RubyObjectTemplate.new(spec, proc {|k| blobber.load(blobber.dump(k))})
+    end
+
+    def pot_for spec
+      PortableObjectTemplate.new(spec, proc {|k| blobber.load(blobber.dump(k))})
+    end
+  end
+end

data/lib/tupelo/client.rb

@@ -0,0 +1,44 @@
+require 'funl/client'
+
+module Tupelo
+  class Client < Funl::Client
+    require 'tupelo/client/worker'
+    require 'tupelo/client/tuplespace'
+
+    include Api
+
+    attr_reader :worker
+    attr_reader :tuplespace
+
+    def initialize(tuplespace: SimpleTuplespace, **opts)
+      super **opts
+      @tuplespace = tuplespace
+      @worker = make_worker
+    end
+
+    def make_worker
+      Worker.new self
+    end
+
+    def make_queue
+      Queue.new ## use lock-free queue based on Atomic
+    end
+
+    def start
+      super
+      worker.start
+    end
+
+    def stop
+      worker.stop
+    end
+
+    def log *args
+      if args.empty?
+        super()
+      else
+        super().unknown *args
+      end
+    end
+  end
+end

data/lib/tupelo/version.rb

@@ -0,0 +1,3 @@
+module Tupelo
+  VERSION = "0.1"
+end

data/test/lib/mock-client.rb

@@ -0,0 +1,38 @@
+require 'tupelo/client/reader'
+require 'tupelo/client/transaction'
+
+require 'mock-queue.rb'
+
+class MockClient
+  include Tupelo::Client::Api
+
+  attr_accessor :worker
+  attr_accessor :log
+  attr_accessor :client_id
+  attr_accessor :blobber
+  attr_accessor :message_class
+  attr_accessor :tuplespace
+  attr_accessor :seq
+  attr_accessor :arc
+  attr_accessor :start_tick
+
+  def updater
+    @updater ||=
+      Fiber.new do
+        loop do
+          log.debug "update begin"
+          worker.update
+          log.debug "update end"
+          Fiber.yield
+        end
+      end
+  end
+  
+  def update
+    updater.resume
+  end
+  
+  def make_queue
+    MockQueue.new
+  end
+end

data/test/lib/mock-msg.rb

@@ -0,0 +1,47 @@
+class MockMessage
+  attr_accessor :client_id
+  attr_accessor :local_tick
+  attr_accessor :global_tick
+  attr_accessor :delta
+  attr_accessor :tags
+  attr_accessor :blob
+
+  def initialize(*args)
+    @client_id, @local_tick, @global_tick, @delta, @tags, @blob = *args
+  end
+
+  def self.[](
+    client: nil, local: nil, global: nil, delta: nil, tags: nil, blob: nil)
+    new client, local, global, delta, tags, blob
+  end
+
+  def inspect
+    d = delta ? "+#{delta}" : nil
+    t = tags ? " #{tags}" : nil
+    s = [
+      "client #{client_id}",
+      "local #{local_tick}",
+      "global #{global_tick}#{d}"
+    ].join(", ")
+    "<Message: #{s}#{t}>"
+  end
+
+  def to_a
+    [@client_id, @local_tick, @global_tick, @delta, @tags, @blob]
+  end
+
+  def == other
+    other.kind_of? self.class and
+      @client_id = other.client_id and
+      @local_tick = other.local_tick and
+      @global_tick = other.global_tick and
+      @delta = other.delta and
+      @tags = other.tags and
+      @blob = other.blob
+  end
+  alias eql? ==
+
+  def hash
+    @client_id.hash ^ @local_tick.hash ^ @global_tick.hash
+  end
+end

data/test/lib/mock-queue.rb

@@ -0,0 +1,42 @@
+class MockQueue
+  class QueueEmptyError < StandardError; end
+  
+  attr_reader :entries
+  attr_reader :yield_on_push
+  attr_reader :yield_on_pop
+  
+  def initialize yield_on_push: false, yield_on_pop: false
+    @entries = []
+    @yield_on_push = yield_on_push
+    @yield_on_pop = yield_on_pop
+  end
+  
+  def empty?
+    entries.empty?
+  end
+  
+  def push val
+    @entries << val
+    if yield_on_push
+      Fiber.yield([:push, val]) rescue FiberError
+    end
+  end
+  alias << push
+  
+  def pop
+    begin
+      while @entries.empty?
+        Fiber.yield :block
+      end
+    rescue FiberError
+      raise QueueEmptyError, "queue empty"
+    end
+    
+    val = @entries.shift
+    if yield_on_pop
+      Fiber.yield([:pop, val]) rescue FiberError
+    end
+    val
+  end
+end
+

data/test/lib/mock-seq.rb

@@ -0,0 +1,50 @@
+class MockSequencer
+  attr_reader :messages
+
+  def initialize
+    @messages = []
+  end
+
+  def tick
+    messages.size
+  end
+
+  def << message
+    message = Marshal.load(Marshal.dump(message))
+    message.global_tick = tick + 1
+    message.delta = nil
+    @messages << message
+  end
+
+  def [](i)
+    @messages[i]
+  end
+
+  def stream
+    Stream.new(self)
+  end
+
+  class Stream
+    include Enumerable
+    
+    def initialize seq
+      @seq = seq
+      @read_tick = 0
+    end
+
+    def << message
+      @seq << message
+    end
+    alias write <<
+
+    def read
+      @seq.messages[@read_tick].tap {|m| m and @read_tick += 1}
+    end
+
+    def each
+      while message = read
+        yield message
+      end
+    end
+  end
+end